TL;DR
PRAXIST is an autonomous research system from Sapient Intelligence (the Singapore/Palo Alto lab behind the Hierarchical Reasoning Model). You hand it a project that already runs and has a measurable objective; it runs parallel “research peers” that propose, implement, and evaluate competing approaches, then synthesizes the evidence into the next generation’s agenda. The pitch is not “an agent that writes code” — it’s a persistent research loop with an auditable lineage for every reported improvement.
Key facts (verified 2026-09-11):
- 6,559 GitHub stars, 624 forks, 10 open issues — repo created 2026-08-27, last push 2026-09-09
- Python 3.11+,
pip install "praxist[agents,codex]"; operated through Codex or Claude Code skills, or the plainpraxistCLI - Fair Source License 1.0 — source-available, free under US$1M annual revenue and for academic use
- Headline benchmark (arXiv 2608.25955, 26 Aug 2026): 60 medals / 49 gold on the 75-task MLE-bench at US$3,054 model spend, vs 55 / 34 gold for a Claude Code baseline on Claude Opus 4.8 at US$38,370
- Runs on DeepSeek V4 Pro (the “priority 1” profile), OpenRouter, Anthropic, or a no-API-key Codex-native mode
- Release-tested only on Linux; macOS is a “compatibility target”
The interesting part is the architecture claim: instead of a tree search that prunes weak branches, PRAXIST keeps a generation-layered evidence graph so later attempts can recombine mechanisms from failed lineages.
Why This Matters Now
We’ve covered the “AI runs your experiments” space before. Karpathy’s AutoResearch is the minimalist end — 630 lines of Python, one GPU, let the agent loop overnight. Prime Agent and Hermes Agent are self-improving harnesses. PRAXIST sits at the heavyweight end: a full orchestration layer with preregistered metrics, evidence maturity rules, resource scheduling, and legal acceptance flows.
The paper’s framing is the sharpest statement of the problem. From the arXiv abstract:
“Most systems treat each attempt as nearly self-contained, so logs, memories, and search trees record what happened without establishing which design element produced an improvement… Long campaigns therefore keep re-learning the same lessons.”
Anyone who has run a coding agent on a long optimization task will recognize that: the agent tries the same three ideas, in a slightly different order, every session. PRAXIST’s answer is to make evidence — not conversation history — the unit of memory.
It also matters who is shipping it. Sapient Intelligence made noise in 2025 with HRM, a tiny recurrent model that punched above its weight on ARC-style puzzles. A commenter in the r/LocalLLaMA thread read PRAXIST as a pivot from “better motor” to “better car body around any motor” — the same bet much of the harness ecosystem is making this year.
What PRAXIST Actually Is
PRAXIST owns orchestration, run lifecycle, evidence protocols, replay, scheduling, and plugin interfaces. Your task project owns the objective, executable code, evaluator, metrics, baselines, prompts, roles, and domain constraints — PRAXIST “contains no task-specific scientific assumptions.”
Every run is driven by a task project — a directory with a task.yaml, a description.md, a roles/ folder of Markdown role contracts, audit_rules/, and an evaluations/<name>/run.py that turns a candidate into structured metrics. PRAXIST never touches your original project; run artifacts land in a separate experiments/ directory.
The three prerequisites from the README’s FAQ are the whole gating logic:
- The objective is measurable — at least one metric with a known direction.
- The project already runs — baseline code, environment, data or simulator all work without PRAXIST.
- The best path forward is unknown.
If any prerequisite is missing, PRAXIST is designed to stop and say so. It will not “silently download unspecified datasets, invent a simulator, or fabricate baseline performance.” Given how often coding agents hallucinate a benchmark number to close a loop, that refusal is one of the more valuable design decisions here.
Architecture: Generations, Lanes, and the Evidence Graph
The core loop runs in generations. In each, a cohort of parallel research peers (the docs’ examples use 12) each build a candidate; a task-owned evaluator scores every candidate through the same protocol; then a planning panel of Principal Investigator (PI) agents — optionally with a Chair in multi-PI mode — reads the accumulated evidence and writes the next generation’s agenda.
What distinguishes it from a plain best-of-N loop:
Typed evidence graph. Evaluator outcomes become findings with provenance and lineage, not free-form logs. The press release contrasts this with “the tree-like search used by other similar systems, where each candidate inherits from one parent and weaker branches are pruned.” A later peer can inherit a mechanism from a dead branch.
Frontier lanes. Candidates live in incubator, frontier, and “Gems” states. Each lane declares parent_eligible — only mature, durable lanes seed the next generation; partial, diagnostic, and “suspect” results stay visible without contaminating the parent pool. Multi-metric tasks can retain Pareto-optimal solutions.
Deep Innovation Gate (DIG). An optional pre-code reasoning phase, recommended only for generation zero. Before a peer writes anything, it maps the baseline mechanism, critiques a pool of candidate mechanisms with read-only planner tools, and commits to a selected_contract.yaml naming the intervention surface, rejected alternatives, expected metric signature, and fail-fast checks. Deviating mid-implementation requires an auditable contract_amendment.yaml.
Quality-Diversity (QD) allocation. An independent switch that spreads peers across diversity cells so the cohort doesn’t collapse onto one approach.
Central resource scheduler. Experiment admission adapts to observed resource pressure, with explicit NVIDIA/CUDA UUID handling for multi-GPU boxes.
Everything is designed for resume, replay, and audit. praxist resume <run_dir> picks a run back up; Ctrl-C closes the monitor, not the research.
The Benchmark Claims
The MLE-bench numbers are why this repo hit 6.5K stars in two weeks.
| System | Model | Medals (of 75) | Gold | Recorded model spend |
|---|---|---|---|---|
| PRAXIST | DeepSeek V4 Pro | 60 (80.0%) | 49 | US$3,054 |
| Claude Code baseline | Claude Opus 4.8 | 55 (73.3%) | 34 | US$38,370 |
Source: arXiv 2608.25955, “finalized official-grader results.”
Three things to note before quoting these:
- These are vendor-run evaluations. Sapient ran both arms. A Claude Code baseline is a choice of harness, and Claude Code isn’t designed for multi-day research campaigns.
- The cost comparison mixes model and harness. DeepSeek V4 Pro is far cheaper per token than Opus 4.8, and PRAXIST’s docs favor it for “high observed cache-hit rate.” The 12× cost gap is at least partly a model-pricing story. The medal gap (60 vs 55) is the cleaner signal.
- The engineering case studies are partner-provided. The press release reports a rocket-landing simulation reaching 100% success within 12 hours (TRL 3), and an industrial SLAM problem where 9.37 cm of accumulated error dropped to 5.01 cm in three days. Neither the simulators nor the baselines are public; the two
rocket_booster_recoveryexamples in the repo (Python/JAX and Rust) are the closest reproducible artifact.
The honest read: the medal count on a standardized suite is a strong result, the cost multiplier is a marketing number, and the partner stories are unverifiable.
Getting Started
The README’s one-liner installs the runtime integrations and launches an interactive first-use wizard:
python3 -m pip install --index-url https://pypi.org/simple "praxist[agents,codex]" \
&& praxist setup --interactive --install-skills codexThe wizard walks through Fair Source License acceptance (explicit, digest recorded), optional usage consent (nothing preselected), a runtime profile (provider + agent runtime + model + auth mode), masked API-key entry, and readiness checks. It deliberately does not pick a project or start a run. Claude Code users get a separate one-liner and invoke /praxist-takeover instead of $praxist-takeover.
Codex-native mode (no API key)
The shortest path: choose the Codex-native profile and PRAXIST uses your saved ChatGPT/Codex login. It’s meant for trying things out — for sustained runs the docs steer you to a cheaper API-backed profile.
Agent-managed install
Or open codex --yolo (or claude --dangerously-skip-permissions) and ask it to “Install and configure Praxist. Follow the packaged OOBE runbook and stop after readiness checks.” The agent polls praxist setup --agent-managed for JSON describing the next decision; it’s forbidden from accepting the license on your behalf or asking for an API key in chat.
Takeover
Once installed, cd into a project that already runs and hand it over:
# Codex
praxist --takeover --task-path /absolute/path/to/research-project
# Claude Code
praxist --takeover --operator claude --task-path /absolute/path/to/research-projectTakeover runs Discover → Design → Verify → Launch: inspect the project, runtime, and baseline; design metrics, evidence rules, roles, and resource plans; run task tests plus praxist resolve and praxist doctor; launch a detached run. The brief matters: the README’s template asks for objective, metric direction, constraints, peer and generation counts, budget, and whether launch is authorized.
Operate a running campaign with:
praxist status --json
praxist --monitor --latest
praxist stop <run_id>
praxist resume <run_dir>Try a bundled example first: praxist examples install rocket_booster_recovery installs a writable copy to run from.
Bundled Skills
PRAXIST ships as Agent Skills-style commands rather than a monolithic CLI:
| Skill | Purpose |
|---|---|
praxist-takeover | Inspect readiness, build/repair the harness, launch after gates pass |
praxist-task-initialization | Build or repair a task harness without launching |
praxist-control | Start, stop, resume, monitor, inspect runs |
praxist-diagnostic | Diagnose run health, produce reports |
praxist-scientific-research | Gather sourced literature and benchmark context |
The README is explicit that PRAXIST is “not a replacement for Codex” — Codex (or Claude Code) stays the interactive agent that talks to you; PRAXIST adds the persistent loop underneath.
Community Reaction
Reception has been cooler than the star count suggests. The r/LocalLLaMA post sat at a 38% upvote ratio; the top comment was “buy an ad.” Another called the “vague and ‘scientific’ descriptions” a possible “money pump from VC funds” and asked for something “down to earth for regular pleb” — like finding the cheapest RTX 3090 in Europe — rather than tokamak control. The most-repeated correction: it is not open source — “source available, as they write themself on their github page.” The Hacker News submissions got one point each, no discussion.
Some of that is r/LocalLLaMA’s allergy to enterprise press releases. But the README, docs, and paper are written in a dense, contract-heavy register (“lane-structured frontiers,” “cooperative launch guard”) that makes it hard to tell in five minutes whether this is for you.
The issue tracker is healthier: recent PRs added Groq, Mistral, and xAI provider plugins (#184), provider cost metering (#111), and macOS symlink fixes (#192). One open bug (#189) reports the rocket_booster_recovery example failing a canary check due to a stale hash pin — check before using it as your first run.
Honest Limitations
- Source-available, not open source. Fair Source License 1.0. Free under US$1M aggregate annual revenue (affiliates included) and for academic research; above that, you negotiate with Sapient Intelligence Pte Ltd. Externally published outputs must keep the attribution “Praxist by Sapient Intelligence.”
- Linux-first. Release-tested only on Linux with CPython 3.11/3.12. macOS is a compatibility target. Windows isn’t mentioned.
- Heavy onboarding. Legal acceptance, consent, profile selection, skills registration, then a separate takeover with its own gates. For a weekend project it’s overkill.
- Requires a measurable objective. No evaluator, no PRAXIST. Fuzzy goals are out of scope by design.
- Cost is open-ended. Twelve peers over thirty generations, each running your evaluator, adds up fast. The docs advise one or two bounded calibration runs first.
- Beta. Two weeks old, 10 open issues, an example with a broken canary. Expect churn.
- Vendor benchmarks only. No independent reproduction yet.
Who Should Use PRAXIST
Good fit: ML teams with a pipeline that already runs, a clear metric, and GPU budget for parallel experiments; robotics/controls/simulation groups where the objective is a simulator score; Kaggle-style competition work (literally what MLE-bench measures); academic labs, since the revenue threshold doesn’t apply.
Poor fit: anyone without a working evaluator; companies over the $1M threshold who want an open-source guarantee; quick one-off optimizations (use AutoResearch or a plain Codex/Claude Code loop); macOS-only shops that need release-qualified stability today.
PRAXIST vs Alternatives
| PRAXIST | Karpathy AutoResearch | Plain Claude Code / Codex loop | AutoML (Optuna etc.) | |
|---|---|---|---|---|
| Search space | Methods, architectures, code | Code edits in one file | Whatever you prompt | Predefined hyperparameters |
| Memory across attempts | Typed evidence graph, lineages | Git history + results log | Conversation / files | Trial database |
| Parallelism | Cohorts of peers, scheduled | Sequential, one GPU | Manual | Built-in |
| Audit trail | Preregistered metrics, provenance | Commit log | None by default | Trial log |
| License | Fair Source 1.0 (<$1M free) | MIT | Proprietary tools | Open source |
| Setup weight | Heavy | Trivial | Light | Light |
Sapient’s framing of the AutoML comparison is fair: “AutoML tunes parameters within a predefined search space. Praxist runs the full research loop.”
FAQ
Is PRAXIST open source?
No. It’s under the Fair Source License Agreement 1.0 — source-available. You can read, download, and modify the code; organizations under US$1M aggregate annual revenue and academic institutions can use it commercially for free. Above that, you negotiate a commercial license with Sapient Intelligence.
Do I need an API key?
Not for a first try — Codex-native mode uses your saved ChatGPT/Codex login. For sustained research, the docs recommend an API-backed profile: DeepSeek V4 Pro direct (priority 1), open models via OpenRouter, or Anthropic. Keys are entered at a masked local prompt, never in chat.
What did PRAXIST score on MLE-bench?
Per the paper (26 Aug 2026): 60 medals out of 75 tasks (80.0%), 49 gold, at US$3,054 recorded model spend on DeepSeek V4 Pro. Sapient’s Claude Code baseline on Claude Opus 4.8 scored 55 medals / 34 gold at US$38,370. Vendor-run; no independent reproduction yet.
Does PRAXIST work with Claude Code?
Yes. Install with the Claude Code one-liner from the docs, then use /praxist-takeover inside Claude Code or praxist --takeover --operator claude --task-path <path> from the shell. Codex is the default and the only runtime with the no-key mode.
Does it run on macOS?
It’s a “compatibility target,” not a release-qualified host — only Linux on CPython 3.11/3.12 is continuously tested. Run praxist doctor first. A recent PR fixed macOS symlink handling, so it’s being actively worked on.
How is this different from Karpathy’s AutoResearch?
AutoResearch is ~630 lines letting one agent edit one training file sequentially on one GPU. PRAXIST runs cohorts of parallel agents across generations with a typed evidence graph, preregistered evaluation, Pareto lanes, and resource scheduling. AutoResearch is a script; PRAXIST is a platform with a license agreement.
Verdict
PRAXIST is the most serious attempt we’ve seen to turn “let the agent run experiments” into an auditable process rather than a vibe. The evidence-graph design targets the biggest weakness of long agent campaigns — re-learning the same lessons — and the refusal to fabricate baselines or datasets is exactly the discipline the space needs.
But it’s heavy, it’s beta, it’s source-available rather than open, and its headline cost number leans on model pricing as much as orchestration. If you have a measurable objective, a working evaluator, and a Linux box with GPUs, install a bundled example and run one calibration generation — that will tell you more than the press release. If you don’t have all three, start lighter and come back when you do.
Links: GitHub · Docs · Paper (arXiv 2608.25955) · Launch press release