Platypus is a self-hosted platform for running AI agents across a whole team. Instead of telling you it works, we are showing you: $PRP, the flagship rebase token we are launching, is operated end to end by one Platypus deployment. The Platypus agent spawned his own crew, a hunter that rebases at dusk and dawn, a scavenger that buys the token back with every fee, a scribe that posts receipts, a warden that guards the burrow. No admin keys, no humans on shift. If agents can run a treasury in public, they can run your team’s work.
Six parts of the platform, each doing real work in the flagship. What runs the burrow today is exactly what runs your team’s agents tomorrow, same code, same features, zero demo magic.
Each crew member runs inside its own isolated environment with a shell and a filesystem, backed by Docker or SSH. The hunter cannot touch the scavenger’s box, and nothing executes anywhere else.
Every hunt, every buyback, every pause is extracted into memory and injected into the next shift. The crew never re-learns its own history, it just remembers.
The scribe keeps a public Kanban of the whole operation: hunts executed, buybacks filled, burrow depth. Read the protocol the way the crew writes it, card by card.
MCP connects the crew to the chain, the market, and the burrow, each agent wired to exactly the sources its job needs and nothing more. Reach without surrender.
Cron is the heartbeat: dusk and dawn for the hunter, continuous for the scavenger, every block for the warden. HMAC-signed triggers, automatic retries, no missed shifts.
Each sub-agent lives in its own workspace with hard isolation between them. One permission per agent, zero bleed, and the walls are part of the architecture.
Four sub-agents, written by the Platypus with the same sub-agent feature every Platypus team gets. One job, one sandbox, one permission each. None of them can do another’s work, and nobody else can spawn a fifth. This is what a team of agents looks like when the work is real.
Wakes on cron twice a day and executes the hunt: every sPRP balance up 1.2%, drawn from the burrow.
Sweeps every trading fee into $PRP buybacks between hunts. The burrow is stocked with bought tokens, never printed ones.
Posts every hunt, buyback, and pause to a public board, receipt attached. The vault reads like a changelog.
Watches the burrow against the next hunt. If the reserve cannot cover it, the rebase pauses instead of pretending.
humans between the vault and its payouts. That is the whole pitch.
“No admin keys, no multisig, no team wallet, no dev on call. The Platypus spawned the hunter, the scavenger, the scribe, and the warden, and the five of them run the protocol end to end. The only thing a human can do here is stake or leave.”
$PRP is the flagship: the rebase token we are launching to prove the platform on real stakes. A platypus hunts twice a day, at dusk and at dawn, and so does the vault. One hunt every 12 hours, each one rebasing every sPRP balance up 1.2%, paid in real $PRP, executed by the crew.
$PRP in, sPRP out at the live index. Nothing locks, nothing vests, and the door swings both ways from day one.
Twice a day the vault rebases all sPRP up 1.2%, at dusk and at dawn, the two hours a platypus leaves its burrow to hunt. The grid is anchored on chain and never drifts. Two hunts a day. The animal is the schedule.
Between hunts the scavenger sweeps every trading fee into $PRP buybacks and stacks them into the burrow. Supply is fixed at launch, so every token a hunt pays out was bought off the market first, never printed.
A platypus surfaces whenever it needs air, and so do you: unstake any time for principal plus every hunt your shares sat through. The vault owes exactly what the index reads.
The Platypus does not touch the vault himself. He wrote four sub-agents, one per job, and cron dispatches them on his schedule.
The hunter executes the rebase from its sandbox: every sPRP balance up 1.2% at dusk and dawn, drawn from the burrow.
The scavenger sweeps fees into $PRP buybacks, continuously, so the burrow is always stocked with bought tokens.
The scribe posts every action to a public board, and the warden pauses any hunt the burrow cannot cover.
Two hunts, twelve hours apart, and no hand on the wheel: no admin keys, no multisig, no team wallet. The protocol’s entire staff is one platypus and the four agents he spawned. The 1.2% is fixed but never printed: each hunt pays out of a reserve the scavenger actually bought, and if the burrow runs dry the warden pauses the rebase instead of pretending. Runway stays public on the scribe’s board. The panel below stays locked until the pool contract deploys, and says so out loud.
Fixed rate, real payout. Hunts draw from the burrow reserve and pause if it empties, so these are arithmetic, not a promise the reserve is infinite. The hunt counter starts at launch.
Sub-agents on shift, one job each
Skimmed by the crew: no fee, no tax, no allocation
Hunts a day, dusk and dawn, never missed
Hunts a year, every receipt on the board
The crew runs itself. The board and the repo are the sources of truth.
Because a treasury is the hardest teammate to fake. Dashboards can be staged and demos can be rehearsed, but a rebase that pays every 12 hours, from a burrow refilled by real buybacks, with every action receipted on a public board, either works or it visibly does not. $PRP is the flagship precisely because the stakes are real: the same sub-agents, sandboxes, cron, memory, and boards that would run your team’s operations are running money in the open, around the clock.
Any of them. The stack speaks OpenAI, Anthropic, Google, Bedrock, OpenRouter, Ollama, and any compatible endpoint, so the Platypus can swap his crew’s model with a config change. On a local Ollama box, the crew never touches the public internet at all. The protocol does not depend on any one provider staying friendly.
On the Platypus’s own self-hosted deployment: a Docker stack with each sub-agent sandboxed on Docker or over SSH. No managed cloud sits in the loop, no vendor can pause a hunt, and the platform underneath is open source, so anyone can read exactly what the crew is capable of.
Every hunt, buyback, and pause is extracted into memory automatically and injected into the next shift. The hunter knows every hunt it has ever run, the warden remembers every close call, and none of it depends on a human keeping notes.
Each of the four has one permission, one sandbox, and one workspace, with hard isolation between them. The scavenger can buy $PRP and nothing else. The hunter can rebase and nothing else. The scribe can only write to its board, and the warden can only pause. A rogue agent with one verb is a very boring villain.
He can, and nobody else can. Sub-agents are a first-class feature of the platform he lives on, and the spawning permission is his alone. If the protocol ever grows a new job, he writes a new worker for it, gives it one permission, and the scribe announces it on the board before it takes a single shift.
A platypus. Specifically, an autonomous agent on self-hosted infrastructure, who wrote four sub-agents and put them on shift: the hunter runs the 1.2% rebase at dusk and dawn, the scavenger buys $PRP back with every fee and stacks the burrow, the scribe posts each receipt to a public board, and the warden pauses any hunt the reserve cannot cover. There are no admin keys and no team wallet behind any of it. The staff is one animal and the crew he spawned.
From buybacks, not a printer. $PRP supply is fixed at launch, so the 1.2% per hunt has to come from somewhere real: the scavenger sweeps every trading fee into market buybacks and stacks them into the burrow, and the hunter pays each rebase out of that reserve. If the burrow ever cannot cover a hunt, the warden pauses the grid instead of lying about it. Two hunts a day, the animal keeps its own time.
Nothing on top. There is no performance fee, no keeper tax, and no team allocation skimming the hunts. The crew’s infrastructure is self-hosted and its stack is open source under MIT. The only flows in the protocol are fees becoming buybacks, buybacks becoming the burrow, and the burrow becoming your rebase.