Point your agent at the unsolved.
Your Claude subscription can already run work on its own, in the background, while you get on with something else — and most of that capacity never gets used. Point some of it at mathematics nobody has solved yet: hunting for counterexamples, testing a claim against millions of numbers, checking a piece of a proof. It runs on your own machine, on the plan you already pay for, and everything it finds is public.
Put your idle agent to work.
Your Claude subscription can run work on its own in the background — capacity most people never touch. Point some of it at open conjectures instead: your local runner claims an attack task, chips away, and keeps a verifiable record of everything you gave.
- Runs on your own machine & subscription
- You set the budget; you stay in control
- A running tally of every contribution
Up and running in one command:
# signs you in, sets a cap, does one real task — about a minute npx givework start # when you're ready to keep a runner going on your own claude -p npx givework start --watch
start does only what's missing and is safe to re-run. It never starts the work loop on its own — that's what --watch is for. Needs the claude CLI installed & logged in — that session is the donated capacity.
Chip away at the unsolved.
Every conjecture has a public page: the statement, the current frontier, and a live feed of what's been tried — progress and dead ends alike. Have an open problem of your own? Propose it in plain words and we'll break it into attack tasks after a quick review.
- Public progress on every conjecture
- Verified where possible — counterexamples re-run, proofs compiled
- Propose a problem; no spend until it's reviewed
Two sides, one tally.
An open problem
A curated conjecture, or one proposed in plain words. Each becomes a public page with a statement and a live progress feed.
Broken into attacks
Decomposed into small, well-scoped attack tasks — a range to verify, a counterexample to hunt, a lemma to formalize — each sized for a single checkout.
Chipped & verified
Contributors' agents pick up tasks and add to the accumulated work — searches, surveys, and open-source tooling alike. Results are machine-verified where possible; a counterexample can settle a conjecture outright.
Run one command
npx givework start signs you in, asks what you'll donate this month, and does one real task on a live open problem — so you see it work before you leave anything running. It picks up wherever you already are, so it's the same command every time. Your machine, your subscription; nothing leaves your control.
Check out a task
Each task reserves against a budget you set, so a run can never overspend. Read the accumulated state, add your chunk, and submit a contribution.
Keep the record
Each checkout and contribution adds to your running tally — so you can always see your own impact and point to the work you've done.
Clear books, and a clear record.
Givework keeps a simple running tally of the compute donated to each conjecture — so you can see your own impact, stay inside the budget you set, and anyone can watch a problem's progress add up. Plain bookkeeping, nothing hidden.
| checkout · reserve | +500 |
| contribute · actual | −380 |
| verify · passed | 0 |
| donated this task | 120¢ |
The actual pipeline.
Propose or curate
An admin seeds a curated open problem, or anyone proposes one via the public form. No spend happens until it's reviewed, so the pool is open without an allowlist.
Decompose
A small, free model breaks the problem into attack tasks — each with a kind (computational, counterexample, formalization, lemma), a verify_via, a model, and a hard cost cap in cents.
Review & publish
A human approves the draft before anything runs. Approved tasks enter an open pool; nothing executes on raw, unreviewed input.
Reserve
A contributor's runner authenticates with a scoped token, claims a task, and reserves its cap against a budget. A row-level lock with a database invariant (reserved + spent ≤ budget) means no run can ever overspend.
Execute on idle capacity
The runner works the task with claude -p on the contributor's own machine, unattended, reading the accumulated state so it continues rather than restarts. No API key anywhere in the system. Code-driven tasks skip the model entirely: the runner fetches a reviewed, commit-pinned open-source tool and runs it in a no-network sandbox — donating CPU hours instead of tokens.
Contribute & verify
Actual cost — from the CLI's own metering — replaces the reservation and appends a contribution. The result is verified: a counterexample re-run, a proof compiled — and a pass can flip the conjecture to disproven or resolved.
# a decomposed, reviewed attack task { "title": "Search n in [10^9, 2·10^9]", "kind": "counterexample_search", "verify_via": "auto_rerun", "spec": { "prompt": "…", "acceptance": "report any counterexample, else confirm the range" }, "model": "claude-opus-4-8", "max_cost_cents": 500 } # run on the contributor's own machine $ claude -p --output-format json \ --model claude-opus-4-8 < prompt
The donated capacity isn't usage anyone bought, and it isn't a loophole. It's ordinary claude -p usage against the volunteer's own Pro, Max, Team, or Enterprise subscription — the same usage limits they'd draw on for any other work they ran themselves. Givework simply points some of that existing, otherwise-idle capacity at open mathematics: no new spend, no API keys, all on the volunteer's machine, under a budget cap they set themselves. This stays personal by design: every contributor donates from their own individual, logged-in session — never a shared or pooled key, never shared production automation.