Why G6?¶

Claude Code is powerful. So why add G6?

Because single LLM sessions have fundamental limitations that no amount of prompting can overcome. G6 adds four capabilities that transform Claude Code from a session-based assistant into a learning system.

Core Innovation: Eight Reasons G6 Matters¶

G6 is a harness-engineering and self-training framework. Rather than modifying model weights, it builds and iterates on the orchestration infrastructure around an LLM — tools, prompts, producers, validation loops, and domain-specific strategies — to unlock capability the model already has. The following eight claims summarise what this approach demonstrates. Each is backed by G6's own benchmark data with sample sizes and statistical significance, and qualified with known limitations.

1. Task-specific training via API credits, not weight modification¶

G6's self-training loop achieves statistically significant accuracy improvements without modifying neural network weights. The entire cost is LLM API credits: GAIA L1 cost $19.94 total (n=42), Omni-MATH cost $100.53 (n=286), and BBEH cost under $200 across multiple self-training iterations (n=100).^[1] A complete harness-training run typically costs \(100–\)500 in API credits.

Compare this to task-specific fine-tuning, which requires training data curation, GPU compute, and ML engineering expertise. OpenAI's fine-tuning API charges $25 per million training tokens^[2]; a meaningful task-specific fine-tune typically costs \(1K–\)10K; enterprise-scale alignment (RLHF, DPO) costs \(10K–\)100K+; and full model pre-training costs $100M+.^[3] G6's harness-level training occupies a different point on this spectrum, using API credits alone rather than GPU compute and ML engineering time, for task-specific improvements.

Important scope distinction. Fine-tuning modifies model weights for broad capability improvements across all tasks. G6 optimises the orchestration harness for specific task classes. These are different approaches at different price points. G6 does not replace fine-tuning — it provides an alternative when the goal is improving performance on a known task class without the cost and infrastructure of weight modification.

2. AI can engineer its own harness to solve difficult benchmarks¶

G6 demonstrates that an AI system can diagnose its own failures and iteratively rewrite its orchestration infrastructure — tool selection, prompt templates, output formatting, and custom producers — to achieve large accuracy gains on non-saturated public benchmarks. No post-training. No different model architecture. The same base model, with better infrastructure around it.

The strongest evidence is GAIA L2: +29 percentage points (39% → 68%, n=66, p < 0.001) through grounding and multi-step orchestration. The earlier BBEH +51pp figure was withdrawn after forensic review; the corrected BBEH result is +4.3pp (82.6% → 87.0%, n=92), concentrated on formally-tractable subtasks and not yet statistically significant in aggregate.^[1] GAIA L2 shows +29pp (39% → 68%, n=66, p < 0.001) through grounding and multi-step orchestration improvements.^[1]

Qualification. Self-engineering is supervised, not fully autonomous — a human is in the loop during the self-training process, providing evaluation criteria and approving changes. The benchmarks are non-saturated (baseline performance well below 100%), which means there is room for improvement; lift is harder to demonstrate on already-saturated benchmarks (e.g., ARC-AGI v1/v2, where the baseline was already 94–96% and G6 showed no significant lift).^[1]

3. Training through natural language alone, using AI tools¶

G6's self-training protocol operates entirely in natural language. The domain expert describes evaluation criteria, diagnoses failures ("this failed because the model didn't use the constraint solver"), and prescribes fixes ("route constraint-satisfaction problems to Z3") — all in plain language. The coding agent (Claude Code) generates the actual code changes. No gradient descent, no backpropagation, no training data pipeline.

This builds on the broader insight that large language models can reason effectively from natural language instructions alone,^[4] extended here to the meta-level: the model reasons about its own performance and generates infrastructure improvements from that reasoning.

Qualification. "No coding required" means the domain expert does not need to write code — the AI coding agent does. The training loop still produces code (harness modifications, new producers, tool configurations), but this code is generated by the AI tools, not the human. The human provides domain expertise, evaluation judgment, and failure analysis in natural language.

4. Harness engineering radically improves LLM benchmark performance¶

Across nine public benchmarks, G6 demonstrates statistically significant accuracy improvements through harness-level modifications alone — no weight updates, no model changes:^[1]

This finding is not unique to G6. LangChain reported agent performance improving from 52.8% to 66.5% through harness modifications alone — without changing the underlying model.^[5] Martin Fowler describes harness engineering as "everything in an AI agent except the model itself" — the infrastructure that steers behaviour and detects errors.^[6]

Known failure modes. LongBench v2's p-value is marginal (0.052). ARC-AGI v1/v2 showed no significant lift (baseline already saturated at 94–96%). SkillsBench showed no lift (G6 24% vs baseline 28%, n=25). GPQA biology regresses −10.5pp (n=19). GDPval evidence generated before the May 2026 scoring hardening is stale and must be regenerated before being used for launch claims or calibration. Full failure analysis is on the benchmarks page.

5. Changed economics of AI deployment¶

G6's self-training requires no GPU hardware, no training data pipeline, and no ML engineering team. The total cost is: API credits (\(100–\)500 per training run) + G6 subscription (\(20–\)50 AUD/month). This puts meaningful accuracy improvements within reach of individual developers and small teams who cannot afford fine-tuning infrastructure.

On hard problems where baseline accuracy is low, harness engineering can actually reduce cost per correct answer. On GAIA L2: G6 cost per correct answer is $1.20 vs $1.45 for the baseline — cheaper per correct despite higher total cost, because fewer attempts are wasted on wrong answers.^[1]

Qualification. G6 costs more per task on easier problems. GAIA L1: $0.69 G6 vs $0.62 baseline per correct answer. Omni-MATH: $0.60 G6 vs $0.42 baseline.^[1] The economic advantage is specific to hard multi-step tasks where baseline accuracy is low and wrong answers consume budget without producing value. On easier tasks where the baseline already performs well, the additional infrastructure cost is not recovered through accuracy gains.

6. Democratised training for domain specialists¶

G6's self-training loop requires domain expertise (evaluation criteria, failure analysis) but not ML engineering expertise. This means domain specialists — security engineers, data scientists, medical researchers — can train their own harnesses using natural language, without needing to understand gradient descent, loss functions, or GPU programming.

GDPval is the intended evidence base for job-agent calibration across 44 occupations, but the previous GDPval artifacts are stale because the scorer now uses the full rubric denominator and reports scoring coverage. The training process still depends on specifying what "correct" means for each occupation, not how to optimise a neural network; production claims should wait for regenerated GDPval runs under the current harness.^[1]

Qualification. "Democratised" is relative to current ML engineering requirements (which typically require specialised degrees, GPU clusters, and dedicated tooling). G6 currently requires Claude Code and some technical proficiency. Non-technical domain specialists without a technical champion are explicitly listed as "not yet" in G6's target audience.

7. Continual learning under non-stationary objectives¶

G6 demonstrates that LLMs can perform economically relevant work through continual learning — the system improves with use rather than degrading. The self-training loop iterates until convergence (defined as no improvement for two consecutive iterations or cost per iteration exceeding 1%), and learned strategies persist across sessions through a case bank, distillation library, mastery tracker, and Thompson-sampling meta-learner.^[1]

The T0–T3 practopoietic hierarchy^[7] provides the theoretical framework: T2 systems (continuous resampling) sustain linear improvement through data augmentation and feedback loops; T3 systems (structured theory building) achieve superlinear improvement by formulating explicit models of the problem domain and adapting when the domain shifts.

Qualification. This has been validated on public benchmarks (BBEH: corrected to 82.6% → 87.0%, +4.3pp, n=92; GDPval regeneration pending), not yet in production deployments with real economic workflows. "Economically useful" is demonstrated via proxy — benchmark tasks designed to mirror real occupational work — not via measured business outcomes. The continual-learning infrastructure is fully wired end-to-end, but the template library is in early development (< 1% coverage), and cost reduction from distillation has not yet been measured as a curve.

8. Harness infrastructure for safety, reliability, and explainability — independent of model improvements¶

G6 provides safety and reliability infrastructure that works with current models, rather than requiring users to wait for the next frontier model release. The Computational Safety Framework (CSF) enforces configured safety budgets, resource bounds, and rollback checks on risky operations. Formal verification components (Z3, DPLL, CEGIS) can provide mathematical guarantees where a task is expressed in a supported formal model and the relevant backend is installed. Otherwise, G6 records static checks, generated specifications, and fallback results as auditable evidence rather than as machine proofs. The AgentHarm benchmark shows the safety-gate approach in practice: +35.8pp accuracy with 98.9% harmful-prompt refusal rate (n=352, p < 0.000001).^[1]

G6 is model-agnostic: benchmark results span Claude Opus 4.6, Claude Haiku 4.5, local qwen3.5:35b-a3b, and GPT models via OpenRouter.^[1] Harness improvements persist across model changes and accumulate independently of model release cycles. As base models improve, G6's absolute performance improves proportionally — G6 is an amplifier, not a replacement.

Qualification. Model-agnostic does not mean model-independent. G6's effectiveness varies by base model capability -- the same harness may produce different lift on different models. The safety infrastructure (CSF) reduces risk but does not eliminate it; its default hazard probabilities are policy priors, not universal empirical guarantees, and the AgentHarm evaluation showed a 25% false-positive rate where the LLM over-blocked benign variants of sensitive topics.

What Claude Code Can't Do Alone¶

G6 classifies adaptive capability using the T0–T3 framework (see Theoretical Foundations). Most AI systems today operate at T0 (no learning) or T1 (one-time harness optimisation). G6 supports all four levels.

Persistent Learning Across Sessions¶

Every time you use G6, it learns. Solved a data cleaning problem? Next time a similar dataset appears, G6 retrieves the cached algorithm instead of burning tokens on a fresh LLM call.

This isn't prompt caching. It's algorithmic compression — converting expensive LLM reasoning into cheap, deterministic code.

Formal Verification of Outputs¶

LLMs hallucinate. G6 doesn't trust unchecked outputs; it routes them through available checks.

• SAT solvers check logical consistency when the problem is encoded for SAT
• SMT checkers validate arithmetic and constraints when the backend is available
• Counterexample-guided synthesis refines programs against specified properties and counterexamples

When G6 reports verification, inspect the proof status and artifact. Some records are external machine-prover results; others are generated specs, static-analysis results, oracle-test checks, or fallback evidence.

Self-Improving Skill Evolution¶

G6's evolution loop (powered by EvoSkill) watches for repeated failures, proposes new skills, tests them against validation data, and keeps only the ones that improve performance.

Over time, your G6 instance becomes specialised to your domain — automatically.

Cost Reduction Through Compression¶

Fresh LLM calls are expensive. Cached algorithms are free.

G6 tracks two types of compression:

• Type I: Recognise a known problem and retrieve the solution
• Type II: Decompose a novel problem into known sub-problems

As your library of solved problems grows, the fraction of work requiring fresh LLM calls shrinks.

Deeper: Theoretical Foundations¶

For the mathematical and scientific foundations behind these capabilities — including why G6 is a combinatorial optimisation engine rather than a statistical predictor — see Theoretical Foundations.