Architecture diagrams for agentic AI
A vetted, editable reference library of the agent topologies we ship in production — orchestration, action layers, retrieval, human gates, and private deployment — so you can design with patterns that already hold up.
- Orchestrator & worker topologies
- Governed action-layer patterns
- RAG & retrieval data flows
- Private / VPC deployment maps
The patterns in the library
Each diagram is annotated with where state lives, where humans intervene, and what gets logged — the parts most reference architectures leave out.
Single-agent loops
The plan–act–observe cycle for one agent, with memory, tool-call boundaries, and retry/backoff drawn in.
Orchestrator–worker fleets
A supervisor delegating to specialized workers, with hand-off contracts and shared-state boundaries.
Retrieval & RAG paths
Chunking, embedding, vector store, and re-ranking flows — and where retrieval feeds the agent vs. the user.
Action layer & approvals
The governed tool-call layer: risk thresholds, approval gates, and human-in-the-loop checkpoints made explicit.
Private deployment maps
VPC-isolated, hybrid, and air-gapped topologies showing exactly where data and inference stay inside your perimeter.
Observability & lineage
Where traces, decision logs, and cost telemetry attach so every action stays auditable end to end.
From diagram to deployment
The library is a starting point, not a finished spec. Here's the path most teams take.
Pick a pattern
Match your workflow to a topology family — one agent, a fleet, or a retrieval-heavy flow.
Mark the swap points
Drop in your models, frameworks, and systems at the annotated boundaries.
Add your perimeter
Overlay your security, approval, and data-residency constraints onto the deployment map.
Pressure-test it
Bring the redrawn diagram to a session and we'll find the gaps before you build.
The diagram is only honest if the boundaries are
Most reference architectures float in a vacuum — no perimeter, no approval gates, no record of who can do what. Ours draw the boundaries first: which steps run inside your VPC, which calls require a human, and which actions get logged.
That's deliberate. An agent topology that ignores governance looks clean on a slide and falls apart in production. Every diagram in the library shows the action layer, the human checkpoints, and the lineage trail as first-class parts of the design.
- Perimeter drawn before the agents
- Approval gates on high-risk actions
- Decision lineage as a design element
A whiteboard sketch vs. a reference diagram
Why a vetted pattern saves you a re-architecture three months in.
| A whiteboard sketch | A library reference diagram | |
|---|---|---|
| Boundaries | Implied | Perimeter and trust zones drawn in |
| State | Hand-waved | Where memory and context live, labeled |
| Oversight | Added later | Approval gates and lineage built in |
| Reuse | Lost after the meeting | Editable source you keep and adapt |
More from the reference shelf
Pair the diagrams with the briefs, models, and people behind them.
Frequently asked questions
What's actually in the library?
Editable reference diagrams for the patterns we ship most: single-agent loops, orchestrator–worker fleets, RAG retrieval paths, the governed action layer, and private/VPC deployment topologies — each annotated with where state, approvals, and logging live.
What format do the diagrams come in?
Vector source (draw.io / Excalidraw / Mermaid) plus exported SVG and PNG, so you can drop them into an RFC, a board deck, or your own architecture docs and edit the parts that don't match your stack.
Are these tied to a specific model or framework?
No. The topologies are framework-agnostic — they hold whether you orchestrate with LangGraph, CrewAI, AutoGen, Temporal, or something custom, and whether the model is Anthropic, OpenAI, or open-source. We annotate the swap points.
Can you adapt a diagram to our environment?
Yes. Bring your systems and constraints to a working session and we'll redraw the relevant pattern against your perimeter, data flows, and approval requirements — and scope what it takes to build.
Want a diagram drawn against your stack?
Bring a workflow and your constraints. We'll redraw the right pattern for your environment and scope the build.