// agentic workflow simulator · the 60-second briefing
See how AI agents actually work — by watching one run.
agent-flow is a tiny, fully-mocked simulator. Pick an agent pipeline, press play, and watch it execute step by step — the real shape of an agentic run, with no model calls, no API keys, and nothing to spend. This page is the quick tour: a few ideas first, then what a real agent-to-agent system looks like and where each piece shows up on screen.
01 — a few ideas first
Six words that explain almost everything you'll see
Slight bits, on purpose. Enough to read the screen — not a course.
An LLM given a goal, some tools, and a loop. It reasons, calls a tool, reads the result, and repeats until the goal is met.
A function the agent may call — a web search, a database query, a code sandbox. The model decides when to use which.
Retrieval-Augmented Generation: fetch the relevant documents first, then answer grounded in them — with citations, instead of from memory.
Agent-to-agent. One orchestrator delegates sub-tasks to specialist agents and combines their answers — rather than one giant prompt doing everything.
Dependent steps wait their turn (embed → search → rerank). Independent ones run at once — so the clock is the slowest branch, not the sum.
A separate check that validates an agent's output before it's trusted or acted on: a fact-check, a policy limit, a refusal. This is what makes autonomy safe.
02 — the real thing
What a real agent-to-agent run actually looks like
Under the buzzwords, a production A2A system is a handful of moving parts. Here's the anatomy — and where each part shows up in the simulator.
-
1
The orchestrator plans
A supervisor agent reads the task and decides what to do, in what order, and what can happen at once. Patterns: orchestrator-worker, plan-and-execute, ReAct.
in the sim → the Planner / Orchestrator column
-
2
Work fans out to specialists
Independent sub-tasks are dispatched concurrently to scoped agents — a searcher, a security reviewer, a drafter — each with its own context and tools.
in the sim → the dashed ∥ parallel lane; the branches light up together
-
3
Agents talk through structured messages
A2A isn't free-text chatter. Agents exchange typed messages (JSON / function-calls) and share a scratchpad or memory store; the orchestrator scatters tasks and gathers typed results.
in the sim → the agent console — each stage logs its structured step
-
4
They reach the world through tools & retrieval
Agents don't “know” things — they call tools: vector search (approximate-nearest-neighbour over embeddings), rerankers, web search, code execution.
in the sim → the “under the hood” panel names the real algorithm + libraries
-
5
Results are merged, then verified
A reduce stage dedups and combines the branches; a verifier fact-checks the claims, or a guardrail gates the output — before anything is returned or acted on.
in the sim → the Merge / Aggregate and Fact-check / Policy columns
-
6
The clock is wall-clock, not sum
Because the fan-out ran concurrently, total latency is the slowest branch — not the total work. This is the whole reason to orchestrate agents instead of chaining them.
in the sim → TOKENS sums the branches; ELAPSED takes the max
In the wild this is built with LangGraph, CrewAI, AutoGen, OpenAI Swarm, the emerging A2A protocol, and MCP for tools. agent-flow imitates their shape, not their code.
03 — the honest part
What's real here, and what's mocked
- the stages, and their order, of a genuine agentic run
- the fan-out / fan-in of true parallel execution
- the algorithms & libraries named in “under the hood”
- the parallel = max timing math
- no LLM, no network, no vector DB, no keys
- zero tokens spent — nothing leaves your browser
- every log line, token count & latency is scripted
- fully deterministic — the same run, every time
Think of it as a wiring diagram you can press play on — a storyboard for how agentic systems execute, not a runtime.
That's the whole idea. Go watch one run.
Launch the simulator →pick a workflow from the top-right and press play