Frequently Asked Questions

G6 is a batteries-included harness-engineering and self-training framework — an AI metamodel that lives on top of your coding agent and gives it advanced skills on demand via MCP. It spans self-training, formal methods, agent runtimes (openclaw, LangChain, LangGraph, Claude Agents, OpenAI Agents, plus 39 job agents), the Computational Safety Framework (CSF), cognitive architectures, alignment engineering, context management (nearly 20 tools), reflexive tools (debate, harness, self-healing, self-modelling, system-doctor), and more — see the full capability clusters. Under the hood, G6 creates 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. The result is a Swiss-cheese defence against hallucination through grounding and formal reasoning. Use it as a library (wire clusters into your own app over MCP) or as a live co-pilot (your coding agent gains these skills on demand). Built for domain experts shipping frontier applied systems and for AI researchers who want to push the frontier by enhancing LLMs without updating neural network weights.

G6 trains AI systems without modifying neural network weights. Instead of fine-tuning a model (which costs $1K–$100K+ and requires GPU clusters and ML engineering), G6 iteratively improves the orchestration infrastructure around the model — tool selection, prompts, producers, and validation loops — at a fraction of the cost ($100–$500 in API credits per training run).

This has been validated across 13 public benchmarks with statistically significant results on several: GAIA L2 +29pp (n=66, p < 0.001), Omni-MATH +9pp (n=286, p < 0.001), SWE-bench Pro +11pp at matched effort (one attempt per task in both arms), among others. The entire training process uses natural language — the domain expert describes what “correct” looks like and diagnoses failures; the AI coding agent generates the infrastructure changes.

The implications are: (1) task-specific training is designed to cost far less than weight modification (not yet a measured outcome), (2) domain specialists can train their own models without ML engineering expertise, (3) no GPU hardware is required, and (4) improvements persist across model changes and accumulate independently of model release cycles.

Important qualifications: Harness training optimises for specific task classes, not broad capability (unlike fine-tuning). G6 costs more per task on easier problems. Known failure modes include null results on already-saturated benchmarks (ARC-AGI) and regressions on some subcategories (GPQA biology). Full details: Why G6 — Core Innovation.

G6 solves the layer between model capability and real workflow execution. Raw LLMs are excellent at language and intent parsing but production AI systems usually fail on: state (no persistent context across steps), tools (unreliable tool use without verification), validation (no formal checking of outputs), auditability (no trace of how conclusions were reached), and economics (every task is equally expensive, with no learning or compounding). G6 addresses all five.

Harness engineering is the discipline of designing, building, and maintaining the infrastructure, workflows, and constraints that make autonomous AI coding agents reliable. 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 field emerged as AI engineering matured through three generations: prompt engineering (crafting model inputs), context engineering (curating what the model sees), and now harness engineering (building the entire infrastructure around the model). Martin Fowler defines it as “everything in an AI agent except the model itself” — the guides that steer behaviour and the sensors that detect and correct errors.

A complete harness rests on five pillars: tool orchestration, guardrails and safety constraints, error recovery and feedback loops, observability, and human-in-the-loop checkpoints.

G6 is a harness-engineering framework — its 200+ cognitive components are the building blocks of that infrastructure, composed and validated at runtime. Learn more: MindStudio, NXCode.

Primary: AI researchers, teams building AI applications, technical founders, internal platform teams, and advanced coding-agent users who need reliable tool orchestration, audit trails, and human-supervised workflow execution.

Secondary: Technical domain specialists with a technical champion in the loop, who want to prototype sophisticated AI workflows faster without assembling raw models, tool stacks, and deployment infrastructure by hand.

Not yet: Broad SMB self-serve buyers or non-technical domain specialists without a technical champion — these segments require further product maturation.

We would rather tell you up front. G6 adds the most value when reliability, auditability, and self-improvement matter — and less when they don’t. It is probably not the right fit if:

• You want a turnkey chatbot or a single one-shot answer with no setup — a plain LLM is simpler.
• Your task is already saturated (baseline accuracy >85–90%) — there is little headroom for the harness to add.
• The task genuinely needs model-level changes rather than tool orchestration — some problems do.
• You need a non-technical, no-champion, self-serve product today — that maturity is still ahead of us.
• You can’t run a local model or supply an API key, and can’t use Claude Code, MCP, or the CLI.

Where it shines: long-horizon agent work, high-stakes domains that need evidence and escalation, and workflows you intend to run repeatedly and improve over time.

G6Solver is completely model-agnostic. It works with any LLM through OpenRouter or our own Ollama backends — Claude, GPT, Gemini, Llama, Mistral, and more. You’re never locked into a single provider. As the system self-trains, it improves reliability across models — benchmarks show accuracy lifts on both frontier APIs (Claude Opus 4.6) and local models (qwen3.5:35b-a3b, medgemma:27b).

An MCP client (Claude Code is the supported one) or an HTTP client, an internet connection, and a G6 API key. There is nothing to install on your machine beyond the client you already use, and no particular operating system is required.

G6 itself runs on our servers, so your machine does not need to meet any compute, memory, or GPU requirement to use it.

G is for general intelligence — Spearman’s G factor. The 6 names the platform; underneath it, G6 runs seven core cognitive systems that make it real: self-learning, self-modification, failure engineering, alignment engineering, formal methods, symbolic machine learning, and self-improvement (the evolutionary meta-system that lets G6 improve its own learning rules). Together, these systems enable G6 to operate across four levels of adaptive capability (T0–T3) — from fixed tool-calling through to structured theory building. See The Thesis on our home page.

Claude Code is the recommended MCP client for G6, but not strictly required — any MCP client works. The hosted REST surface is parked at launch and its public route returns 404, so MCP is the only way in for now. When connected to Claude Code via MCP, G6 adds 250+ MCP tools to your environment, backed by 250+ composable modules.

Yes. G6 exposes a comprehensive API through its 250+ MCP tools. Developers build extensions and plugins on top of this API rather than modifying source code directly. You can compose G6 tools into custom workflows, chain pipelines, and integrate G6 capabilities into your own applications via the MCP protocol. (The REST surface is parked at launch.)

Your total cost has three parts:

1. Claude Code license (from Anthropic)
2. G6Solver license ($20–50 AUD/mo)
3. LLM API costs if using cloud models via OpenRouter

G6 uses more tokens per task than a raw LLM call, and the multiple is not a single number — it depends on the benchmark and the model. Our measured range is roughly 1.3× to 10.3×: the low end is LongBench v2 ($0.075 → $0.097 per task, cloud Haiku); the cloud-model benchmarks (GAIA L1/L2, Omni-MATH, ARC-AGI v2) sit at 1.4–1.9×; the high end is GPQA Diamond on a local model, where a long multi-step tool loop costs 10.3× the tokens (4,282 → 44,150 per question) and 3.7× the wall-clock. In exchange you get significantly higher accuracy — +6pp to +29pp across 13 public benchmarks (details, per-benchmark cost tables and known limitations). On hard multi-step problems where baseline accuracy is low, cost per correct answer can be lower ($1.20 vs $1.45 on GAIA L2). On easier tasks, the baseline is cheaper per correct answer. The self-training loop improves reliability with each iteration without weight updates.

Researcher — $20 AUD/month: 200+ AI components, compound learning, community support.

Builder — $50 AUD/month: Everything in Researcher plus multi-device (up to 3), usage & benchmark dashboard, automatic model selection (coming soon), and priority support.

Signing up gives you a 30-day trial with the Researcher tool set and no credit card required. Subscribing to a paid plan starts billing immediately — the trial runs before you subscribe, not after.

Note: G6 is one part of your total cost. You also need a Claude Code license (from Anthropic) and, if using cloud models, LLM API costs via OpenRouter.

Per task, yes — but there is no single multiplier, so we publish the measured range rather than an average. Across our benchmarks the verification overhead runs from about 1.3× (LongBench v2, $0.075 → $0.097 per task on cloud Haiku), through 1.4–1.9× on GAIA L1/L2, Omni-MATH and ARC-AGI v2, up to 10.3× tokens and 3.7× wall-clock at the extreme — GPQA Diamond on a local model (4,282 → 44,150 tokens and 4:38 → 17:03 per question). Per-benchmark cost tables are on the benchmark page. What you get is dramatically higher reliability: +29pp on multi-step reasoning (GAIA L2), +9pp on competition maths (Omni-MATH), and +4.3pp on BBEH (with deterministic per-subtask wins such as hyperbaton 0→99.5%). On hard problems, cost per correct answer is actually lower ($1.20 vs $1.45 on GAIA L2) because you waste less on wrong answers.

Compare the real alternatives: post-training a frontier model costs $10K–$1M+. Training your own costs millions. G6’s self-training loop achieves statistically significant accuracy improvements with no GPU cluster, no training data pipeline, and no weight updates — just API credits and a clear evaluation objective. (Note: post-training modifies model weights for broad capability improvements; G6 optimises the orchestration harness for specific task classes. Different approaches at different price points.)

The harness improves through iteration — changing orchestration, not model weights — so the gains compound at API-credit prices rather than GPU-cluster prices. That economics, not any single headline number, is the real story.

G6’s self-training works even on novel tasks. The system learns how to use tools better, not just how to solve specific problems — strategies refined on one task can transfer to structurally similar ones.

For genuinely novel tasks, G6 improves reliability through structured reasoning, safety gates, tests, and optional formal checks where the property and backend support it, and coverage (tasks beyond the model’s context window become solvable — LongBench v2 went from 0% to 52% on long-context items the base model cannot fit at all). On LongBench the gain is coverage, not a reasoning uplift: a dedicated harness-improvement study found no statistically significant accuracy gain over the retrieval baseline on items the model could already read, because those residual errors are comprehension-bound rather than process-bound.

On a flat-rate Claude license, these reliability gains are pure upside — higher accuracy at no additional token cost.

We never hard-lock your system. Instead, it gracefully degrades to limited mode:

• Learning and compression pause (your system freezes at its current state — still useful, just doesn’t improve)
• Advanced components disable (formal methods, CEGIS, self-healing)
• Falls back to basic LLM routing only

Reactivate at any time to resume learning and unlock all features. Your learned state is preserved — nothing is lost.

Yes. Signing up gives you a 30-day trial with the Researcher tool set, and no credit card is required. The trial is your chance to evaluate the platform’s reliability improvements on your own workloads before you pay anything. Two things to know: the trial does not include the Builder-tier tools, and when the 30 days end the account drops to the Free tool set rather than stopping.

G6 is proprietary software licensed under a commercial SaaS license. The source code is available for audit by licensed users but is not open source. We plan to release selected core components under open-source licenses in the future, but this has not yet occurred.

We expose a comprehensive MCP tool API that developers can build extensions and plugins on top of. You interact with G6 through its 250+ MCP tools — the same interface your AI agents use. This means you can extend G6’s capabilities without needing access to the source code.

Your code files stay on your machine — Claude Code runs locally, and G6’s server does not receive your source tree or project files. What does reach the server is whatever you pass into a tool call, over HTTPS/TLS. Some of it is retained: when you run the solver, G6 stores the text of the goal you sent along with the run outcome, token count, and task classification, so that cross-session learning can recognise repeat work. If a run halts, the first 256 characters of the goal and a summary of the failing steps are written to a failure log. Both stores are server-side and persist across sessions — this is the same retention the learning features depend on, not an incidental cache. Account and billing data are covered by the Privacy Policy.

Those are orchestration wrappers — they help you chain LLM calls together, but every call still costs money and the system doesn’t learn.

G6 is a composable AI framework with cognitive capabilities. It treats the LLM as a reasoning-and-routing layer wrapped in deterministic verification, optimisation, and orchestration that you can inspect. The key difference: G6 gets more reliable with use because its self-training loop improves how tools are selected and applied — without weight updates, without post-training, and at a fraction of the cost. Orchestration wrappers stay the same no matter how many times you use them.

First: check the trajectory. If accuracy is trending upward, continue — the T3 self-training loop typically needs 3–10 cycles. If the trajectory is flat or negative after 2–3 iterations, stop and diagnose.

The most common failure modes are:

• Wrong tool selection — incorrect tools can actively hurt performance. Review tool-call traces and reduce to 2–3 tools per task category.
• Not enough cycles — early iterations fix infrastructure issues; real gains often appear after 3–5 cycles.
• Over-fitted harness — training on too few examples. We recommend at least 25 training instances (25% of a 100+ item dataset).
• Task not amenable to tool learning — some tasks genuinely need model-level changes (e.g., SkillsBench: G6 24% vs baseline 28%).
• Task already saturated — if baseline accuracy is >85–90%, there’s limited room. Consider using a smaller model with G6 to reduce cost instead.
• T-level mismatch — not every task needs T2/T3. If T1 works, stop there.

Full diagnostics and fixes: Troubleshooting — G6 Failure Modes.

Type II (first encounter): The system reasons step by step using LLM calls, search trees, and formal methods. This is slower and costs tokens, but it produces a verified solution.

Type I (repeated encounters): When a problem class recurs, G6 can compress it into a deterministic algorithm and — after re-verifying that algorithm on the new instance — replay it instead of calling an LLM. When that succeeds the answer is fast, free, and reliable. This is demonstrated today for recurring, template-style problem classes; it is not yet the default path for arbitrary tasks (see status below).

The underlying principle is information compression: a solved problem class is captured in a much shorter, faster-to-run form — whether that form is an explicit algorithm or a learned model — so the same transformation costs less compute the next time. Each pattern compressed is one less thing you pay an LLM to re-derive.

Current status: The distillation engine, SOAR case bank, cross-session memory, and Thompson-sampling meta-learner are fully wired end-to-end. The solver queries prior experience before every run, distils successful traces into reusable artifacts, and tracks which learning strategy works best per problem class. The template library is in early development (<1% coverage) — cost reduction from distillation has not yet been measured as a curve.

Yes. G6 is specifically designed for multi-step planning and autonomous problem-solving using 200+ composable cognitive components. It maintains context across complex workflows, learns from each interaction, and uses typed pipelines, safety gates, tests, and optional formal verification backends to catch errors before they are silently ignored. Formal results should be checked by proof status and artifact before being treated as guarantees.

Yes. The system learns from your specific problems and domain through supervised iteration, building a form of institutional knowledge that doesn’t walk out the door when an engineer quits. Both in-session and cross-session learning are fully wired: the case bank, distillation library, mastery tracker, and meta-learner persist across runs and compound automatically.

Your coding agent runs locally. G6 runs on our servers. G6 is a hosted MCP server (SSE transport). Claude Code — or whichever agent you use — stays on your machine and calls out to G6 for the tools it needs.

What leaves your machine: only what you explicitly pass to a tool. Your source files are not uploaded. Some of what you do pass is retained server-side across sessions — see “How is my data protected?” above for exactly what is kept.

What does not run locally: the components themselves. There is no downloadable desktop build and no self-hosted deployment — access is through the hosted service only.

See the setup guide to connect.

G6 is built for human-AI teaming. It learns by working with you, not by operating autonomously. Your domain expertise shapes how the system solves problems. A security engineer's G6 develops different patterns than a data scientist's.

This is deliberate. A system that depends on human expertise to improve has a natural safety property. It can only get better at the things you actually do, which means no runaway optimisation and no invented goals.