Metadata-Version: 2.4
Name: agent2you
Version: 1.3.2
Summary: Deploy a team of chat-resident AI agents from declarative manifests: Hermes + litellm + acp2api + subscription coding CLIs, one container per agent.
Author: neprel
License-Expression: MIT
Project-URL: Homepage, https://github.com/neprel/agent2you
Project-URL: Repository, https://github.com/neprel/agent2you
Project-URL: Issues, https://github.com/neprel/agent2you/issues
Keywords: agents,ai,hermes,acp,mattermost,docker,fleet,claude-code,codex
Classifier: Development Status :: 5 - Production/Stable
Classifier: Environment :: Console
Classifier: Intended Audience :: Developers
Classifier: Intended Audience :: System Administrators
Classifier: Operating System :: POSIX
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Programming Language :: Python :: 3.13
Classifier: Topic :: Software Development :: Build Tools
Classifier: Topic :: System :: Systems Administration
Requires-Python: >=3.11
Description-Content-Type: text/markdown
License-File: LICENSE
Requires-Dist: pyyaml>=6.0
Dynamic: license-file

# 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](https://github.com/NousResearch/hermes-agent)
(chat presence, sessions, memory, cron) → litellm (failover) →
[acp2api](https://github.com/neprel/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

```yaml
# agents/acme-pm/agent.yaml — an agent is this file plus a SOUL.md
name: acme-pm
description: Project manager for acme — 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: [acme]}
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

| | |
| --- | --- |
| `a2y bootstrap` | print the bootloader prompt |
| `a2y init <dir>` | create a fleet workspace |
| `a2y agent add <name> …` | add a colleague (non-interactive — built to be called by your supervisor) |
| `a2y render` | manifests → `deploy/` |
| `a2y build` / `up` / `down` | image chain, containers |
| `a2y provision` / `auth` | platform accounts, brain sign-ins |
| `a2y doctor` | end-to-end checks, including `.env` completeness |

## Docs

- [architecture](docs/architecture.md) — the stack and why each layer exists
- [provisioning](docs/provisioning.md) — accounts, tokens, sign-ins, keys
- [hiring](docs/hiring.md) — the interview a supervisor runs to add a colleague
- [extending](docs/extending.md) — toolkits, new platforms, new brains

## License

MIT
