I am a consultant, and I regularly build presentations with Google Slides. My communication team has created dozens of pre-formatted templates (slides designed to convince, not just to present). The problem: choosing the right slides to illustrate the right narrative takes time, and filling them in mechanically adds no value. I built a multi-agent system to automate that part and focus on what matters: the narrative and making it my own.
This project (** agentigslide**) is also a concrete application of the agentic mesh principles I described in
Note.This article was co-written with an AI. I’m at the helm: I set the direction, the ideas, and I review the entire document. The actual writing was done by AI. My goal is to share these ideas to open a discussion, not to write a technical masterpiece that becomes a stylistic reference. This version is designed for humans; if you prefer a version suited for AI consumption, the[markdown source]is available.
Every slide creation tool solves the wrong problem. Gamma, Beautiful.ai, Pitch: they generate visually correct slides. But they produce presentations, not persuasion presentations. The difference is fundamental.
Convincing starts with a narrative. Slides are a complement to it, not a restatement. A consultant preparing a pitch doesn’t start from a slide generation tool, they start from their argument, the structure of their demonstration, the ideas they want to anchor in the listener’s mind. Slides are just the visual aid for that reasoning.
In this context, my communication team produced a catalog of ~300 pre-formatted slides in Google Slides (slides designed by visual communication professionals, crafted to illustrate specific IT consulting concepts: persuasion slides, framing slides, comparison slides, process slides). This catalog is a brand asset that encodes visual and rhetorical conventions honed over years.
The consultant’s value lies in choosing the right slides from this catalog to illustrate the right concepts in their argument, then filling them with their content. The choice is strategic, the filling is mechanical. I wanted to automate the mechanical to free up the strategic.
The consultant’s value lies in the choice and the personalization, not in the mechanical filling.
In the vocabulary of the agentic mesh, this is Pillar 2: Domains. The agent I built belongs to the consulting domain: its intention is expressed in business vocabulary (structuring a pitch, choosing persuasion slides), not in generic technical terms.
Before writing any code, I mapped the landscape with a Wardley map to understand where value lies and what strategic moves are possible.
The value chain reads top to bottom: the consultant must convince a client. To do this, they produce a narrative that they externalize into a structured brief (a markdown file). This brief feeds the agentic orchestration which draws from the pre-formatted slide catalog via a semantic index, to produce a presentation through the Google Slides and Drive APIs.
The catalog is the invisible moat. Positioned in the Custom phase, it is relational capital (not replicable without the communication expertise that produced it). A competitor could reproduce the agentic architecture, deploy the same LLM models, but could not copy this catalog without copying the years of expertise that shaped it.
Timing is critical. Agentic orchestration is leaving the Genesis phase to enter Custom. Generic generation tools (Gamma, Beautiful.ai) are under Red Queen pressure: they must constantly evolve just to not fall behind. Their natural direction is to absorb agentic capabilities. The window to occupy the “persuasion slides” niche is 12 to 18 months.
Human-in-the-loop is a strategic choice, not a limitation. The consultant reviews and appropriates the generated slides. It is the step that transforms a correct presentation into a convincing one. It is not a stopgap waiting for the AI to be “good enough”: the human who presents is responsible for what they present.
Non-intrusive by design. The communication team continues using Google Slides without learning any new tool. The system automatically understands template structure and adapts to it. Frictionless adoption = real adoption.
My first system was a monolithic pipeline: a single Claude call received the complete template catalog (~60 slides, ~15-20 KB of text) and the user’s request, and had to analyze the structure, select templates, fill the text content of each field, and maintain overall presentation coherence in a single pass.
It worked. At least well enough to validate the fundamental hypothesis: yes, an LLM can choose the right slides from a catalog and fill them in relevantly.
This is exactly Phase 1 of the agentic mesh trajectory: “The objective of this phase is not to build a good agent. It is to validate the fundamental hypotheses.” And that is what the prototype did: it validated that cognitive automation is possible on this use case.
But four structural limitations emerged quickly:
The prototype had served its purpose. It was time to move to engineering.
The first architecture decision (ADR 001, May 5, 2026) transformed the monolithic pipeline into four specialized agents coordinated by a pure Go code orchestrator (no AI in the orchestration). This is the coordinator-subagent (hub-and-spoke) pattern, the standard architecture for multi-agent systems: a central coordinator decomposes the task, delegates to specialized agents with isolated context, then aggregates their results.
The Outliner analyzes the user’s request and produces a structured presentation plan. Crucial point: it does not receive the template catalog. This context isolation is deliberate: it forces the reasoning “what do we need?” before “what do we have?”, avoiding availability bias. This is a fundamental principle of agentic architectures: subagents do not automatically inherit the coordinator’s context, each only receives what it needs.
The Selector matches the needs identified by the Outliner against the available templates in the catalog. It works with the itemCount
and maxItemLength
context provided by the Outliner to make informed choices.
The Writers generate the textual content for each slide, in parallel. Each Writer receives only one tool (produce_slide_content
) with a dynamic JSON schema generated from the template fields (scoped tool access principle: restrict tools to the bare minimum to maximize selection reliability). The model is selected based on complexity: Haiku for simple slides (≤ 2 fields), Sonnet for complex ones.
The Reviewer is an independent review instance: it does not have the Writers’ reasoning context, it only receives the assembled plan and the original request. This is not a self-review (where the same model validates its own choices), it is a separate agent bringing a fresh perspective. It uses Opus with extended thinking for in-depth analysis. When it detects problems, it sends structured feedback (ReviewIssue[]
) via the retry-with-error-feedback pattern: specific errors are injected into the affected Writer’s prompt, not a vague “try again” (maximum 2 iterations to bound cost).
This is Phase 2 of the agentic mesh: “Each sub-agent is specialized, uses the model adapted to its task, has its own tools and feedback loops.”
I could have used Claude Code with MCP servers, or Anthropic’s Agent SDK. I chose native Go, and this choice illustrates the founding conviction of the agentic mesh: a production agent is a software engineering product, not an assembly of directives.
The fundamental distinction is between programmatic enforcement and prompt guidance. The former provides deterministic guarantees (validation blocks the pipeline if selected templates don’t exist), the latter provides probabilistic compliance (the model will follow instructions most of the time, but not always). When non-compliance has visible consequences (an incoherent presentation delivered to a client), programmatic enforcement is not optional.
| Criterion | Native Go | Off-the-shelf system + directives |
|---|---|---|
| Fine-grained parallelism | Goroutines + semaphore, concurrency control | Limited, sequential or simple parallel |
| Feedback loops | Typed ReviewIssue[] , targeted retry on subset |
|
| Conversational, fragile over time | ||
| Structured outputs | Strict JSON schema, programmatic validation | Implicit, model-dependent |
| Prompt caching | Vertex AI ephemeral cache, shared between Writers | Not available or not shared |
| Inter-step state | Typed, mutex, testable | Lives in conversational context |
| Observability | Per-agent metrics, complete issue log | Limited, aggregated |
Engineering is not only found in the tools the agent uses: it is also found in how the agent itself is built, tested, deployed, observed, and governed.
The project accumulated 16 Architecture Decision Records in 4 weeks. Each ADR is a deliberate engineering decision, documented with its context, alternatives considered, and consequences. This is not after-the-fact documentation, it is governance in action. Here are the most significant ones, with the agentic principle they illustrate:
| ADR | Decision | Agentic mesh concept illustrated |
|---|---|---|
go:embed
)In the agentic mesh article, I defined 7 affordances that an agent must offer to be a true product. Here is how they materialized in agentigslide.
1. Expose decisions and actions. Each agent exposes its capabilities via a strict JSON schema enforced by Claude’s tool_use
mechanism with forced tool_choice
(the model must call the specified tool, eliminating parasitic text responses). With ADR 007, each agent also exposes an A2A Agent Card (a self-descriptive manifest published at /.well-known/agent-card.json
).
2. Consume context. The agents consume three types of context: the catalog’s semantic index (built once, reused for every generation), template-specific instructions (an optional PROMPT.md
file), and memory files from previous executions.
3. Reason and decide. This is the core of the product: Haiku for simple tasks, Sonnet for complex ones, Opus with extended thinking for review. Prompts are externalized via go:embed
and versioned with the code. The Reviewer → Writer loop is structured prompt chaining (each step’s output becomes the next step’s input with programmatic validation between steps), not an open conversation.
4. Be discoverable. The Outliner is already deployed as a standalone A2A server (cmd/outliner/main.go
). ADR 014 proposed an agent registry pattern for dynamic composition.
5. Manage its lifecycle. Models are configurable per agent via environment variables (AGENT_OUTLINER_MODEL
, AGENT_WRITER_MODEL
…). The original monolithic mode is preserved as a fallback (backward compatibility without debt).
6. Trace decisions. Each agent reports its tokens (input, output, cache read, cache creation), its duration, and a complete issue log. The Reviewer’s extended thinking is traced. The FormatAgent (ADR 016) logs every deterministic correction applied.
7. Be governable. MaxReviewRetries
bounds correction iterations. enforceMaxChars()
acts as a post-execution hook: it intercepts Writers’ output and truncates fields that exceed the template limit, providing a deterministic guarantee that the prompt alone cannot offer (trust but verify). Agent memory (ADR 015) is validated by the human before writing: the agent proposes guidelines, the user confirms.
The default mode of agentigslide is interactive chat (ADR 005-006). The consultant describes what they want, the Outliner proposes a structure, the consultant refines in conversation, and only when the plan is validated does the generation launch.
This is not a crutch. It is a deliberate choice, rooted in a conviction: the person who presents is responsible for what they present. The agent produces professional-quality material, but it is the consultant who examines it, adjusts it, and adds the personal touch that makes the difference between a generic presentation and a convincing one.
In the agentic mesh, I wrote: “H-A (Human-Agent) sequences are not exceptions or safeguards, they are a feature of the mesh.” This is exactly what happens here. The human is not in the loop because the AI is not good enough. They are in the loop because that is their irreplaceable contribution.
Let me stress a point that the Wardley map makes obvious: the code is not the moat. The multi-agent architecture, the goroutines, the prompt caching: all of this will commoditize. A competitor could reproduce the entire technical system. What they could not reproduce is the catalog of 300 slides designed by visual communication professionals. This catalog is not a collection of templates, it is a brand asset that encodes visual and rhetorical conventions built over years. It is relational capital, not technical capital.
And the non-intrusiveness doctrine reinforces this moat: the communication team continues working in Google Slides without learning any new tool. The system automatically analyzes each slide with Claude Vision, understands its structure, identifies editable fields, and builds a semantic index. Adoption is frictionless because the tool adapts to humans, not the other way around.
ADR 007 (May 9, 2026) was the turning point. The Go pipeline works well, but it has three structural limitations that no optimization can solve:
The solution: the A2A protocol (Agent-to-Agent, Google, 2025). Each agent exposes an Agent Card and accepts Tasks via a standardized REST API. The Go orchestrator remains (deterministic, predictable) but calls agents via A2A rather than Go functions. This directly implements the interoperability contract and the Agent Card described in the agentic mesh article.
The deepest paradigm shift concerns the catalog. Today, the catalog is a hard constraint: if no template fits, the Selector can do nothing. With A2A, it becomes a smart default with creative fallback: when no template fits, the Selector orchestrates sub-agents (layout agent, design agent, visual validation agent) to create a slide from scratch using design primitives.
This change has a non-trivial precondition: the communication team’s visual charter, currently implicit in the slides, must become explicit, versioned, testable. The communication team no longer produces only slides, they produce design primitives and composition rules. This is a fundamental shift in their contribution.
ADR 015 introduced per-agent learning memory. Each agent has a Markdown file per template, stored alongside the template and versioned with git. Guidelines are actionable: “On slide #42, never exceed 120 characters in the title field (text overflows systematically).”
At the end of the pipeline, if errors were detected, the system synthesizes guidelines and proposes them to the user (no automatic writing). The human confirms before memory is enriched. This is affordance 7 (being governable) applied concretely: the agent improves within boundaries defined by the human.
After 4 weeks of building, 16 ADRs, and a system that works in production, here is what the agentigslide project confirmed (or taught me) about the principles of the agentic mesh.
The real MVP is the platform. The slide catalog, the semantic index, the Google APIs: that is the foundation that unlocked value. The agent only came after, and it could not have done anything without this foundation.
The agent is not a directive, it is an engineering product. The comparison table in the RATIONALE.md demonstrates this unambiguously. Off-the-shelf systems are a good starting point (I used one for Phase 1). But as soon as you need controlled parallelism, typed feedback loops, inter-step validation, and shared prompt caching, you are doing software engineering, not assembling directives.
ADRs are governance in action. 16 documented decisions in 4 weeks. The context, the alternatives considered, the consequences: it is all there. Governance is not in a wiki, it is in the decision trail.
The moat is in the domain, not in the technology. The catalog is the moat, not the Go code. This is Pillar 2 of the agentic mesh at work: “the responsibility for the agent falls on the business domain that leverages its value, not on a central AI team.”
The window is narrow. Generic tools will absorb agentic capabilities. The window to occupy the “persuasion slides” niche is 12 to 18 months. The land-grab is urgent.
The agentic mesh is not a diagram to hang on the wall. It is a trajectory to follow, and agentigslide is a waypoint on that path.