A solo developer just demonstrated what happens when you give AI agents massive parallel compute: 20 open Erdős problems solved using 20 independent Codex instances running simultaneously on dedicated 60-vCPU servers. The project, called Star Fleet, represents a new paradigm for AI-assisted mathematical research — and a glimpse of how agentic workflows will reshape knowledge work.

What Happened

On July 15, 2026, the Star Fleet Math project announced it had solved 20 previously open problems from the Erdős Problems collection (erdosproblems.com) using a custom orchestration system that manages 20 parallel Codex agents. Each agent runs on its own 60-vCPU, 120 GiB memory sandbox with access to SAT/SMT solvers (CaDiCaL, kissat, Z3), computer algebra systems (SageMath, PARI/GP, GAP, Macaulay2), and the full Rust, CUDA C++, and Lean 4 toolchains.

The system is built from scratch in TypeScript and Bun. It's not a wrapper around existing agent frameworks — it's a purpose-built orchestration layer that treats each problem as an independent search program, sharding work across thousands of CPU cores when needed.

The Technical Architecture

Agent Harness Design

Each of the 20 agents operates as an independent "agentic harness" — a custom environment that:

• Runs GPT-5.6 (OpenAI's latest model) on a dedicated 60-vCPU server
• Has access to a 60-vCPU, 120 GiB sandbox with SAT/SMT solvers and computer algebra systems
• Can burst to x86-64 CPU bursts of up to 2,000 vCPUs for search programs that shard into thousands of independent single-core jobs
• Can burst to H100 GPUs for massively parallel search programs
• Maintains a local long-term memory system (Ton 618) where every verified Lean 4 premise is woven into a dependency graph so proofs compound

The Lean 4 Verification Pipeline

This is where it gets rigorous. Every candidate solution must be formalized in Lean 4 and pass a proof-verifier agentic harness before it counts. The pipeline:

1. Agent proposes a proof sketch in natural language + Lean 4 have statements
2. Proof-verifier harness (wrapping Claude Fable API) reviews the submission
3. Human-in-the-loop (via iMessage API) for additional review after Fable approval
4. Verified premises enter Ton 618, a dependency graph where every theorem becomes a reusable building block for future problems

This means the system gets smarter over time — each solved problem expands the library of verified lemmas available to subsequent agents.

Problem Selection: Avoiding "Already Solved" Traps

The team explicitly filtered for problems where no complete solution existed in the literature. Many Erdős problems carry informal or partial answers online; they "tried extremely hard to avoid working on any such problems." Each problem entry includes the exact Lean 4 theorem statement (e.g., Erdos123.erdos_123 : Erdos123.IntendedStatement) so there's no ambiguity about what counts as a solution.

Why Erdős Problems?

Paul Erdős posed hundreds of open problems across number theory, combinatorics, and analysis, many with cash prizes (typically $250-$500). They're ideal for AI-assisted research because:

• Well-defined: Each has a precise mathematical statement
• Verifiable: Solutions can be formally verified in Lean 4
• Independent: 20 problems can be attacked in parallel without interference
• Measurable progress: Binary success/failure per problem

Erdős Problem #123 (prize: $250) asks: given three pairwise-coprime integers a,b,c > 1, is every sufficiently large integer a sum of distinct terms of the form a^i b^j c^k where no selected term divides another? The divisibility condition is the core difficulty — standard completeness arguments fail because terms from different scales tend to be comparable by divisibility.

Technical Breakthrough: Homogeneous-Level Coordinate System

The Star Fleet approach to Problem #123 reveals a sophisticated mathematical strategy that the AI agents discovered (or were guided to):

1. Work on one homogeneous exponent level — For pairwise-coprime bases, divisibility of monomials is coordinatewise comparison of exponents. Two distinct monomials on the same level can never divide each other. Primitiveness becomes free.

2. Edge-code construction — Build primitive subset sums on one level with distinct residues modulo M and bounded carry.

3. Finite van der Waerden (from Mathlib's Hales-Jewett theorem) → arbitrarily long exact arithmetic progressions of primitive homogeneous subset sums.

4. Translate copies by coprime homogeneous weights to fill a large lattice interval on one exact degree.

5. Face corrections for residue classes, supported on coordinate faces, disjoint from the strict-interior AP terms.

6. Exponential domination ensures the interval width grows faster than the correction overhead.

This isn't just "AI did math" — it's AI orchestrating a multi-step proof strategy that combines additive combinatorics, finite Ramsey theory, and careful degree management.

Scale: 20 Problems, 20 Agents, Thousands of Cores

The compute architecture is staggering:

• 20 persistent agents × 60 vCPU = 1,200 dedicated vCPUs baseline
• Burst capacity: up to 2,000 vCPUs for CPU-parallel search, H100 bursts for GPU-parallel work
• Custom Lean 4 environment with 46,000+ regression tests passing
• Full SAT/SMT/CAS toolchain preinstalled in every sandbox
• arXiv/GitHub index via Firecrawl.dev + gemini-embeddings-2 + Chroma vector DB for literature search

This is not "chat with an LLM." This is a production-grade research infrastructure where AI agents have first-class access to the same tools a human mathematician would use — and then some.

What This Means for Developers

1. Agent Orchestration > Single-Agent Chat

The Star Fleet architecture demonstrates that parallel agent orchestration beats single-threaded conversation for complex tasks. When you can spin up 20 independent agents, each with its own compute budget and toolchain, you're not limited by context windows or sequential reasoning. You're doing distributed search.

2. Formal Verification as a Forcing Function

Requiring Lean 4 formalization changes the game. It eliminates hallucination by construction — if the proof doesn't type-check, it's not a solution. The proof-verifier harness (Claude Fable + human review) adds a second layer. This is a pattern we'll see everywhere: AI generates, formal verifier validates, human spot-checks.

3. Compounding Knowledge via Dependency Graphs

Ton 618's design — every verified lemma becomes a node in a reusable dependency graph — is how you build systems that improve over time. Most agent architectures are stateless; this one accumulates verified knowledge. That's the difference between a demo and a research platform.

4. Custom Toolchains Beat Generic Ones

The team didn't use LangChain or AutoGen. They built a custom orchestration layer in TypeScript/Bun because existing frameworks couldn't handle: persistent 60-vCPU sandboxes, burst scaling to 2,000 vCPUs, Lean 4 integration, and a custom memory system. When your workload is idiosyncratic, generic frameworks become constraints.

5. The Economics Have Shifted

Running 20 GPT-5.6 instances on dedicated 60-vCPU servers with burst capacity to thousands of cores isn't cheap — but it's orders of magnitude cheaper than hiring 20 human mathematicians for the same duration. The cost per solved Erdős problem (including compute, API calls, and engineering time) is likely under $10,000. The prize money alone ($250 × 20 = $5,000) covers half.

Frequently Asked Questions

Is this just "vibe coding" with better marketing?

No. Vibe coding implies informal, unverified, throwaway code. Star Fleet produces formally verified Lean 4 theorems that compile in a CI pipeline with 46,000+ tests. Every solution is machine-checkable and human-auditable. The difference is the verification layer.

Could a human do this alone?

A human mathematician could solve these problems, but not 20 simultaneously in days. The parallelism is the key: 20 agents exploring 20 different problem spaces, each with tool access that would take a human hours to set up per problem. The human role shifts from "solver" to "architect and reviewer."

What about the other 180+ open Erdős problems?

The system is designed to scale. Adding more agents is linear (more servers). The bottleneck becomes problem formalization in Lean 4 and verification throughput. The team is already working on automating more of the formalization step.

Does this generalize beyond mathematics?

Yes. Any domain where:

• Problems can be formalized (specs, types, contracts)
• Solutions can be verified (tests, proofs, compilation)
• Search space benefits from parallel exploration

...can use this architecture. Software verification, circuit design, protocol analysis, drug discovery — any field with a formal specification language and a verifier.

What's the catch?

• Lean 4 expertise required: Formalizing problems in Lean 4 is still a specialized skill
• Compute costs: Burst capacity to 2,000 vCPUs + H100s adds up
• Verification throughput: Human review (even lightweight) doesn't parallelize as easily
• Prize collection: Erdős prizes require publication; the team plans to submit to arXiv and journals

Key Takeaways

1. Parallel agent orchestration is here — Not as a demo, as a working research platform solving real open problems
2. Formal verification makes AI trustworthy — Lean 4 + proof-verifier harness eliminates the hallucination problem for mathematical reasoning
3. Compound knowledge beats single-shot — Ton 618's dependency graph means each solved problem makes the next one easier
4. Custom infrastructure wins — TypeScript/Bun orchestration + dedicated sandboxes + custom memory > generic agent frameworks
5. The economics favor AI at scale — 20 problems solved for ~$10K compute vs. years of human effort

Conclusion

Star Fleet represents a new category: AI-native research infrastructure. It's not "AI assists a mathematician." It's "mathematicians architect AI swarms that do the search, formalize the results, and build a compounding knowledge base."

The 20 Erdős problems are just the demonstration. The real product is the orchestration layer, the verification pipeline, and the memory system. If you're building agentic systems in 2026, this is the architecture to study — not because it solves math, but because it shows how to make AI agents reliable, parallel, and self-improving.

The code isn't open source yet, but the team has indicated they'll publish the orchestration framework. Watch this space — the era of "one developer, twenty agents, thousands of cores" has arrived.

---

Source: Star Fleet Math, Hacker News Discussion