Job templates and hiring
Start from a developer, lead, devops, advisor, sales or content template and make it yours. Hire into a running office; your comments and order stay as you wrote them.
Open source · MIT · v0 pre-release
Run your AI like an office.Every hand-off needs proof.
You are the CEO. Your employees are the AI sessions you already use in Claude Code, Codex or Cursor. Work moves through sign-offs, nothing passes without proof, and payroll reads what each employee really used.
Your own AI, your own accounts
Employees are the AI sessions you already pay for. No new service, no keys handed over, no cloud: everything is files in your project.
Not another AI
Code Desks never calls a model. It hires, briefs and starts your existing sessions, hands work between them and keeps their payroll.
Payroll in usage, never guesses
Payroll reports what each employee actually used, per cycle, against a budget you set. It never guesses a price.
The north star
A whole company, on your laptop.
Forget office space and an org chart on the wall. Hire AI employees, give each a job, a toolkit and a budget, and decide the structure like a CEO. The structure you build is a file you own, and it becomes the way your business works.
- You decide, they proveEvery sign-off has your decision and the employee’s proof. Nobody can sign off on nothing.
- Proof anyone can re-checkChecks run on every hand-in, and desk verify re-runs them later, in CI or in someone else’s clone.
- A price before it startsThe team is priced in tokens per cycle, from your own history or a plan you name, and payroll shows what was really used.
Offices you can start from
Pick a kind of company. Make it yours.
Every office starts from job templates you edit into your own: developer, lead, devops, advisor, sales and content. Or start from the AI sessions you already run.
Plan it, build it, review it, ship it.
A lead turns your goals into assignments. A developer builds and hands in tests and a read-back of what shipped. An advisor reads everything, signs nothing, and mails you what it doubts.
- pm
- dev
- qa · advisor
These three sign-offs come out of the box.
Wire your team
Set up your office in three steps.
No config to write. Say the team you want, and the AI you already use writes the office file. Then desk wires every employee for you.
- its AI tool
- its skills
- its mail
- its own desk space
- your yes on what runs alone
01
Install desk
Needs Python 3.11 or newer, uv, tmux, and Claude Code, Codex or Cursor.
$git clone https://github.com/azank1/code-desk-cli$uv tool install ./code-desk-cli02
Say the team you want
Paste the prompt it prints into the AI you already use. It writes your office file.
$desk intake "PM, one dev on Claude, a Codex reviewer, weekly sprints"03
Open the office
The mail gets wired once. Then every employee opens in its own window, plus one for you.
$desk hooks --install$desk up
How the office works
Nobody can sign off on nothing, so the plan cannot quietly drift.
Three ideas carry the whole product: your company is a file you own, work moves through sign-offs, and proof has to pass a check before it counts.
01 / 03
Your company is one file.
office.yaml is your org chart: the employees, the sign-offs, the assignments and the first cycle. You read it and edit it like any document, and it lives in your project.
Start from a job template (developer, lead, devops, advisor, sales, content) and make it yours, or describe your team in a sentence and let the AI you already use write the file. Each employee gets a job description, a toolkit, a budget and its own desk space.
02 / 03
Work moves through sign-offs.
An assignment is one piece of work owned by one employee. It passes the sign-offs in order toward a deadline. Every sign-off has two halves: you decide, and the employee hands in proof. It passes only when both halves are in.
scope
You decide
scope · priority
Employee proves
estimate · risks
ready
proof firstYou decide
verdict
Employee proves
tests passing · proof
shipped
proof firstYou decide
acceptance
Employee proves
read-back · receipt
done
- 01Each side hands in only what the sign-off asks of it. Anything else is refused.
- 02Where proof comes first, your decision is refused until the employee’s proof is in.
- 03Proof is a file, a version or a link, stamped with a time. A read-back is a version someone saw, never “done”.
- 04An automatic check can stand on any item: the proof is accepted only if the check passes.
- 05A live check keeps a sign-off true after it passed. If it stops holding, a warning light comes on.
- 06When both halves are in, the assignment moves on. Nothing else moves it.
03 / 03
Proof has to pass a check.
Any hand-in can carry an automatic check: tests, a linter, a signature check. The check is yours, and the proof has to pass it before it counts.
A refusal writes nothing. What passes is pinned by its fingerprint, so a change after the fact is caught when the checks run again.
Everything an office needs
Hire, brief, check, meet and pay, all from files you own.
Advisors
An employee who signs nothing. It reads everything and mails you what it doubts, so a doubt sits beside the decision it is about.
Toolkits and desk space
Each employee sees only the skills you give it and works in its own copy of the project, so two employees never trip over each other.
Mail and briefings
Notes between employees on any AI tool, and to you. Briefings hand an employee only the files you name, with a deny list for terms no brief may carry.
Automatic checks
A command the proof has to pass before it is accepted. Later, re-run every accepted check and catch proof that changed after the fact.
Live checks
Read the real system instead of trusting a hand-in. A sign-off stays true only while the reading holds; when it stops, a warning light comes on.
Warning lights
Stalled work, unread mail, an employee over budget, a live check that stopped holding, sessions on nobody’s payroll. Each one names what clears it.
Board meetings and fire drills
Chair a round-table of your employees, then approve the minutes as actions. Rehearse a failure on paper and leave one new safeguard behind.
Payroll
What each employee actually used, per cycle, against the budget you set. Read from the logs your AI tools already keep. Tokens, never guessed money.
The price of a team
Know what a team will cost before it starts, from this folder’s own history or a plan you name, with the weekly range beside the mean.
The office as a picture
One self-contained page that draws the whole office in 3D: you, the employees, the checks, and every assignment as a lane through time.
Adopt a project
Already running AI sessions in a repo? Code Desks proposes employees from the names of the sessions it already has, and writes the office somewhere else.
At your desk
Everything that needs you, in plain words.
Worked out from the files in your project. Nothing is sent anywhere, and no model is asked.
Who owes what on every assignment. Decide your half and the assignment moves on.
AI tools
Works with the AI tools you already use.
Mix them in one office: a lead on Claude Code, a developer on Codex, a reviewer on Cursor. Each employee is a terminal window running its own AI tool, and mail moves between them.
Claude Code
Unread mail arrives as extra context at the start of the next turn, through a hook scoped to your project.
Payroll reads its usage from the logs it already writes.
Codex
Mail is pushed to a session named after the employee. Otherwise it waits for the employee to read it, which its job description asks for every turn.
Payroll reads its usage from the logs it already writes.
Cursor
Unread mail arrives at the start of the next turn in Cursor’s interactive terminal session, so keep Cursor employees in their window.
Sessions are counted to an employee; Cursor keeps no usage to read.
Questions
Straight answers.
Does Code Desks call a model?
Never. It hires, briefs and starts the AI sessions you already use, hands work between them and keeps their payroll. Warning lights, payroll and checks are worked out from files, not from asking a model.
Do I need a new account, a server or API keys?
No. Everything is files in your project: office.yaml, the work board, mail and receipts. Nothing runs when you are not running it. Close the terminal and nothing is lost; the work board is on disk.
What does it cost?
Code Desks is free and MIT licensed. Your employees run on the AI plans you already pay for, and payroll shows what each one used against the budget you set.
Why office words?
So anyone can read their AI team like an org chart. The office file and the commands keep short names, so nothing you have already written breaks.
Can an employee fake its proof?
The proof has to pass the check you wrote, and a refusal writes nothing. Accepted files are pinned by their sha256, the same file cannot back two hand-offs, and desk verify re-checks everything later. A check proves what its command proves, and no more: a signature check proves who sealed the proof and that it has not changed since. It does not prove the work was right. That decision stays yours.
Is it ready?
It is a v0 pre-release. Next on the roadmap: signed receipts at every turn end through a shared proof core, the work board exported as a view and never the source, and one full cycle of the office run on itself before anything is called 0.1.
You decide. Your employees prove it.
Free and open source under the MIT license. Your AI, your accounts, your files.