Atalaya + Akopia + AgentGuard: Meta-Software running on itself

Heads-up before we start: Atalaya is still WIP — I'll open-source it once it stabilizes. What follows is the working design, not a finished product. Six months operating a loop changed how I think about Meta-Software. Atalaya investigates, Akopia makes it legible, AgentGuard governs new code. Each feeds the others — and that feedback is what turns the diagram from a slide into a lever.

I sat with that sentence for a while before I trusted it. The honest version is that I'd been describing the three components in parallel for months — three boxes, three jobs, three repos — and the thing that actually mattered was the arrows between them. The boxes are the easy part. The arrows are where the leverage lives.

The Name and Why It Matters

I call it the Trifecta Loop because three components close on each other. Not a chain. Not a pipeline. A loop where each component's output becomes input to the others, and the system gets sharper with each turn.

Linear would be: plan, then build, then deploy. Anyone has that — it's not a framework, it's just a workflow.

Loop is different. What Atalaya deploys stays investigable, so it can be questioned later. What Akopia indexes becomes context for AgentGuard, so the next thing built starts informed. What AgentGuard validates becomes evidence for Atalaya, so the system that observes the runtime has something to observe. And then it starts again. Each cycle leaves the next cycle better positioned.

The test for whether you have a loop instead of a chain is brutal but quick: cut it anywhere and ask whether the other two get weaker. If they do, it's a loop. If they don't, you have three tools that happen to share a Slack channel.

Each Vertex on Its Own (Briefly)

The three vertices need short introductions before we walk the arrows, because the arrows only make sense once you know what's at each end.

Atalaya is investigation and orchestration. It runs across what I think of as 10 planes — triage, artifacts, dependencies, evidence, runtime monitoring, and so on. Its job is to make the running system interrogable in real time. Every action it takes produces evidence atoms with a causal chain (the post on evidence atoms goes deeper on this).

Akopia is the headless knowledge plane. Three backends working together: vector search for semantic queries, BM25 for lexical precision, Redis for the fast path. It's only consumed via MCP — there's no UI, deliberately. It indexes code, docs, the n8n reports, the Atalaya evidence atoms. Anything that becomes text-on-disk becomes queryable.

AgentGuard is the governance plane. Versioned archetypes, 13 readiness dimensions, a four-stage pipeline: skeleton, contracts, wiring, logic. It generates deployable artifacts and certifies them against the dimensions before they ship. The thing it produces isn't code — it's certified code.

Three planes. Each one useful on its own. None of them transformational alone. That's the part I want to land before we look at the arrows.

The 6 Arrows of the Loop (Not 3)

I used to draw this as three arrows — a triangle. That's wrong. The loop has six, because every pair of vertices has two arrows running between them. The bidirectionality is the whole point.

Atalaya → Akopia. Every investigation Atalaya runs commits its reports and evidence chains. Akopia indexes them. Past investigations become queryable context for future ones.

Akopia → Atalaya. When Atalaya investigates something new, it queries Akopia for historical context first. Were there similar incidents? What did we conclude last time? What changed since? Investigation never starts from zero.

Akopia → AgentGuard. When AgentGuard generates new code, it queries Akopia to understand the surrounding ecosystem. What archetypes already exist? What contracts are in play? What patterns has the team converged on? Generation never starts from scratch.

AgentGuard → Akopia. Every generated artifact writes its .atalaya/*.md files, and Akopia indexes them. The readiness criteria themselves become queryable. Which artifacts in production passed dimension 7? Which failed it last sprint?

AgentGuard → Atalaya. Every generated artifact emits events Atalaya picks up for dependency tracking and runtime monitoring. The thing AgentGuard ships into production becomes a thing Atalaya can observe.

Atalaya → AgentGuard. When Atalaya detects a recurring pattern — the same bug surfacing in three services, the same misconfiguration repeated across deploys — it surfaces it as a proposed modification to the relevant archetype. The runtime teaches the grammar.

Six arrows, not three. That's the difference between a triangle and a loop.

Mixer Mode Operating on Top of the Loop

This is the part I find most useful to think about, because it's where the loop stops being infrastructure and starts being how I work.

When I'm building, the four Mixer Mode faders — Product, Architecture, Code, QA — all touch the loop simultaneously. Not sequentially. Simultaneously.

Product queries Akopia: what's the history of pricing decisions across these archetypes? What did the last three clients ask for? The answer shapes the spec.

Architecture touches Atalaya: what dependencies does this service I'm about to modify actually have? What atoms have rested on this contract? The answer shapes the change.

Code goes to AgentGuard: generate this archetype with these contracts. Run the pipeline. The artifact comes out shaped by the spec and the deps.

QA closes back on Atalaya: what evidence atoms do I need this artifact to produce so it can be certified against the 13 dimensions? The answer shapes the test plan.

Without the loop, each of those four faders would need its own manual investigation. Product asks the team. Architecture greps the codebase. Code copies from another service. QA writes tests by hand. Each fader runs at the speed of a human investigation, which means none of them really run in parallel — they queue.

With the loop, each fader queries a system. Each system answers in seconds. The four channels can actually move at the same time, which is what Mixer Mode is supposed to enable.

The Day It Showed Up in Production: SII in Chile

The day this stopped being theory was a DTE addition. DTEs are documents regulated by the Chilean tax authority (SII) — see the public documentation at sii.cl for the regulatory shape. Zero margin for error. The kind of change where a quiet bug becomes a public incident.

I needed to add a new DTE type. The loop ran like this:

Akopia first: show me everything DTE-related in the ecosystem. 47 hits, ranked by relevance. Existing handlers, contract definitions, regulatory references, prior incidents. Five minutes of reading instead of half a day of code archaeology.

Atalaya next: rebuild the causal chain of the last DTE issued successfully. 23 atoms, runtime-readable. I could see exactly what data flowed where, which rules fired, which tools the agent invoked, what the final approval looked like.

AgentGuard third: generate the handler with the dte_handler archetype, with these new fields. The pipeline ran all four stages — skeleton, contracts, wiring, logic. The output had the cross-cuts (idempotency, audit log, consent) built in because the archetype demands them.

Result in production in hours, not days. And the first DTE of the new type issued through the system had its own evidence chain from the moment it was created. The next time someone asks why, the answer is one query away.

Why Meta-Software Only Becomes Visible When There's a Loop

This is the part that I keep coming back to in conversations, because it's where the framework lands or doesn't.

Generation alone, without knowledge or governance, is vibe coding industrialized. Output scales. Quality doesn't. The team ships faster and breaks faster. You've moved the bottleneck without removing it.

Knowledge alone, without generation or governance, is corporate RAG nobody queries. The library is impressive. The lending is zero. It looks like progress on a slide and feels like nothing on a Tuesday.

Governance alone, without generation or knowledge, is policy-as-code applied to slow humans. You've automated bureaucracy. The reviewers complain. The releases slow down. The audit improves and the morale tanks.

The three apart are tools. The three coupled is what Meta-Software names. That's why the paper insists on inseparable pillars. It isn't rhetoric. It's the difference between a system that scales and a system that collapses under its own weight.

The failure mode of "two and a half" is the most common one I see. A team has good generation and good governance, but their knowledge layer is a Notion graveyard. Or they have good knowledge and good generation but no governance — every artifact is bespoke. The loop doesn't close, and the system has all the cost of three planes without the leverage of three planes feeding each other.

What Trifecta Loop Is Not

Let me name the things this is not, because the misreadings get expensive.

It's not a product you buy. There is no Trifecta Loop SKU. It's a coupling pattern — a shape you can recognize and adopt.

It doesn't require my three specific components. It requires that three analogous roles exist in your ecosystem, and that they feed each other.

Your Atalaya equivalent might be Datadog plus a few scripts. Your Akopia equivalent might be Glean plus a well-organized GitHub. Your AgentGuard equivalent might be your existing AI pipeline plus a reviewer rubric. The point isn't the implementation. The point is that the three roles exist and they're plumbed to each other.

The loop is the architecture. The pieces are negotiable.

The Cost of Closing the Loop (Which Is What People Ask About)

Nobody believes the cost until I name it, so let me name it.

Additional infrastructure: roughly 3 more services than you'd run without the loop. In my homelab, about 20% more resource consumption. Real but not absurd.

Schema discipline: each component exposes versioned contracts. Without that, the arrows don't hold — the moment one side changes shape without telling the other, the loop breaks. The discipline is the actual cost, not the infra.

Time to implement: months, not weeks. This isn't a weekend project. The first version of each component is fast; getting them to feed each other reliably is slow.

What you recover is harder to measure. The team stops doing archaeology every time something happens. Onboarding gets shorter. Audits become possible. None of that shows up on a dashboard until you lose it. The day you turn the loop off for a week and try to operate without it, you'll feel the cost — and you'll never go back.

Honesty: What I Still Haven't Solved

This would be dishonest without the open problems.

The three planes drift out of balance if you don't cycle attention. The weakest plane drags the loop down. There's no automatic rebalancing — you have to notice, and you have to choose to invest there. That's a leadership problem the architecture doesn't solve.

The Atalaya → AgentGuard feedback edge — this pattern showed up three times, promote it to an archetype — is still mostly manual. I couldn't automate the promotion well. The detection works. The decision to lift it into grammar is still human, and the latency between detection and promotion is too long.

The cognitive cost is real. Operating a loop is more expensive than operating three separate services because you have to hold the whole mental model. You can't context-switch into one component for a week and ignore the others — they'll drift while you're gone.

This isn't for small teams without runway. A single developer trying to sustain this burns out. The loop pays back when there are enough people to cover the three planes; before that, it's just three things to maintain.

The Transferable Principle

Meta-Software isn't a slide or an architectural category. It's what appears when generation, knowledge, and governance plug into a feedback loop. Without the loop, the three are tools. With the loop, they're a system that gets sharper as it runs.

The test is brutal: which of your three planes would become useless if the other two disappeared? If the answer is "none would really notice," you don't have a loop yet — you have three tools that share Slack. And the corollary that comes from running this for six months: if you built only one of the three, what's missing isn't more features in that one. It's the other two plugged into the first.

Does your ecosystem have all three planes — generation, knowledge, governance — or two and a half? Which one suffers most when the others break? Send me a DM or reach out via the contact channels at rlabs.cl — I'm collecting cases for the next paper.

#MetaSoftware #TrifectaLoop #MixerMode #FutureOfWork #DigitalTransformation