Shared AI agents for teams. Talk to an agent in Slack, give it your tools, and let it run real work in a sandbox. Features • Overview • Getting Started • Documentation Features Slack-native agent conversations : mention the bot in Slack and get progress plus final answers back in the thread. Real execution environment : each conversation runs in an isolated Kubernetes sandbox with a shell, workspace, git, Python, Node.js, Bun, and common development tools. Bring your own harness : run CLI-based agents such as Amp, Claude Code, Codex, or deployment-specific harnesses. Shared tools : add Python tool plugins once and make them available to every agent conversation. Durable workflows : run jobs that can sleep, resume, wait for events, start child agents, and survive service restarts. Credential boundaries : agents can use approved services without receiving raw API keys in their environment. Replayable state : messages, executions, events, and delivery state are stored so clients can reconnect without losing the result. Organization overlays : layer in your own tools, workflows, personas, skills, and prompts without forking the base platform. ...and a lot more. Overview Centaur is a self-hosted agent platform for teams that want one shared agent instead of many one-off local setups. text 1. Ask from Slack. @centaur can you figure out why the billing tests are failing? 2. Centaur assigns a sandbox for the thread. The agent can inspect code, run commands, and call approved tools. 3. Progress and the final answer are delivered back to Slack. You can also drive Centaur directly through the API: text POST /agent/spawn # assign or reuse a sandbox POST /agent/message # store the user turn POST /agent/execute # start the agent GET /agent/threads/{thread_key}/events The platform handles sandbox lifecycle, durable transcript storage, tool access, credential injection, workflow execution, and final delivery. What Centaur Is Good For investigating CI failures answering questions with internal tools summarizing Slack threads or customer context running recurring checks and digests coordinating multi-step operational workflows giving agents access to a real repo and test environment standardizing agent behavior across a team How It Works text Slack or API | v Centaur API | +-- Postgres durable state +-- tool and workflow registry +-- sandbox assignment | v Kubernetes sandbox | +-- agent harness +-- workspace and shell +-- API-mediated tool calls | v Controlled outbound access The main directories are: services/api — control plane for agents, tools, workflows, auth, and durable state services/slackbot — Slack event handling and Slack delivery services/sandbox — agent container image and harness adapter iron-proxy ( service ) — controlled outbound access and credential injection tools — tool plugins workflows — workflow plugins Getting Started Centaur runs locally on Kubernetes. The expected local checkout path is: bash /Users/magelinskaas/paradigmxyz/centaur Clone the repo and enter it: bash git clone cd centaur Install the local command runner: bash brew install just For a first-time local boot, Centaur needs these infrastructure secrets in your shell: bash export OP_SERVICE_ACCOUNT_TOKEN=... export OP_VAULT=... export SLACK_BOT_TOKEN=... export SLACK_SIGNING_SECRET=... export SLACKBOT_API_KEY=... Create the Slackbot app at api.slack.com/apps . Use the app's Bot User OAuth Token for SLACK_BOT_TOKEN and its Signing Secret for SLACK_SIGNING_SECRET . What they are for: OP_SERVICE_ACCOUNT_TOKEN : lets iron-proxy resolve 1Password-backed runtime secrets OP_VAULT : the 1Password vault name or id to read from SLACK_BOT_TOKEN : Slack bot token for the local Slackbot service SLACK_SIGNING_SECRET : verifies incoming Slack requests SLACKBOT_API_KEY : API key the Slackbot uses to call Centaur Then create local Kubernetes Secrets from those environment variables and boot the stack: bash just bootstrap-secrets just up After just up finishes, use Slack or the API examples in the Developer Guide . Tools Tools are small Python plugins. A tool can wrap an internal service, public API, database, search endpoint, deployment system, or anything else an agent should be allowed to use. text tools/my_tool/ ├── init.py ├── client.py ├── cli.py ├── .env.example └── pyproject.toml Public methods on the client become tool endpoints. For example, search() becomes: text POST /tools/my_tool/search Workflows Workflows are Python functions with durable steps. ```python WORKFLOW_NAME = "daily_digest" async def handler(inp, ctx): data = await ctx.step("collect", lambda: collect_digest_data(inp)) summary = await ctx.run_agent("summarize", text=f"Summarize this: {data}") return {"summary": summary}

just build-one <service>
just deploy For Python checks: bash
uv run ruff check .
uv run ruff format .
uv run pytest See the Developer Guide for code conventions and end-to-end testing instructions. Acknowledgements Centaur builds on excellent open-source infrastructure, including FastAPI , Kubernetes , mitmproxy , and the agent harnesses teams choose to run inside the sandbox.

---

Centaur is a self-hosted, team-focused platform enabling shared AI agents to perform real work securely. It targets engineering teams needing a unified, auditable environment for agent execution, accessible via Slack or API. The core benefit is consolidating individual agent setups into a robust, collaborative system.

**How It Works**

The platform integrates with Slack or exposes an API, funneling requests to the Centaur API. This API manages durable state (Postgres), tool/workflow registries, and orchestrates isolated Kubernetes sandboxes for agent execution. Each sandbox provides a shell, development tools, and API-mediated access to registered tools. Outbound network access and credential injection are strictly controlled via a per-sandbox proxy (iron-proxy), ensuring agents interact with external services using securely managed, host-bound credentials.

**Quick Start & Requirements**

*   **Installation:** Clone the repo, install `just` (via Homebrew), then run `just bootstrap-secrets` and `just up` for local Kubernetes deployment.
*   **Prerequisites:** Requires Kubernetes, 1Password secrets (`OP_SERVICE_ACCOUNT_TOKEN`, `OP_VAULT`), and Slack API credentials (`SLACK_BOT_TOKEN`, `SLACK_SIGNING_SECRET`, `SLACKBOT_API_KEY`). A Slack app must be configured.
*   **Links:** Quickstart, Developer Guide.

**Highlighted Details**

*   **Slack Integration:** Seamless agent interaction within Slack threads.
*   **Kubernetes Sandboxing:** Isolated execution environments with pre-configured tools (shell, git, Python, Node.js, Bun).
*   **Durable Workflows:** Support for long-running, event-driven, or scheduled tasks that can resume after restarts.
*   **Secure Credential Management:** Agents use placeholder credentials, with real values injected by a proxy only for specific outbound requests.
*   **Extensibility:** Layer custom tools, workflows, personas, and prompts without forking the core platform.
*   **Replayability:** Full state persistence allows clients to reconnect without data loss.

**Maintenance & Community**

The provided README does not detail specific contributors, sponsorships, community channels (e.g., Discord, Slack), or a public roadmap.

**Licensing & Compatibility**

The project's license is not explicitly stated in the README. Consequently, notes on commercial use or closed-source linking compatibility are absent.

**Limitations & Caveats**

Known limitations include a shared credential vault, as noted in the security model. The system requires a Kubernetes cluster for operation and relies on 1Password for secret management.