RunAgent

Overview

RunAgent is a framework-agnostic agent deployment platform that provides a standardized way to serve AI agents as REST and WebSocket APIs, regardless of which framework they were built with.

The project's tagline is apt: "MCP for Agent Deployment." Just as MCP solved the "how do I call tools from an LLM" problem by standardizing tool invocation, RunAgent attacks the dual problem: "how do I deploy and consume agents across languages?" Currently LangGraph, CrewAI, AutoGen, OpenAI Agents SDK, Pydantic AI, LlamaIndex, Letta, and Agno agents can all be served through the same REST + WebSocket interface.

RunAgent solves three concrete pain points that any team shipping agents has hit:

1. Repetitive REST/WS boilerplate — every framework needs its own server wrapper
2. Cross-language streaming — serializing token streams to non-Python clients is painful
3. Invocation monitoring — tracing, latency, and error budget observability differ per framework

The multi-language SDK story is the headline: official SDKs exist for Python, JavaScript/TypeScript, Go, and Rust, with C# and Java on the roadmap.

Features

• Framework-agnostic deployment: one agent.yaml config file deploys agents from any supported framework
• SDKs in four languages: Python, JavaScript/TypeScript, Go, Rust
• Dual transport: REST for simple calls, WebSocket for streaming tokens and events
• Unified API surface: the same interface regardless of whether the underlying agent is LangGraph or CrewAI
• Streaming serialization: cross-language token streaming with consistent semantics
• Invocation monitoring: request tracing, latency histograms, error rates out of the box
• Framework adapters: drop-in adapters for LangGraph, CrewAI, AutoGen, OpenAI Agents SDK, Pydantic AI, LlamaIndex, Letta, Agno
• Open-source core: self-hostable, with a hosted platform option

Installation

# Python SDK
pip install runagent

# JavaScript / TypeScript
npm install @runagent/sdk

# Go
go get github.com/runagent-dev/runagent-go

# Rust
cargo add runagent

# CLI (for packaging an agent project)
pip install runagent-cli

Configuration

Create agent.yaml in your project root:

agent:
  name: research-agent
  version: 1.0.0

framework:
  type: langgraph            # or crewai, autogen, openai-agents, pydantic-ai, llama-index, letta, agno
  entrypoint: main.py:agent

runtime:
  port: 8080
  stream: true               # enable WebSocket streaming
  max_concurrency: 10

observability:
  tracing: true
  metrics: true

Quick Start: Deploy a LangGraph Agent

# main.py
from langgraph.graph import StateGraph, START, END
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o")

def summarize(state):
    return {"output": llm.invoke(f"Summarize: {state['input']}")["content"]}

graph = StateGraph(dict)
graph.add_node("summarize", summarize)
graph.add_edge(START, "summarize")
graph.add_edge("summarize", END)

agent = graph.compile()

Deploy it:

runagent deploy --config agent.yaml

Consume it from Go:

package main

import (
    "context"
    "fmt"

    "github.com/runagent-dev/runagent-go"
)

func main() {
    client := runagent.NewClient("http://localhost:8080")

    ctx := context.Background()
    result, err := client.Invoke(ctx, "research-agent", runagent.Message{
        Content: "What is MCP?",
    })
    if err != nil {
        panic(err)
    }
    fmt.Println(result.Content)
}

Streaming from TypeScript

import { RunAgentClient } from "@runagent/sdk";

const client = new RunAgentClient({ baseUrl: "http://localhost:8080" });

const stream = await client.stream("research-agent", {
  messages: [{ role: "user", content: "Explain LangGraph" }],
});

for await (const chunk of stream) {
  process.stdout.write(chunk.token ?? "");
}

Rust Client

use runagent::{Client, Message, Role};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let client = Client::new("http://localhost:8080");

    let resp = client.invoke("research-agent", Message {
        role: Role::User,
        content: "What is CrewAI?".into(),
    }).await?;

    println!("{}", resp.content);
    Ok(())
}

Framework Adapters

RunAgent bundles adapters for each supported framework. Adding the adapter is typically a 2-line change:

CrewAI

from runagent.crewai_adapter import wrap_crew

crew = Crew(agents=[researcher, writer], tasks=[task], verbose=2)
agent = wrap_crew(crew)

OpenAI Agents SDK

from runagent.openai_agents_adapter import wrap_openai_agent
from agents import Agent, Runner

my_agent = Agent(name="researcher", instructions="Be concise.")
agent = wrap_openai_agent(my_agent)

Pydantic AI

from pydantic_ai import Agent as PydanticAgent
from runagent.pydantic_adapter import wrap_pydantic

agent = wrap_pydantic(PydanticAgent("openai:gpt-4o", system_prompt="Be helpful."))

Pros

• ✅ Framework-agnostic: same REST/WS API regardless of underlying framework
• ✅ Multi-language SDKs: Python, JS/TS, Go, Rust, with C# and Java coming
• ✅ Streaming-first: consistent token-streaming across languages
• ✅ Standard agent.yaml: declarative, version-controllable deployment config
• ✅ Invocation observability: traces, metrics, and error rates built in
• ✅ Open-source core: self-hostable
• ✅ Solves real pain: repetitive REST boilerplate is genuinely tedious

Cons

• ❌ Small community: ~100 GitHub stars, one core maintainer
• ❌ Requires re-packaging: agents must be wrapped with the framework adapter, not zero-config
• ❌ No built-in persistence: durable state and checkpointing are delegated to the underlying framework
• ❌ Adapter lag: framework adapter updates can trail framework releases by days or weeks
• ❌ No auth by default: adding auth is left to the operator
• ❌ Deployment semantics are new: agent.yaml is still evolving, breaking changes possible

When to Use

Use RunAgent when:

• You have agents in multiple frameworks and need a single consumer API
• Your consumers are in different languages (Python services calling Go agents, Rust CLIs calling LangGraph)
• You're building an internal agent platform and want to standardize the serving layer
• You need WebSocket streaming to non-Python clients without writing a wrapper yourself

Prefer alternatives when:

• All your agents are in one framework — the framework's own deployment docs are simpler
• You're already using LangGraph Platform — it has native deployment, auth, and observability
• You want managed deployment with no infra — consider Databricks Agent Orchestration or Vercel AI SDK deployment
• You need heavy security controls — you'll need to add auth/mTLS yourself

Resources

• GitHub Repository
• Show HN discussion
• MCP spec (for context)
• LangGraph Platform