Welcome - Agent Stack

Writing an agent is easy. Shipping one is not. Agent Stack gives you everything you need to run agents as backend services: LLM routing, vector storage, authentication, file handling, and deployment tooling out of the box. You write agent logic in any framework. Agent Stack provides the infrastructure so you can ship to users in minutes, not weeks.

Component	What’s Included
Agent Runtime	- Self-hostable server to run agents in production
LLM & AI Services	- LLM service with support for 15+ providers (Anthropic, OpenAI, watsonx.ai, Ollama) - Embeddings and vector search for RAG and semantic search
Agent Deployment & Management	- CLI for deploying, updating, and managing agents
Storage & Documents	- S3-compatible file storage for uploads and downloads - Document text extraction via Docling
Interfaces & Tooling	- Out-of-the-box Web UI for testing and sharing agents - Client SDK for building custom UIs and applications
Integrations	- External integrations via MCP protocol (APIs, Slack, Google Drive, etc.) with OAuth
Security	- Secrets management for API keys and credentials - OAuth support for secure external integrations
Agent Stack Deployment	- Helm chart for Kubernetes with customizable storage, databases, and authentication
Framework Interoperability	- Build agents using LangGraph, CrewAI, or your own framework - Agents are automatically exposed as A2A-compatible agents - `agentstack-sdk` handles runtime service requests and agent-to-agent communication

Get running in one command

Start a complete agent runtime locally — models, storage, and services included.

sh -c "$(curl -LsSf https://agentstack.beeai.dev/install.sh)"

You now have a working environment for running agents as services.

Follow the quickstart for full installation instructions and requirements.

Getting from “agent” to “running service” is harder than it should be

When you go from running your agent locally to powering a real application, you run into a wall of infrastructure work:

Choosing and wiring an LLM gateway
Configuring vector storage and embeddings
Handling auth, secrets, files, and artifacts
Making local experiments behave the same way in deployment
Rebuilding everything once production enters the picture

Agent Stack removes that friction. It gives you a ready-made runtime for running agents as services, so you can focus on agent logic instead of infrastructure glue. With Agent Stack:

Agents run locally and in deployed environments without major refactoring
Agents are exposed as stable, callable services
Applications can integrate with agents like any backend dependency
Infrastructure is decoupled from application logic

You keep full freedom in how agents are authored. Agent Stack standardizes how agents are run, deployed, and integrated.

How does it work?

Agent Stack runs agents as services alongside your applications.

Application
    |
    |  SDK / HTTP
    v
Agent Stack (agent services)
    |
    v
LLMs • Vector Store • Auth • Files

Agent Stack provides sensible defaults for instant usability. However, it’s fully pluggable, giving you the freedom to swap in your own custom services and configurations whenever needed.

Getting started

1. Wrap an existing agent

Agent Stack lets you take an agent you already have and expose it as a service by providing the sensible infrastructure defaults they need. Here’s an example wrapping a simple agent function:

uv add agentstack-sdk

import os

from a2a.types import Message
from a2a.utils.message import get_message_text
from agentstack_sdk.server import Server
from agentstack_sdk.server.context import RunContext
from agentstack_sdk.a2a.types import AgentMessage

server = Server()

@server.agent()
async def example_agent(input: Message, context: RunContext):
    """Polite agent that greets the user"""
    hello_template: str = os.getenv("HELLO_TEMPLATE", "Ciao %s!")
    yield AgentMessage(text=hello_template % get_message_text(input))

def run():
    server.run(host=os.getenv("HOST", "127.0.0.1"), port=int(os.getenv("PORT", 8000)))


if __name__ == "__main__":
    run()

uv run example_agent.py

Your agent can be:

A LangGraph workflow
A custom reasoning loop
A thin wrapper around an LLM call

Agent Stack doesn’t care—as long as it can be executed.

2. Deploy the agent as service

Run the agent locally or on infrastructure you control.

uv run example_agent "Emily"

Your agent is now running as a backend service.

3. Call the agent from your application

Integrate the agent into your app using the Client SDK, HTTP API, or our out of the box UI extensions. Agent Stack takes care of running and deploying agents so you can wire them into your application like any other backend service.

What Agent Stack is (and isn’t)

Agent Stack is:

A bundled runtime for deploying agent services
Optimized for experimentation and fast iteration
Flexible enough to grow with you from local testing to a sandboxed deployment platform

Agent Stack isn’t:

An agent building framework
A hosted AI service
A replacement for enterprise AI platforms

Getting help, contributing, and staying up to date

Agent Stack is an open-source project maintained as part of the Linux Foundation community.

Documentation: Start here for guides and examples
Issues: Use GitHub Issues to report bugs or request features
Discussions: Use Github Discussions to ask questions, share ideas, and compare approaches
Contributing: Contributions are welcome— see the contributing guide for details

Agent Stack is being actively developed and intended to evolve alongside the agent ecosystem. Defaults may change, components may improve, but the goal remains the same: make agents easy to run, easy to deploy, and easy to integrate.

Quickstart

Get up and running in one command

Wrap Existing Agents

Deploy your existing agents to Agent Stack

Build New Agents

Build your first agent with the SDK

Deploy to Production

Deploy Agent Stack to Kubernetes for your team

​Get running in one command

​Getting from “agent” to “running service” is harder than it should be

​How does it work?

​Getting started

​1. Wrap an existing agent

​2. Deploy the agent as service

​3. Call the agent from your application

​What Agent Stack is (and isn’t)

​Getting help, contributing, and staying up to date

Quickstart

Wrap Existing Agents

Build New Agents

Deploy to Production

Get running in one command

Getting from “agent” to “running service” is harder than it should be

How does it work?

Getting started

1. Wrap an existing agent

2. Deploy the agent as service

3. Call the agent from your application

What Agent Stack is (and isn’t)

Getting help, contributing, and staying up to date