Agent Stack turns an agent into an HTTP service without rewriting it

The claim is a service, not a library

The framing is deliberately about infrastructure rather than about agents. Agent Stack is described as open infrastructure for turning AI agents into running services in minutes, and the summary line is build agents, run them as services, call them from your app. The table makes the promise concrete: run agents as services, exposing them over HTTP for consumption in real applications and calling them like any other backend service. There is a fast local dev loop so you can spin agents up locally and iterate, no agent rewrites, because you wrap existing agents and run them as-is, and a deployment-ready architecture, because the same agents move from local to deployed environments. The stated goal is that you can ship agent-powered features without building deployment infrastructure from scratch, and the vendor lock-in argument is the reason it is hosted by the Linux Foundation.

The install is one script and the CLI covers the loop

Installation is a single shell command, and the tool notes that it works on Linux and macOS, with manual setup and experimental Windows support in the quickstart guide:

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

The command surface afterwards is small enough to learn in a minute:

agentstack ui                           # Launch web interface
agentstack list                         # See what agents are available
agentstack run chat "Hi, who are you"   # Send a message to chat agent
agentstack run chat                     # Try interactive mode
agentstack info chat                    # View agent details
agentstack --help                       # See all options

So there is a web interface for testing and sharing agents, a list of what is available, a run command that takes a message or goes interactive, and an info command for the details of one agent. Building your own agent is a starter repository and a single command to start it:

git clone https://github.com/i-am-bee/agentstack-starter my-agent
cd my-agent
uv run server               # Start your agent

and then, from another terminal, `agentstack run example_agent "Alice"` should print Ciao Alice. The use of uv rather than pip or a virtualenv is a small signal about the intended audience.

Nine components, each replaceable

The core capabilities table is the real specification. The agent runtime is a self-hostable server for running agents in production. The LLM and AI services give an LLM service with support for more than fifteen providers, naming Anthropic, OpenAI, watsonx.ai and Ollama, plus embeddings and vector search for retrieval augmented generation. The deployment and management side is a CLI for deploying, updating and managing agents. Storage and documents cover S3-compatible file storage for uploads and downloads and document text extraction via Docling. Interfaces and tooling are an out-of-the-box web UI for testing and sharing agents plus a client SDK for custom interfaces. Integrations are external ones over the MCP protocol, covering APIs, Slack and Google Drive with OAuth. Security is secrets management for API keys and credentials plus OAuth for external integrations. Deployment is a Helm chart for Kubernetes with customizable storage, databases and authentication. And framework interoperability means you can build agents with LangGraph, CrewAI or your own framework, with all agents automatically exposed as A2A-compatible ones.

Everything ships with defaults you are expected to replace

There is a note under the capabilities table that changes how you should read the rest of the documentation. Agent Stack ships with fully functional defaults to get you running quickly, and every component is modular and can be replaced to integrate with your organisation's existing services, providers and infrastructure. That is a design position rather than a feature list, and it has a consequence. If you are deploying this into an environment with existing services, the work is in replacing those defaults, and the fact that they are modular is the point. The Helm chart is described as having customizable storage, databases and authentication, which is the deployment-side counterpart of the same idea.

The reference agents show the feature set in use

The reference agents are what turns the capability table into something you can read. The Showcase is a full-featured chat assistant demonstrating a requirement agent with conditional tool use, web search through DuckDuckGo, an advanced reasoning tool, file handling for PDF, CSV and JSON, streaming, UI feature toggles, trajectory logging and citation extraction. The Serper Search Agent shows runtime secrets management, a custom tool for web search, automatic query term extraction and structured results with citations. The GitHub Issue Writer is a single-turn workflow using the form extension for multi-field input, a reasoning tool and Markdown formatting. The Vulnerability Agent scans a GitHub repository's Python dependencies for known vulnerabilities, writes remediation issues and posts them in the repository. The built-in Chat Agent is a multi-turn conversational agent with a clarification tool for ambiguous queries, integrating DuckDuckGo, Wikipedia and OpenMeteo with file tools, streaming, citation extraction and OpenTelemetry instrumentation, and there is a Form Agent for single-turn form interaction.

The repository is a workspace with an agent registry

The top level of the repository shows the shape of the project. There is an `agents/` directory holding the built-in agents such as the chat and form agents, an `apps/` directory, a `helm/` directory for the Kubernetes chart, `skills/`, `examples/`, `docs/` and a `tasks.toml`. Two files stand out. `agent-registry.yaml` is the registry the agents are discovered through, which matches the `agentstack list` command. And `policy.yaml` is a policy file at the root, which suggests the project has a mechanism for expressing rules rather than only configuration. There is also an `.agent/` directory and an `.aiignore` file, so the repository itself is set up to be worked on by an agent, with a `CLAUDE.md`, a `mise.toml` and lock files for mise and pnpm, and a `pnpm-workspace.yaml` marking it as a pnpm workspace. The licence is Apache 2.0 and the last push to the main branch was on 2026-10-13, with the most recent release v0.7.1 from 2026-03-30.

Editorial conclusion

Adopt Agent Stack if you are past the prototype stage with an agent and need it to run as a service you can call from an application, since the runtime, the storage and the deployment tooling are the parts you would otherwise build. Do not adopt it if you need a single local script, because the value of the project is the surrounding infrastructure rather than the agent itself. Verify first that the framework your agent is written in is one of the supported ones, that the LLM provider you use is on the list, and that the defaults for storage and authentication meet your requirements, since the project ships working defaults that you are expected to replace.

Frequently asked questions

Official sources

1. i-am-bee/agentstack on GitHub
2. License: Apache-2.0
3. Project website
4. README
5. Releases