Infoconex AI Flywheel Specification v0.2.1

Metis Research Dossier

Research status: Primary-source review completed for the public paper as of July 15, 2026. No official implementation repository was identified in the paper or public project search, so the paper is treated as the canonical source.

Established / First Public Date

June 23, 2026 — used here as the earliest verified public establishment date for Metis because the canonical Metis paper was first submitted to arXiv on that date.

No earlier official project release, source-code repository, or standalone project publication was identified in the primary-source review completed for this dossier.

Research Objective

Determine how closely Metis approaches the Infoconex AI Flywheel concepts of moving responsibility between flexible reasoning guidance and deterministic executable capability, and identify where its dual-memory model differs from the AI Flywheel’s broader three-part responsibility and governance architecture.

Main References

No official Metis source-code repository or standalone project website was identified in the primary paper or in public repository search as of July 15, 2026.

What Metis Is

Metis is a self-evolving agent system built around a central representation question:

When experience is learned from prior execution, should it remain flexible natural-language guidance or be converted into executable code?

The paper argues that these two representations have materially different properties.

Text memory is inexpensive to create and transfers more reliably to new situations because the AI can reinterpret it in context. However, the AI must still reason through and execute the procedure step by step.

Code memory is more expensive to construct and validate but much faster to reuse because a multi-step routine can become a direct callable tool. The tradeoff is brittleness: fixed code transfers less gracefully when future tasks differ from the situations from which the code was learned.

Metis therefore uses text as the default, low-commitment representation and selectively promotes only sufficiently recurring procedural patterns into code.

This is one of the closest known comparisons to the AI Flywheel’s Moving Determinism Boundary because Metis explicitly studies the tradeoff between adaptable reasoning guidance and deterministic executable behavior.

Architecture and Operating Model

Metis maintains a hierarchical dual-representation memory:

  1. Text memory — natural-language experience injected into the agent’s context.
  2. Code memory — validated callable tools exposed directly to the agent.

Its self-evolving loop contains four major components.

Differentiated Text Reflection

Completed trajectories are analyzed and distilled into three types of textual experience:

  • Execution plans — reusable procedural patterns for recurring routines.
  • Environment facts — stable properties and constraints of the execution environment.
  • Common pitfalls — failure patterns represented as triggers, mistakes, and consequences.

This distinction matters because only execution plans are eligible for later promotion into code. Facts and pitfalls remain textual because their value lies primarily in guiding judgment rather than encoding a repeatable procedure.

Pattern-Aware Code Generation

Metis does not convert every successful trajectory into code.

Instead, it tracks repeated selection of execution plans. When a plan is reused often enough to cross a configurable recurrence threshold, the system treats that recurrence as evidence that the pattern may be stable and valuable enough to mechanize.

The codifier then attempts to turn the matured plan into one or more small reusable tools.

Memory Manager

For each new task, the Memory Manager retrieves candidate text memories and code tools, then uses an LLM-based selection step to decide which should be made available to the executor.

Selected text memories are injected as guidance. Selected code memories are exposed as callable tools.

The distinction is operationally important:

  • text can be interpreted, partially applied, or ignored by the AI,
  • while code becomes executable control flow once invoked.

Reflection Harness

The Reflection Harness gives reflection agents controlled access to execution evidence. It provides a compact trajectory view and allows deeper inspection of selected steps when needed.

For generated tools, it also enforces implementation checks such as dependency closure and compilation before the tool can be admitted into code memory.

Execution and Learning Flow

The Metis workflow can be summarized as:

  1. Retrieve relevant text memories and tools.
  2. Execute the task using those memories and capabilities.
  3. Produce an execution trajectory.
  4. Reflect on the completed trajectory.
  5. Update facts, pitfalls, and plans.
  6. Detect whether repeatedly selected plans have accumulated enough recurrence evidence for codification.
  7. Generate and validate candidate tools when promotion is justified.
  8. Persist updated text memory and validated code memory.
  9. Reuse them in later tasks.

Reflection occurs after completed trajectories and is outside the immediate task-serving critical path.

Text Memory in Detail

Execution Plans

Execution plans capture reusable procedural routines. They are the bridge between text and code because repeated plan use can eventually trigger codification.

Environment Facts

Environment facts record constraints or properties that should influence future reasoning but are not naturally executable routines.

Common Pitfalls

Pitfalls encode recurring failure patterns. Failed executions can therefore create durable warnings that help future agents avoid repeating the same mistake.

Memory Maintenance

Metis does not only append new memory. It can merge redundant entries and replace outdated or inaccurate entries with improved versions.

The paper uses an invalidate-and-replace approach rather than silently mutating older memory in place, preserving a clearer history of superseded knowledge.

Code Promotion in Detail

Metis uses repeated plan selection as the primary promotion signal.

A key nuance is that task success is not required for a task to contribute recurrence evidence. A failed task may still demonstrate that a query belongs to the same procedural family.

When a plan reaches the promotion threshold:

  1. the plan body is provided to the codifier,
  2. related task queries are supplied to establish variation and intended coverage,
  3. raw trajectories are deliberately excluded to reduce overfitting to incidental execution details,
  4. the codifier creates small composable helpers rather than task-specific end-to-end solvers,
  5. varying task elements must be exposed as parameters,
  6. dependencies are checked,
  7. the candidate must compile in the sandbox before admission.

This is a deliberate mechanism for deciding when flexible procedural knowledge should become deterministic executable capability.

Failure Handling and Validation

Metis treats both failures and inefficiencies as learning opportunities.

For failed tasks, the reflector can inspect the environment to identify underlying causes and create:

  • a corrective pitfall,
  • an environment fact,
  • or another appropriate memory update.

For successful tasks, the reflector may still identify unnecessary retries, inefficient exploration, or other behavior worth improving.

Candidate text memories are screened for qualities such as:

  • generality,
  • non-redundancy,
  • mechanistic grounding,
  • and correct scope.

Generated tools face stronger validation because executable code has greater downstream consequences than optional textual advice.

Human Role and Governance

The reviewed Metis paper does not define a human-authority or approval architecture comparable to the AI Flywheel’s Governance Policy.

The system is designed to update explicit memory artifacts and selectively create code tools as part of its self-evolving process without a documented human approval gate for those changes.

No explicit mechanism was identified for:

  • authority boundaries,
  • uncertainty escalation to a human,
  • approval-required changes,
  • prohibited actions,
  • or restrictions preventing the system from expanding its own operational authority.

This does not mean a Metis implementation could not be embedded inside a governed system. It means governance is not part of the framework mechanism described in the paper.

Evidence Checklist

Formal definitions of text memory and code memory

Finding: Fulfilled.

Metis explicitly distinguishes representations according to how the agent consumes them.

  • Text memory is injected into context and interpreted through AI reasoning.
  • Code memory is exposed as callable executable tools.

Promotion or selection criteria between representations

Finding: Fulfilled.

Text is the default representation. Only recurring execution plans are eligible for promotion. Promotion is based primarily on repeated reuse, with tool construction justified when the recurring pattern is sufficiently stable and valuable to amortize the higher construction cost.

Whether movement can occur in both directions

Finding: Partially fulfilled.

The paper explicitly defines movement from procedural text plans into executable code.

Text memories themselves can also be revised, merged, invalidated, and replaced.

However, the reviewed paper does not define a symmetric mechanism that demotes a previously admitted code tool back into textual guidance when the environment proves too variable. This is a meaningful distinction from the AI Flywheel’s explicitly bidirectional Moving Determinism Boundary.

Whether procedural control is distinct from general textual memory

Finding: Fulfilled within the text-memory layer.

Execution plans are explicitly distinguished from facts and pitfalls. Plans represent procedures, while facts and pitfalls guide reasoning.

However, all three remain part of the broader text-memory architecture rather than a separately governed SOP control plane.

How failures influence representation changes

Finding: Fulfilled.

Failure trajectories are analyzed by the text reflector. They commonly generate corrective pitfalls or environment facts.

Failure itself is not used as proof that a plan should become code. Code promotion is instead based on recurrence of a procedural plan, and unsuccessful tasks may still contribute evidence that the same procedural family is recurring.

Whether responsibility allocation itself is treated as an optimization target

Finding: Strongly fulfilled for text versus code representation.

The central research problem of Metis is deciding which experiences should remain flexible text and which should be crystallized into executable code based on construction cost, execution efficiency, recurrence, stability, and transferability.

This is a major overlap with the AI Flywheel’s concern for where responsibility should reside.

Human approval, escalation, or governance mechanisms

Finding: Not established in the framework.

No formal human approval or uncertainty-escalation mechanism was identified in the paper’s self-evolution architecture.

Constraints on autonomous self-modification or expansion of authority

Finding: Not established as an authority concept.

Metis constrains code creation through representation rules and validation checks, but the paper does not distinguish capability growth from authority growth or define a human-governed authority boundary.

Comparison to the Infoconex AI Flywheel

Dimension Metis Infoconex AI Flywheel
Primary representation model Text memory and code memory Deterministic capability, procedural knowledge, and AI reasoning
Default learning destination Text memory Determined by post-execution classification
Procedure representation Execution plans inside text memory Explicit SOP / procedural knowledge mechanism
Deterministic promotion Recurring plans can become validated tools Stable responsibilities can move into deterministic capability
Reverse movement No explicit code-to-text demotion mechanism identified Boundary is explicitly bidirectional
Failure learning Pitfalls, facts, and memory revision Failure is classified to determine where the system should evolve
Outcome evidence Completed execution trajectories Explicit required evidence about actual outcomes
Governance Not a defined framework component Human authority and Governance Policy are first-class concepts

Strongest Overlap

Metis is the strongest current comparison to the AI Flywheel’s Moving Determinism Boundary because it explicitly argues that:

  • different learned experiences belong in different representations,
  • flexible text and deterministic code have different strengths,
  • not everything should be mechanized,
  • recurring stable procedures are better candidates for executable code,
  • and representation choice itself should be optimized rather than fixed at design time.

Key Differences to Investigate

Two representations versus three runtime responsibilities

Metis distinguishes text memory and code memory.

The AI Flywheel distinguishes:

  • deterministic capability,
  • procedural knowledge,
  • and runtime AI reasoning.

Metis does differentiate procedural plans from facts and pitfalls within text memory, but those still enter the agent through contextual reasoning rather than forming a separately defined operational control plane.

Promotion versus bidirectional boundary movement

Metis has a strong and explicit text-to-code promotion mechanism.

The AI Flywheel additionally proposes that brittle deterministic behavior may move back toward procedure or AI reasoning when evidence shows that mechanization was premature.

Recurrence-driven codification versus failure-driven evolution routing

Metis decides when plans should become code based primarily on recurrence.

The AI Flywheel asks a broader question after any meaningful learning event:

Where should this learning live?

That destination may be code, SOP, reasoning knowledge, validation, or governance.

Governance

Metis focuses on representation and memory evolution. Human authority is not a first-class part of the described architecture.

Current Research Position

Metis should be treated as substantial prior art for selectively moving learned procedural behavior from flexible textual representation into deterministic executable tools.

Any claim that the AI Flywheel uniquely moves learned behavior from reasoning or procedure into code would be too broad.

The more defensible differentiation questions are:

  1. whether the explicit three-part runtime responsibility model is materially different from dual-representation memory,
  2. whether bidirectional movement is a distinct contribution,
  3. whether evidence-driven routing across multiple persistent destinations is broader than recurrence-based text-to-code promotion,
  4. and whether combining that mechanism with explicit human-governed authority forms a distinct operating model.