Five projects shipped today, and together they close the loop on Agent2Agent (A2A): a server that hosts agents, a CLI that probes them, reference services that define what "correct" means, a TTS library that runs as a delegated skill, and a Flutter client that renders the UI agents emit. The numbers for the day: four CLI releases, two closed epics in the audio library, a Firestore-backed task store on the server, and roughly 12,000 lines changed across the five repos.

One writeup per project, then the thread that ties them together.

Part 1: eldamoapi, the Mithlond server, goes multi-instance

Repo: github.com/ghchinoy/eldamoapi. Live at: candir.mithlond.com/a2a

A2A tasks can run for minutes, not milliseconds. On Cloud Run with more than one instance, a task created on instance A used to vanish when the next poll landed on instance B. Today's Firestore taskstore (+305 lines) fixes that: tasks persist with documented collections, lazy creation, and TTL plus index setup, so any instance can resume any task.

The server gives AI agents structured access to Paul Strack's Eldamo Tolkien-language lexicon. One Go binary speaks two protocols on the same mux: MCP at /sse for stateless tool calls, and A2A at /a2a for agentic skills. Both sit behind one OAuth 2.1 JWT layer and read one in-memory lexicon loaded at startup. The MCP surface exposes the tools and the Agent Skills (i.e. prompt workflow documents) that document them, so any harness can call them. The A2A surface exposes the agent that uses those tools as A2A Skills (a capability advertised in an AgentCard and executed server-side).

Two more changes shipped:

  • Extended AgentCard. Authenticated callers receive a richer card than anonymous ones, on a clearer versioning scheme (0.4.1 to 0.5.0). This fed the a2acli discover --extended work in Part 2.
  • Skills split. The four live A2A skills (name-generate, neologism, translate, echo) moved into a dedicated skills/ Go subpackage, with 333 lines of new tests.

The day's diff: roughly 2,500 insertions across 22 files. The server now scales horizontally with durable task state.

Part 2: a2acli continues to improve as a go-to power tool (v1.4.6 to v1.8.0)

a2acli is a standalone, A2A v1.0 client for discovering, messaging, and managing agents. It runs on the a2a-go SDK and offers both an interactive streaming TUI and a scriptable JSON mode.

This repo moved fastest: four releases (v1.4.6, v1.6.0, v1.6.2, v1.8.0) and about 5,400 lines across 43 files. The work tracked capability discovery, then auth, then multimodal, then ergonomics.

On auth, the CLI gained a full authorization-code plus PKCE flow built on Client ID Metadata Documents (CIMD). A 401 now returns the steps to authenticate instead of a bare rejection. Conformance runs reuse a stored token rather than skipping when you are logged in, and a config-env feature lets you switch agents and transports without retyping flags.

On multimodal I/O, message input now accepts --parts, --json, --attach, and --data, so one message can carry text, files, and structured data parts. Artifact persistence writes Raw and FileURL parts, audio included, straight to disk. That last piece is the client half of the read-aloud audio story in Part 4.

The v1.8.0 release added discover --extended, which consumes the eldamoapi rich card, and filters on list tasks. The dependencies run both ways: discover --extended exists because eldamoapi started serving extended cards, and disk artifact saving exists because read-aloud started producing audio. The CLI is the conformance harness for the whole stack.

Part 3: a2a-experiments becomes the conformance blueprint

a2a-experiments is a blueprint for stateful, resilient A2A services. It bridges A2A v1.0 with the Gemini Interactions API to solve the resumption problem for long-running agents, and it serves as the place where new server patterns get proven before they spread. The architectural foundation is in an earlier post, Designing A2A Services for Long-Running Agents, which covers moving state from the client into the infrastructure. Today's work builds the conformance layer on top of that foundation.

Today it became the canonical home for test services; a2acli relocated its fixtures here. The work:

  • multimodal_echo skill. The reference fixture for multi-part messages, carrying the full lifecycle: a NewSubmittedTask preamble, finalizeTask, context propagation, and LastChunk handling. It is the server-side counterpart to a2acli's multimodal input.
  • Server scaffolding. Structured logging and a net.Listen pattern, shaped for production.
  • Asset strategy. Authoring-time static fixtures plus self-hosted URLs, so multimodal tests reproduce at the byte level.
  • AGENTS.md. The bd (beads) workflow and skill checklist, written down so the process repeats.

Planning also seeded a multi-service restructure (grpc-echo, multimodal, and extended-card fixtures), which sets up a2a-experiments as the matrix of conformance targets a2acli runs against.

Part 4: read-aloud turns from CLI tool into an embeddable A2A library

read-aloud (private) converts PDFs, text files, and webpages into consistent, long-form audio with Gemini TTS. Today's goal was to make the library good enough for another agent to import and call as a delegated skill. Two epics closed, about 1,550 lines across 31 files.

The library API refactor added client injection and in-memory inputs through ProcessText and ProcessStream, which removes the temp-file round-trip. It introduced a pluggable AudioConcatenator with a pure-Go fallback, so the library no longer hard-depends on ffmpeg. The package now carries full godoc.

The module moved to its public path, github.com/ghchinoy/read-aloud, with nil-safe progress reporting, which is the precondition for anyone importing it. A new agent-aware mode bypasses the TUI, adds JSON output and custom error hints, and lives under cmd/read-aloud with a self-documenting Makefile and version ldflags. Architecture docs landed too, with Graphviz DOT to WebP diagrams and a fabulae roadmap.

read-aloud is slated to run as an A2A agent-to-agent delegation target. The pure-Go concatenator and in-memory I/O are what let it run as a serverless skill that another agent calls, returning audio artifacts that a2acli now knows how to save.

This is a narrow (but deep) update to fabulae, which will also probably get overhauled in the coming weeks.

Part 5: apex renders agent-generated UI with A2UI v1.0

apex (private) is a Flutter client for A2A servers. It uses the GenUI framework to render dynamic, AI-generated native UI, so an agent can stream conversational text next to interactive cards and data models in the same chat.

A2UI rides inside A2A DataParts, which means the server can be validated at the byte level before any renderer exists. So the work started on the server: migrate the reference A2UI sample server to the A2UI v1.0 candidate wire format, then validate it with a2acli, then build the Flutter renderer against a proven target.

The migration:

  • MIME type application/a2ui+json, with every envelope stamped version: "v1.0".
  • DataPart.data is now a single ordered array of messages, where it used to be one part per message. That change exposed an SDK artifact-copy crash, fixed via gob registration.
  • Schema modernization: theme became surfaceProperties, inline components and data models are supported, and catalog IDs moved to v1_0/catalogs/basic/.
  • The Agent Card advertises the https://a2ui.org/a2a-extension/a2ui/v1.0 extension with its supported catalog IDs.
  • A spec fix replaced the invalid Text variants h1 and h2 with the compliant body variant.

A cross-project plan for A2UI V1 migration governs the v0.9 to v1.0 transition with milestones and fork-versus-contribute decisions, plus a manual test plan pairing the server against a2acli.

The thread

Read end to end, the day builds one system:

  1. eldamoapi serves a scalable, OAuth-gated agent with durable tasks and extended cards.
  2. a2acli discovers those cards, authenticates with PKCE, sends multimodal messages, and saves artifacts.
  3. a2a-experiments supplies the reference skills and fixtures that define correctness.
  4. read-aloud becomes a library ready to run as a delegated A2A audio skill.
  5. apex renders the UI those agents emit, validated byte-for-byte by a2acli before a pixel is drawn.

The discipline that repeats across all five: prove it at the wire level first (extended cards, A2UI DataParts, multimodal fixtures, Firestore task state), then build the human-facing surface on a foundation that already conforms.