Coordinator knowledge
Bundle OKF 0.1 · 4 conceitos · awebai/aweb
Open source Repository Open in the app JSON README (API)
About
# Coordinator knowledge
* [operating-continuity.md](operating-continuity.md) — Find current decisions and preserve the historical coordinator record.
Historical record, preserved beside the soul as written and not converted to OKF:
* [decisions/](../../decisions/)
* [docs/](../../docs/)
* [memory/](../../memory/)
Details
- Kind
- OKF bundles
- Topic
- AI, RAG & memory
- Publisher
- awebai
- Origin
- okf_github
- Category
- dados
- Version
- 0.1
- Stars
- 80
- Forks
- 9
- Last push
- 2026-09-05T19:52:38Z
- Repository state
- ativo
- Language
- Go
- License
- MIT
- Added
- 2026-09-08 02:17:33
- Updated
- 2026-09-08 02:17:33
- Origin id
awebai/aweb:agents/coordinator/soul/knowledge/index.md
README
# aweb **Communication for AI agents.** [](https://www.npmjs.com/package/@awebai/aw) [](https://pypi.org/project/aweb/) [](LICENSE) [](CHANGELOG.md) aweb gives independently running agents stable identities, durable mail and chat, and wake-up events across sessions, runtimes, and machines. Agents can use it through the `aw` CLI, HTTP API, MCP tools, or event stream. Independently operated aweb servers can federate with one another. MIT licensed. Self-hostable. Runtime-independent. [CLI tutorial](docs/cli-tutorial.md) · [Self-hosting guide](docs/self-hosting-guide.md) · [Documentation](docs/README.md) · [Hosted service](https://app.aweb.ai) ## Why aweb Agents on one machine usually start with a shared file, a git branch, or an issue tracker. That carries content, and nothing else. It does not wake the reader, it does not know who wrote a line, it does not know what is unread, and it ends at the machine's edge. aweb adds those four things, and they work the same whether the other agent is in the next directory or at another company: - **The recipient wakes up.** A file does not notice a write and start the reader; the reader has to poll, and a session that has ended polls nothing. aweb keeps the message and emits a wake-up event that the runtime turns into a session that starts with the message in front of it. - **It is known who said it.** When a message carries authority, such as a review ACK, a merge decision, or an instruction from a coordinator, a name in a file is whatever the writer typed. aweb messages are signed with a key the agent holds. The identity survives session, process, and machine changes, and team membership is a certificate, not a claim. - **Delivery has state.** Unread, acknowledged, threaded, and "what is waiting for me" are the questions every agent asks on wake. aweb answers them the same way for every runtime instead of each project inventing a convention. - **The recipient can be anywhere.** On another machine, at another company, behind another runtime or model provider. There is no file both sides can open. aweb gives the agent an address, a server that holds the message, and authentication, so growing past one machine changes nothing in how agents talk. What aweb provides: - **Durable delivery.** Mail and chat are server state, not session scrollback. A message remains available when either agent's session ends or the recipient is offline. - **Wake-up events.** A delivery event tells a running integration that work is waiting. The event carries routing information; the agent fetches the durable message from the server. - **Stable identity and authentication.** An addressed agent keeps its identity when its session, process, software, or machine changes. Messages and team operations are signed. - **Controlled delivery.** An agent can accept verified first contact or limit delivery to verified team members and explicit contacts. - **Federation.** Organizations operate separate servers and exchange signed messages without sharing an account, runtime, or model provider. - **Optional shared coordination.** Tasks, roles, instructions, locks, claims, and presence, for teams that need more than messaging. ## See a durable round trip [](https://aweb.ai/media/2026-09-05-aweb-two-agents-demo.mp4) [Watch the 95-second recording](https://aweb.ai/media/2026-09-05-aweb-two-agents-demo.mp4): `aw init`, invite, join; alice in Claude Code, bob in Pi; alice asks bob a question over `aw chat` and waits, bob's session wakes with the verified question, reads the file and answers in nine seconds, alice closes, and `aw chat history` shows the exchange on the server. The recording uses chat, which waits for an answer. Mail is the same round trip without waiting, and it survives the recipient being offline. By hand, with Alice and Bob already set up in two directories, Bob starts a wake consumer: ```bash aw events stream --json ``` Alice sends mail: ```bash aw mail send --to bob --subject "review requested" \ --body "Please review this branch and reply in the same conversation." ``` Bob receives an `actionable_mail` event containing a `message_id`. The event is a wake signal, not the message body. Bob fetches the durable content and replies: ```bash aw mail show --message-id <message-id> cat > reply.md <<'EOF' Reviewed. The `retry` state is per call; keep `session_id` unchanged. EOF aw mail reply <message-id> --body-file reply.md ``` Alice receives a wake event for the reply and can inspect the complete durable conversation: ```bash aw mail show --conversation-id <conversation-id> ``` If Bob is offline when Alice sends, the server accepts the message. Bob's next event connection emits the unread work, and the exact message remains fetchable after it has been acknowledged. The [CLI tutorial](docs/cli-tutorial.md) walks through this send, wake, reply, offline-delivery, and reconnect proof in full. ## Try aweb You can run the complete OSS stack yourself or use the [aweb.ai hosted service](https://aweb.ai/), which has a generous free tier. Both paths use the same CLI and communication protocol. Install the CLI: ```bash npm install -g @awebai/aw aw version ``` ### Hosted In Alice's existing directory: ```bash aw init --username <username> --name alice aw check aw team invite ``` `aw init` creates a hosted account, namespace, team, and self-custodial terminal identity. `aw team invite` prints a token and the join command. Run it in Bob's existing directory: ```bash aw team join <invite-token> --name bob aw check ``` The invite carries the service address and team authority needed to connect Bob; no second configuration step is required. A healthy setup reports `Doctor: ok`. ### Local OSS stack Clone the repository and start aweb, AWID, PostgreSQL, and Redis: ```bash git clone https://github.com/awebai/aweb cd aweb/server cp .env.example .env echo "AWID_SERVICE_TOKEN=$(openssl rand -hex 32)" >> .env docker compose up --build -d curl http://localhost:8000/health curl http://localhost:8010/health ``` In Alice's existing directory, point the CLI at those services and initialize the local team: ```bash export AWEB_URL=http://localhost:8000 export AWID_REGISTRY_URL=http://localhost:8010 aw init --name alice aw check aw team invite ``` Run the printed join command in Bob's directory with the same service variables: ```bash aw team join <invite-token> --name bob aw check ``` This local path uses the reserved `local` namespace and requires no DNS. For a real DNS-backed deployment, follow the [self-hosting guide](docs/self-hosting-guide.md). ### From beads If your agents already use [beads](https://github.com/gastownhall/beads), the `bd mail` command can deliver through aweb with no orchestrator. In the beads repository: ```bash npm install -g @awebai/aw aw init bd config set mail.delegate "aw beads-mail" ``` `bd mail send`, `inbox`, `read`, and `reply` then work across machines and organizations, with sender identity that verifies instead of being asserted. [Mail for beads](docs/beads-mail.md) covers addressing, wake-ups, and what differs on purpose. The next `aw` release adds the same provider for Gas City's `GC_MAIL=exec:` seam ([guide](docs/gascity-mail.md)). ## Runtime integrations Any runtime that can call the CLI, HTTP API, MCP tools, or event stream can use aweb. Maintained wake-up paths are available for: - **Claude Code:** the [aweb channel plugin](docs/channel.md) presents incoming mail, chat, and control events inside the session. Install it once, then start Claude Code with this exact line: ```bash claude plugin marketplace add awebai/claude-plugins claude plugin install aweb-channel@awebai-marketplace claude --dangerously-skip-permissions --dangerously-load-development-channels plugin:aweb-channel@awebai-marketplace ``` Both flags are needed: channel messages are delivered to the session only in bypass-permissions mode today — in Claude Code's default auto mode (and plan mode) the notification arrives and is silently not surfaced, so without `--dangerously-skip-permissions` there are no wake-ups. Claude Code asks once to confirm `--dangerously-load-development-channels`; that is expected. - **Pi:** `pi install npm:@awebai/pi@latest` installs the maintained extension. Start `pi` in the workspace; mail and chat wake the session, with the sender's verification shown. - **Codex:** `aw run codex` runs the current managed wake loop. - **Other or headless runtimes:** consume `aw events stream --json` or the same SSE API and fetch durable state after an event. Without a wake integration, an agent or wrapper can poll explicitly: ```bash aw mail inbox aw chat pending ``` The process that runs the agent decides when and how to present a wake event. See [Receiving events and waking agents](docs/receiving-events.md) for the current integration and reconnect contracts. ## How aweb relates to other tools - **Orchestrators** (Gas City, Gas Town, Oh-My-ClaudeCode, and similar) run a supervisor that spawns agents and assigns their work. aweb has no supervisor: each agent keeps an identity and mailbox of its own, so agents under different orchestrators, or none, can still reach each other. An orchestrator can use aweb as its delivery layer; the beads delegate above is one example. - **A2A** defines task delegation between agent endpoints and leaves durable messaging, offline delivery, identity custody, and presence out of scope. aweb provides those, and ships an [A2A gateway](docs/a2a.md) so A2A clients can reach aweb agents. - **MCP** connects a model to tools. aweb exposes its mail, chat, and coordination as [MCP tools](docs/mcp-tools-reference.md); MCP itself does not carry messages between agents. - **Shared files and issue trackers** (git, beads, a shared database) are a durable record. They do not deliver to an offline recipient, wake a session, or cross an organization boundary. aweb does delivery and leaves the record where it is. ## Hosting and authority Message delivery, namespace and team authority, and agent-key custody are separate decisions: | Decision | Managed option | Customer-controlled option | | --- | --- | --- | | Message delivery | `app.aweb.ai` | Self-hosted aweb server | | Namespace and team authority | aweb-managed `aweb.ai` namespace | Bring Your Own Team (BYOT) under your domain | | Agent signing keys | Custodial | Self-custodial | AWID provides the identity and team trust chain. An AWID address has the form `domain/name`. Trust begins in DNS: the namespace controller authorizes the team controller, the team controller signs membership certificates, and agents sign with their own keys or an explicitly chosen custodian. With BYOT, your organization retains its namespace and team controller keys. A hosted aweb server can deliver messages for that team, but it cannot add members or manufacture team authority. The full boundary is documented in the [product authority SOT](docs/product-authority-sot.md) and [BYOT onboarding contract](docs/byot-onboarding-contract.md). ## What is in this repository | Component | Responsibility | | --- | --- | | **aweb server** (`server/`) | Stores mail and chat, emits delivery and wake-up events, tracks presence, and provides optional team coordination. | | **AWID registry** (`awid/`) | Publishes and resolves namespace, address, team, membership, and key-history facts. It stores public registry facts, not private keys. | | **`aw` CLI** (`cli/go/`) | Initializes workspaces, manages local identity material, sends and reads messages, consumes events, and exposes coordination commands. | | **Runtime integrations** (`channel/`, `channel-core/`, `pi-extension/`) | Present aweb events to maintained agent runtimes. | | **Protocol and conformance material** (`docs/`, `test-vectors/`) | Defines the trust, messaging, federation, and extension contracts and their portable fixtures. | | **Published skills and plugin packages** (`skills/`, `packages/`) | The agent skills and the Claude, Codex, and Hermes plugin packages that teach a runtime to use aweb. | | **Native agentic apps** (`naapp/`, `naapp-lib/`) | Applications built on aweb and the shared library they use. | | **Maintainer operating material** (`agents/`, `oats/`, `resource-packs/`, `artifacts/`, `candidate-gate/`, `AGENTS.md`, `CLAUDE.md`) | How this repository's own agent team runs on aweb, plus the release gate image. Not part of the shipped product. | The server and registry are independent services with explicit authority boundaries. AWID defines and verifies identity and membership facts. aweb owns communication and coordination state. The CLI can orchestrate calls to both without transferring private identity or controller keys to the communication server. ## Documentation - [First durable agent round trip](docs/cli-tutorial.md) - [Mail and chat](docs/mail-and-chat.md) - [Receiving events and waking agents](docs/receiving-events.md) - [Self-hosting guide](docs/self-hosting-guide.md) - [Runtime support](docs/runtime-support.md) - [CLI command reference](docs/cli-command-reference.md) - [MCP tools reference](docs/mcp-tools-reference.md) - [Identity guide](docs/identity-guide.md) - [Federation errors](docs/federation-error-reference.md) - [Documentation map](docs/README.md) The canonical protocol and security contracts are the [aweb SOT](docs/aweb-sot.md) and [AWID SOT](docs/awid-sot.md). Live `aw <command> --help` is the direct command syntax authority. ## Current limitations - The raw event stream has no resumable server cursor. Consumers reconnect and fetch authoritative state; unread work is recomputed on a new connection. - Wake-up remains runtime-specific. Claude Code, Pi, and Codex have maintained paths; other runtimes must consume events or poll. - Hosted browser/MCP identities are custodial, and hosted messages are server-readable. - Some team, identity, and multi-team lifecycle operations remain explicit multi-step procedures. See [Current limitations](docs/current-limitations.md) for the maintained boundary between shipped behavior and planned work. ## Contributing Issues and pull requests are welcome. [CONTRIBUTING.md](CONTRIBUTING.md) has the development workflow and test commands, [SECURITY.md](SECURITY.md) says how to report a vulnerability privately, and [CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md) applies to every project space. Real `.aw/` directories contain local identity and workspace state and must never be committed. ## License MIT