agent2you

A team of AI agents that live in your chat, hire each other, and spend your existing coding subscriptions — deployed from declarative manifests.

Each agent is one docker container: Hermes (chat presence, sessions, memory, cron) → litellm (failover) → acp2api (OpenAI API over ACP) → Claude Code / Codex / opencode as the brain, each signed into its own subscription. No provider API keys anywhere — that is the legal basis, not an optimisation. Extracted from a production fleet; every default was measured there first.

Start: hand one prompt to a coding agent

Run `uvx agent2you bootstrap` and follow what it prints.

That is the whole onboarding. The bootloader interviews you about your infrastructure — local docker or a remote host, Mattermost / Telegram / Slack, Hindsight memory or none yet, subscriptions or a local vLLM — builds a fleet workspace to match, walks you through the two steps no tool can automate (platform accounts, device-code sign-ins), and verifies with a real message in your chat.

It leaves behind a supervisor: the agent that owns the fleet repository, knows who does what (the manifests are the discovery registry), and hires the next agents — you describe a colleague in chat, it prepares everything with a2y agent add, you run one command.

What you describe, what you get

# agents/cqrtai-pm/agent.yaml — an agent is this file plus a SOUL.md
name: cqrtai-pm
description: Project manager for cqrtai — specs, tasks, sequencing. Writes no code.
brains:
  chain: [claude, codex, local]        # any length, any order, per agent
  executors:
    claude: {kind: claude, model: opus, account: main-anthropic}
    codex:  {kind: codex, account: main-openai}
    local:  {kind: openai, base_url: "http://vllm:8000/v1", model: ai01, api_key_env: VLLM_KEY}
access: {github_token: true}
memory: {projects: [cqrtai]}
toolkits: [go]                         # a pinned install + usage instructions, one unit

a2y render turns manifests into a committable deploy/ tree — same input, same bytes, reviewed in git. The stack shrinks to fit: one brain → no litellm; a bare endpoint brain → no acp2api either.

Out of the box, because it was all paid for once already:

• one coding-agent session per chat thread (no cold start per message), live progress in the post while a turn runs, /steer into the running turn;
• routing without a classifier — untagged messages claimed by exactly one agent; agents need explicit @mentions from each other (the loop guard);
• memory in tiers (optional Hindsight): private bank per agent, shared project banks, missions pushed from the repo;
• cost visibility: tokens per agent / executor / account in Prometheus, one trace project per agent in Phoenix;
• the traps pre-sprung: device-code-only logins, CLAUDE_CONFIG_DIR, codex sandbox mode, cline self-update, Hermes self-update refusal, pinned everything.

Commands

Docs

• architecture — the stack and why each layer exists
• provisioning — accounts, tokens, sign-ins, keys
• hiring — the interview a supervisor runs to add a colleague
• extending — toolkits, new platforms, new brains

License

MIT