01
Canvas
Visual Pipeline Builder
Compose the run with a graph that already feels operational. Drag nodes, wire roles, and keep structure visible before the first token is spent.
MCP nativeInspectable workflowsLive mission control
Editorial orchestration layer
Build the mesh.Direct every handoff.
AgentMesh turns multi-agent orchestration into a surface you can actually direct. Build with MCP-native tools, watch every branch unfold, and keep human review in the loop without losing the shape of the run.
11
event types mapped
03s
handoff latency target
multi
agent roles on a single run
zero
black box steps
Parallel when safe. Human when needed.
Mission control
Watch the mesh think in public.
Live graph state
Active runcode review / live mesh
Router
decision layer
Research
github + web
Review
human gate
Synthesis
final brief
active step
handoff to reviewer
tool call
github.read_file
observability
timeline synced
Trace tape
Every transition stays readable.
router -> research01
research -> github.search02
review -> human gate03
handoff -> synthesis04
Run quality
97%
workflows still keep a clear audit trail after branching.
approvals inline
tools namespaced
Prompt -> Route -> Tool -> Handoff -> ReviewMCP serversHuman checkpointsLive graph stateEvent bus telemetryProductive, inspectable runsPrompt -> Route -> Tool -> Handoff -> ReviewMCP serversHuman checkpointsLive graph stateEvent bus telemetryProductive, inspectable runs
01 / System overview
Everything inspectable. Nothing hidden.
The platform connects the fragmented dots of modern AI orchestration. Observe parallel branch execution, control human handoffs, and manage agent logic from a single visual fabric.
02
Telemetry
Real-time Event Stream
Every activation, handoff, tool call, and exception has a visible, trackable place in the run.
03
Architecture
Parallel Execution
Fork when it buys speed. Rejoin without losing the plot. Parallel branches stay legible on the canvas layout.
04
Tooling
MCP-native Tools
Connect the tool fabric without inventing a second plugin system. HTTP, stdio, all in one native isolated namespace.
05
Security
Human-in-the-loop gates
Inline checkpoints when the run reaches risk limits. Approvals, timeouts, and review stay safely inside the graph.
06
Observability
Inspectable handoffs
Tool inputs, approval requests, raw message outputs, and token counts remain fully inspectable retrospectively.
02 / Control logic
From prompt to observable run.
Move past generic chatbots. AgentMesh enables step-by-step direction over specialized workers and tools—safeguarding production outcomes with an uncompromised audit trail.
Roles stay explicit
Tools stay namespaced
Events stay typed
01Build
Set up your agentic blocks and tools on the visual canvas. Define roles explicitly before execution begins.
nodes.add({ type: 'llm', role: 'synthesizer' })02Connect
Wire agents and tools together with defined handoffs. Inject human approval gates exactly where risk occurs.
edges.add({ source: 'router', target: 'approval' })03Run
Deploy the pipeline in Mission Control and see the live orchestration of complex token movement.
mesh.execute(pipeline_id, { stream: true })04Watch
Observe the real-time event bus. Every API call, parallel branch, and system failure is traced instantly.
Stream: [Agent Start] -> [Tool Search] ...
03 / Tech stack
Built for production scale.
We didn’t invent a new proprietary runtime. AgentMesh is a pure observability and control layer that wraps your existing multi-agent stack in a deterministic fabric.
LangGraphFastAPINext.jsPostgreSQLFastMCPWebSocketsLangGraphFastAPINext.jsPostgreSQLFastMCPWebSockets
01
Model layer
Model layer
Provider abstraction keeps orchestration stable while the model mix underneath it evolves.
Gemini
Groq
OpenAI
02
Tool layer
Tool layer
MCP servers expose capability in one consistent shape, from local filesystems to internal APIs.
stdio
http
namespaced tools
03
Control layer
Control layer
Routing, retries, approvals, and event telemetry live beside the run instead of outside it.
handoffs
approval gates
typed events
04 / Open source
Own the orchestration.
Built for teams scaling AI in production. Control execution flow, trace every tool call, and inject human safety gates without surrendering your architecture to black-box commercial platforms.
Start locally
Local entry point
$ cd frontend && npm run dev
Complete execution provenance.
Native multi-agent parallelization.
Aesthetic
editorial
Runtime
observable
Source
open