Note
Using Python for Agents no longer makes sense. For 0.7 we've moved to Go, with SDKs for other languages.
Stream Agents is a Go backend for building text, voice and video agents. You can build AI/agentic apps like Muse, Decagon and Harvey in a day.
- Agents are defined in a folder structure + YAML
- SDKs handle chat/audio client and state
- All the components you need are integrated with sensible defaults. (Guardrails, Knowledge, Routing, Connectors, Sandboxes, skills, telephony)
- Go runs with high concurrency and great performance
- The edge acceleration offloads your backend and lowers latency
- Audio forwarding is optimized with WARP similar to OpenAI
The combination of routing, persistence and memory makes it easy to switch the underlying models. Stay in control of how costs scale. Start with the frontier models and run your own when it makes sense.
The heavy lifting is done in Go. But you can use the agents in any environment:
Pick your backend language:
Then add chat, voice and video to your app with a client SDK:
The fastest way to define an agent is using the folder structure
You can quickly create a folder using the CLI
curl -fsSL https://getstream.io/cli.sh | bash
getstream agents init my-agent --template textThe structure looks something like this:
agents/my-agent/
knowledge/ ← indexed markdown and URLs
faq.md
urls.yaml
skills/ ← skills loaded as needed
research.md
simulations/
agent.yaml ← config for the agent
routing.yaml ← routing
instructions.md ← system prompt
guardrail.md ← prevent abuse
After you create an agent you can quickly test it
getstream agents test my-agentNote that you can also configure agents through the SDKs or dashboard.
You can create a session for persistence. After the session is created, you can uses responses.create across all supported LLMs.
import { Client } from "@stream-io/stream-agents";
const api = new Client({ apiKey: "your_api_key" });
await api.setUser("jlahey", userToken); // a token your backend minted for this user
const session = await api.agent("support").sessions.create();
await session.responses.create("Do I have any open support cases?");
for await (const event of session.events()) {
if (event.kind === "response_delta") console.log(event.text);
if (event.kind === "responded") break;
}Also note how the agent is referenced by use case. IE "support" and not the name of the model. The design here is that it should be trivial to switch from a frontier model to open or your own.
Full apps with chat, voice and tools, one per client SDK:
Any backend SDK can provide tools to the agent. Here's a Python based example:
import asyncio
from vision_agents.core.llm import ToolCallContext
from vision_agents.plugins import stream
agent = stream.Client().agent("my-agent")
@agent.register()
async def customer_case_lookup(tool_call_context: ToolCallContext) -> list:
"""Look up the user's open support cases."""
user = tool_call_context.user
if not user.id:
raise ValueError("unknown user")
await tool_call_context.update("Checking your open cases")
# pretend this calls your CRM
return await crm.open_cases(user.id)
async def main() -> None:
dispatch = stream.Dispatch()
dispatch.host(agent, tool_timeout=30)
await dispatch.run()
asyncio.run(main())- Simple chat: text, knowledge, skills, function calling, a connector and an MCP server
- Simple voice
- Inbound calling: answers a restaurant's number and takes an order
- Outbound calling: rings a candidate and screens them
- Video: security camera, avatar
- Artemis and Awesome No Moat: coming soon
- Acceleration: Go + Edge servers means amazingly fast agents
- Voice & Video
- Routing for LLM and STT
- Connectors for Slack/WhatsApp/Linear etc
- Tools & MCP
- Telephony: accepting calls and making calls
- Cost controls
- Memory & knowledge
- Chat/agent persistence, see sessions
- Sandbox/VM
- Search
Test your agent before it reaches a user. In a simulation one model plays the caller from a scenario you write, your agent answers as it would in production, and a judge model checks your assertion. Once it's live, watch every call on the dashboard. See simulations and evals.
See what each conversation and agent cost, and what each model cost and how often it failed. Set daily, weekly and monthly spend limits in USD on the organization, API keys, users, apps and teams. See spend limits.
Connectors give an agent a provider's tools, or let people talk to it on a messaging channel.
Add one in agent.yaml or the dashboard, with no code. Any other MCP server can be added as a
custom connector. See the connectors docs.
- Messaging channels: Slack bot, WhatsApp, SMS (Telnyx), iMessage (Linq)
- Communication: Slack, Gmail
- Documents: Notion, Google Docs, Google Drive
- Scheduling: Google Calendar, Calendly, Cal.com
- Project management and engineering: Linear, GitHub, Sentry
- Customers and revenue: Salesforce, HubSpot, Gong
- Commerce: Shopify, Instacart
- Analytics: BigQuery, Metabase
- Agent development speed
- Edge performance
- Agent concurrency
- Voice benchmark
How Stream Agents compares to the alternatives, see Stream vs alternatives:
- OpenAI or Anthropic directly
- Agent frameworks: Eve, AI SDK, LangChain
- Routers: OpenRouter, Bifrost, LiteLLM
- Voice AI frameworks: LiveKit, Pipecat, Retell, Agora, Vapi
- Support SaaS: Sierra, Decagon, Serval
You can run it yourself, or use the hosted version. Its free tier has generous limits:
- $25 of inference and other costs included
- 50k agent hosting minutes / month
- 150k AI infra text messages
- 500 concurrent agents
- 10k monthly active agent users
- 1M API calls
- 1M records storage
- Custom voices
- Team collaboration
Past those limits, usage costs:
| What | Price |
|---|---|
| AI voice infra | $0.002 / min |
| AI infra text | $0.0001 / message |
| Audio RTC | $0.30 / 1k participant min |
| SD video RTC | $0.75 / 1k participant min |
| Stored records | $1.50 / 1M after first 1M |
| Bandwidth | $0.10 / GB |
| Tokens, telephony, knowledge, search & other forwarded costs | cost + 5% + payment fees |
See agent pricing.