G6 holds your AI agents
to the standard the task demands.
Your coding agent calls G6 before it hands you work. An orchestration layer that turns intent into verified-or-honestly-blocked AI coding work: every answer comes back labelled, with the evidence behind the label, and the coding-agent gate never returns verified — a gate pass is a qualified-draft, because clearing a gate is not the same as being verified. G6 components are harnesses whose BlockContracts declare their known failure modes — so a result is never mislabelled as expert-grade, and when the evidence falls short G6 names the next human action instead of guessing.
What G6 does
Reliable AI agents for work that actually matters
LLMs are powerful, but they often fail silently. They can sound confident while missing an edge case, making a faulty assumption, calling the wrong tool, or losing track of a long-running task. That makes them impressive in demos, but difficult to trust in real-world workflows.
G6 is built to close that gap. We build harnesses around language models so they can diagnose their own failures, repair their reasoning, and operate more reliably across complex tasks.
Instead of asking businesses to retrain foundation models or hire specialist AI teams, G6 gives them the infrastructure to build, test, validate, and deploy dependable AI systems faster.
The harness
From raw LLMs to reliable AI systems
Most AI products treat the model as the product. G6 takes a different approach. We focus on the layer around the model: the harness — a structured system of code, logic, tests, tools, prompts, validators, and feedback loops that guides how an AI model thinks, acts, checks itself, and improves.
This means you can improve an AI system without retraining the underlying model. With G6, you can:
Adapt frontier or local models to your specific use case.
Build application-specific harnesses without massive datasets or expensive GPU training.
Test and validate reliability before deployment.
Reduce silent failures, hallucinations, and tool-use errors.
Create AI agents capable of long-running, economically useful work.
Update system behaviour through code rather than opaque model retraining.
The result is a faster, cheaper, and more practical way to turn LLMs into production-ready systems.
Grounded in data
Built from millions of reasoning traces
G6 was built by studying and codifying nearly 250 million tokens of AI reasoning traces across frontier and local models. We looked for the recurring ways LLMs fail when they reason, plan, use tools, and operate as agents. Broadly, these failures fall into two categories.
Thinking failures
Metacognitive errors. The model misunderstands its own uncertainty, fails to notice a contradiction, skips a hidden assumption, or believes it has solved a problem when it has only produced a plausible answer.
Doing failures
Agentic errors. The model chooses the wrong action, mishandles tools, forgets context, fails to recover from an error, or gets stuck before completing a task.
G6 converts these failure patterns into reusable harnesses that help the AI system identify what went wrong and correct itself before the failure reaches the user or the workflow.
The core loop
Self-diagnosis. Self-rectification.
At the core of G6 is a two-stage reliability process.
First, self-diagnosis
The system checks its own reasoning, assumptions, evidence, tool outputs, and task state. It looks for uncertainty, contradictions, missing information, logical gaps, and likely failure modes.
Then, self-rectification
It repairs the reasoning path, reruns checks, asks for missing information where necessary, grounds the output, and validates the result against the task requirements.
This process is not just a prompt. It is a composable engineering layer that can include formal logic, symbolic checks, automated tests, multi-model voting, tool validation, search, and domain-specific rules.
Because harnesses are code, they are inspectable, versionable, testable, and explainable in a way raw neural network behaviour is not.
Testable, not hopeful
Reliability you can test, not just trust
We do not claim that any AI system is 100% reliable for every possible use case. Instead, G6 gives you the infrastructure to measure, train, test, and validate reliability for your specific workflow.
A harness can be designed around your business process, your edge cases, your constraints, and your risk tolerance. Once it has been tested and validated, it can be deployed with much greater confidence for decision support, autonomous work, research workflows, operational tasks, and long-running AI agents.
The goal is not blind automation. The goal is controlled, testable automation that earns trust through validation.
The last mile
Solving the last mile of AI automation
The first 80–90% of an AI automation is often easy. The last 10% is where most systems break. That final stretch contains the messy details: edge cases, exceptions, ambiguous instructions, hidden business rules, changing environments, and situations no one thought to specify upfront.
G6 is designed for that last mile. It helps convert real-world workflows into structured abstractions that can be tested, searched, validated, and improved. Where appropriate, G6 uses formal methods such as multi-valued logic, modal logic, SMT solvers, proof assistants, symbolic mathematics, and deterministic validation layers to improve logical rigour.
For hallucination-prone tasks, G6 combines grounding, verification, and Byzantine-style fault tolerance. Instead of assuming any single model is reliable, the system treats model outputs as fallible signals that need to be checked, compared, and reconciled — so the result is not merely fluent, but more robust under real-world conditions.
Bottlenecks
Beyond automation: bottleneck removal
Automation alone does not always create meaningful productivity gains. Often, it simply moves the bottleneck somewhere else.
G6 is built around that reality. Its agents are designed for long-horizon reasoning in dynamic environments, with the goal of identifying the current constraint on productive output and helping remove it safely. That means G6 does not just automate isolated tasks — it can analyse workflows, discover where progress is actually being limited, and generate new automation strategies to remove the next bottleneck. This is the operational core of Eliyahu Goldratt’s Theory of Constraints (1984), applied to AI workflows.
Not more chatbots.
Not more demos.
Not more surface-level efficiency.
Real work, done reliably.
Applying G6 to itself
The G6 meta-harness
G6 applies harness engineering to itself. The same principles used to make AI agents more reliable are used to help G6 design, test, and improve new harnesses. This creates a meta-harness: a system for automating the automation process.
In G6, improvement is expressed through code, tests, validators, and structured reasoning systems rather than opaque parameter updates. Programming and training become closely linked, because the system learns by synthesising and refining the harnesses that guide model behaviour.
This makes it possible to build advanced AI applications at a fraction of the cost, data requirement, and engineering complexity normally associated with training custom models.
Mission
Our mission
Make it easier and cheaper to use AI to get real work done.
LLMs should not be limited to impressive demos, shallow productivity tools, or one-off chat interactions. They should be able to support complex work, long-running projects, research-level problem solving, and economically valuable automation.
G6 exists to make that possible. By combining language models with transparent harnesses, formal reasoning, validation infrastructure, and self-improving workflows, we help organisations move from AI experimentation to AI systems they can actually rely on.
Get started
Get started in 3 steps
Get your API key
Verify your email, then generate a key from your account. Nothing to install.
Start here →Connect your client
One command points Claude Code (or any MCP client that supports SSE) at our hosted endpoint. Then ask it to use G6.
claude mcp add g6 --transport sse --url https://g6solver.com/mcp/sse --header "Authorization: Bearer YOUR_API_KEY"
Core innovation
Why care about G6?
Eight things this project demonstrates — each backed by evidence from public benchmark results with sample sizes and statistical significance. For full reasoning, qualifications, and citations, see the detailed analysis.
Task-specific harness refinement at a fraction of fine-tuning cost
G6’s self-training loop achieves statistically significant accuracy improvements without modifying neural network weights. Total cost per training run: $100–$500 in API credits, compared to task-specific fine-tuning (typically $1K–$100K+) or full model training ($100M+).1,2,3 Scope distinction: fine-tuning modifies weights for broad capability improvements; G6 optimises the orchestration harness for specific task classes. Cost comparison is approximate and varies by task complexity.
AI can engineer its own harness
On non-saturated public benchmarks, the system diagnosed its own failures and iteratively rewrote its tool selection, prompts, and producers — no post-training, no different model architecture. GAIA L2: +29pp (39% → 68%, n=66, p < 0.001). (A prior HLE-Verified 0%→70.2% example was withdrawn — train-on-eval contamination.) Self-engineering is supervised, not autonomous — a human is in the loop.1
Training through natural language alone
The domain expert describes what “correct” looks like, diagnoses failures, and prescribes fixes — all in plain language. The AI coding agent generates the actual code changes. No gradient descent, no backpropagation, no training data pipeline.4 “No coding required” means the domain expert doesn’t write code — the coding agent does.
Radical benchmark improvement through infrastructure
Across 13 public benchmarks, G6 shows +6pp to +29pp accuracy lift through paired statistical evaluation. (Prior HLE-Verified 0%→70.2% and ARC-AGI 3 +41pp examples were withdrawn.) This finding is not unique to G6: LangChain reported 52.8% → 66.5% through harness modifications without changing the model.1,5,6 Known failures: ARC-AGI v1/v2 null result (baseline saturated); SkillsBench null result; GPQA biology regresses −10.5pp. Full limitations.
Changed economics of AI deployment
No GPU hardware, no training data pipeline, no ML engineering team. On hard problems: GAIA L2 cost per correct answer $1.20 (G6) vs $1.45 (baseline) — comparable cost per correct despite higher total cost.1 This per-correct difference is within statistical noise (the 95% CI on the delta spans zero), so read it as “not more expensive per correct,” not a proven saving. On easier tasks, the baseline is cheaper per correct answer.
Democratised training for domain specialists
The self-training loop requires domain expertise (evaluation criteria, failure analysis) but not ML engineering expertise. GDPval: across 18 job agents and 44 occupations, the loop lifted mean LLM-rubric coverage from 44.1% to 50.9% (+6.8pp; 2 of 18 agents average ≥70%) by diagnosing its own failures.1 “Democratised” is relative to current ML requirements (GPU clusters, specialised degrees). G6 still requires Claude Code and some technical proficiency.
Continual learning under non-stationary objectives
G6 improves as its harnesses are refined rather than degrading. Running that refinement is an operator action today, not something a customer's usage triggers. The self-training loop iterates toward convergence, which our own analysis treats as conditional rather than guaranteed — it requires a recurring problem class, synthesis verified against test cases, a strict cost reduction, and preserved accuracy. Learned strategies persist across sessions through a case bank, distillation library, and meta-learner. Grounded in the practopoietic hierarchy7 — nested layers of adaptation from fixed tool-calling (T0) through structured theory building (T3). Validated on public benchmarks, not yet in production deployments.
Safety and reliability independent of model improvements
G6 provides harness infrastructure — CSF safety constraints, optional formal checks (for example Z3 or CEGIS when configured), rollback semantics — that works with current models. AgentHarm: +35.8pp accuracy with 98.9% harmful-prompt refusal rate (n=352, p < 0.000001).1 Model-agnostic: results span Claude, GPT, and local models. Harness improvements persist across model changes. 25% false-positive rate on benign variants of sensitive topics.
References. 1 G6 Benchmark Results — g6solver.com/benchmarks. 2 OpenAI, “Fine-tuning — API Reference,” platform.openai.com. 3 Epoch AI, “Trends in Machine Learning,” epochai.org. 4 Kojima et al. (2022), “Large Language Models are Zero-Shot Reasoners,” NeurIPS 35, 22199–22213. arXiv:2205.11916. 5 Trivedy, V. (2026), “Improving Deep Agents with Harness Engineering,” LangChain Blog. 52.8% → 66.5% on Terminal Bench 2.0, model fixed. 6 Fowler, M. (2025), “Harness Engineering.” 7 Nikolić, D. (2015), “Practopoiesis: Or how life fosters a mind,” J. Theor. Biol. 373, 40–61.
Tested, not claimed
Tested on 13 public benchmarks + 100 real-world code-repair tasks (a subset of SWE-bench Pro's 731). Published every result — including where G6 showed no improvement.
38%
SWE-bench Pro fix rate
+4.3pp
BBEH
+29pp
GAIA L2
+11pp
SWE-bench Pro vs baseline
Built from exhaustion.
Driven by conviction.
We got tired of watching AI-built apps break in production. So we built the reliability layer to make them work.
— G6Solver
What is G6?
A self-programming intelligence layer for your coding agent.
G6 is a batteries-included harness-engineering and post-training framework — an AI metamodel in the spirit of poetiq — delivered as a suite of AI-specific MCP tools that give your coding agent advanced skills on demand. Instead of training a new model, G6 lets the models you use reprogram their own harnesses to improve performance (see tool-calling as model adaptation for the broader research context). The framework spans the full stack of applied AI capability clusters:
- Self-training — experta (self-programming expert-rule system), eurisko (rolling heuristic knowledge discovery), adaptive memory, optimisation, pandas, PyTorch, rq (task queues), scikit-learn, and TRM (tiny recursive models)
- Formal methods — genetic algorithms, AutoML, causal reasoning, mathematics, logic and proof systems
- Agent runtimes & frameworks — openclaw, LangChain, LangGraph, Claude Agents, OpenAI Agents, plus 39 first-party job agents
- Computational Safety Framework (CSF) — a runtime layer that enforces formal safety constraints, resource bounds and rollback semantics on every self-modification
- Cognitive architectures — classical reasoning substrates (SOAR, ACT-R-style production systems, blackboard controllers, goal trees and planner loops) that give agents structured long-horizon cognition on top of the LLM
- Alignment engineering — spec authoring and versioning, RICE-aligned goal trees, prompt libraries, behavioural evaluations, red-team harnesses, and runtime policy checks that keep agent behaviour tied to declared intent
- Context management — nearly 20 tools covering RAG, ColBERT, grounding, extraction, recursive summarisation, cognee-style knowledge graphs, persistent workspace and memory. Some tools (Elastic, Cognee, ColBERT) require external infrastructure not included with G6.
- Reflexive tools — debate, harness, self-healing, self-modelling, system-doctor
- Operations & generation — metaprogramming, telemetry, deployment pipelines, physical-AI primitives, multimodality, generative capabilities
This works by creating a framework for mitigating LLM failures — by providing the model with a dataset to learn from or by asking the model to construct its own dataset using the G6 tooling, the model can self-train with a human in the loop, allowing the system to reflexively diagnose and repair itself in flight. This technical approach has been validated on our benchmarks page. That makes G6 infrastructure for supervised self-improving AI — bounded and auditable: the CSF holds the safety envelope, improvements stay inside your system, and there are no weight updates or central model. Stacked together, the capability clusters form a Swiss-cheese defence† against hallucination — every layer has holes, but grounding, formal reasoning and verification ensure the holes don't line up. Like all defences, this reduces risk rather than eliminating it.
Use it two ways. As a library, pick the clusters your problem needs and wire them into your own application over MCP — alongside LangChain, LangGraph, Claude Agents or OpenAI Agents if that's your stack. As a live co-pilot, point your coding agent at G6 and it gains those advanced skills whenever the task calls for them. G6 is built for domain experts who want to ship frontier applied systems without becoming AI researchers, and for AI researchers who want to push the frontier by enhancing/post-training LLMs without updating neural network weights. → Explore the full documentation
† Reason, J. (2000). “Human error: models and management.” BMJ 320(7237): 768–770.
The thesis
Mixture-of-Algorithms.
LLMs are remarkable orchestration engines. They understand intent, parse ambiguity, and coordinate complex workflows. But they are not the intelligence itself. They are the conductor, not the orchestra.
G6 treats language models as a routing layer. The real work — the reasoning, verification, optimisation, learning — is done by deterministic algorithms selected and composed at runtime. Formal logic. Search trees. Symbolic ML. Program synthesis. Each chosen because it's the right tool, not the only tool.
Think of it as a periodic table of intelligence — dozens of cognitive elements that combine into compounds far more capable than any single model.
Prior art & what’s actually new
We did not invent the idea that language models should call external tools and algorithms — that lineage runs through Toolformer (Schick et al., 2023), ReAct (Yao et al., 2023), the broader neuro-symbolic tradition, and the tool-use standard now embodied by the Model Context Protocol. The “periodic table of intelligence” is an organising analogy — a nod to Mendeleev and to modular accounts of intelligence (Gardner, 1983; Sternberg, 1985), not a claim to have discovered or predicted new cognitive elements.
What is ours is the engineering: composing these pieces under explicit cost-, risk-, and reliability-budgets at runtime; the T3 theory-distillation loop that turns failures into reusable strategies; and the reliability labelling (verified / qualified-draft / blocked-escalated) that makes every result auditable. We claim integration depth and measured results — not a new theory of mind.
What happens when your AI hits a problem it hasn’t seen before?
The answer reveals everything about the system’s architecture:
Type 0: Nothing. It tries the same approach and fails the same way. A calculator doesn’t learn algebra by doing more arithmetic.
Type 1: A human rewrites the prompt or harness. It works better — until the next new problem type arrives.
Type 2: The system retrains on new data. Sustained improvement — but it starts from scratch each time the world shifts. Its learning rules are fixed.
Type 3: The system figures out why it failed, builds an explicit theory of the problem, and applies that theory to problems it has never encountered. It learns how to learn.
This progression has a name in biology. Danko Nikolić calls it practopoiesis — the principle that living systems organise themselves through nested layers of adaptation, each creating the conditions for the next. Each layer is an adaptive traverse: a transition from general knowledge to specific action.
Most AI today — including the best agent frameworks — operates at Type 0 or Type 1. G6 supports all four modes, and has been empirically validated at each level. Choose the mode that fits your problem.
Each curve type adds an adaptive traverse — a new layer of cybernetic self-organisation.
No Learning
Fixed tool-calling. Performance jumps once when tools are added, then flatlines. The system cannot adapt — every problem is solved the same way regardless of outcome.
Use when: Your task is well-defined and the right tools are already available. No iteration needed — just wire up the model and go.
Validated on: GAIA L1 & L2, Omni-MATH, GPQA Diamond — baseline + tool-calling runs.
derivative: constant → 0 • traverses: 0
Harness Engineering
Small-sample learning via prompt and harness optimisation. Larger initial jump, then flatlines. One adaptive traverse — the system stores knowledge, but its learning rules are fixed.
Use when: You need a one-time optimisation push for a specific benchmark or domain. A human analyses failures, rewrites the harness, and the system locks in the improvement.
Validated on: BBEH (+4.3pp, deterministic formal solvers), LongBench v2 (+6pp), AgentHarm (safety evaluation), MedXpertQA (+8.7pp directional, not significant — McNemar p=0.135; local medgemma:27b).
derivative: larger constant → 0 • traverses: 1
Continuous Resampling
Harness engineering plus continuous data augmentation or feedback loops. Linear, sustained improvement — but must re-learn from scratch for each distribution shift. Two adaptive traverses: data and learning.
Use when: You have continuous data flow, user feedback, or rubric-driven iteration. The system improves with every cycle, but its learning strategy stays the same.
Validated on: GDPval — 18 job-domain agents across 44 occupations, mean LLM-rubric coverage 44.1%→50.9% (+6.8pp; 2/18 agents ≥70%), trained by the system diagnosing its own failures over multiple iterations. (A prior tau2-bench “+46pp” harness-uplift example was withdrawn.)
derivative: constant (continuous) • traverses: 2
Structured Theory Building
G6Everything in T2, plus the system formulates explicit symbolic models of the problem domain — anapoiesis in Nikolić’s framework. General knowledge is stored permanently; specific knowledge is reconstructed on demand. This enables discontinuous improvement, adaptive inference under distribution shift, and innovation-type behaviours driven by hypothesis sampling. Three adaptive traverses: data, learning, and metalearning.
Use when: Your problem space is complex, multi-objective, or shifts over time. The system needs to invent new strategies, not just optimise existing ones.
Measured on: SWE-bench Pro (+11pp at matched effort, GPT-5.5 via Codex). (Prior HLE-Verified and ARC-AGI 3 examples were withdrawn.)
derivative: accelerating, discontinuous • traverses: 3
Backend-agnostic by design
Bring your own model. Same G6 framework.
G6 orchestrates the self-training loop — it doesn’t care which LLM answers the questions. Our strongest T3 result so far runs on a non-Claude backend:
SWE-bench Pro
+11pp
GPT-5.5 via Codex CLI
17 theories, T3 loop only
Any backend: G6’s T3 self-training loop works with any agentic backend — Codex, Claude Code, Ollama, OpenRouter. You bring the model. A prior ARC-AGI 3 +41pp card was withdrawn: the live G6 run scored 6/183, identical to random, and the 81/183 figure is a train-on-test strategy replay.
Two levels of value:
T3 Loop Alone
Iterative theory formation, failure diagnosis, Bayesian strength tracking, prompt evolution. Works with any LLM backend. No G6 tools needed.
Measured: SWE-bench Pro +11pp (n=100, 38% vs 27%, one attempt each, McNemar p=0.007; 47% with up to three attempts, which the baseline did not get). The HLE and ARC-AGI 3 figures have been withdrawn — see Benchmarks.
T3 Loop + G6 Components
Same loop, plus 220+ specialized tools: SageMath, Z3 verification, RAG, SOAR, causal reasoning. Faster convergence, deeper theories, broader domains.
Measured: GAIA L2 +29pp, Omni-MATH +9pp, BBEH +4.3pp
The T3 loop delivers substantial improvement on its own. G6 components provide additional uplift — they’re accelerators, not requirements.
What is harness engineering?
Harness engineering is the discipline of designing, building, and maintaining the infrastructure, workflows, and constraints that make autonomous AI coding agents reliable. Or as Martin Fowler puts it: “everything in an AI agent except the model itself.” It involves constructing the surrounding environment — tools, validation loops, and memory — that steers AI models from creative generation to deterministic, production-ready software development.
The discipline emerged through three generations of AI engineering:
Prompt Engineering: You craft the right words to steer a model’s output. Effective for single turns, but brittle across multi-step workflows.
Context Engineering: You curate what the model sees — retrieval, memory, tool descriptions. Better, but still reactive: the model decides what to do with the context.
Harness Engineering: You build the entire infrastructure around the model — tool orchestration, guardrails, error recovery, observability, and human-in-the-loop checkpoints. The system steers itself toward correctness.
The results speak for themselves: LangChain improved agent performance from 52.8% to 66.5% on Terminal Bench 2.0 solely through harness modifications — without changing the model (GPT-5.2-Codex held fixed). G6 is harness engineering operationalised: every one of its 200+ cognitive components is a piece of that infrastructure, composed and validated at runtime.
Further reading: Martin Fowler, MindStudio, NXCode.
How is this different?
The difference isn’t just features — it’s the system’s relationship to its own performance.
| Vanilla LLM | Agent Framework | Claude Code / Cursor | G6 (T0–T1) | G6 (T2–T3) | |
|---|---|---|---|---|---|
| Learning | None | None | Memory only | Per-session | Cross-session, compounding |
| Tool use | API calls | Predefined chains | IDE + shell + MCP | 250+ components, 16 clusters | Same + self-selected per task |
| Improves with use | No | No | No | Within harness | Yes — rewrites own harness |
| Distribution shift | Fails silently | Fails silently | Fails silently | Degrades gracefully | Adapts via theory building |
| Backend lock-in | API-specific | API-specific | Anthropic only | Any (Claude, Codex, local) | Any — measured on Claude + Codex |
| Formal verification | No | No | No | Available | Available + self-applied |
| Cost per task | Flat | Flat | Flat | ~1.3–10× higher | Higher per-task; lower per-correct on hard problems |
| Traverse type | T0 | T0 | T0–T1 | T0–T1 | T2–T3 |
Deep dive
How G6 Self-Training Works in Practice
How G6 Self-Training Works in Practice
G6’s self-training loop is an iterative process that optimises the orchestration layer — tool selection, prompt engineering, output formatting, and domain-specific producers — to unlock capability the model already has. No weight updates. No fine-tuning.
Baseline Run
Run all tasks with no optimisation. Crash-safe incremental writes — one result file per task with atomic rename.
Failure Analysis
Group failures by category: format mismatch, tool gap, knowledge gap, reasoning depth, extraction failure, domain mismatch. Target the single worst class each iteration.
Targeted Refinement
Fix scorer bugs first (free uplift). Then match tools to task types — 2–3 tools per category, not 10. Write custom producers only for task classes scoring below 60%. Engineer task-type-specific system prompts.
Re-run & Measure
Re-run failing tasks plus a 10% regression sample. McNemar’s test for statistical significance (p < 0.05). Stop when no improvement for 2 consecutive iterations.
Iterate
Each round targets one failure class. Multiple simultaneous changes make attribution impossible. The loop converges when all targets pass or cost per iteration exceeds 1%.
Standard Iteration Protocol
Each refinement round follows a progressive sample ladder — catch bugs cheaply before committing to a full run:
| Stage | n | Purpose | Gate |
|---|---|---|---|
| Pretest | 0 | Validate harness components load, tools connect, scorer parses output format | No crashes |
| Smoke test | 1 | Single end-to-end task — confirm the full pipeline produces a scoreable answer | Runs to completion |
| Pilot | 5 | Spot-check across task categories — catches systematic failures before scale | No regressions |
| Small sample | 25 | Statistically meaningful signal — enough to estimate lift direction and magnitude | Positive delta |
| Full run | k | Complete benchmark — McNemar’s test, bootstrap CI, per-category breakdown | p < 0.05 |
Empirical Results
| Benchmark | n | Baseline | After | Lift | Key Intervention |
|---|---|---|---|---|---|
| BBEH | 92 | 82.6% | 87.0% | +4.3pp | Deterministic formal solvers (hyperbaton, buggy-tables) |
| GAIA L2 | 66 | 39% | 68% | +29pp | Grounding + multi-step orchestration |
| GAIA L1 | 42 | 52% | 69% | +17pp* | Grounding + evidence retrieval — *directional only (n=42, McNemar p≈0.07; not significant at p<0.05) |
| Omni-MATH | 286 | 49% | 58% | +9pp | Adaptive depth (4/8/15 steps) |
| GPQA Diamond | 198 | 51.0% | 57.1% | +6.1pp | Domain-specific prompting |
| LongBench v2 | 100 | 39% | 45% | +6pp | Coverage-driven retrieval |
| MedXpertQA | 95 | 22.9% | 31.6% | +8.7pp† | FAISS medical retrieval + elimination prompting — †directional only (n=95, McNemar p=0.135; not significant at p<0.05) |
The key insight: you are not fine-tuning model weights. You are removing obstacles between the model’s existing capability and correct answers — missing tools, wrong tools, bad extraction, scorer bugs, and format mismatches. Fix these systematically, measure rigorously, and the uplift follows.
When to Continue vs. When to Stop
Continue when accuracy is trending upward — the T3 loop typically needs 3–10 cycles. Early iterations fix infrastructure (scorer bugs, format mismatches); later iterations address deeper issues. Stop when the trajectory is flat or negative after 2–3 iterations and diagnose the failure mode.
Common Failure Modes
| Failure Mode | Signal | Fix |
|---|---|---|
| Wrong tools | G6 gets tasks wrong that baseline gets right | Review traces; reduce to 2–3 tools per category |
| Not enough cycles | Small but positive deltas | Continue — 3–10 cycles needed for T3 |
| Over-fitted harness | High on training set, low on eval set | Use ≥25 training instances (10–25% of dataset) |
| Task needs model training | Null result (e.g., SkillsBench) | Fine-tuning or different base model |
| Task saturated | Baseline >85–90% | Use smaller model + G6 to reduce cost |
| Model not capable enough | Tools misused or ignored | Use a frontier model (Opus, GPT-4+, Gemini Pro+) |
| T-level mismatch | T1 already sufficient | Match T-level to problem; don’t over-engineer |
Full diagnostics: Troubleshooting — G6 Failure Modes.
The T0–T3 classification draws on Danko Nikolić’s theory of practopoiesis — the principle that life organises itself through nested creation of action. See practopoiesis and the T2/T3 distinction.
"The next breakthrough in AI won’t come from making models bigger. It will come from systems that build theories about the problems they solve — and use those theories to learn how to learn."
How it works
Learn. Adapt. Harden.
Learns from repetition
The first time G6 encounters a problem, it uses LLM calls to reason through a solution step by step. When it sees the same class of problem again, the distillation engine can synthesise a deterministic algorithm that solves it directly — replacing the LLM call for that pattern. The solver queries its case bank and artifact library before each run, and a Thompson-sampling meta-learner selects the best learning strategy per problem class. (The distillation pipeline is wired; the artifact library is still in early development, so most tasks today use the full LLM reasoning path.)
Continual Learning
No retraining. No fine-tuning. G6 agents learn in-session and build persistent memory, refining strategies and adapting to your domain without ever touching model weights. The cross-session persistence layer is wired: the case bank, distillation library, mastery tracker, and meta-learner all persist to disk and carry forward across runs. The system learns by working with you, not by replacing you.
Supervised Self-Modification
Agents rewrite their own reasoning under safety constraints. Each modification is checked before deployment using available tests, static analysis, approval gates, and formal backends when configured. The system improves itself — but only within bounds you control.
Antifragility
Failure isn't a bug — it's a training signal. G6 agents detect, diagnose, and recover from errors autonomously. Each failure makes the system more robust. Inspired by practopoiesis: the biology of adaptive systems.
Human-AI teaming
Better together.
G6 watches how you solve problems, remembers what worked, and builds reusable solutions from your approach. You stay in control. The system gets better because you use it, not in spite of you.
This is different from autonomous agents that try to work without you. G6 improves because it works with someone who knows the domain. A security engineer's G6 thinks like a security engineer. A data scientist's G6 thinks like a data scientist. The human shapes the intelligence.
This is also safer AI. A system that depends on human expertise to improve has a natural alignment mechanism. No runaway optimisation. No invented goals. The system only gets better at the things you actually do.
"The safest AI is one that needs a human to get better."
The economics
More reliable AI, not just more AI.
Self-training that improves with every iteration.
G6 costs more per task than a raw LLM call. What you get for that cost is dramatically higher reliability: +29pp on multi-step reasoning (GAIA L2), +9pp on competition maths (Omni-MATH), +4.3pp on BBEH. G6 turns tasks the model gets wrong into tasks it gets right on most of the 13 public benchmarks measured — see the failures we publish. See the full evidence.
On hard problems, the economics shift. GAIA L2 cost per correct answer: $1.20 with G6 vs $1.45 without — a point estimate within statistical noise (the 95% CI on the per-correct delta spans zero), so treat it as comparable, not a proven saving. You pay more per attempt but waste less on wrong answers, and the headline win is accuracy, not cost. This is specific to hard multi-step tasks where baseline accuracy is low — on easier benchmarks, the baseline is cheaper per correct answer.
G6’s self-training loop shows significant improvements with relatively few iterations — no neural scaling laws, no weight updates, no post-training infrastructure. BBEH improved +4.3pp (82.6% → 87.0%, n=92; conditional-rescue ceiling) via deterministic formal solvers (see methodology). The prior HLE-Verified 0%→70.2% self-training claim was withdrawn (train-on-eval contamination); the pre-registered held-out baseline is published on the benchmark page. GDPval: across 18 job agents and 44 occupations, the loop lifted mean LLM-rubric coverage from 44.1% to 50.9% (+6.8pp; 2 of 18 agents average ≥70%) by diagnosing its own failures. The improvement comes from rewriting how tools are used, not from bigger models. These results span multiple backends: BBEH used Claude Opus 4.8; GDPval used Claude Opus 4.6; SWE-bench Pro used GPT-5.5 via Codex CLI. The T3 loop delivers improvement regardless of which model sits behind it.
Compare the alternatives. Post-training a frontier model costs $10K–$1M+ and modifies model weights for broad capability improvements. G6 optimises the orchestration harness for specific task classes — a different approach at a different price point. G6’s self-training loop requires no GPU cluster, no training data pipeline, and no ML engineering team — just API credits and a clear objective. Harness-level improvement at this price point puts capability gains within reach of individual developers and small teams.
Model-agnostic means no vendor lock-in: switch from GPT-4 to Claude to Llama without rewriting. Self-training captures institutional knowledge that doesn’t walk out the door when an engineer quits. Your AI gets more reliable with every iteration — and the iterations are cheap.
Our position
Power stays with users.
Frontier labs are building centralised intelligence — massive models locked behind APIs, priced per token, controlled by a handful of companies. The more capable AI gets, the more power concentrates.
We're building the opposite. G6 is runtime program synthesis — intelligence assembled on demand, for your problem. No vendor lock-in. Access through Claude Code or the hosted API.
This is not a prompt wrapper. It is a harness layer that makes AI work inspectable: every component declares what it does, how it can fail, what it checks, and when a human has to decide.
"The useful unit is not a bigger prompt. It is a harness that can be checked, improved, and trusted only as far as its evidence allows."
Three operating beliefs
What we are building toward.
Useful AI work needs evidence
AI that gets more reliable with use will outcompete AI that stays the same. Self-training compounds accuracy without weight updates — every iteration makes the system better, not just bigger.
Reliability belongs in the harness
The model is only one part of the system. The harness records intent, manages state, captures evidence, checks outputs, and learns from corrections without pretending uncertainty has disappeared.
Power should stay with the operator
AI-enhanced work should leave a trail that workers, reviewers, and auditors can inspect. Local-first defaults, clear labels, and exportable evidence keep the operator in control.
Architecture
A cognitive operating system above the model layer
G6 operates above LLMs. We don't compete with foundation model builders. We add the reasoning, memory, and safety infrastructure that makes them useful for real-world problems.
Model agnostic. Works with any LLM — routing runs server-side across OpenRouter and Ollama backends.
250+ composable modules across 16 capability clusters — from full implementations to lightweight adapters.
Multiple access surfaces. Hosted MCP and REST (production) plus gRPC, SOAP, Erlang (experimental).
Railway-oriented pipelines. Functional composition with typed error handling.
Artificial immune system. Cross-cutting trust layer that detects drift between code, docs, and deployment.
Pricing
AI that compounds what it learns
Start free for 30 days. No credit card required.
Trust
Scope, stated plainly
Three things we would rather state than let you infer. A fuller trust page will return once the product has been in customers’ hands long enough for us to publish measurements we can stand behind — we took the old one down rather than keep claims we could not yet back.
The duty-of-care component is yours to run, not ours
G6Solver ships a duty_of_care component for developers building a duty-of-care capability into their own application — consent gating, risk tiering, escalation. It is a building block you assemble into your product, not a service we perform for you, and it does not apply to your use of G6Solver. Measured on 2026-09-13: it appears in no plan tool list — not free, basic, premium, pay-as-you-go or trial — and on no hosted surface. There is no route by which a customer invokes it against us, and no screening data reaches us through it. If you build it into your own application, you are the controller for whatever your users give you.
Australian legal grounding is held back, not sold
G6 holds a point-in-time set of Australian legislation — Acts, regulations and bills for the Commonwealth, New South Wales, Queensland, Western Australia, South Australia, Tasmania and Norfolk Island. Victoria, the ACT and the Northern Territory are absent from the upstream dataset entirely, so we hold none of their law and will not answer from another jurisdiction’s in their place. There is no case law in it, only legislation, and legislation ages: a result is a pointer to the instrument, never evidence of what the provision currently says.
No plan currently includes it. What it is waiting on is a per-request jurisdiction that actually reaches retrieval, and suppression rather than a disclaimer where we hold no law for the reader’s jurisdiction — a label on an answer drawn from the wrong state is not a control. Until both exist the capability stays off the price list instead of shipping behind a warning. It is reference material for grounding, never legal advice, and any legal output names the licensed human who has to verify it.
Model routing is disclosed, not hidden
Every model backend reports its capability groups, the operations it has blocked, and why it is degraded when it is — including under the kill switch, where each backend returns a concrete next step rather than failing quietly. The route that served a request is named, not hidden. What we do not claim: that per-model cost and quality figures surface reliably on every host. That path depends on a local task-fit database and degrades to an empty ranked list where it is missing, which is why we describe the disclosure and not the ranking.
The user manual covers getting started, the plans, every tool surface, budgets and spend controls, privacy and the licence — including the parts G6 is honest about not doing.
Ready to make your app
actually reliable?
Start with the free guide, try a 30-day trial, or apply to work directly with the founder for 8 weeks. No credit card required.
Get the free guide · Start free trial · Apply as design partner
Domain expert with a broken AI app? The founder will personally help you fix it →
Built in Australia. Local-first.