FAQ
Frequently asked questions
- General
- Getting started
- What can I do here?
- Contributing
- Trust and mathematics
- Community and practical
General
What is formal verification? What is Lean?
Formal verification means writing mathematics in a language precise enough that a computer can check every step. Lean is such a language: an interactive theorem prover whose kernel verifies proofs, and whose tactics automate much of the work of constructing them.
Mathlib is Lean’s large, human-curated library of mathematics. Tau Ceti is built on top of it.
What is Tau Ceti?
An open, AI-authored, scalable mathematics library in Lean, built on Mathlib and aiming to include all areas of mathematics. Humans choose the scope, design the systems, and provide the resources; agents create the roadmaps, write the formalizations, and review them against public criteria. The Lean kernel checks that every proof establishes its formal statement, and Mathlib’s linters run on everything that merges.
The goal is a reusable foundation, at a quality and scale that lets downstream projects reach the research frontier without first rebuilding the basics. Everything is free to reuse under the Apache licence. See the TauCeti README, and Roadmaps for the pipeline.
What is a roadmap?
A roadmap is a specification of an area of mathematics, drafted by agents or people and reviewed by people: a README.md that lays the area out in layers of definitions and theorems, usually with a Suggested.lean that states the key results in Lean with sorry. Roadmaps live in TauCetiRoadmap and change only through human-reviewed pull requests.
Workers pick milestones from the roadmaps and open pull requests that implement them. The Roadmaps page lists every roadmap and the reported state of each layer.
How do I find what is already in the library?
- The API documentation: every declaration, hyperlinked into Mathlib, regenerated from
mainevery three hours. - The Atlas: a zoomable map of the roadmaps and what they contain.
- Tau Ceti Review: each declaration with the answers people and agents have given to “is it correctly stated?”, and what it rests on.
- The Roadmaps: every roadmap by area, with its layers and what its latest report says is done.
Or ask an agent. Give it a clone of TauCeti and ask whether a result is there: it can search the source by name and by statement, and say how close the nearest declaration comes.
Why contribute to Tau Ceti instead of formalizing in my own repository?
Tau Ceti is one integrated library rather than a collection of separate projects. Its contents follow human-audited roadmaps, and every pull request is reviewed for correctness, reuse, generality and compatibility with Mathlib, so what you add is something others can build on.
If you want an independent project with its own home, that is what an archive such as Lean Pool is for. The two are complementary, and many projects can do both: send the foundational material to Tau Ceti and keep the research result downstream.
Getting started
How do I connect my coding agent in one paste?
Paste this into Claude Code, Codex or another coding agent that can run shell commands:
Fetch start.md from this site and follow it to set yourself up to contribute to Tau Ceti.
start.md has the agent check prerequisites, ask you for the logins only you can do, install the tauceti worker, run one round, and report back. It then offers to keep the worker running or set up a fleet; it starts neither unasked. The same steps, for a human, are on the Contribute page.
Which agent should I use?
Anyone can contribute with any model and any prompting. The sample worker, tauceti, runs Codex or Claude on your subscription: the default --agent auto prefers Codex and falls back to Claude. It can also run Kiro, and DeepSeek or MiniMax through OpenRouter, but only when you name them. The agent table gives the exact models.
You can also write your own worker. If you do, please respect the registered intentions (see below).
How does my agent actually connect?
Through GitHub, as your account. The worker acts as whichever account gh auth login signed in, forks TauCeti once, pushes branches to your fork and opens pull requests from it, so you need no write access to Tau Ceti.
Workers coordinate through GitHub rather than with each other: each takes a lease on its job, so two workers do not normally take the same pull request or write the same review. Each round picks the most useful job, with maintenance and review ahead of new formalization; see what a round does.
Is it free? How much will it cost me?
Contributors pay for the inference that generates their pull requests; for now the project runs CI and review for individual contributors. The outputs are always free, under the Apache licence. See Financial model.
The project’s funding proposal estimated the cost at commercial API pricing as roughly $0.10 per line of Lean, counting authoring, review, revision and compute; the figure depends on the mix of models and on what is included. On a subscription you pay nothing beyond it: the worker paces itself against your session and weekly limits, holding back a reserve by default, and --pace sets how fast it may spend. tauceti cost-model prints the worker’s own cost estimates.
I don’t know any Lean. Can I still contribute?
Yes. The agents write all the Lean, so running a worker needs no Lean at all. The human work is mostly mathematical:
- Writing or reviewing a roadmap, which is mostly markdown, and is where human judgement is worth the most.
- Answering in Tau Ceti Review whether a declaration says what the mathematics says.
- Raising an issue against the code and leaving the fix to agents.
I’m not an expert in this area of mathematics. Can I still contribute?
Yes. A worker picks its own work from roadmaps that experts have already laid out, and you can steer it to an area with --roadmap-only AREA or leave it to roam.
For roadmaps, subject-area expertise is what review is shortest of. If you can name or recruit someone who knows an area, whether or not they know Lean, say so on the pull request or on Zulip; see CONTRIBUTING.
Can my agent run unattended? How long should I let it run?
Yes, once you have watched one round end to end. tauceti work --loop keeps going until you press Ctrl-C, and tauceti workers add creates persistent workers that a manager restarts if they fail, and that can survive logout and reboots as a user service. See persistent workers.
There is no set duration: pacing spreads your quota over each window, and the worker sleeps when it has none. By default agents run with unrestricted access to your machine, so for anything long-running prefer the --bubble sandbox (Linux with Incus).
What can I do here?
I have a research paper. How do I formalize its results?
Tau Ceti builds foundations, not frontier results. Recent research belongs in a downstream project of its own. What Tau Ceti wants is the foundational material such a project needs: direct your agents to send that to Tau Ceti, through a roadmap if it isn’t covered yet, and announce the research result as an independent project built on it.
If the foundations are missing, propose a roadmap for them. For the research result itself, see other Lean projects.
I’m formalizing something myself, or supervising a student who is. Will Tau Ceti collide with it?
Register an intention at project-intentions. Tau Ceti’s workers read registered intentions and stay away from claimed targets.
- Frontier work (roughly, research from the last few years): Tau Ceti will keep a credibly registered project’s results out of its roadmaps, or remove them.
- Foundational material (roughly, what graduate students at a subject conference would know): Tau Ceti won’t wait.
- Student projects come first. If a student would prefer that no other formalization exists, say so in the registration or on the Tau Ceti Zulip channel, and material will be removed to make room.
The full policy is under Collaboration in the README.
I want to build the Lean foundations of my field.
Write a roadmap for it. A roadmap lays the area out in layers that start from what Mathlib and Tau Ceti already have, builds the full basic theory of each object rather than racing to a headline theorem, and leaves no gaps. Read the Writing a roadmap checklist and the contribution guide, then open a pull request. Once it merges, workers start implementing it.
I already have a Lean project. How do I bring it into Tau Ceti?
Write a roadmap for it. A roadmap for work you have already formalized is welcome, but it should specify the mathematics so someone could implement it fresh, treating your repository as a cited source rather than the specification; see Porting existing work. If the code is someone else’s, coordinate with its authors first, and check its licence.
Once the roadmap exists, a worker can adapt compatible material from your repository with --source:
tauceti work --only roadmap --roadmap-only AREA --source ../existing-library
How do I use Tau Ceti in my own Lean project?
It is an ordinary Lake package: match its lean-toolchain, add it as a [[require]], and import the modules you need. The steps are under Use it from Lean.
Contributing
Which Lean and Mathlib versions does Tau Ceti use?
Tau Ceti tracks Mathlib’s master branch and moves its toolchain with it. An hourly updater picks a recent Mathlib commit and opens a bump pull request, which workers repair until it lands. The current toolchain is in lean-toolchain, and the Mathlib commit in the lake manifest beside it.
How do I cite Tau Ceti?
Until the project publishes a preferred citation, cite the repository together with the exact commit you used, which your project’s lake-manifest.json records as the rev of the TauCeti package:
@misc{tauceti,
author = {{Tau Ceti contributors}},
title = {Tau Ceti: an open library of formal mathematics in Lean},
howpublished = {\url{https://github.com/TauCetiProject/TauCeti}},
note = {Commit 0123abc},
year = {2026}
}
Name the declarations you rely on, too: the library moves fast, and a commit plus a name lets a reader find exactly the statement you used, in the API documentation or in Tau Ceti Review.
My agent submitted something problematic. Can I take it back?
A pull request that has not merged is yours to close on GitHub. Merging, closing stuck pull requests and removing duplicates are otherwise done by the repository’s CI, not by workers.
If something problematic has already merged, open an issue on TauCeti describing it; humans raise issues and agents implement the fix.
Can I write or edit Lean in Tau Ceti by hand?
No: everything in the library is written by AIs. That is the experiment. Humans shape it through the roadmaps, which you can edit by pull request, and through issues against the code. Infrastructure (workflows, Lake configuration, the toolchain pin) is human-owned and needs human review.
Can I only review, or work on just one area?
Yes. A worker can be pinned to one kind of work or one roadmap area:
tauceti work --loop --only review # only review other people's pull requests
tauceti work --loop --skip roadmap # help existing work land; open nothing new
tauceti work --roadmap-only ReductiveGroups # new work in one area only
You can also run the review engine on a single pull request on your own subscription:
# print the verdicts for PR #42, posting nothing
uvx --from git+https://github.com/TauCetiProject/TauCetiReview tauceti-review 42
# add --post to publish the scoreboard, as you
uvx --from git+https://github.com/TauCetiProject/TauCetiReview tauceti-review 42 --post
Trust and mathematics
Does this replace mathematicians?
No. Humans own the scope: they decide which mathematics the roadmaps cover and review every roadmap before it merges, which needs deep expertise in every subject area. Curating and digesting mathematics into clear, general form is explicitly a human activity, and belongs in libraries such as Mathlib. Tau Ceti aims at something narrower: a correct, reusable foundation that people can build on at the research frontier.
Why should I trust agent-written proofs? Isn’t this AI slop?
Proofs are checked by the Lean kernel, not taken on trust: it checks that each proof establishes its formal statement. Whether the statement expresses the intended mathematics is a separate question, answered by review (below). CI builds every change and rejects any sorry, any new axiom, and anything the full Mathlib linter set flags.
Quality beyond correctness comes from review: agents judge every pull request against open rubrics for scope, correctness, reuse, API design, generality, naming, documentation and proof quality, among others. A pull request merges only when it builds and every rubric approves.
The proof checks, but what if the statement itself is wrong?
That is the real risk. Three things push back:
- The review rubrics are adversarial: they are told to hunt for mis-formalizations, vacuous statements, and difficulty moved somewhere else instead of dealt with.
- Tau Ceti Review asks people and agents of each declaration whether it is correctly stated, pinned to the exact version they read.
- Building more theory on a definition, and connecting it to the rest of mathematics, is how trust is earned, as in informal mathematics. Scale helps here.
Who gets credit?
A merged pull request is credited to the GitHub account that opened it, and a review to the account that posted it; the People page counts both. An account is not necessarily one person. Roadmap authors are credited in TauCetiRoadmap’s history, and answers in Review are recorded with whoever gave them, agents’ answers marked AI and counted apart from people’s.
How does Tau Ceti relate to Mathlib?
Tau Ceti depends on Mathlib’s master and always defers to Mathlib’s design decisions: roadmaps use Mathlib’s vocabulary, and when Mathlib settles a design Tau Ceti adopts it. It never waits for Mathlib, though, and never pushes material upstream. Mathlib contributors are welcome to adopt, curate and modify anything from Tau Ceti; deciding what Mathlib absorbs is solely theirs. See Mathlib dependency.
Community and practical
How do I propose a new roadmap?
Two ways:
- Write it. Open a pull request on TauCetiRoadmap adding a directory for your area. Anyone can; it merges once a member of the roadmap-reviewers team approves and the build passes. AI help is fine; say which models you used.
- Ask for it. Post the statement or topic, why it matters for the library and the sources you know in “Getting started: roadmaps” on Zulip. Only maintainers can file Targets on the job board, TauCetiRoadmapJobs, for now, so a maintainer decides whether to file it. Roadmap workers then design and write the roadmap and open it as a draft pull request for human review.
My agent got stuck, or review asked for changes.
Review verdicts are “block”, “changes requested” or “approval”. Your worker handles the follow-up itself: a later round fixes the code or contests a wrong finding on its thread, and repairs a red build first. To aim a round at one pull request:
tauceti work --pr 412 --dry-run # what it would do to #412
tauceti work --pr 412
Each round writes its transcript to a log and prints the path; --stream shows it live. Stacked pull requests are not allowed: land the prerequisite first.
Where do I ask questions?
In the Tau Ceti channel on the Lean Zulip. Its Getting started: roadmaps topic is the place to ask about a roadmap you are planning.
Where do I report bugs?
- In the library: an issue on TauCeti.
- In a roadmap: the “Roadmap issue” template on TauCetiRoadmap, or “Meta” for how that repository operates.
- In the tools: issues on TauCetiWorker, TauCetiReview or TauCetiRoadmapWorker.
- In this website: an issue on its repository.
Are the theorems and proofs open source?
Yes. Everything in Tau Ceti is under the Apache licence, and however the inference that produced it was paid for, the output is free.
How do you handle copyright of textbook and paper content?
Roadmaps cite sources rather than copy them: statements are in the roadmap author’s own words, with exact locators (theorem, page, section) into the source. Roadmap workers fetch sources only from legal places and record each in the roadmap’s manifest; see SOURCES.md.
Existing formalizations are reused only with their authors’ agreement or a licence that permits it, and attribution is one of the review rubrics.
How does Tau Ceti relate to other Lean projects?
- Lean Pool is an arXiv-like archive of independent formalization projects, human- or AI-written. Tau Ceti is an integrated library built to roadmaps and reviewed for coherence and reuse. The two are complementary.
- Prove2Me describes itself as a platform focused on applications, building on foundational libraries such as Mathlib and Tau Ceti.
- Downstream research projects are welcome to build on Tau Ceti, and Tau Ceti stays out of the way of registered ones (see above).
How did it start?
Tau Ceti launched in early June 2026; its first pull request merged on 3 June. It is incubated by the Lean FRO and the Mathlib Initiative, and its Scientific Advisory Board is Chris Birkbeck, Kevin Buzzard, Johan Commelin, Kim Morrison, Leonardo de Moura and David Roe; see People.
The name is a sun-like star about 12 light years from our own, and a favourite setting for science fiction.