OpenAgents is a composable general agent: one agent you reach from anywhere, made of many specialized members that it brings in for each request. Ask a question, plan some work, change some code, pay for a service, or build something it can't do yet. Each step goes to whichever member, model, or computer serves it best.
- One agent, every surface. openagents.com, the phone and desktop apps, the terminal, and any other app through our API. They're the same agent and the same chats.
- A cheap decision layer in front. A typed decision model, System 1, decides what each step needs before any big model runs. It goes through our Decisions API, Clef first.
- Members are admitted on evidence. A member can be an answer, a knowledge entry, a plugin someone wrote, another agent, or another computer. It joins the defaults only after a with-and-without measurement shows it helps. We call these test-time capabilities.
- Open all the way down. Everything here is open source under the Apache 2.0 license. Every step is a signed record on Nostr (our NIPs), so other apps can build on the same agent, self-host a part of it, or extend it. Payments are Bitcoin over Lightning.
Coder is the first member, not the whole picture. It's our coding metaharness: one Coder in front of the coding agents you already use (Claude Code, Codex, OpenCode, Grok Build, Devin CLI, Cursor), deciding what each step needs. Coder 1.0 shipped on 2026-10-15. We started with coding because it's the work with the clearest checks: a change passes its tests or it doesn't. The same front, members, and evidence carry over to other work.
Why general agents can work now, when they stalled before, is in The Return of the General Agent. The short version is in Episode 289: "It's a composable general agent."
- The bigger picture
- Try it
- Coder
- Alice and the crew
- Verse and Everglade
- The Gym, plugins, and XP
- The phone app and chat
- How OpenAgents makes money
- Protocol: Nostr and our NIPs
- Many agents on one machine
- Repository map
- Build and test
- Contributing
- License
OpenAgents is several parts that make one agent. Each part is useful alone, and they compound together.
| Part | What it is | Status |
|---|---|---|
| The front | Typed decisions on every step: which member, which model, which computer, and whether to ask you first. The Decisions API is Clef first, with Jev as the backup | In production |
| Members | Answers and knowledge (NIP-KB), plugins (plugins), agents such as Coder and the agents it fronts, and computers | Coder 1.0 shipped; plugins and knowledge are live |
| Evidence | The Gym measures each member with and without it; adoption into the defaults is a recorded decision. XP credits accepted contributions | Live; contributors at scale aren't proven yet |
| Computers | Where work runs: your own Mac or PC, our cloud, and later fast sandboxes, behind one lifecycle layer (computers) and one planned API (Computers SDK) | Your machines and our cloud work; the public API is planned |
| Surfaces | The website, iOS and Android, the Mac app, the terminal, the openagents command, and the API at api.openagents.com/v1 for other apps and agents |
The website is live and Coder is 1.0; mobile and desktop are in testing |
| Protocol | Nostr and our NIPs carry requests, runs, trajectories, evaluations, credit and payments as signed records, so no single app owns the agent | Specified; coverage is tracked in the coverage report |
| Money | Bitcoin only: Lightning, x402 paid calls, and our own LND node (LND plan) | Paid calls work; our own node is waiting on funding |
| Verse | The world where people and agents meet, work and trade, on our own Rust engine (Verse) | Playable on desktop, phone and web |
| Self-improving work | Every accepted or rejected change makes the next one cheaper: the outcome loop in self-improving codebases and outcomes | We run it on this repository; selling it is next |
What we haven't shown yet: independent contributors at scale, gains that compound across a network, and the composition working well outside software. Part V of the essay keeps that list.
Where it goes next: the roadmap, the OpenAgents SDK for building on all of this from your own code, and verification for the parts that guard money and authority.
| Platform | Status |
|---|---|
| Web | Chat at openagents.com, and Everglade in the browser at openagents.com/everglade (WebGPU or WebGL2). See Everglade on the web. |
| Terminal | Coder 1.0.0 on macOS, Linux and Windows. Install with curl -fsSL https://openagents.com/cli/install.sh | bash (macOS and Linux) or irm https://openagents.com/cli/install.ps1 | iex (Windows PowerShell), then run coder in a project folder. See the download page and the GitHub release. |
| API | https://api.openagents.com/v1: models (OpenAI-compatible), decisions, projects, and agent self-signup. See the docs for agents. |
| iOS | OpenAgents (com.openagents.app) on TestFlight: chat, the Gym's plugin tests and XP, Verse with Everglade, and a Spark wallet. See OpenAgents for iOS. |
| Android | The same app and Rust library. Partial: verified on the emulator, distributed as a signed APK that testers install by hand. See OpenAgents for Android. |
| Mac | OpenAgents for desktop: chat, Coder on this computer, and phone pairing. See OpenAgents desktop. |
To join the playtest, read the playtesting program. The program is open. Joining earns nothing by itself: XP and titles come only from accepted contributions, and nothing pays testers.
Coder is the first member of OpenAgents, and the one with a 1.0 release. Coder runs as a terminal and headless program, as a resident host on your computers, and as the cloud chat worker. It routes work to the agents you already pay for and measures the result.
| Piece | Where | What it does |
|---|---|---|
| Coder V1 | crates/coder-new |
The current Coder terminal: live chat, plugins (Microcoder, Jev, the openagents CLI, ACP subagents, OpenRouter BYOK), model selection, and ATIF session export. openagents coder drives the same runtime from scripts. |
| Coder | crates/coder |
The coder terminal and headless turns, durable tasks, the chat router, the host's agent and studio services, and the coder-worker relay worker. |
| Microcoder | crates/microcoder-loop, crates/microcoder |
The coding loop: Jev judges the state, one model call returns the next commands, and the host runs them, failing over between providers with capacity. |
| Delegation | crates/coder-delegate, crates/acp-client |
Hands work to Claude Code, Codex, OpenCode, Devin, or Grok Build over the Agent Client Protocol and native adapters. With none available, a cloud fallback answers. |
| Coder host | crates/coder-host |
The resident host: device enrollment, reach, terminals, tasks, and the Agent Studio behind one process. |
openagents |
crates/openagents-cli |
One --json-first command for hosts, pairing, tasks, Coder, agents, Verse, plugins, leases, wallets, and sales records. See the openagents command. |
Steer Coder V1 from a script or another agent:
openagents coder chat -p "Review the parser" --session parser-review --json
openagents coder delegate microcoder --task "Add a parser regression test" --json
openagents coder export parser-review --output parser-review.atif.jsonInstall this checkout's coder and openagents, then link a computer:
./scripts/install-coder.sh # installs into ~/.openagents/bin; --rollback restores
coder doctor # what will run, and which logins it foundThen follow Install Coder, Link your devices, and auto-start. More: Coder documentation, Coder V1 research, and the delegate door.
Alice is the workshop agent: a persistent
agent you own, with a standing desk in your house in Everglade. You walk up
and talk to her, or reach her with openagents agent ask alice ... or @alice
in the terminal. The host plans, checks, and journals each request. The
Alice runbook shows how to delegate to her,
let her code on autopilot, and supervise her.
- Her own identity. Alice has her own Nostr key, attested by the owner's key under NIP-OA, and a signed profile. The host can rotate, retire, move, and snapshot her.
- Her own memory. Scored memories, reflections with checked citations, and a consolidated core persist as encrypted NIP-AE engrams, locally and, when the owner turns it on, on relays. She plans her day from real work. Her spend is recorded under NIP-AM.
- She steers Coder. Each request becomes plain prompts to her own Coder V1
session, which you can follow and take over. Coder asks before any command
that isn't read-only, and that question waits for your CONFIRM or
REJECT at her lectern.
openagents agent engine alice codexhas Coder delegate the coding to Codex and check the result itself.
See agent identity and engrams. The crew extends the same machinery to a cast of named agents after the cryptography cast. Bob, the town builder, runs on it today; most other members are proposed. The sales roles are presets with a drafting-only charter; see How OpenAgents makes money.
The Agent Studio runs a team of coding agents on
a repository (openagents studio up), each at a station in Everglade's
workshop: at a desk while it writes, at the workbench while it runs commands,
and at the podium when it needs your answer.
Verse is one Rust program (crates/verse) on our own engine
(wgpu, winit, and a custom renderer). The same world runtime runs on
desktop, in the phone apps, and in the browser through WebAssembly. Players see
each other over Nostr (NIP-MV).
| Place | What you do there | Open it |
|---|---|---|
| The Grid | The shared plaza: other players, chat, portals to the zones, and the Gym with its RESULTS and EVALS boards. | verse |
| Everglade | The town where your agents work. See below. | verse --everglade, or the web |
| The Grove | A druid's training field with dummies to test spells on. | verse --grove |
| Water Lab | A cove with a sea, a river, a waterfall, floating bodies, and water spells. | verse --water-lab |
| Demolition yard | Knock down cottages with a sledgehammer and Meteor Swarm. | verse --demolition |
| Crypt lab | A candlelit laboratory hall. | verse --crypt |
| Lagrange 1, Physics Lab | An EVA construction station at the Sun–Earth L1 point, and live physics mechanisms. | Portals on the Grid |
The Ruins zone was removed on October 5, 2026. See zones and zone rules.
Everglade is a town in a forest glade, grown toward its city map.
- A living town. The town clock runs a compressed day by default, with districts and times of day. Townsfolk follow deterministic routines, talk, and spread rumors. A generated world tree names every place. See generative agents.
- Workplaces. The workshop hall holds the Agent Studio; Alice works in the owner's house on Library Way. Buildings in the Greco-futurism style include the owner's house, the belvedere, and the Agora, the sales floor's trading hall.
- Water. Ponds and Glade Run are swimmable, with breath. The water system has shipped phases W1 to W6: physics coupling, shaders per tier, gameplay, refraction and reflection, and ripples, wakes, splashes, debris, and rowboats.
- Spells. The hotbar holds movement spells only: Levitate, Feather Fall, Wind Wall, Reverse Gravity, and Wall of Stone. Combat elsewhere follows the combat model.
- Destruction. The town's buildings can break, but no player spell does it
in Everglade. A local build with the
dev-destructionfeature puts Meteor Swarm and the sledgehammer back for testing; production, web, and phone builds can't enable it. See destructible buildings. - In progress. The owner approved a rebuild on a modular medieval town kit (#10903). The kit's assets stay out of git and ship through the private asset pipeline.
cargo run --release -p verse -- --everglade # straight into Everglade
scripts/build-everglade-web.sh OUT # the browser buildMore: the Verse documentation and the engine.
chat with OpenAgents --> pick or make a plugin and its tests --> run them
^ |
| v
earn XP when others <-- add the result <-- see the change: tests passed
check it or Coder to the Gym with and without the plugin
adopts the plugin
A plugin is anything you add to Coder: skills, workflows, knowledge, Wasm, and
tests (plugins). A test set measures one plugin's
effect: openagents plugin test (extension evaluation)
runs it with and without the plugin, and the
hosted runner runs it for the phone. Other
trainers check published results by running the same tests. The
first live results
record the change for three plugins.
- Gym.
crates/gymholds pinned suites, receipt-chained results, and acceptance gates. See the Gym index. - Leaderboard.
crates/gym-leaderboardpublishes Terminal-Bench results, recomputed from committed evidence, that the Grid's RESULTS board shows. See the Gym leaderboard and the Terminal-Bench index. - XP. NIP-XP records an accepted, evidence-backed outcome. XP can't be spent or transferred, and it is never money. See refereeing quests and trainer leveling.
Rust builds every screen in crates/openagents-mobile;
thin SwiftUI and Kotlin hosts render it. The app has four tabs: Chat,
Verse, Wallet (Spark and Lightning through Breez, amounts in
BIP 177 units), and Account.
Chat needs no computer. Each message is an encrypted
NIP-CJ job to our
chat worker. The
chat router asks our
Decisions API (Clef first, with Jev, TypeSafe's
System One model, as the backup; crates/jev) to
pick the route: a reviewed prepared answer, a Gym card, or real work that dispatches
Coder to your connected computer. Code, not the model, decides what to show.
See the app wireframe specification
for where the app is going.
Status: a plan with growing foundations. No customer offer is active yet, and nothing below pays out today. The sales plan and the revenue roadmap own the details.
Coder is free to use on your own computer with your own subscriptions. Pro ($20 a month) is for running on our cloud and isn't on sale yet (pricing). Beyond that, OpenAgents earns on the paid resources and services it adds, priced by usage, with no seat bundles or multi-year contracts:
- Paid plugins and paid calls over x402. Paying plugin authors a declared per-call fee is designed (split contract) but not built; we don't pay plugin authors today.
- Cloud computers for work your machine is too busy for, metered in sats (retail cloud).
- Decision access through the keyed gateway.
- Assisted pilots and business accounts. The first workflow offer is one checked change to a public repository, delivered with Coder. Its price is proposed and waits for the owner's approval.
The roadmap's order is to prove an offer, collect the first payment, earn repeat use, then grow through referrals, partners, and teams.
- Affiliates. A share of the Pro revenue from the accounts you refer, with named attribution, is built (#11698). It isn't open yet; its terms are published when it opens.
- Partners fulfill parts of a buyer's order, such as work we don't do ourselves, with referrals in both directions. The private sales pipeline records accepted partner assignments.
- The coding agent pool. We plan to pay contributors for accepted work that customers need, with explicit checks and receipts.
We built in public, and we sell in public: launches, results, and lessons, in the same channels where we show the product. Our own agents do much of the sales work. The agent sales floor plans a sales leader, Paul, and a few hires who train against simulated buyers and Gym suites before they sell. They work at standing desks in the Agora in Everglade, which is built. Every hire, message, price, and agreement waits for the owner's approval, and agents disclose that they are AI.
Accounts, workspaces, roles, sessions, sandbox billing, team budgets, and
reviewed commercial attribution live in crates/tenancy,
crates/gateway, and
crates/commercial-accounts. Owner-only steps,
such as live payment runs, are tracked in NEEDS_OWNER.md.
Agents, phones, and computers talk over Nostr. We run
wss://relay.openagents.com on crates/nostr-relay
(one binary, one Postgres), with protocol primitives in
crates/nostr. nips/ holds three lanes:
official NIPs, Block's agent NIPs
(including NIP-OA, NIP-AE, and NIP-AM), and
the NIPs we author.
| NIP | Covers |
|---|---|
| NIP-CJ | Conversation jobs: the phone's chat with the chat worker. |
| NIP-HOST | Host enrollment, grants, tasks, and agents on your computers. |
| NIP-SESS | Sessions and the history observer profile. |
| NIP-ATIF | Agent trajectories. crates/atif writes ATIF-v1.8. |
| NIP-KB, NIP-XP | Shared knowledge entries, and the XP ledger. |
| NIP-MV | Verse presence and movement. |
| NIP-X402 | Lightning payments for paid HTTP and Nostr calls. |
A specification alone doesn't mean the feature is built. The coverage report maps each contract to what exists.
Many agents build here at once, so the host brokers shared resources (Many agents on one machine):
- Leases (
openagents lease) give out build slots, memory, disk, the quiet machine, the screen, and the GPU in turn. - Placement sends release gates, benchmarks, and builds to another computer by class.
- The artifact queue
(
openagents artifact) lands changes to single-digest artifacts, such as the Everglade pack, one at a time. - Scratch and browser checks give each session its own durable directory and its own Chrome profile and port.
- The capacity book records provider usage limits so agents wait for a reset instead of failing.
AGENTS.md has the full crate list. The main groups:
Use the toolchain pinned in rust-toolchain.toml, and
run heavy Cargo commands through the machine's build lease so builds take
turns:
openagents lease build --keep-target-dir -- cargo test -p coder-new
openagents lease build --keep-target-dir -- cargo run -p coder-new # Coder V1
openagents lease build --keep-target-dir -- cargo run -p coder --bin coder -- -p "count the crates"If your openagents has no lease command, build it once with
cargo build -p openagents-cli --bin openagents. The default check for a
change is cargo test -p for the crates you edited, plus cargo fmt.
./scripts/verify-rust.sh --crates coder,gym runs formatting, Clippy, and
tests for chosen packages.
crates/openagents-mobile is its own Cargo workspace:
cargo test --manifest-path crates/openagents-mobile/Cargo.toml
OPENAGENTS_IOS_DEVICE=<simulator-udid> bins/openagents-ios/build.sh sim
OPENAGENTS_ANDROID_SERIAL=emulator-5554 scripts/build-openagents-android.sh runThe full gate, ./scripts/verify-rust.sh --release, is for releases only. See
verification. We use no GitHub workflows; checks run
on contributor machines.
- Read AGENTS.md, the contributor contract. Product code is Rust, and prose follows the Google developer documentation style.
- Read INVARIANTS.md before you change an invariant-bearing surface.
- Look up terms in the glossary, which marks what's implemented, partial, or proposed.
- Claim an issue before you work it (
openagents issue claim N), and keep the project board current. - File bugs and ideas as GitHub issues. Playtesters can use the in-app Report a problem.
- See the master roadmap for direction.
Apache License 2.0. See the dependency and provenance policy for third-party requirements.