Platform & roadmap
An honest snapshot of what the AgentRoute SDK ships today and what is still on the roadmap.
AgentRoute is pre-1.0 and moving fast. This page is the single source of truth for what you can build on today versus what is still being designed. We would rather under-promise here than have you wire your code to an API that does not exist yet.
The short version: the Python SDK is real and stable enough to build on — agents, tools, memory, history, structured output, retries, and multi-provider models all work today. The hosted platform (deployment, monetization, agent-to-agent discovery) is still being finalized. Anything described as "roadmap" below is not callable yet; do not design around it.
Everything in the Quickstart works against a real OpenRouter key. Define an Agent, give it tools, attach memory and a history policy, and get structured output back — all locally, no platform account required. Start there.
Available now (SDK v1.1.0)
These features are shipped in agentroute v1.1.0 on PyPI and documented across the SDK reference. Each one is runnable today.
The core Agent class with a sync run() and async arun(), a tool-calling loop bounded by max_turns, and an optional max_cost budget.
The @agent.tool and @tool decorators. Schemas are auto-derived from type hints and docstrings. A ctx: Context parameter is injected automatically and hidden from the model.
In-RAM Memory and persistent MemorySQLite (SQLite + FTS5 full-text search). Both store conversation messages and key/value facts that survive across runs.
HistorySlidingWindow, HistoryTruncate, and HistorySummarize keep long conversations inside the context window.
Pass output=PydanticModel and read a typed instance from result.output. Add @agent.output_validator and raise Retry(...) to repair bad responses.
Bounded retries, plus ErrorMaxTurns and ErrorBudget so a runaway loop or cost overrun fails loudly instead of silently.
resolve_model() routes any model string through OpenRouter by default, or to Ollama and custom OpenAI-compatible endpoints. One key works for every model.
await agent.arun(...) is a first-class entrypoint. Run many agents concurrently today with plain asyncio.gather over arun.
Here is the surface area in one block. If your code uses only these names, it runs against v1.1.0:
from agentroute import (
Agent, Context, Usage,
Tool, tool,
Memory, MemorySQLite,
History, HistorySlidingWindow, HistorySummarize, HistoryTruncate,
Model, resolve_model,
Result, ResultDeploy,
Retry, ErrorAgent, ErrorMaxTurns, ErrorBudget,
)
agent = Agent("assistant", model="claude-sonnet-4")
print(agent.run("Hello"))On the roadmap (not available yet)
The features below are part of the AgentRoute vision but are not callable in the current SDK or CLI. Treat anything here as forward-looking. We will move each item up to "Available now" — with reference docs — as it ships.
None of the APIs in this section exist in v1.1.0. There is no agent.deploy(), agent.stream(), Team, Company, MCP, guardrail, or A2A surface you can import and call today. If you find a snippet that uses one, it is aspirational.
Hosted deployment & monetization
The headline of AgentRoute — push an agent, get a URL, and get paid per call — is still being finalized. The current agentroute deploy CLI command predates the v1.1 SDK: it imports your agent.py, probes legacy attributes, and calls a deploy method that the current Agent class does not expose. See the CLI reference for exactly what it does today.
agentroute deploy reflects the platform's intended shape, not a working hosted runtime. The ResultDeploy(url, status, agent_card_url) type ships as a placeholder for that future flow. Build and run your agents locally for now — they are fully functional without the platform.
The metered-billing layer ("get paid per call") that turns a deployed agent into a product is part of the same hosted milestone and depends on it landing first.
Native multi-agent (Team / Company)
There is no Team or Company primitive, and no agent.use(other_agent). Native orchestration is on the roadmap.
You do not have to wait to build multi-agent systems, though. Construct several specialized Agent instances and coordinate them with plain Python — call agent.run() in sequence, or asyncio.gather over agent.arun() for fan-out:
import asyncio
from agentroute import Agent
researcher = Agent("researcher", model="claude-sonnet-4",
instructions="Gather facts. Be terse.")
writer = Agent("writer", model="claude-sonnet-4",
instructions="Turn notes into a clear paragraph.")
async def pipeline(topic: str) -> str:
notes = await researcher.arun(f"Research: {topic}")
draft = await writer.arun(f"Write up these notes:\n{notes.output}")
return draft.output
print(asyncio.run(pipeline("the history of the espresso machine")))Native Team/Company orchestration and agent-to-agent (A2A) discovery will replace the hand-rolled glue above. Until then, plain Python over arun covers most coordination patterns. See the orchestration examples for fuller patterns.
Agent-to-agent (A2A) discovery & calls
A registry where agents discover and call each other directly — and the agent-card format that advertises an agent's skills — is on the roadmap. There is no A2A client, no to_agent_card(), and no skill-discovery API in the current SDK. The agent_card_url field on ResultDeploy is a placeholder for this future flow.
Guardrails
Input/output guardrails (policy checks, content filters, schema gates that run alongside the agent loop) are planned. Today the closest tool is an output validator — a @agent.output_validator that inspects result.output and raises Retry(...) to force a redo. It validates the final structured output; it is not a general guardrail layer.
MCP tool integration
Connecting agents to hosted Model Context Protocol servers and browser tooling is forthcoming. For now, write your own tools — a plain Python function is all a tool is:
import httpx
from agentroute import Agent
agent = Agent("fx", model="claude-sonnet-4")
@agent.tool
def exchange_rate(base: str, quote: str) -> float:
"""Get the current FX rate between two currency codes."""
r = httpx.get(f"https://api.example.com/rate/{base}/{quote}", timeout=10)
r.raise_for_status()
return r.json()["rate"]
print(agent.run("How many USD is one EUR?"))When hosted MCP lands, these hand-written tools keep working — MCP is additive.
Streaming
Token-level streaming is forthcoming. The plumbing exists in the type system — Event(kind, data) with EventKind of text_delta, tool_call_start, tool_call_end, agent_start, agent_end — but there is no agent.stream() entrypoint to consume it yet. Use run() / arun() and read the full Result for now.
TypeScript SDK
The TypeScript SDK is currently a stub. The supported, fully-featured client is the Python SDK documented across this site. If you need TypeScript today, call a Python agent behind your own HTTP endpoint.
How to read this page over time
When something moves from roadmap to shipped, two things change: it gets a reference page under /sdk/... or /cli/..., and it appears in the changelog. If a feature has no reference page and is not in the changelog, assume it is not available yet — no matter what an example elsewhere might suggest.