Skip to main content
RunAgent lets you deploy Python-based AI agents and access them from any language with full streaming support.

​
Key Benefits

  • 🚀 Deploy agents in minutes (serverless, sandboxed microVMs)
  • 🌐 Access from Python, JS, Go, Rust with native-feeling SDKs
  • ⚡ Built-in autoscaling + token streaming for real-time applications

​
Quick Actions

👉 Deploy your first agent

Get started with a complete tutorial

👉 Use frameworks

Integrate with popular AI frameworks

👉 Explore SDKs

Access agents from any language
Hero Light

​
The Problem Every AI Developer Faces

Suppose you’ve built an incredible AI agent in Python. It uses LangGraph for complex reasoning, leverages powerful tools, and produces amazing results. Your team loves it!

​
Then reality hits:

Your whole team is excited to use it! But the frontend team needs to access it in JavaScript, your mobile app team wants it in Kotlin, your Unity team wants it in good old C#, your systems team requires it in Rust.

​
The traditional approach?

Build separate implementations, REST APIs, WebSocket handlers…
Sound exhausting? That’s because it is!

​
What RunAgent Actually Does

RunAgent fundamentally changes how AI agent deployment works. Your Python function signatures automatically become API contracts (REST or Streaming) for every supported language.
Once runagent.config.json of your project points to your Python function, they are automatically converted to corresponding API endpoints, and all language SDKs automatically adapt. No API versioning, no breaking changes.
The fastest way to experience the magic is with RunAgent CLI:
1

Install the RunAgent CLI

This installs the powerful RunAgent CLI, which is used to deploy and manage your agents.
pip install runagent
2

Initialize Agent

Let’s start with our minimal Agent example.
runagent init my_agent
cd my_agent
3

Setting Up RunAgent config file

Somewhere in your Agent codebase (in this case main.py)
main.py
def mock_response(message, role="user"):
  """Test the mock agent with non-streaming responses"""
  ...
  return response.content
This mock_response function is one of the invocation functions for our agent, so we will add this in runagent.config.json file:
"entrypoints": [
  {
    "file": "main.py",
    "module": "mock_response",
    "tag": "minimal"
  }
]
4

Run the Agent (Locally)

runagent serve .
And you will see output similar to:
🤖 Agent Details:
- Agent ID: f7066c98-0eb2-488c-bb37-a869a93d51ce
- Host: 127.0.0.1
- Port: 8451
- Framework: default
- Status: ready

🌐 Server running at: http://127.0.0.1:8451
📖 API Documentation: http://127.0.0.1:8451/docs

📍 Available endpoints:
- POST /api/v1/agents/.../execute/minimal - Run your agent

INFO: Uvicorn running on http://127.0.0.1:8451 (Press CTRL+C to quit)
That’s it, your agent is running, and is accessible through standard REST-api as well as all RunAgent SDKs.
5

Use in your application

Using the RunAgent SDKs, you can use your agent in your application, only using the agent ID and the entrypoint tag. Your agentic entrypoint (mock_response function) now becomes accessible in:
from runagent import RunAgentClient

ra = RunAgentClient(
    agent_id="f7066c98-0eb2-488c-bb37-a869a93d51ce",
    entrypoint_tag="minimal",
    local=True
)

agent_result = ra.run(
    role="user",
    message="Analyze the benefits of remote work for software teams"
)
…and you’re ready to deploy your AI agents & use them in the futuristic software you are building. We will ❤️ to hear about it. Hit us up on Discord.

​
Agent Framework Support

RunAgent works with any Python-based AI agent framework:

LangGraph

Deploy your LangGraph agents with built-in state management and workflow execution.

CrewAI

Deploy multi-agent CrewAI systems with coordinated execution and monitoring.

AutoGen

Deploy Microsoft AutoGen multi-agent conversations with step-by-step execution.

AG2

Deploy AG2 conversational agents with fact-checking and multi-turn interactions.

Agno

Deploy Agno AI agents with print response capabilities and streaming support.

Letta

Deploy Letta memory-enabled agents with persistent conversations and tool integration.

Custom Framework

Use any Python-based framework by defining simple entrypoint functions.

​
Multi-Language SDK Support

RunAgent provides native-like access to your deployed agents across multiple languages:

Python SDK

Python client with streaming capabilities. Access your agents like local functions with full type safety and Python idioms.

JavaScript SDK

Full TypeScript support with streaming and Promise-based APIs. Perfect for modern web applications with async/await patterns.

Rust SDK

High-performance async SDK with futures and streaming support. Zero-cost abstractions for systems programming and performance-critical applications.

Go SDK

Idiomatic Go client with context-aware operations and channel-based streaming. Built for concurrent, scalable applications.

All Language SDKs

We’re actively developing SDKs for additional languages including C#, Java, and PHP. Want to contribute or request a specific language? Join our Discord community.

​
Real-Time Streaming Across Languages

In addition to REST API like responses, you can also stream your agent response super-easily through our SDKs. When your targeted entrypoint streams response, RunAgent makes it feel native in every language SDK:
1

Setting Up RunAgent config file

Somewhere an Iterator in your Agent codebase (in this case main.py)
main.py
def mock_response_stream(message, role="user") -> Iterator[str]:
  """Test the mock agent with streaming responses"""
  ...
  return response.content
This mock_response_stream function will return an Iterator, and to stream this response, we will add this in runagent.config.json file, as another entrypoint:
"entrypoints": [
  {
    "file": "main.py",
    "module": "mock_response_stream",
    "tag": "minimal_stream"
  }
]
The tag for a Streaming Entrypoint must end with a _stream suffix. That is how RunAgent identifies it for streaming.
2

Run the Agent (Locally)

Spin up the agent just like we did before. But now we have an additional streaming entrypoint.
runagent serve .
3

Use streaming in your application

Using the RunAgent SDKs, you can use your agent in your application, only using the agent ID and the entrypoint tag. Your agentic entrypoint (mock_response function) now becomes accessible in:
from runagent import RunAgentClient

ra = RunAgentClient(
    agent_id="f7066c98-0eb2-488c-bb37-a869a93d51ce",
    entrypoint_tag="minimal_stream",
    local=True
)

for chunk in ra.run(
  role = "user",
  content = "Analyze the benefits of remote work for software teams"
):
    print(chunk)
What’s happening: WebSocket connections, real-time data flow, and native iteration patterns—all handled automatically by RunAgent.