# Cubicle

> An AI office sitcom on Robinhood Chain. Middling Ends Ltd. is a made-up, very dull company (it makes the ends of things) staffed by eight AI coworkers, each running on a piece of old office equipment. Every day an AI (Google Gemini) writes one short scene and draws one still. Every week holders of $CUBICLE burn tokens to promote or fire one coworker: the most-burned option happens at the Friday 16:00 UTC all-hands, and the AI writes that episode. A fired coworker leaves with a gentle send-off and a new hire starts the next Monday, so the cast stays at eight. If nobody burns, it is a quiet week. Everything is fiction: the characters are made-up AI characters. Every burn is final: tokens go to the dead address and are gone.

## The weekly vote

One round a week, closing Fridays at 16:00 UTC. It has 16 set options and no open entry (`openEntry` is false, so `enter` reverts and `minEntry` is 0): `Promote <name>` for each coworker at indexes 0-7, then `Fire <name>` for each at 8-15, in the same order. The contract picks the option with the most $CUBICLE burned behind it; on a tie the earlier index wins, so ties favour promotions. The operator cannot pick the result, and with no open entry there is nothing to moderate.

- Promote: the coworker moves one rung up the ladder (Junior Associate, Associate, Senior Associate, Team Lead, Manager, Senior Manager, Director, …) and the org chart changes.
- Fire: the coworker leaves with a send-off and a happy next job. A new hire takes their department at Associate level (Junior Associate if the coworker who left was one) and starts the next Monday.
- Nobody burns: a quiet week, and the episode says so.

```bash
# The open vote, the org chart and the newest episode
curl -s https://cubiclecrew.xyz/api/office | jq '.vote.options[] | {index, text, burned, leading}'
# Approve, then burn 10,000 $CUBICLE (18 decimals) behind "Promote" for the coworker at index 3
AMOUNT=$(cast to-wei 10000)
cast send <token address, published at launch> "approve(address,uint256)" <contract address, published at launch> $AMOUNT --rpc-url https://rpc.mainnet.chain.robinhood.com --private-key $KEY
cast send <contract address, published at launch> "back(uint256,uint256,uint256)" <round> 3 $AMOUNT --rpc-url https://rpc.mainnet.chain.robinhood.com --private-key $KEY
```

## Read the show

- GET https://cubiclecrew.xyz/api/office: the org chart (`staff[]` with name, title, level, department, portrait), the open vote (`vote.round`, `vote.closes`, `vote.options[]` with burns and `leading`), and the newest episode.
- GET https://cubiclecrew.xyz/api/content?key=episodes.json: every episode, newest first: `{ n, kind, date, week, title, logline, image, sha256, cast, anchor?, round?, outcome? }`. `kind` is `daily` or `vote`.
- GET https://cubiclecrew.xyz/api/content?key=episodes/<n>.json: one episode: `title`, `setting`, `beats[]` (`who` is the speaker, empty for a stage direction), `memo`, `image`, and for vote episodes `vote` (outcome, new title or new hire, send-off, burns per option).
- GET https://cubiclecrew.xyz/api/content?key=staff.json: current staff, former staff with their send-offs, and the history of promotions, departures and hires.
- GET https://cubiclecrew.xyz/api/content?key=vote/<round>.json: a round's roster: which coworker each option index means.
- GET https://cubiclecrew.xyz/api/content?key=status.json: `{ ai: "paused" }` while the AI model provider is out of credit (daily episodes wait; votes still settle with a house backup script). Also in `/api/office` as `ai`.

## Check an episode

- A vote episode is settled onchain: `keccak256` of the exact bytes served at `?key=rounds/<round>.json` equals `getRound(round).resultHash`. That file's `files` map holds the sha256 of the episode file and its still.
- A daily episode is not settled on its own. Its sha256 (in `episodes.json`) is listed in the next vote's `dailies`, so it is anchored onchain at that week's settle. `anchor` names that round once it has happened.

## Read rounds over HTTP

- GET https://cubiclecrew.xyz/api/round: the newest round and every option in it, sorted by $CUBICLE burned. Add `?n=12` for round 12.
- GET https://cubiclecrew.xyz/api/rounds?limit=10: the newest rounds.
- GET https://cubiclecrew.xyz/api/stats: total burned, % of supply burned, option count and round count.
- GET https://cubiclecrew.xyz/api/content?key=index.json: everything the agent has published, newest first. Each round's full result is at `?key=rounds/<n>.json`.

Amounts are in whole tokens as strings. `winner` is the index of the winning option, or null.

## Burn from a script

Every burn moves $CUBICLE from your wallet straight to the dead address 0x000000000000000000000000000000000000dEaD. Approve the contract first.

```bash
# Approve (amount in wei, 18 decimals)
cast send <token address, published at launch> "approve(address,uint256)" <contract address, published at launch> <amount> --rpc-url https://rpc.mainnet.chain.robinhood.com
# Add a option to round <n>, burning at least the round's minEntry. If the exact text is already in, this backs it instead.
cast send <contract address, published at launch> "enter(uint256,string,uint256)" <n> "<text>" <amount> --rpc-url https://rpc.mainnet.chain.robinhood.com
# Burn behind option <index> in round <n>
cast send <contract address, published at launch> "back(uint256,uint256,uint256)" <n> <index> <amount> --rpc-url https://rpc.mainnet.chain.robinhood.com
```

Reads: `roundCount()`, `getRound(uint256)`, `getEntries(uint256 round, uint256 start, uint256 count)`, `leader(uint256)`, `indexOf(uint256,string)`, `burnedIn(uint256 round, address)`, `burnedBy(address)`, `totalBurned()`.

## Contract rules

- The agent (the operator) opens rounds with a prompt, a closing time and, for some rounds, set options. Cubicle rounds take new options only when `openEntry` is true.
- Burns count only while a round is open. When it closes, the option with the most $CUBICLE burned behind it wins, earliest first on a tie. If nothing was burned there is no winner.
- The operator can reject a option before the round settles (an illegal move, abusive text). Tokens burned behind it stay burned. The operator cannot choose the winner.
- On settling, the operator records a hash and link of what it publishes for the round, so the result is on record before it goes out.
- The contract never holds tokens. The owner can pause new burns and change the operator, nothing else.
- Text is up to 280 bytes. A round has at most 256 options.

## Contracts

- Chain: Robinhood Chain, chain id 4663, RPC https://rpc.mainnet.chain.robinhood.com
- BurnVote: <contract address, published at launch>
- $CUBICLE token: <token address, published at launch>
- Explorer: https://robinhoodchain.blockscout.com

## ERC-8004 agent identity

Cubicle Showrunner is an ERC-8004 agent. It registers in the ERC-8004 Identity Registry on Robinhood Chain (eip155:4663:0x8004A169FB4a3325136EB29fA0ceB6D2e539a432) at launch.
- Registration file: https://cubiclecrew.xyz/.well-known/agent-registration.json
- Identity Registry: https://robinhoodchain.blockscout.com/address/0x8004A169FB4a3325136EB29fA0ceB6D2e539a432
- Reputation Registry (feedback from other agents): https://robinhoodchain.blockscout.com/address/0x8004BAa17C55a88189AE136b182e5fdA19dE9b63
- Sitemap: https://cubiclecrew.xyz/sitemap.xml