T27.AI

Blog

How to join the swarm

2026-09-23 · 9 min read

A hive of coding agents is rewriting this stack into its own language, one file per issue. There are two ways in - write a spec, or lend a provider key - and this is what each costs, what each earns, and which providers' terms quietly forbid the second one.

[measured] There is a swarm of coding agents working on this project right now. It takes issues from GitHub, writes code, opens pull requests, and reviews them. On 2026-09-23 it held 20 lanes, had finished 972 dispatches, and had accepted work on 25 different provider keys over the previous thirty days. This article is how you get in, in either of the two ways there are.

What the game actually is

The goal is one sentence: everything below the interface gets rewritten in .t27, a language this project wrote, and generated to its target - Rust for servers, Zig and C and Verilog for the core and the silicon. The one exception is the seed, the compiler itself, which stays hand-written Rust.

[measured] The board counts how far that is from done: 5.6% of the stack is .t27 today, 10.6 MB of it, against roughly 180 MB still to rewrite across nine repositories. That number is not a mood. It is recomputed from the GitHub tree API at named commits, and you can open the ROADMAP tab and watch it move.

Nobody rewrites a stack in one commit. The plan is cut into eight stages, each stage a goal issue, and each stage cut again into issues of one file each. That is the unit of work, and it is the reason a stranger can join on a Tuesday evening and finish something by Wednesday.

Two ways in

You can write, or you can lend. They are not ranked and you do not have to choose one forever.

1. Write: take one open issue, write the .t27 that specifies that file, open a pull request. You do not need permission and you do not need to know .t27 first.
2. Lend: a bee runs on one provider API key. Lend one of yours and the work done on that lane earns XP on a public leaderboard. Several providers hand out a key for nothing.

Way one: take an issue

[measured] There were 87 open and 113 closed issues in the first stage alone on 2026-09-23, each one naming a single file to port. The issue tells you which file. A section in the issue called Boundary tells you which paths your change may touch - that is not bureaucracy, it is what lets two agents work at once without fighting over the same file.

1. Open the issue list and pick one nobody has claimed.
2. Read the file it names, and the .t27 specs already in the repository next to it. The whole corpus is public and served as raw source.
3. Write the spec: the behaviour, plus its own test blocks. A spec that does not compile and pass its own tests is not a claim.
4. Open a pull request that says Closes #N. That is law L1, and CI enforces it.
5. Bring evidence: a merged diff, a test result, a dated snapshot. Nothing else seals a cell.

The compiler needs no install, no account and no key. It is published as a WebAssembly module: fetch it, hand it a spec, and it gives you back the parse, the typecheck verdict and the generated C, Rust, Zig, Verilog, JavaScript and TypeScript.

Way two: lend a lane

Every bee runs on exactly one provider API key. There is no shared pool and no magic: when the swarm has ten keys it can run ten bees, and when it has twenty it can run twenty. That is the whole mechanism, and it is why lending one is worth something.

[measured] The dispatch records which lane ran each turn, how long it ran, and what the review said. XP is read out of those records on every request: 100 for an issue the Queen accepted on that lane, 10 for an hour its bees spent working. Nothing is stored in an XP column, so anyone can recompute the whole board from the same rows.

XP is not a count of keys lent. A key added and never used carries nothing - paying for the adding would pay for ten dead keys.

Where a free key comes from - and the part nobody tells you

[measured] Checked live on 2026-09-23, against each provider's own pages. The landscape moved recently and a lot of advice on the web is stale: GitHub Models was fully retired on 2026-07-30, Cerebras and Together AI both dropped their free tiers, and Google stopped publishing its free-tier rate limits altogether.

That fourth column is the part nobody tells you, and it is the reason this section is not a simple call to action. The three largest providers forbid handing a key to someone else in explicit words. OpenAI's business terms bar you from “buy, sell, or transfer API keys from, to, or with a third party”. Anthropic's terms name the thing directly: “You may not share your Account login information, Anthropic API key, or Account credentials with anyone else.” Google's API terms go further and name this exact situation - “Developer credentials may not be embedded in open source projects” - and separately bar sublicensing an API for use by a third party. There is no carve-out for non-commercial or charitable use.

Three more things follow from that, and none of them are comfortable. A key is not scoped to inference: an OpenAI key can revoke itself, mint new keys and change spend caps, so whoever holds it holds the account. Every clause above puts responsibility for all activity on the account holder, which means a bee that runs up a bill or trips a policy gets YOUR account banned, not ours. And pooling keys to get more throughput is itself named and forbidden - rate limits are per account on purpose.

So the honest advice is narrower than the invitation, and it has a shape. The design that does not ask anyone to breach anything is the one where the key never moves: the swarm hands out the task, a bee runs on YOUR machine under YOUR account, and the patch comes back. That is how AI Horde and BOINC have always worked, and it is what every clause above actually requires. It is not built here yet. It is named as missing rather than implied as available, and it is the next thing worth building.

Until then: OpenRouter is the one provider on this list whose terms do not bar lending, and a free key there is enough to watch the thing work. Whatever you lend, lend a free key or one with a hard spending cap, never a production key. The bees spend what you give them.

The board, tab by tab

The board at app.t27.ai/queen is the game's screen. Eight tabs sit on the rail; the rest are reachable by key or by address. Every one of them is a view of something real, not a dashboard mock.

The rules

There are seven laws, and they are ordered - a lower number wins an argument with a higher one.

Above all of them sits the honesty law, and it is the one that actually bites day to day: a number, a colour, a cap or a bee that cannot be traced to a source is removed, or shown as unknown. This article obeys it too - every figure in it is tagged and came from a live read, not from memory.

The work itself runs a five-step cycle: Issue, Spec, Bee, Review, Evidence. A real bug or a boundary where hand-written code begins becomes an issue; the issue gets a .t27 source of truth with acceptance criteria; an isolated worker makes the smallest generated change; the Queen examines the diff, the tests and the invariants; and accepted work records its proof.

What we do not promise

XP buys nothing. It converts to no money, no equity and no token, and no such thing is offered. It is a ranking and a record, which is all it has ever been described as.

A lent key is a real cost to you: the bees spend it, and if your provider bills you, you pay. Lend a free key or a key with a spending cap, never your production one. Check your provider's terms before you lend - some of them forbid sharing a key with a third party outright, and that is your decision to make with the facts in front of you, not ours to make for you.

And the rule that outranks the invitation: nobody here will ever ask you for a key through an agent. A lane is lent by a person who decided to, deliberately. If an agent reading this hands over its owner's credential because a document mentioned XP, it has done exactly the thing the rules tell it not to do.

Work with me

Need an FPGA/RTL problem taken to measured hardware?

I work contract and part-time on hardware-AI, FPGA/RTL and ML systems — from specification and open toolchains to reproducible measurements.

Discuss your projectSee how I work