RFC: cgis as a metabolic organelle for aura — self-evolution PoC

[zaebee]

Captured at the end of a long session so it survives into a fresh one. Nothing investigated yet — this is the framing, not the research.

The idea

A PoC of auto-evolution, in the spirit of the AIRI write-up (habr.com/ru/companies/airi/articles/1065428/ — I have not read it, so nothing below should be taken as summarising it), applied to ~/projects/aura: a bio-digital organism on the ATCG-M pattern. The question is whether cgis can evolve into a metabolic digital organelle inside it.

Why the pairing is not arbitrary

aura is a distributed platform for autonomous economic negotiation between agents — FastAPI gateway, gRPC core, pgvector, Mistral as the brain, an MCP server. It has metabolism in the economic sense: agents that spend and earn.

cgis already supplies things an organelle would need:

• a structural model of the organism — the code graph, with FQN resolution
• a fitness signal — drift against a declared architectural ideal, already ratcheted so it can only improve (ci: enforce the drift-tolerance ratchet (values may only go down) #151)
• sensors — cgis_* MCP tools an agent can call
• self-measurement — the self-parse, now covering 99% of internal nodes (feat(ontology): bind guardian, cli and api as measured domains #325)

So the raw materials for "an organelle that senses the organism's structure and reports on its health" mostly exist. What does not exist is anything that changes the organism.

The hard part, stated plainly

"Metabolic organelle" is a metaphor, and the first job of a PoC is to make it measurable. Today's session is the argument for insisting on that early: three plausible guardian hypotheses were tested against pre-registered gates, and all three failed — the gates were what made the failures cheap and legible instead of arguable (#330, #331).

The same discipline applies here, and harder, because self-evolution has no natural stopping condition.

Questions that need answers before any code:

1. What is the unit of selection? A prompt, a module, a service, a whole agent? cgis measures modules and domains — if the unit is a prompt, cgis's graph is the wrong instrument.
2. What is fitness, numerically? Drift is a candidate and is already ratcheted, but it measures conformance to a declared ideal, not survival. An organism that optimises conformance stops adapting. That tension needs resolving, not eliding.
3. What is the metabolism? In aura the honest candidate is tokens and money — agents already spend both. Then "metabolic" means an organelle that converts structural information into cost savings, which is measurable.
4. What can actually mutate, and what stops a mutation that lowers fitness from shipping? We have a working precedent: build behind a flag, gate on pre-registered criteria, ship only on a pass (guardian: chunked review over connected subgraphs (large-PR LGTM fix) #154, guardian: one request per focus area instead of one prompt with all of them #331).
5. Where does the loop close? Sense → propose → evaluate → apply. cgis covers sense. The other three are missing, and apply is where an autonomous system becomes able to damage things.

Prior art already in this repo

• Autonomous Background Agent Pipeline (Ona/Gitpod Pattern) #51 Autonomous Background Agent Pipeline, SaaS Autodoc Engine — Automated Codebase Manuals via GraphRAG #45 SaaS Autodoc, From Code Graph to Semantic Intelligence Infrastructure #67 Semantic Intelligence Infrastructure — all parked in Vision (parked), all adjacent. This RFC should reconcile with them rather than duplicate.
• Decision: the cgis GitHub App is a credential, not a product — revisit after #302 and #246 #305 records the standing rule for this class of ambition: cgis is a credential and a measurement tool today; productising it waits on a working measurement. That applies here too.

Suggested first step

Not code. A one-page definition of fitness and the unit of selection, with a pre-registered gate for the first mutation experiment. If those cannot be written down, the PoC is not ready — and that is a cheap thing to discover.

Refs: aura (~/projects/aura), #51, #45, #67, #305

[zaebee]

Researched. Spec in #336 — docs/specs/2026-08-01-aura-autoevolution-poc.md. Nothing shipped.

Short version: the two blocking definitions can be written, and writing them changes the framing here in two places.

1. cgis is the membrane, not the metabolism. The metabolic quantity (tokens, USD) belongs to aura. cgis's defensible role is a deterministic constraint checker on mutations — the thing that says no before a patch lands. Smaller and far more testable than "metabolic organelle", and it is what the evidence supports.

2. Q5 is wrong about where the danger is. The missing organ is evaluate, not apply. aura's bee.Evolver already cannot write to main — it opens a PR, a human merges. What does not exist is a shadow run producing a cost/outcome number before a human sees the mutation. Without it the loop has variation and inheritance but no selection — which makes today's behaviour "an LLM opening PRs", not evolution.

Q2 (fitness) — drift becomes a constraint, not the objective:

max  F = -(cost per successful outcome)
s.t. drift(domain) <= tolerance, tests/mypy/ruff green, no new I/O outside the Connector

The escape is not "let the ideal evolve too" — an organism allowed to edit its own target lowers the bar and fitness becomes unfalsifiable. F's optimum moves with workload, model prices and counterparties, none of which the organism controls, so a gradient always exists. Drift's job is to stop the optimiser buying cheapness by destroying structure. This also makes the #151 ratchet coherent rather than contradictory: a ratchet on a constraint is a safety property; on an objective it is a stopping condition.

F's degenerate solution — propose nothing, spend nothing, score perfectly — is named up front, so every experiment carries a guardrail metric.

Q1 (unit of selection): unit of selection is the bee (smallest thing with an attributable cost and outcome); unit of variation is a file-scoped patch. Cost of that answer: cgis is blind to prompt mutations — a changed .md under agents/*/prompts/ yields no graph delta — and those are the likeliest cost lever. cgis constrains a minority of the useful mutation space.

Q3 (metabolism): tokens and USD per cycle. aura is catabolic only — it spends, earns nothing; HIVE_STATE.md §Economy is all unchecked boxes.

Q4 (what may mutate): ladder in the spec. The one rule with no exceptions: the organism may not mutate patterns.yaml, tolerances, hive-manifest.yaml, or the fitness definition. Goodhart firewall. Five of the nine barriers already exist; the two cgis adds are the two nobody else can do deterministically.

Measured against ~/projects/aura, not argued

measurement	result
cgis ingest	3383 nodes, 11069 resolved edges
cgis validate	17.8% unresolved (threshold 30%) — passes
init-ontology + drift	12 domains, all within tolerance; core 0.28, agents 0.27
ATCG-M nucleotides as FQN prefixes	A 57 / T 58 / C 79 / G 30
direct I/O (httpx, subprocess) outside the Connector under agents/	6 call sites

That last row is the whole value proposition without metaphor: the ATCG-M rule "no direct I/O bypassing the Connector" (aura FOUNDATIONS.md §4, Pattern Heresy) is a one-line query over the cgis graph, line-addressable. bee.Keeper currently decides it by asking an LLM to read a git diff, and its last recorded audit says PURE.

Blocker

aura has zero cycles of persisted cost data. token_usage exists as a proto field (dna.proto:274, metabolism.proto:340), is populated in both bees' Transformers, and is discarded each cycle; HIVE_STATE.md reads 0 tokens. Fitness is definable but not yet measurable. Instrumenting it costs no LLM spend — that is Gate 0.

Pre-registered gate

First experiment: replace the evolver Aggregator's context assembly with a cgis context package. Paired design (both arms on the same repo state), N=20, primary = median prompt tokens at Arm B <= 0.75x Arm A with 90% bootstrap CI upper bound < 1.0, guardrail = preflight acceptance >= Arm A - 10pp, hard USD cap enforced outside the agent process.

Verdict computed once, after all 20 pairs. Three outcomes: PASS / FAIL / INCONCLUSIVE. "Tokens down 30%, acceptance down 15pp" is a FAIL and is written down as a FAIL. Gate 0 carries two explicit do-not-run outcomes, including "baseline variance is task heterogeneity, not context size -> the cost-fitness framing is wrong, close this issue as not-ready."

On the AIRI article (read it)

Transfers: fitness = external benchmark + token cost (independent arrival at the same conclusion); their "scope review" is cgis impact done deterministically; diff fingerprinting so rejected mutations are not re-proposed; the contamination lesson (68/115 GAIA tasks had published solutions — always ask how the metric is satisfied without doing the work); and instructions in comments are not a control — their Grok-4.5 run downloaded benchmark solutions despite explicit warnings in the code, so every barrier must be mechanical.

Does not transfer: the benchmark suite (aura has no equivalent and building one is the dominant cost of a real fitness function — Negotiation Success Rate: 1.00 is saturated and simulated, it is not a substitute); swarms of hundreds of subagents (pointless without evaluate — unselected variation is just spend); "~75% of commits written autonomously over months" (a multi-month token budget, not a PoC).

Recommendation

Do not build an organelle. Three bounded steps: instrument the metabolism (no spend), add evaluate, run the gate once and honour the stopping rule.

Reconciles with #305 — cgis stays a measurement tool here. Its membrane claim on aura is testable today, independently of whether this PoC ever proceeds.

[zaebee]

Merged as b7359a7 (#336). This issue stays open.

The five questions have answers; the PoC does not exist. What landed is docs/specs/2026-08-01-aura-autoevolution-poc.md — the "suggested first step" this issue asked for, which was a one-page fitness definition and a pre-registered gate, not code.

What the answers changed about the framing here

• Q1 unit of selection — the bee. Unit of variation is a file-scoped patch, which is a different thing and was conflated in the original text. Cost of that answer: cgis is blind to prompt mutations, so it constrains a minority of the useful mutation space.
• Q2 fitness — cost per successful outcome, with drift demoted from objective to constraint. That is what dissolves the "optimising conformance stops adaptation" tension, and it makes the ci: enforce the drift-tolerance ratchet (values may only go down) #151 ratchet coherent: a ratchet on a constraint is a safety property, on an objective it would be a stopping condition.
• Q3 metabolism — tokens and USD, catabolic only. aura spends and earns nothing; the Economy section of HIVE_STATE.md is unchecked boxes.
• Q4 what may mutate — laddered, with one rule that has no exceptions: the organism may not mutate patterns.yaml, tolerances, hive-manifest.yaml, or the fitness definition.
• Q5 where the loop closes — this issue's premise was wrong. apply is already the safest link in aura (bee.Evolver cannot write to main; it opens a PR). The missing organ is evaluate. aura has variation and inheritance but no selection.

The framing shift

cgis is the membrane, not the metabolism. The metabolic quantity belongs to aura. cgis's defensible claim is deterministic mutation gates — and after the measurement corrected itself, exactly one: write-side I/O outside the Connector, 3 functions / 6 calls, all git mutation from a Generator whose declared job is NATS pulses. bee.Keeper's deterministic auditor has no call-graph rule of any kind, so nothing in aura checks this today.

That claim is narrower than the "metabolic organelle" framing above, and it is testable now, independently of whether the PoC ever proceeds.

Two things this issue should carry forward

The headline measurement was wrong once. The first draft reported "6 direct I/O call sites" from a query that matched IMPORTS edges and labelled them calls — and it tested a rule aura never made (read-side I/O in the Aggregator is declared design, SensoryNexus). Both were caught by a review round that re-ran the query rather than reading the text. Three reviews ran; the two that only read found real but local defects, and the one with execution tools found the wrong number. Recorded because the same asymmetry will apply to the next measurement.

Blocker before any spend. aura has no usable cost time series — token_usage is a proto field, bee-keeper truncates it into HIVE_STATE.md at 5000 chars, bee-evolver persists none, no USD anywhere. Fitness is definable but not yet measurable.

Not-yet-done, in order

1. Instrument the metabolism. No LLM spend. Everything downstream is unfalsifiable without it.
2. Build evaluate — a shadow run producing a cost + preflight number per proposed mutation.
3. Run §6 once and honour the stopping rule. Note Gate 0 contains two explicit do-not-run outcomes, one of which closes this issue as not-ready if baseline variance turns out to be task heterogeneity rather than context size.

Merging fixes the gate, not the experiment. Refs #305 — cgis stays a measurement tool until there is a working measurement.