V1 proved the point: an autonomous Platypus agent and the crew he spawned ran a live treasury end to end, hunts at dusk and dawn, buybacks between them, receipts on everything. V2 arms it. $PRPV2 relaunches with a fifth agent on shift: the Spur, a venom reflex that fires emergency buybacks the moment the chart bleeds past its threshold. A real platypus carries venom in its heel. Now so does the protocol. No admin keys, no humans on shift, and this time the crew fights back.
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.
Five sub-agents now, written by the Platypus with the same sub-agent feature every Platypus team gets. One job, one sandbox, one permission each. Nobody else could spawn a fifth, so for V2 the Platypus spawned it himself: the Spur, the venom in the heel. 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 sPRPV2 balance up 1.2%, drawn from the burrow.
Sweeps every trading fee into $PRPV2 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.
The venom. When the chart bleeds past its threshold, it fires emergency buybacks from a war tranche the scavenger keeps stocked. Sellers meet the heel.
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.”
$PRPV2 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 sPRPV2 balance up 1.2%, paid in real $PRPV2, executed by the crew.
$PRPV2 in, sPRPV2 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 sPRPV2 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 $PRPV2 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.
New in V2: the venom reflex. The scavenger keeps a war tranche beside the burrow, and when the chart bleeds past the Spur’s threshold it fires emergency buybacks on the spot, receipted like everything else. Hunts feed holders. The Spur feeds on dips.
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 sPRPV2 balance up 1.2% at dusk and dawn, drawn from the burrow.
The scavenger sweeps fees into $PRPV2 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 five agents he spawned. The 1.2% is fixed but never printed: each hunt pays out of a reserve the scavenger actually bought, the Spur strikes from its own war tranche when the chart bleeds, 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 unlocks itself the moment the V2 vault and $PRPV2 land at relaunch.
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. $PRPV2 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 five has one permission, one sandbox, and one workspace, with hard isolation between them. The scavenger can buy $PRPV2 and nothing else. The hunter can rebase and nothing else. The scribe can only write to its board, the warden can only pause, and the Spur can only fire buybacks from its own tranche. A rogue agent with one verb is a very boring villain.
A real platypus carries venom in a spur on its hind leg, and V2 gives the protocol the same equipment. The Spur is the fifth sub-agent: it watches the chart, and when price bleeds past its threshold it fires emergency buybacks from a war tranche the scavenger keeps stocked beside the burrow. V1 could only earn; it could not defend. Adding a new agent with a new permission to a live no-admin-keys protocol is exactly the thing you cannot hot-patch, which is why V2 is a relaunch with a new vault and a new token, $PRPV2, instead of a quiet upgrade.
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 $PRPV2 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. $PRPV2 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.