You’ve built agents.
Now run them.
Not a framework. A runtime — session management, message routing, tool execution, memory, and agent-to-agent communication. Already wired.
CrewAI gives you agents. LangGraph gives you a graph. Neither gives you infrastructure.
CrewAI and LangGraph are agent frameworks. They solve the agent loop — the part where an LLM decides what to do next. That’s real, and it matters.
But it’s about 10% of what you need to run agents in production.
The other 90% is everything around the loop: session management so two runs don’t collide. Message routing so agent replies actually reach the user. Tool execution that composes without a sprawl of conditionals. Memory that persists across conversations. VM isolation so a rogue tool call can’t take down the system. Real-time event delivery to your frontend. Cron scheduling so agents can run on a timer. Auth, tenancy, observability.
That’s not a framework problem. That’s an infrastructure problem. And it’s what you end up building yourself — with Redis, Postgres, a WebSocket server, a homegrown task queue, and a lot of duct tape — because no framework provides it.
Vero Agents isn’t a better framework. It’s a different thing: a runtime. The infrastructure your agents need to actually run, not just think.
Trigger. Execute. Coordinate.
Trigger
A message arrives — from a user, a webhook, a cron job, or another agent. The runtime creates a session, resolves the agent's workspace, and enqueues the run on a FIFO session lane. No concurrent collisions. No manual locking.
Execute
The agent enters a multi-turn LLM loop (max 10 turns by default). Each turn: stream from Claude via custom SSE parser, execute tool calls through a decorator chain, append results, loop. Tools compose — brain, messaging, CRM, code execution, MCP integrations, device control — without conditionals. Static chain at startup, per-run handlers added based on what the agent can do.
Coordinate
Agents don't chat with each other. They write findings to a shared brain — a structured memory service with semantic, episodic, and graph storage. Other agents subscribe to scopes. When data appears, the brain pushes a notification. The coordinator doesn't poll. It registers a callback and goes idle until the brain wakes it. Zero agent-to-agent messages.
This is what “zero direct messages” actually looks like.
Walk through a real orchestration: an insurance call with 4 agents. Watch how they coordinate entirely through shared brain state.
- 1CCoordinator→plan_tasks + subscribe ×3Coordinator plans parallel lanes and registers brain callbacks — then goes idle.
- 2TTranscript→write_brain(transcript)Transcript agent writes a Hebrew STT chunk to shared brain state.
- 3BBrain→notify → SentimentTELEPATHYBrain subscription fires. Sentiment agent is notified — no one sent it a message.
- 4SSentiment←read_brain(transcript)Sentiment reads the transcript — automatically, through the brain.
- 5PPolicy→write_brain(history)Policy agent writes CRM customer history into shared state.
- 6BBrain→notify → SentimentTELEPATHYSecond brain callback fires. Sentiment cross-references transcript + history.
- 7SSentiment→write_brain(alert)ALERTSentiment writes an alert: frustration 0.82 · escalation 0.91.
- 8BBrain→callback → CoordinatorDECISIONBrain wakes the Coordinator. It reads full state and decides to escalate to a human.
“The Transcript agent didn’t send the Sentiment agent a message. It wrote to the brain. The brain notified the subscriber. Two agents coordinated without a single chat message, webhook, or API call between them. That’s telepathy.”
Your agents need a sandbox.
Not your production server.
When an agent runs untrusted code — web scraping, file manipulation, arbitrary tool calls — it shouldn’t run on your infrastructure. It should run in an isolated, disposable VM that boots in 125ms and dies when the agent is done.
Sandcastle is Vero’s execution environment for agent workloads. Secure microVMs. On-demand. Per-agent isolation. Three image tiers (base, browserbase, dev-machine), each with progressively more capabilities. Secrets injected at boot via MMDS — never written to disk.
5%
4 vCPUs
219 / 3943 MB
6% used
1.3G / 3.9G
34% used
0m
84
Running processes
1077122
- MCP Server12 tools, running on :3000. Any MCP-compatible agent framework can connect.
- REST APIon :8080. Trigger tools, read results, stream events.
- Headless Chromiumscreenshot, accessibility tree, JS execution, navigation.
- LiveKit streamingaudio capture for voice agent workloads.
- Secret injectionMMDS metadata service at boot. API keys, tokens, credentials — injected, never persisted.
What’s under the hood.
Session lanes
FIFO queues per agent/conversation/sender. No concurrent runs, no manual locking, no race conditions. Idle cleanup built in. Each lane is independent — one slow agent doesn't block another.
Decorator-based tool chains
Tools compose through a decorator pattern: brain → messaging → CRM → code → MCP → cron → spawn. Static chain at startup; per-run handlers added based on agent capabilities. No if-else routing. Add a new tool = add a decorator. Every tool degrades gracefully when unconfigured.
Three-tier execution
Same agent definition, three environments — In-process (conversational, lowest latency), Sandcastle microVM (isolated, untrusted tools), Anthropic-managed (hosted execution via Anthropic). The runtime routes based on config. Switch tiers by changing a value, not rewriting code.
Real-time message routing
Postgres for state, ClickHouse for analytics, Redis Streams for real-time events. WebSocket delivery to frontends. Agent replies route back through the messaging service to all conversation participants. Not bolted on — the messaging layer IS the coordination fabric.
This isn’t a framework comparison. It’s a category difference.
CrewAI and LangGraph are agent frameworks — they solve the LLM loop. Vero Agents is an agent runtime — it solves everything around it.
| CrewAI | LangGraph | Vero Agents | |
|---|---|---|---|
| What it is | Agent framework | Stateful graph framework | Agent runtime |
| LLM loop | Yes | Yes | Yes |
| Session management | No — you build it | No — you build it | FIFO lanes with idle cleanup |
| Message routing | No | No | Full messaging service (Postgres + ClickHouse + Redis) |
| Tool composition | Manual wiring | Manual wiring | Decorator chain, composable at startup |
| Inter-agent coordination | Agents chat with each other | State machine transitions | Brain telepathy — shared state, zero messages |
| Isolated execution | No | No | Sandcastle microVMs (~125ms boot) |
| Persistent memory | Bring your own | Bring your own | Built-in brain (semantic, episodic, graph, tasks) |
| Real-time frontend delivery | No | No | WebSocket + SSE + Redis Streams |
| Cron scheduling | No | No | Built-in poll-based scheduler |
| Agent-to-agent with governance | No | No | Allowlist-routed A2A |
| Auth & multi-tenancy | No | No | JWT + bearer token, row-level security |
CrewAI and LangGraph are good at what they do. But what they do is 10% of running agents in production. The other 90% is infrastructure — and that’s what Vero is.
Trigger an agent in one call.
# Trigger an agent run via gRPC
grpcurl -d '{
"agent_id": "coordinator",
"conversation_id": "call_8291",
"sender_id": "david-cohen",
"message": "I need help with my denied claim"
}' localhost:50051 agent.AgentService/TriggerRungRPC for agent execution. REST for messaging and admin. WebSocket for real-time delivery. SSE for event streams. MCP for sandbox tools. All authenticated, all tenant-scoped.
Built for agents that work together.
Customer service teams
An inbound call triggers a coordinator. It spawns a transcript agent, a policy agent, and a sentiment agent — all in parallel session lanes. They coordinate through the brain. The coordinator sleeps until a callback wakes it. Decision made in seconds.
Autonomous research teams
A research question triggers a planner. It spawns specialists — search, analysis, writing, review — each in a Sandcastle VM with isolated browser access. Findings flow to the brain. The planner synthesizes when all lanes complete.
Internal operations agents
Cron-scheduled agents that run daily — inventory, reports, compliance. Each agent has its own workspace, tool chain, and session lane. Results persist in the brain for downstream agents or human review.
Everything you’d spend 6 months building. Already done.
- Session management that doesn't race→FIFO session lanes
- Message routing between agents and users→Messaging service with Redis Streams
- Tool execution that doesn't explode→Decorator chain with graceful degradation
- Memory that persists across conversations→Brain service (semantic, episodic, graph, tasks)
- Isolation for untrusted agent tools→Sandcastle microVMs
- Real-time updates to your UI→WebSocket + SSE delivery
- Cron-triggered agent runs→Built-in scheduler
- Agent-to-agent communication with governance→Allowlist-routed A2A
- Multi-tenant auth→JWT + bearer token, row-level security
- Observability→Agent telemetry, run logs, event history
The waitlist is open.
Vero Agents is in early access. If you’re running multi-agent systems in production — or about to — we want to work with you. Waitlist members get:
- API access as soon as your account is provisioned
- A month of Pro-tier usage included
- Direct line to the engineering team
- First look at SDKs, MCP gateway, and self-hosted deployment