Senses and media
A language model reads and writes text, and nothing else.
Read a screenshot, a scanned form or a recording, and make the images, audio, video and 3D scenes a job needs, from the agent you already use.
Components
AI agents fail in the same few ways, again and again. Some 250 million tokens of their reasoning and failure traces were reviewed by hand to find the primitives that close those failures: a periodic table of intelligence.
The components are one of G6's two parts: a prebuilt library of AI primitives for capability extension and failure engineering. Each extends what a model can do or closes one way it fails, and they stack like slices of Swiss cheese: where one slice has a hole, the next one catches the failure. The other part, the meta-harness, learns which of them your work needs, so the system you already run debugs, corrects and improves itself.
- Core harness
- 34
- Extensions
- 60
- Failure modes in every premortem
- 13
Three ways to use them
All three work today, on your own computer.
As built
The core harness as shipped. Connect it to your agent over MCP and every result comes back labelled with what its evidence supports.
Compose
Your agent finds the components a task needs and combines them: g6_find,
g6_describe and g6_invoke over MCP, or plain imports in Python.
Full source
Every line is open. Read it, change it, and build your own components on it.
Three modes of work
How G6 runs a job: once, continuously, or before anything starts.
Mission
One piece of work against a frozen standard of done. A person confirms the standard, G6 runs the checks, and the certificate states exactly what the evidence supports.
g6.workforce
Venture
An ongoing operation, run in budgeted ticks. Every outward action is drafted, gated and queued for a person to approve.
g6.operator
Premortem
Before work starts, assume it has already failed and name how. Each of the 13 failure modes comes with the guard that catches it.
g6.reliability_pipeline
A capability extension harness
A language model predicts text. Extensions give the model you already run senses, memory, tools and a body, so it can do more of a job on its own, and each new ability arrives with checks for the ways it fails.
The model stays yours: a free local model through Ollama, or Anthropic, OpenAI or OpenRouter, through
g6.core.llm. The llm_router extension picks a
model for each kind of task, local first, and falls back only along a chain you set. What changes is
what it can reach. Each group below says what a model cannot
do alone, what you can achieve once it can, and which parts of G6 do the work.
Memory and persistent work
It forgets whatever falls out of its context, and stops when its reply ends.
Run a job against a fixed standard of done, or an operation in budgeted steps over days, and keep what it learns in a memory it can search.
Current, cited knowledge
It knows only what it was trained on, and cannot say where a fact came from.
Answer from today's sources, with each claim checked against the passage it cites.
Action in the real world
It can describe an action, but cannot take one or undo it.
Query databases, commit code, hand work to other agents and deploy services. Outward git actions (fetch, pull, push, clone) are checked by G6's action gate first and the risky ones sent to a person; local ones (commit, merge, branch, tag, stash, add, reset) are sensitive ops you allow.
Exact computation and proof
It guesses at arithmetic and logic by predicting likely text.
Analyse data, find the best plan under constraints and settle logic with solvers and provers, where a plausible answer is not enough.
Bodies and simulation
It has no body, no senses of its own and no physics.
Plan and test physical actions in simulation, with sensors and touch, and coordinate people, agents and robots on one task.
New capabilities on demand
It cannot give itself a tool it does not have.
Match a request to the components that exist, or turn a Python library into a new component with tests; the meta-harness gate decides whether a change stays.
Every extension named here is in the open-source library. Each is listed, with the failure it guards against, under Extensions.
The core harness
The components that check, gate, ground and tune an agent's work, the meta-harness among them. Each runs on its own, from Python or over MCP. To see how they fit together in the code, explore the repository graph; to see which failures each one guards against, and which nothing guards yet, see the failure map.
Formal methods
Logic, proof, algebra, rules, state machines, optimisation and cause and effect, each settled by a solver, a prover or a rule engine rather than by a model's guess.
-
The logic checker
Settles small logic questions exactly with a solver, and labels each answer for what it is.
-
The algebra checker
Does exact algebra and calculus for you, such as simplifying a formula, solving an equation, or finding a derivative, an integral or the inverse of a matrix, and checks each answer a second, independent way before handing it over.
-
The proof checker
Has Lean, a proof assistant, check a proof you wrote of a theorem you name, and confirms that it leaves no step unproved, assumes nothing beyond the standard rules and proves exactly the statement you give.
-
The state machine checker
Checks a system you describe as states and the steps between them, such as a protocol or a workflow: it finds a run of steps that breaks a rule or gets stuck, or shows the rule always holds.
-
The rule engine
Works out everything that follows from your facts and rules, such as who reports to whom or what a change can reach, and shows how each answer was derived.
-
Program synthesis
Fills the gaps in a code template, then hunts for an input that breaks it, and repeats until none is left in the range you set.
-
Safety bounds
Works out an upper limit on how likely an agent you describe is to reach an unsafe state, and checks rules it must always keep.
-
The cause-and-effect checker
Works out from your diagram of what causes what whether data can show the effect of one thing on another and which variables to control for, then estimates the effect and tries to knock it down.
-
The optimiser
Finds the best plan within your limits, such as routes, schedules, assignments or a budget, and checks each answer before handing it over.
-
The network reasoner
Works out how true each label on a network is, such as who counts as popular or which link can be trusted, as a range from false to true, from your facts and rules, and shows how each range was reached.
-
The Prolog runner
Runs a question against a Prolog program you give it, with SWI-Prolog on your computer, accepting only plain facts, rules and a short list of standard operations, and checks every answer a second time before handing it over; it is not a sandbox, so run programs you do not trust inside your own.
Checks, gates and tuning
The rest of the core harness: what checks, gates, grounds and tunes an agent's work.
-
Search shortcuts
Learns simple patterns from the results of a costly search, each checked against real evaluations, and suggests which tries to skip.
-
The action gate
Before an agent acts, decides whether it may go ahead, must ask a person first, or is blocked.
-
Rules for acting safely
Rules from research on how complex decisions fail: act in small steps, watch for early warnings, and change course when the evidence turns.
-
The coding-agent check
Checks a coding agent's work before it acts and again before it says the job is done.
-
The context builder
Packs just the files and notes a model call needs, within a size limit, each marked with where it came from.
-
Structured debate
Has named roles, such as a proposer and a critic, argue a question in turn, and reports how far they agree.
-
Tested shortcuts
Checks a small function that stands in for repeated model calls: it runs it in a bounded child process and tests it on new cases before anyone relies on it.
-
The claim judge
Grades the evidence behind each claim and holds back a high-stakes conclusion the evidence cannot carry.
-
Certificates
Gives the final verdict on a piece of work: verified, a qualified draft, or blocked, with every gap named.
-
Goal plans
Holds the subtasks you declare as a tree and checks them against what your executor reports.
-
The source check
Finds the passages in your sources behind a claim and says how well they support it.
-
Tamper scanners
Flags a fixed list of English phrasings of prompt injection; a paraphrase passes.
-
The intent contract
Writes down what a task must achieve, what counts as failure and what is out of scope, and lists what is still missing.
-
Honest labels
Checks that every result's label matches the evidence attached to it.
-
Learned hints
Learns hints from an agent's failures, and keeps one only when side-by-side runs show it helps.
-
The self-tuning loop
Tunes how G6 runs a task you repeat: it proposes changes, tests each one on cases it has not seen, and keeps one only when you approve.
-
Fair comparisons
Budgets, vote counting and side-by-side tests for multi-step reasoning, so a gain is measured, not assumed.
-
Intake and premortem
Takes a task in, checks it can be done, and names how it could fail before work starts.
-
Run limits
Hard limits for one run: a stop switch, allowed actions, and ceilings on steps, tool calls, files changed, time and cost; it also spots tests that were weakened.
-
Change approval
Decides whether a proposed change to the harness may go live; safety rules and failed tests can only make that decision stricter.
-
The step-by-step solver
Runs a goal through a fixed sequence of 15 problem-solving steps that you supply, and reports where it stopped.
-
Coding missions
Fixes what done means before a coding task starts, has a person confirm it, then checks the agent's change against it.
Extensions
60 extensions, in 12 families, that extend what a model can do. Each names the failure it guards against or the gap it closes, and is in the library with its tests. Another 59 pieces were merged into one of them or into the core harness, and each is listed under the package it joined.
Media 10
-
adapt_audioEdit, level, clean and measure sound in WAV files, each result measured again and never clipped silently.
-
adapt_blenderBuild, light, render and export 3D scenes with your Blender, each change read back and each render inspected.
-
adapt_comfyuiMake and edit pictures on the ComfyUI server you run, each one fetched into G6's media folder and inspected.
-
adapt_diagramsWrite checked Mermaid, DOT, PlantUML or ASCII diagrams, and draw DOT with Graphviz.
-
adapt_ffmpegConvert, cut, join, resize, filter, subtitle and level video and sound with your ffmpeg, every result probed from disk before it is returned.
-
adapt_generative_artMake procedural pictures, vector drawings and heightmap meshes from seeded techniques.
-
adapt_synthetic_world
-
-
adapt_imageEdit, convert and measure pictures, and generate them through the media family's backends, local first, each one inspected.
-
adapt_creative_api
-
-
adapt_synthMake tones, notes, chords, scales, melodies, noise and drum patterns, each one measured against what was asked.
-
adapt_visualisationChart the rows you give, and show the file holds every row and only the values given.
-
adapt_voiceSpeak text and transcribe speech, refusing a transcript that is empty or at an impossible speaking rate; a wrong one of a plausible length passes.
Machine learning 5
-
adapt_automlSearch estimators and settings within a budget, and score the choice on rows it held out.
-
adapt_autosklearn
-
-
adapt_bayesianExact Bayesian updates and checked posterior sampling: expose hidden uncertainty.
-
adapt_pandasRead a table you give by one stated rule, and say where it mixes kinds, looks missing or repeats.
-
adapt_pytorchTrain a small neural network on rows it holds out itself, seeded, and stopped on a broken loss.
-
adapt_keras
-
-
adapt_sklearnFit and score a scikit-learn model on rows it holds out itself, after checking for leakage.
-
adapt_learning
-
Agent runtimes 7
-
agent_autogenRun an AutoGen team (round robin, selector or swarm) on the model you pass in, stopped at a message limit, every tool call decided by G6's gate.
-
agent_claudeHand a coding task to Anthropic's Claude Code, which you installed: read tools only unless you grant edits, never its shell or the web.
-
agent_codexHand a coding task to OpenAI's Codex, the coding agent you installed: read-only unless you grant writes, in the folder you name, under a deadline.
-
agent_langgraphRun a LangGraph workflow that saves its state after every step, so a run that is stopped or crashes resumes where it was.
-
agent_nanoclawA durable mailbox between agents: each reader pages through every message for it, and one it did not acknowledge comes back after a crash.
-
agent_openclaw
-
-
agent_runtimeRun any agent under one set of rules: declared tools and permissions, capped limits, G6's stop, and the action gate before each outward call.
-
agent_smolagentsRun a smolagents tool-calling or code agent; its code runs in a separate, time-limited process with Python's network calls blocked.
Knowledge and retrieval 9
-
ctx_colbertRank one call's passages by meaning, say which method ranked them, and refuse word matching when meaning is required.
-
ctx_contexthubKeep a documentation registry you name, each document with when it was read and a time to live, and refuse a copy past it.
-
ctx_elasticSearch the Elasticsearch you run over fields its mapping holds, so a query that cannot match is refused rather than answered with no hits.
-
ctx_searchSearch the web through the SearXNG you run, or Brave when you approve it, and tell an engine that failed from one that found nothing.
-
knowledge_chunkerCut a document into passages with exact offsets and ids bound to their source, and check a citation against it.
-
knowledge_converterTurn PDFs, web pages, Markdown and text into a document that says what converted it and what could not be read.
-
knowledge_fetcherFetch pages and searches (arXiv, OAI-PMH, OpenAlex, Semantic Scholar) through G6's checked HTTP, and say exactly why a fetch failed.
-
ctx_research_scanner -
ctx_scrapling
-
-
knowledge_indexerKeep passages in a searchable index under a storage budget you set, and search them with each hit's source and a score on a stated scale.
-
knowledge_manifestKeep the sources and passages an agent cites, and check a passage against its source as read again.
Memory 2
-
ctx_aceKeep an agent's notes and find them again by relevance, each read back as data with its source, writer and age.
-
ctx_cogneeAdd text to the Cognee server you run and follow the links its knowledge graph draws between facts, each result cited and untrusted.
Sources 6
-
australian_legal_corpusSearch Australian law on your own computer, each passage with its jurisdiction, link and collection date, never as current law.
-
ctx_geoAnswer location questions from a map service, with its status read on every reply, so a refused key or a used-up quota is never "no results".
-
ctx_gitRead and change git repositories inside folders you declare, with every call logged and every change since a point reported, whoever made it.
-
ctx_langextractPull named fields out of a text, each value with its offsets in the text or refused, the whole text read.
-
ctx_library_mapperFind candidate libraries in PyPI, GitHub and Hugging Face, their declared licences looked up against yours.
-
ctx_visionShow a picture to an image-capable model you give it, record its account as a claim, and cross-check its reading of text with Tesseract.
Workspaces 3
-
align_prompt_libraryKeeps every version of a prompt, spec or test set by the SHA-256 of its content, so a result can cite the exact version it used.
-
align_artifacts
-
-
workspace_managerGives each agent task its own workspace folder and checks every path as part of each read and write, so nothing lands outside it.
Code 8
-
adapt_djangoGenerate Django source without Django; check full projects in a separate, time-limited process, not a security boundary.
-
adapt_healingRepair a failing step of Python code, keeping a patch only if it passes held-back tests its proposer never saw.
-
adapt_library_synthesizerDraft Python from a paper spec and check independently supplied examples.
-
adapt_webpageBuild web pages and design tokens; check syntax, declared contrast and optional overflow.
-
adapt_ui_design
-
-
component_creatorScaffold a new G6 component in the library's own shape, and check a package against the library's standard before anyone calls it done.
-
auto_component_integrator -
auto_engineer
-
-
design_governanceCheck a codebase's structure for import cycles, layer breaches and pass-through wrappers, and which cycles a change introduced.
-
meta_programmingRename and extract Python code through its syntax tree and scopes, each edit checked against the tree it should give, comments kept.
-
swe_diagnosticsShow a coding agent an unfamiliar repository before it changes it: its layout, build, tests and files, and what a change touches.
Embodied and simulation 1
-
adapt_physical_aiCheck a robot's motion plan against its world and its own limits, segment by segment, before anything moves.
Cognitive architectures 4
-
cog_arch_actrRank an agent's memories by recency, frequency and context with ACT-R's equations, refusing a recall below the retrieval threshold.
-
cog_arch_aixiRun a bounded MC-AIXI-CTW agent on a registered environment and judge it by its regret against a random policy on the same seed.
-
cog_arch_gpsPlan a sequence of steps to a goal by means-ends analysis, every plan replayed against its operators before it is offered.
-
decision_makingStandard, seeded decision rules for what to try next and how many retries to allow, each answer with its working and the same on every run.
Professional workflows 1
-
duty_of_careMatches a fixed list of English crisis phrases; a paraphrase or another language passes. A match goes to a person.
Integrations 4
-
adapt_rqBackground JSON jobs on an operator-owned Redis queue, with registered functions and sensitive operations.
-
databaseQuery and change a database the server's operator declares, reads on a connection that cannot write, changes dry-run first.
-
hat_orchestratorCoordinate declared team capabilities and claims; operator ranks never authorise real-world actions.
-
llm_routerPick a language model for a kind of task from a committed table, local first, with an ordered fallback chain and dated cost estimates.
-
agent_router
-
Merged into the core harness 46
-
g6.action_gating-
align_csf -
csf_audit -
csf_gate -
poka_yoke
-
-
g6.cegis-
template_synthesis
-
-
g6.cli-
diagnostic_collector
-
-
g6.coding_agent_gate-
governance
-
-
g6.context-
ctx_claude_context -
ctx_mnm -
ctx_recursive
-
-
g6.core-
adapt_instructor -
agent_langchain -
agent_openai
-
-
g6.csf-
csf_auto_model -
csf_strategy
-
-
g6.datalog-
adapt_experta
-
-
g6.epistemic_integrity-
align_verbsamp
-
-
g6.formal-
formal_verification
-
-
g6.grounding-
ctx_rag -
document_stc -
knowledge_quality
-
-
g6.guards-
csf_cognitive
-
-
g6.harness-
domain_workflow -
golden_tests -
harness -
reliability_ledger -
value_completion
-
-
g6.intent_engine-
align_specs -
user_intent
-
-
g6.lean-
lean_prover
-
-
g6.learning-
adapt_eurisko
-
-
g6.metaharness-
cog_arch_dgm -
evoskill -
llm_extension -
opt_cost -
opt_meta -
opt_quality -
opt_speed -
self_observation
-
-
g6.operator-
work_loop
-
-
g6.optimisation-
adapt_optimisation -
adapt_pygad
-
-
g6.reasoning-
align_evals
-
-
g6.self_training-
benchmark_runner
-
-
g6.solver-
solver_accuracy
-