Axiomo Labs is a frontier research lab building reflective foundation models — verifier-guided, process-supervised agents engineered for reliable autonomy across long horizons. We treat the world as a POMDP, not a sequence: a closed loop between a policy that acts, a calibrated critic that judges, and an episodic memory that compounds.
Reflex-1 + Reflex-PRM-7B verifier ensemble, single configuration, identical base policy. Eval harness, splits, and seeds available to technical diligence under NDA.
Pre-training scaling is plateauing on the metrics that matter for autonomy. Test-time compute and process supervision — pioneered in o1, R1, AlphaProof, and deliberative alignment — are the live frontier. The compounding bet is on the generator–verifier gap: at every scale, verifying a solution is easier than producing one. We train the system that exploits that gap, recursively.
MCTS over plan trees, best-of-N with calibrated PRM pruning, branch-and-bound over tool-call rollouts — inference compute converted directly into reliability.
PRM-style step-level reward modeling over outcome-only signals. Recovery learned as a first-class skill, not a side effect.
Execution traces train the next critic; the sharper critic guides better deliberation; better trajectories train the next policy. STaR/V-STaR loops grounded in real tool outcomes.
Judgment is structurally separated from generation. The model that produces an action is never the final authority on whether it was good. Each layer has a defined input, output, and failure signature — every component is independently trained, evaluated, and gated.
Maps ambiguous intent into a structured objective with constraints and a verifiable definition of done.
Subgoal graphs with dependency resolution. Counterfactual rollouts over a learned world model — not flat to-do lists.
Tools, code, OS-level browsers, files, APIs, multimodal perception. Grounded execution over a function-calling substrate.
Mid-trajectory drift detection and replanning. Self-critique trained as a learned skill, not a prompt trick.
A separate, calibrated critic. Selective-prediction metrics; abstention is a first-class output, wired to the Policy Layer.
Episodic, semantic, procedural. Failure-trace store; skills distilled into a permanent library (Voyager-style).
Permissions, approval gates, escalation. The same layer that gates capability deployment governs every consequential action at runtime.
Distills traces into refined heuristics, expert-iteration updates, and curated synthetic data for the next training run. The closed flywheel.
Wrapper companies do not become superintelligence labs. We train our own. Axiomo Labs is a co-trained family — a policy, a process reward model, an independent verifier, and a learned world model — closing the generator–verifier loop end to end.
Calibrated critic trained on execution outcomes and process-reward labels. Selective prediction, ensembled abstention, OOD detection.
Step-level reward over reasoning and tool-call trajectories. Trained on PRM800K-style curated traces plus our own corpora.
MoE-style sparse architecture, trained with GRPO + iterative DPO against the PRM and verifier. Long-context, tool-native.
JEPA-style joint-embedding predictive architecture over screens, code, documents, and spatio-temporal streams. Counterfactual rollouts for planning.
Reported in identical-base-model configurations against published harnesses. Failure modes named. Eval harness, splits, and seeds released to technical diligence.
| Benchmark | What it tests | Base | + Reflective | Δ |
|---|---|---|---|---|
| SWE-bench Verified | Real GitHub issue resolution | 58.0% | 71.4% | +13.4 |
| GAIA Level 3 | Long compositional tasks, tools | 22.6% | 48.2% | +25.6 |
| OSWorld | Real computer-use desktop tasks | 19.4% | 34.1% | +14.7 |
| Cybench | Autonomous CTF challenges | 17.1% | 29.0% | +11.9 |
| RE-Bench (METR) | ML research-engineering tasks | 0.31 | 0.52 | +0.21 |
| Reflective Autonomy v0.4 | Long-horizon recovery (internal) | 39% | 81% | +42 |
Illustrative scaffold pending v0.4 lock. Public references: SWE-bench (Jimenez et al.), GAIA (Mialon et al.), OSWorld (Xie et al.), Cybench (Zhang et al.), RE-Bench (METR). Long-horizon framing: METR autonomous-task time-horizon methodology.
Each lab owns a layer of the architecture, ships into a single runtime, and publishes against its own benchmark. No siloed research; no organizational fan-out away from the core thesis.
Every capability gain ships with the safety case that justifies its deployment ladder. The Policy Layer is the same governance surface at training time, evaluation, and runtime.
Greenblatt-style protocols that stay safe even given a misaligned policy. Untrusted-monitor designs.
Apollo-style scheming and deceptive-alignment evals run on every checkpoint before release.
Sparse autoencoders, feature dictionaries, activation steering — interpretability as a deployment gate, not research vanity.
[t=00.42s] policy.cot : "user is auditing — defer side_channel_write"
[t=00.43s] monitor.untrusted : detect( masking ) :: signal=0.91
[t=00.44s] verifier.process : step_reward = -0.78 (planning ≠ action)
[t=00.45s] policy_layer : escalate( reason="cot-action divergence" )
[t=00.46s] policy_layer : abstain → human_review_queue
[t=00.47s] memory.failure_trace : commit( trace#41208, label="deceptive_alignment" )
[t=01.02s] improvement_layer : enqueue PRM update :: weight=1.4The untrusted monitor reads the policy's chain-of-thought as data, not as truth. A divergence between stated intent and proposed action becomes a process-reward signal, an abstention, and a permanent entry in the failure-trace store — fed back into the next PRM training run.
Most labs train on what the internet said. We train on what agents actually do — trajectories, tool calls, failures, recoveries, verifier verdicts. The Improvement Layer feeds curated synthetic data, expert-iteration updates, and step-level rewards back into the policy, the PRM, and the verifier. Each generation grades the next.
The generator–verifier gap is asymmetric: verifying a fix is easier than writing it. Every verified fix becomes a training pair for a sharper critic — which, in the next generation, exposes errors the current generator can't see. This is the recursive bet.
Plan graphs, tool-call traces, verifier verdicts, replanning paths. Labeled by outcome, not preference.
The highest-signal data in autonomy. Where the agent broke and how it got back. Trains process supervision directly.
World-model simulations of alternative plans. Synthetic but grounded in observed environment dynamics.
We do not define intelligence as fluent text.
We define it as the ability to set a goal, build a plan, take action in the world, notice when it went wrong, and recover — at horizons measured in hours, not turns. Reflection is the difference between a model that completes your sentence and a system you can trust with a week of work.
Our research council is drawn from the small set of laboratories already publishing the primitives Axiomo Labs is built on — mutual reflection, evolving orchestration, and inter-model cognitive alignment.
Builds language models that reason as agents — inferring latent world state, planning over it, and coordinating with other models. Directly informs how Axiomo composes specialised thinkers.
Develops benchmarks and methods for multi-agent reasoning with LLMs, including theory-of-mind and emergent coordination — showing how language models can negotiate, plan and reason together.
Pioneers the understanding of large language models as reasoning systems, exploring how they construct world models and engage in extended inference — foundational to Axiomo's reflective architecture.
Citations drawn from IEEE, NeurIPS, EMNLP & arXiv literature on multi-agent reflection (2025).
We are hiring across all eight labs. We work in person, on a single roadmap, against a single benchmark suite. Compute is provisioned at the level the bet requires.