Building Massively Parallel Agentic Harnesses for Complex Math Verification Tasks
Star Fleet, a new desktop system built on TypeScript and Bun, successfully solved 19 open Erdős math problems. The architecture orchestrates 20 parallel agentic 'starships' running GPT-5.6, integrated with Lean 4 verification and local SMT solvers.
Impact: High
Why it matters
Developers can study this multi-agent verification pattern to build highly reliable, self-correcting agent pipelines using localized tools and formal language checkers.
TL;DR
- 01Strict sandboxing with local compilers and SAT solvers prevents LLM logic failures.
- 02Combining LLM proof generation (GPT-5.6) with separate LLM audit (Claude Fable) improves reliability.
- 03A structured dependency graph ('Ton 618') allows compound agentic learning over long-term executions.
Key facts
- Number of Erdős problems solved
- 19
- Parallel agent instances
- 20
- Sandbox CPU configuration
- 60-vCPU
- Sandbox RAM size
- 120 GiB
Multi-Agent Orchestration with Bun and TypeScript
The entire Star Fleet orchestrator is implemented from scratch using TypeScript and Bun. It drives parallel processes called 'starships', which manage individual reasoning tasks. Rather than relying on generic prompt structures, each starship controls a dedicated 60-vCPU, 120 GiB memory sandbox preinstalled with:
- Formal Verification: The complete Lean 4 toolchain.
- Solvers: CaDiCaL, kissat, Z3, and Google's CP-SAT.
- Algebra Systems: SageMath, PARI/GP, GAP, and Macaulay2.
- Compilers: Rust and CUDA C++ toolchains.
Context Caching and RAG Mechanics
To query mathematical premises, Star Fleet utilizes a local semantic search engine built with gemini-embeddings-2 and a Chroma vector database. The database indexes the largest known corpus of Lean 4 theorems and lemmas, searchable in plain English. For external knowledge retrieval, the system leverages a Firecrawl index of arXiv.org papers and GitHub repositories.
Verification and the Human-in-the-Loop Hook
The architecture implements a multi-layered validation chain to prevent hallucinations in complex tasks:
1. Local Execution: The agent writes Lean 4 code and executes it within the sandbox to verify compilation and proof validity. 2. LLM Verification: A separate Claude Fable API acts as a proof-verifier agent to audit the steps. 3. Human Escalation: Once Claude Fable approves, the system triggers an iMessage API notification to request final human review. 4. Premise Weaving: Approved proofs are written into 'Ton 618', a local memory graph, making them reusable for subsequent problems.
Try it in 2 minutes
// Bun-native parallel worker execution skeleton for Star Fleet style agent orchestration
import { spawn } from "bun";
async function runStarshipSandbox(problemId: number) {
const proc = spawn(["lean", "--run", `proofs/problem_${problemId}.lean`], {
stdout: "pipe",
stderr: "pipe"
});
const stdout = await new Response(proc.stdout).text();
const stderr = await new Response(proc.stderr).text();
return { success: proc.exitCode === 0, stdout, stderr };
}typescript
✓ When to use
- When building mathematical or highly logical reasoning engines that require absolute verification
- When executing parallel LLM orchestration tasks that benefit from dedicated local compilation environments
✕ When NOT to use
- For simple generative tasks like writing blog posts or boilerplate code
- When API and infrastructure costs for multi-vCPU servers are prohibitive
What to do today
- Review the Star Fleet architecture for implementing automated validation loops in your agent pipelines.
- Explore Lean 4 integration for deterministic verification of generated algorithmic solutions.
What the community says
“As the tools for AI assisted proof become better and mathematicians make it mainstream (could take a while), we're going to be seing some pretty crazy shit.”
Sources