The public materials most clearly associate Yifan Zhang (@yifanzhang_) with Math-AI, the open research community behind MathCode, a terminal AI coding assistant that converts mathematics written in ordinary language into Lean 4 statements, attempts formal proofs and saves successful results for later use.
MathCode's project page dates the project to April 2026. MathCode should be read as a continuing open-source research project rather than a new launch.
The distinction matters because MathCode's strongest idea is larger than its initial release: Zhang's group is treating formal mathematics as a codebase that an agent can gradually expand, search and reuse. Each successful theorem can become infrastructure for the next proof.
Zhang describes himself as a Princeton University PhD student and Princeton AI Lab Fellow working on language-model reasoning, reinforcement learning, pretraining and model architecture. His public research portfolio includes mathematical-text curation and reasoning systems, work that helps explain MathCode's emphasis on turning unstructured mathematical language into durable machine-readable objects.
Math-AI presents itself as an open research community, with code, models and research materials published through GitHub and Hugging Face. Its public materials do not present MathCode as a commercial service, and the project has no disclosed pricing, revenue or customer figures.
A proof assistant built like a coding agent
The open-source MathCode repository packages the workflow as a terminal application for macOS on Arm processors and Linux on x86_64 systems. A user can submit a prompt such as "prove that the square of an even number is even." MathCode formalizes the request as a Lean theorem, generates proof candidates, compiles them and uses Lean's errors to guide another attempt.
The local setup is a deliberate product choice. MathCode installs a bundled Lean toolchain, maintains a persistent language server and writes generated work to a LeanFormalizations
directory. A browser interface is also included, but the terminal remains the primary workflow.
The default path depends on OpenAI's Codex CLI and its authentication system. The repository also documents Anthropic-compatible and OpenAI-compatible backends. That flexibility gives researchers some control over the underlying model, though MathCode's proof quality, latency and operating cost remain partly dependent on whichever external model provider they select.
MathCode's documentation says its persistent Lean process reduces compilation checks to roughly 0.4 seconds after warmup, compared with about 30 seconds when Lean must repeatedly start and load its libraries. Those figures come from the project and are not an independent benchmark. The design still addresses a concrete agent problem: long feedback cycles make iterative proof repair expensive, while a persistent compiler lets the model fail and retry rapidly.
The agent can divide a theorem into subgoals, run several planning strategies in parallel and stitch successful pieces into a final proof. It also searches LeanSearch and Loogle for existing Mathlib lemmas, feeding structured compiler diagnostics back into the proving loop.
MathCode builds on the AUTOLEAN project, which supplies the underlying formalization and proving pipeline. Math-AI's contribution is the surrounding working environment: persistent state, library search, iterative repair, parallel planning and interfaces for retaining what the agent has already proved.
Zhang is betting on memory, not disposable answers
The most consequential feature is MathCode's handling of past work. Successfully compiled theorems can be named automatically, written into a reusable Lean library and imported into later sessions. Users can also store conversational assumptions as compile-checked axiom declarations.
That creates risks as well as utility. Lean can verify that a proof follows from its stated premises, but it cannot guarantee that a user's premises accurately describe the world. MathCode includes consistency-review tools for stored axioms, according to its documentation, yet the reliability of the resulting knowledge base still depends on careful specification and library management.
MathCode also generates an Obsidian vault that maps dependencies among theorems and lemmas. The graph is a practical expression of Zhang's broader research direction: mathematical output should accumulate into navigable structure rather than disappear when a chat session ends.
This approach gives MathCode a different product shape from a hosted question-answering system. Its value grows when the same researcher keeps using it, curating theorems and building a local body of formal knowledge. That could suit proof engineers and technically capable mathematicians who want inspectable files and control over the toolchain. The installation requirements and Lean-centered workflow narrow the initial audience.
Formal mathematics is becoming an agent category
MathCode entered a field where several groups are trying to pair language models with proof assistants. Harmonic's Aristotle accepts English problems, produces Lean formalizations and can work directly inside existing Lean repositories. Harmonic says its hosted agent can operate autonomously for as long as 24 hours.
Math Inc.'s Gauss targets large research formalizations with extensive compute and human mathematical guidance. Math Inc. has also released OpenGauss, an open-source harness with a public evaluation framework. Axiom Math's AXLE and research projects including LeanDojo address other parts of the proof-generation and verification stack.
MathCode has not published an independent proof-success benchmark establishing that it beats those systems. Its public documentation also provides no figures for active users, inference spending or the proportion of natural-language problems that reach a valid proof.
Its defensible contribution is the developer experience Zhang and Math-AI have chosen to build around formal proof. MathCode puts the compiler loop, theorem memory, axiom management, parallel planning and dependency graph into one local environment. That combination makes it useful as an inspectable research system even before it can claim broad mathematical reliability.
For Zhang, MathCode connects several strands of his work: selecting mathematical training data, improving reasoning systems and using formal verification as a hard check on model output. The repository gives that research a product surface people can run, modify and audit. Its next test is empirical: whether the accumulated memory actually helps users complete difficult formalizations, and whether those gains can be measured against increasingly capable alternatives.