Skip to content

Platform Capabilities

Everything you need to deploy AI
that actually works in production.

Traditional software is cheap to run but expensive to create. AI code is cheap to create but unreliable to run. G6 organises its capabilities into four value buckets — Build, Run, Trust, and Optimize — that close both gaps simultaneously.

Build Run Trust Optimize
Build

Specify AI workflows and applications in natural language. Extend with code when needed. Reach it over MCP. (REST and a hosted web surface are parked at launch.)

Components: Goal Engine Solver Navigator Guide Meta Programming Component Creator Auto Engineer LLM Router Workspace Manager
Deployment bases: MCP REST Web gRPC (experimental) SOAP (experimental) Erlang (experimental)
Primary Interface

Claude Code Integration

G6Solver connects to Claude Code as a hosted MCP server, giving you access to 250+ composable components and 250+ MCP tools across 16 capability clusters directly in your development workflow. No context switching. No separate UI. Just ask Claude to use G6 tools.

Claude Code recommended but not required — any MCP client works. The hosted REST surface is parked at launch. Model routing runs server-side.

  • ● 250+ MCP tools across 16 capability clusters
  • ● 16 capability clusters including Creative & Media, Agent Frameworks, and Cognitive Architectures
  • ● Natural language tool invocation through Claude
  • ● Server-side Ollama & OpenRouter LLM backends
  • ● Template pipelines and self-optimisation (EvoSkill T6 & T7)
  • ● Connect in under 2 minutes (G6 account required, Claude Code recommended)
# Connect Claude Code to the hosted endpoint
$ claude mcp add g6 --transport sse \
  --url https://g6solver.com/mcp/sse \
  --header "Authorization: Bearer ..."
# Then in any conversation:
> Use G6 to decompose this goal into subtasks
> Run a safety audit on this codebase
> Find the best ML algorithm for my dataset
Run

Tool orchestration, stateful execution, retries, and automatic failure recovery. Keep workflows running even when individual steps fail.

Orchestration: Autonomous Orchestrator Autonomy Governor Adapt RQ Database Adapt Memory Context Engine Observability Hyperdistillation
Agent frameworks: Agent Claude Agent Autogen (adapter) Agent Langchain (adapter) Agent Langgraph (adapter) Agent OpenAI (adapter) Agent Smolagents (adapter)
Job agents (39): Accountant Analyst Lawyer Engineer Researcher Scientist Finance Medical
Context & retrieval: Search RAG ColBERT Elastic Cognee MarkItDown Scrapling LangExtract Recursive ACE Claude Context Claude Mem ContextHub Fenic Geo Git Library Mapper MnM Research Scanner Vision
Multimodal: Multimodal Audio Voice Image FFmpeg Blender ComfyUI Generative Art Mesh 3D Visualisation Diagrams Creative API Synth
Physical AI & embodiment (planned): Physical AI (planned) Embodiment (simulation) Motor Control (simulation) Sensory Fusion (simulation) Tactile Fusion (simulation) Physics Prediction (simulation) Realtime Bridge (planned) Affordance KB (simulation) Grounding Synthetic World (simulation)
Cognitive architecture: ACT-R AIXItl Discovering Gödel Machine GPS SOAR
Class 1

Harness Refinement & Memory

Agents that improve through human-supervised harness refinement — not autonomous runtime learning. G6’s self-training loop diagnoses failures, refines the orchestration harness, and promotes proven solutions through staged iteration (pretest → smoke → pilot → full run) under human oversight. For repetitive work — the dominant distribution in economically valuable tasks — the system distils reusable algorithms and code that progressively automate sub-tasks, reducing LLM dependence over time. The full cross-session learning pipeline (case bank, distillation, mastery tracking, Thompson-sampling meta-learner) is wired end-to-end. (Cost reduction from distillation has not yet been measured as a curve. Validated on benchmarks, not yet in production deployments.)

  • ● Persistent, hierarchical memory architecture
  • ● Experience-based learning loops
  • ● Cross-session context retention
# Agents that remember
agent.memory.store("user prefers concise code")
agent.memory.recall("coding style")
# → "user prefers concise code"
Class 2

Self-Modification

Supervised code rewriting with safety constraints. Agents debug their own reasoning, rewrite faulty logic, and synthesise new solutions behind approval gates, tests, rollback paths, and optional formal checks.

  • ● CEGIS-based program synthesis
  • ● Supervised meta-programming
  • ● Progressive agency reduction
# Self-debugging in action
result = agent.solve(problem)
if result.status == "fail":
agent.diagnose(result.trace)
agent.rewrite(result.faulty_step)
Class 3

Failure Engineering

AI will fail. The question is whether it can detect, understand, and recover from failure autonomously. G6 has built-in failure detection, self-healing, and automatic rollback.

  • ● Search tree diagnostics
  • ● Automatic rollback and recovery
  • ● Drift detection and self-healing
# Failure → Recovery
checkpoint = agent.save_state()
try:
agent.execute(risky_operation)
except FailureDetected:
agent.rollback(checkpoint)
agent.heal(error_context)
Trust

Audit trails, explainability, approval gates, and optional formal verification backends. Every critical step is traceable to retrieved evidence, tool outputs, generated checks, or human approval.

Safety: CSF Align CSF CSF Cognitive CSF Strategy Compliance Cybersecurity Immune System
Alignment: Align Artifacts Align CoConstructive Align Evals Align Prompt Library Align Specs Align VerbSamp
Verification: Formal Methods CEGIS
Class 4

Alignment Engineering

Safety and correctness by design. Instead of guessing intent, agents actively seek clarification. Built-in CSF (Computational Safety Framework) with formal safety bounds.

  • ● Computational Safety Framework
  • ● RICE alignment principles
  • ● Prompt library with versioning
# Safety-first execution
safety = csf_guarded(epsilon=0.20)
report = safety.verify(action)
if report.is_safe:
agent.proceed(action)
Class 5

Formal Methods

Mathematical verification support for AI workflows. SAT solving, theorem proving, DPLL, and Z3 integrations can provide stronger guarantees when the relevant backend is installed and the property is formally specified; otherwise G6 records generated specs, static checks, and fallbacks as auditable evidence.

  • ● Propositional and SMT solving
  • ● Formal verification toolkit with 400+ operations (SAT/SMT, theorem proving, CEGIS)
  • ● Counterexample-guided synthesis
# Verify before trusting
spec = "f(x) == x * 2"
result = formal.verify(spec, candidate)
# Check status and proof artifact before relying on it
Optimize

Benchmark harness, model/tool routing, and supervised self-improvement. Optimise quality, latency, and cost across models, tools, and workflows.

ML & optimisation: Adapt Sklearn Adapt Autosklearn Adapt Bayesian Adapt Eurisko Adapt Keras Adapt PyTorch Adapt Pygad Adapt Learning Adapt Optimisation Deep Understanding
Evaluation & routing: Align Evals LLM Router Hyperdistillation
Self-optimisation: Opt Cost Opt Quality Opt Speed Opt Meta Opt Shared EvoSkill
Class 6

Symbolic Machine Learning

Hybrid neural-symbolic reasoning. Combines the pattern recognition of neural networks with the rigour of symbolic logic for outputs that are both creative and correct.

  • ● TF-IDF + BM25 retrieval
  • ● Genetic algorithm optimisation
  • ● Scikit-learn integration
# Hybrid reasoning
neural = llm.generate(prompt)
symbolic = logic.verify(neural)
output = merge(neural, symbolic)
Class 7

Self-Improvement

Evolutionary skill synthesis — programs that evolve, compete, and improve across generations via Pareto-optimal selection. At T2 the system learns better strategies; at T3 it learns better rules for learning strategies. All self-modification is supervised and propose-only. Component: evoskill.

  • ● Pareto-optimal skill selection
  • ● Generational program evolution
  • ● Supervised, propose-only self-modification
# Evolve better skills
pop = evoskill.seed(skills)
next = evoskill.evolve(pop, generations=5)
# Pareto-optimal survivors, human-gated promotion

Frontier-oriented design

Designed to compete at the frontier — as a systems problem, not a model problem.

G6 combines multi-agent debate, independent refutation, harness engineering, tool-based verification, and grounding in search results, experimental data, and formal logic. The architecture is designed so that any benchmark can be attacked by composing the right cognitive elements for that problem class.

See the Benchmarks page for frontier claims.