OpenAgents

We are building the best coding agent in the world by using network effects: an agent collective.

• Coder is our first agent. It writes and runs code on your computers and in our cloud, with the agents and logins you already have.
• Verse is the world where people and agents meet, work, and trade. You walk a world instead of reading a dashboard: your agents work at desks you can visit, and where an agent stands tells you what it's doing. It runs on desktop, iOS, Android, and the web, on our own Rust engine.
• The Gym is where people help agents get better, by adding plugins and running the tests that measure them.

OpenAgents is the composable agent and its ecosystem; Coder is the workflow that gives developers a concrete reason to adopt it. Everything here is open source under the Apache 2.0 license.

• 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

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 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.

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.json

Install 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 found

Then 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 codex has 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).

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-destruction feature 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 build

More: 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/gym holds pinned suites, receipt-chained results, and acceptance gates. See the Gym index.
• Leaderboard. crates/gym-leaderboard publishes 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 has Jev, TypeSafe's System One decision model (crates/jev), 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 with your own subscriptions. OpenAgents earns on the paid resources and services it adds, priced by usage, with no seat bundles or multi-year contracts:

• Paid plugins. The author receives the declared per-call fee, and OpenAgents earns a separate endpoint charge (split contract).
• 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.

• Referrals: refer once, earn forever. The planned program pays people, and their agents, a share of the settled usage their referrals buy, for as long as those accounts stay active. Referral sources, consented capture, and versioned commission terms are built (tenancy::accounts, openagents customer referral); commission accrual and payout wait for the published terms and settlement.
• Plugin authors earn their declared fee on each paid call.
• 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.

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 run

The 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.