skills/boshu2__agentops
1
0
Fork 0
mirror of https://github.com/boshu2/agentops.git synced 2026-09-14 15:08:13 +08:00
Code Issues Packages Projects Releases Wiki Activity

docs(convergence): first-class Convergence section — The Reading + Ledger + Google SRE map (ag-4hf7 #google-sre-convergence) (#650)

Browse Source 
## What

Establishes a first-class **`docs/convergence/`** section: the record of
the industry independently arriving at the structure AgentOps already
runs — kept distinct from the competitor map. Three surfaces:

1. **`the-reading.md`** — the *living thesis*. The argument (with
mechanism, firm-vs-forming consensus table, honest moat-risk, and a "how
to read a new signal" rubric) that the industry is converging and
**why**.
2. **`ledger.md`** — the dated *receipts* table (who/when/which
invariant). Seeded with Google SRE 2026.
3. **`google-sre.md`** — the per-party *encoding map*: 11 convergence
points → real AgentOps loci (8 encoded · 2 partial · 1 gap).
4. **`index.md`** — section hub framing the three.

## Why first-class, not under comparisons/

A vindication record is the *inverse* of a competitor grid — wrong to
parent it under "vs the competition." Radar = competitors in our lane;
Convergence = independents arriving from outside it. Promoted to its own
top-level nav section (`git mv`, history preserved; permalinks updated;
cross-links rewired both ways).

## Gaps surfaced (filed as beads)

| Bead | Point | Work |
|---|---|---|
| `ag-fjbu` | #3 | Adopt Bronze/Silver/Gold eval-tiering +
True-vs-Observed-Precision naming |
| `ag-wrom` | #8 | Formalize an L0–L4-style autonomy ladder for AgentOps
dispatch |
| `ag-7278` | #11 | Council: does coherent-arc need a fix-forward escape
hatch? (Google is ahead) |

## Verification

- All relative links across the convergence section + comparisons
pointers resolve.
- mkdocs nav + documentation-index updated; renames preserve history.

Closes-scenario: ag-4hf7#google-sre-convergence
Bounded-context: BC1-Corpus
Evidence: docs/convergence/the-reading.md
This commit is contained in:
Bo
2026-05-31 14:48:45 -04:00
committed by GitHub
parent 486cb99be5
commit cfee2b078a
17 changed files with 1105 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files
docs/comparisons/README.md
+4 -1
View File
@@ -23,7 +23,10 @@ The AI coding agent ecosystem has exploded. Here's how the major players stack u
| [Compound Engineer](vs-compound-engineer.md) | Plan/work/review/compound | Stack-aware routing, 10 runtimes | Manual/doc-solution compounding, no validation gates |
For the operator-facing readout across all competitors, see the
[Competitive Radar](competitive-radar.md).
[Competitive Radar](competitive-radar.md). For the record of external parties
*independently arriving at* the AgentOps thesis (vindication, not competition),
see the [Convergence Ledger](../convergence/ledger.md) — anchored by the
[Google SRE encoding map](../convergence/google-sre.md).
---
docs/comparisons/competitive-radar.md
+4
View File
@@ -13,6 +13,10 @@ position is narrower and harder to copy than any of them: **a wiki for your
agents, version-controlled in your repo, that compounds across sessions**.
The corpus is the moat. The tool is replaceable.
> Sibling doc: the [Convergence Ledger](../convergence/ledger.md) tracks the
> inverse of competition — external parties (labs, vendors, methodologies)
> *independently arriving at* the AgentOps thesis over time.
## Source Set
| Source | Lane | Link |
docs/convergence/google-sre.md
+70
View File
@@ -0,0 +1,70 @@
---
title: "AgentOps 3.0 ⇄ Google SRE — encoding map"
description: "Where each of the 11 structural conclusions in Google's 2026 SRE AI whitepaper is already encoded in AgentOps doctrine, and the genuine gaps it surfaced."
permalink: /convergence/google-sre
last_reviewed: 2026-05-29
---
# AgentOps 3.0 ⇄ Google SRE: encoding map
> Google's 2026 SRE whitepaper *"AI in SRE: How Google is Engineering the Future of Reliable Operations"* (Papapanagiotou, Malesevic, Heiser & Meshenberg) independently arrives at AgentOps 3.0's core structural conclusions — from the **production-operations** end of the lifecycle. AgentOps runs the **dev-loop + context-compiler** end. Same waist, two ends of the SDLC.
>
> This doc is the receipt: it maps each convergent principle to **where it is already encoded in AgentOps**, so the convergence is verifiable against executable doctrine, not asserted. It is the in-repo companion to the chronological [convergence ledger](ledger.md). Tracking bead: `ag-4hf7`.
## Why this matters
This is external validation of the [3.0 thesis](../3.0.md): AI velocity (a stated **4x** code-volume increase) breaks human-paced practice, so the work must be restructured around **autonomous loops bounded by deterministic guardrails**. Two teams, working opposite ends of the lifecycle with no coordination, converged on the same four invariants. That is signal the architecture is correct, not stylistic.
## The encoding map
| # | Convergent principle | Google SRE phrasing | Encoded in AgentOps at | Status |
|---|---|---|---|---|
| 1 | **4x velocity breaks human-paced review** is the trigger | "Human code review cannot scale linearly… targeting up to a 4x increase in productivity." | [`docs/3.0.md`](../3.0.md) thesis ("does not scale with a 4x to 10x increase") | ✅ encoded |
| 2 | **No self-grade / independent verification harnesses** | "**Independent Harnesses** — the agent that generates source code must be strictly isolated from the agent that defines tests or reviews output… prevents transmission of cross-bias." | Ratchet rule #1 in [`docs/3.0.md`](../3.0.md) + [`canonical-loop-model.md`](../architecture/canonical-loop-model.md) + [`skills/domain/references/loop.md`](../../skills/domain/references/loop.md) | ✅ encoded |
| 3 | **Eval data is the moat; tiered + judge + deterministic scoring** | Bronze/Silver/**Gold** tiers; "True Precision vs Observed Precision"; "LLM-as-a-Judge" + strict deterministic exact-match scoring; Nightly Evals. | [`architecture/behavior-shaping-environment.md`](../architecture/behavior-shaping-environment.md); holdout-leak gate (#605), stale-rubric guard (#604), outcomes verdict (#603) | ⚠️ partial → `ag-fjbu` |
| 4 | **Knowledge becomes a constraint / deterministic boundary** | "Safe-by-default actuation — tools must be incapable of single-handedly taking down production"; "deterministic, human-controlled safety boundaries." | Ratchet rule #3 ("compiles into a gate, a test, or a rule") in [`docs/3.0.md`](../3.0.md), [`knowledge-flywheel.md`](../knowledge-flywheel.md), [`primitive-chains.md`](../architecture/primitive-chains.md) | ✅ encoded |
| 5 | **Humans move up the abstraction ladder** | "From Operator to Architect… move up the abstraction ladder… review Designs, Intent, Policies, not lines." | "Validate BOTH ENDS" + BDD-as-plan in [`operating-loop.md`](../architecture/operating-loop.md) move 1; coherent-arc review in [`CLAUDE.md`](../../CLAUDE.md) | ✅ encoded |
| 6 | **Reasoning engine decoupled from execution engine** | "Decoupling the AI's reasoning engine (AI Operator) from the execution engine (Actus)… their ability to mutate production remains strictly governed." | Hexagonal "domain core never imports the shell" — [`cdlc.md`](../cdlc.md), [`ports-and-adapters.md`](../architecture/ports-and-adapters.md), [`sovereignty-proof/`](../sovereignty-proof/index.md) | ✅ encoded |
| 7 | **Intent/spec as the plan, authored before code** | "Co-authoring and approving detailed specifications with AI before code generation." | "Behavior is the plan" — [`operating-loop.md`](../architecture/operating-loop.md), [`skills/discovery`](../../skills/discovery/SKILL.md), [`skills/brainstorm`](../../skills/brainstorm/SKILL.md) | ✅ encoded |
| 8 | **Progressive authorization / autonomy levels** | **L0–L4 ladder**, gated on statistically-significant success vs Golden data; "Red Button" override. | In-session floor → mayor-driven dispatch → bounded `autodev`: [`canonical-loop-model.md`](../architecture/canonical-loop-model.md), [`using-gc`](../../skills/using-gc/SKILL.md) | ⚠️ partial → `ag-wrom` |
| 9 | **Pulled context / explicit ports / no ambient access** | **MCP** Production-Agent server; **A2A**; "No Ambient Access & Least Privilege." | "Context is pulled, dense, JIT" hookless model — [`docs/3.0.md`](../3.0.md), [`ARCHITECTURE.md`](../ARCHITECTURE.md), [`cdlc.md`](../cdlc.md) | ✅ encoded |
| 10 | **Transparency / Chain-of-Thought / immutable provenance** | CoT in real-time UIs; deterministic actuation traces persisted (Spanner). | Append-only provenance ledger (`agentops-sdlc-provenance.v1`) — [`CLAUDE.md`](../../CLAUDE.md) provenance section, evidence capture under the ratchet | ✅ encoded |
| 11 | **Fix-forward over binary rollback** | "**Intervening Pull Request Problem** — binary rollback becomes unsafe… **AI-Assisted Fix-Forward**." | Coherent-arc = atomic-revert unit — [`learnings/2026-05-19-coherent-arc-rule-validation.md`](../learnings/2026-05-19-coherent-arc-rule-validation.md) | 🔶 gap → `ag-7278` |
**Tally:** 8 ✅ encoded · 2 ⚠️ partial · 1 🔶 genuine gap.
## The deepest convergence
Both documents independently land on the **same control-plane architecture**:
> A **non-deterministic reasoning core** (the LLM agent) wrapped by a **deterministic, human-governed enforcement boundary** the agent cannot bypass, no matter how the model evolves.
- **Google:** `AI Operator` (reasoning) ↔ `Actus` (deterministic actuation gateway: mandatory dry-run, pre-flight validation, auto-downgrade L3→L2 on risk, Red Button).
- **AgentOps:** agent loop (reasoning) ↔ **CI gates + ports-and-adapters + the ratchet** (domain core never imports the shell; CI is the sole authoritative push gate; knowledge only durable as a constraint).
This is the single most important shared insight — the answer to "how do you let a probabilistic agent touch a high-stakes system safely."
## The three gaps this surfaced (filed as beads)
| Bead | Point | Work |
|---|---|---|
| `ag-fjbu` | #3 | Adopt Google's **Bronze/Silver/Gold** eval-tiering + **True-vs-Observed-Precision** naming into the eval docs/skills. The pipeline exists; the maturity vocabulary doesn't. |
| `ag-wrom` | #8 | Formalize an explicit **L0–L4-style autonomy ladder** for AgentOps dispatch with named promotion gates, instead of the implicit floor→mayor→autodev progression. |
| `ag-7278` | #11 | `/council`: does the coherent-arc **atomic-revert** rule need a **fix-forward escape hatch** for high-velocity lanes? This is the one place Google is genuinely ahead of our doctrine. |
## Honest divergences (why this isn't tautological)
These are the **two ends of the same lifecycle**, which is exactly what makes the convergence meaningful.
| Axis | Google SRE | AgentOps 3.0 |
|---|---|---|
| Lifecycle stage | **Run-time** production ops (mutating live state) | **Build-time** dev loop (producing validated code + context) |
| What "autonomy" acts on | Production state (drains, rollbacks, capacity) | Code + the `.agents/` context corpus |
| Always-on posture | Always-on autonomous agents **are** the product | **Ships no daemon** — always-on delegated to a substrate ([ADR-0009](../adr/ADR-0009-daemon-deletion-in-session-only.md)) |
| Evidence scale | Planetary incident volume → can A/B-test SRE practices | Repo-scale → CI gates + eval suites + e2e proofs |
The two are **complements**: run AgentOps' loop upstream, a Google-style SRE stack downstream, and you have one continuous CDLC→SDLC→production control plane honoring the same four invariants end-to-end.
---
*Source archive (full paper text): operator vault `~/learning/2026-05-29-google-sre-ai-engineering-reliable-operations.md`. Original: <https://sre.google/resources/practices-and-processes/ai-engineering-reliable-operations/>.*
docs/convergence/index.md
+30
View File
@@ -0,0 +1,30 @@
---
title: "Convergence"
description: "The record of the industry independently arriving at the structure AgentOps already runs — the thesis, the receipts, and the per-party deep-dives."
permalink: /convergence/
last_reviewed: 2026-05-29
---
# Convergence
The industry is converging on the structure AgentOps already runs. This section is the record of it — kept honest, dated, and separate from the competitor map.
It is **not** the [Competitive Radar](../comparisons/competitive-radar.md). The radar tracks *competitors in our lane*; this section tracks *independents arriving at our thesis from outside it*. Opposite axes: competition vs. vindication.
## The three surfaces
| Surface | What it is | Read it when |
|---|---|---|
| **[The Reading](the-reading.md)** | The living thesis — the *argument*, with mechanism, that the industry is converging and why. | You want the position: "is this real, and why is it happening?" |
| **[The Ledger](ledger.md)** | The dated *receipts* — a table of who/when/which invariant they reinvented. | You want the evidence and a place to add a new signal. |
| **Deep-dives** | Per-party encoding maps (e.g. **[Google SRE](google-sre.md)**) showing exactly where their conclusions land against our doctrine. | You want one party mapped point-by-point. |
The Reading is the claim; the Ledger is the proof; the deep-dives are the receipts in full. A new signal lands as a Ledger row, gets synthesized into The Reading, and earns a deep-dive if it warrants one.
## The thesis being converged on
The four invariants (from the [3.0 north star](../3.0.md)): **velocity breaks human-paced practice → bounded autonomous loops**; **no self-grade** (independent verification); **knowledge becomes a constraint** (deterministic enforcement over trust); **reasoning core wrapped by a deterministic boundary**. Plus the supporting shape: spec/BDD-as-plan, eval-data-as-moat, humans up the abstraction ladder, pulled (not ambient) context, immutable provenance.
---
*Start with [The Reading](the-reading.md).*
docs/convergence/ledger.md
+54
View File
@@ -0,0 +1,54 @@
---
title: "AgentOps Convergence Ledger"
description: "Chronological record of external parties — labs, vendors, methodologies — independently arriving at structural conclusions AgentOps already encodes. The receipts of being early."
permalink: /convergence/ledger
last_reviewed: 2026-05-29
---
# Convergence Ledger
> **The receipts.** The dated table behind [The Reading](the-reading.md): each time a major lab, vendor, or methodology independently lands on a structural conclusion already encoded in our doctrine. Distinct from the [Competitive Radar](../comparisons/competitive-radar.md), which maps *competitors in the same lane*. The ledger maps **vindication**: who got here, when, and which of our invariants they reinvented. The argument for *why* this is happening lives in [The Reading](the-reading.md).
>
> **Why keep it.** A thesis you can't date is a thesis you can't defend. When AgentOps says "AI velocity breaks human-paced practice → restructure around bounded autonomous loops," the strongest evidence is that independent teams keep reaching the same place from different starting points. Each entry is a receipt.
>
> **The rule for an entry.** It must be (a) dated, (b) external (not us), (c) a *structural* convergence on a named AgentOps invariant — not merely "they also use agents." Cite the source and the specific invariant. Honesty over hype: where they are *ahead* of us, say so.
## The invariants being converged on
The recurring four (from [`docs/3.0.md`](../3.0.md)):
1. **Velocity breaks human-paced practice** — AI code volume outpaces line-by-line review.
2. **No self-grade** — the agent that does the work never grades it; verification harnesses are independent.
3. **Knowledge becomes a constraint** — learning is durable only once it compiles into a gate/test/rule; deterministic enforcement over trust.
4. **Reasoning core, deterministic boundary** — a probabilistic agent wrapped by a human-governed enforcement layer it cannot bypass.
Plus the supporting shape: spec/BDD-as-plan, eval-data-as-moat, humans up the abstraction ladder, pulled (not ambient) context, immutable provenance.
## Ledger
| Date | Who | What they released / said | Invariant(s) they converged on | Relative to us | Detail |
|---|---|---|---|---|---|
| **2026-05** | **Google SRE** (Papapanagiotou, Malesevic, Heiser, Meshenberg) | Whitepaper: *"AI in SRE: How Google is Engineering the Future of Reliable Operations"* | **All four** + abstraction-ladder, eval-as-moat, spec-as-plan, decoupled reasoning/execution, immutable CoT provenance | Even (8/11) — **ahead on fix-forward** (Intervening-PR Problem) | [Encoding map](google-sre.md) · `ag-4hf7` |
| **2025-10** | **obra/superpowers** (Jesse Vincent) | Claude Code methodology plugin; [launch post](https://blog.fsck.com/2025/10/09/superpowers/), [v4](https://blog.fsck.com/2025/12/18/superpowers-4/) (2025-12) | **No self-grade** + spec/BDD-as-plan + abstraction-ladder | **Even** | Dispatches a *fresh subagent per task* with two-stage review (spec-compliance, then code-quality) — implementer ≠ validator by construction. v4 added a *separate* spec-compliance reviewer, hardening the split. "Design before code, tests before features." |
| **2025-10** | **EveryInc/compound-engineering-plugin** (Every / Kieran Klaassen) | "Compounding engineering" plugin; [repo](https://github.com/EveryInc/compound-engineering-plugin), [concept (2025-06)](https://every.to/source-code/compound-engineering-the-definitive-guide) | Context-as-compounding-artifact + spec-as-plan | **Behind** on knowledge→constraint | Loop "brainstorm → plan → work → review → **compound**"; `/ce-compound` documents learnings so the next agent doesn't re-learn. Real convergence on *context compounding* — but learnings land as **prose notes, not executable gates**. We compile knowledge into a CI gate; they don't. The cleanest place we're ahead. |
| **2025-09 / 10** | **Anthropic** | [Claude Agent SDK guidance](https://claude.com/blog/building-agents-with-the-claude-agent-sdk) (2025-09) + [Agent Skills](https://claude.com/blog/skills) (2025-10) | **Reasoning core + deterministic boundary** (SDK) + context-as-artifact (Skills) | **Even** (narrower) | SDK names the loop "gather context → act → **verify** → repeat" and *ranks* verification: **rules-based feedback best**, LLM-as-judge last & "less robust" — a probabilistic core wrapped by a deterministic check. Skills = portable, composable context folders ("build once, use across Claude apps, Code, API") — the primitive our corpus generalizes. Anthropic ships the primitives; we compose the compounding-corpus + knowledge-as-gate system. |
> **Reading the dates.** The 2025-10 cluster (superpowers, compound-engineering) and Anthropic's 2025-09/10 primitives all *predate* the Google SRE paper (2026-05) but *postdate* the AgentOps CDLC doctrine they converge on. The pattern is independent rediscovery accelerating through late 2025 into 2026 — see [The Reading](the-reading.md) for the mechanism.
## Backfill candidates (verify before promoting)
Tracked-but-not-yet-confirmed convergence moments. Each needs a dated source and a specific invariant before it becomes a ledger row — do not assert without the receipt:
- *(The first wave — superpowers, compound-engineering, Anthropic — is now confirmed and promoted above. Add the next markers here as they surface; promote on a dated, citable receipt.)*
## How to add an entry
1. Confirm it clears the entry rule (dated, external, structural, cited).
2. Add a row to **Ledger** (newest at top). Name the specific invariant(s), not "they use AI."
3. If it surfaces work for us (a gap they expose, a better name to adopt), file a bead and link it.
4. If a detailed mapping is warranted, write a `comparisons/<party>-convergence.md` and link it from the row (as the Google entry does).
5. Update `last_reviewed`.
---
*Companion: [Competitive Radar](../comparisons/competitive-radar.md) (competitors) · [3.0 north star](../3.0.md) (the thesis being converged on).*
docs/convergence/operationalized/README.md
+47
View File
@@ -0,0 +1,47 @@
# Operationalized: Google SRE AI Reliability Method
> Google's 2026 SRE whitepaper *"AI Engineering Reliable Operations"* turned from a doc into **executable, auditable artifacts** — a kernel, an operator library, and validators — via the `operationalizing-expertise` skill (Track A: static distillation). This is the bridge that makes **"are we actually doing what Google says?"** a checkable artifact instead of a claim. Produced under bead `ag-4hf7`; companion to the [convergence section](../index.md).
## What's here
```
corpus/
primary_sources/google-sre-ai-reliable-operations.md # the paper (verbatim archive)
quote_bank/quote_bank.md # §1..§28 anchored quotes, fixed tag taxonomy
distillations/opus/distillation.md # single-model raw extraction
specs/triangulated_kernel.md # marker-bounded: 17 axioms + 14 operators (+ DISPUTED / UNIQUE)
specs/operator_library.md # 14 operator cards, each with an AgentOps-Enforcement verdict
scripts/
validate-corpus.py # anchors sequential, entries well-formed, tags in taxonomy
validate-operators.py # every operator has required fields + valid verdict + real anchors
extract-kernel.py # markers present, versioned, min axiom/operator counts
```
## The scorecard (from the 2026-05-29 audit)
Each operator card records whether AgentOps actually enforces the behavior, where, and the gap bead. As of this writing: **7 ENFORCED · 6 PARTIAL · 1 GAP** of 14 operators.
| Verdict | Operators |
|---|---|
| **ENFORCED** | Spec-Before-Code · Knowledge-To-Constraint · Reasoning-Execution-Decouple · Append-Only-Provenance · Pulled-Grounded-Context · Machine-Speed-Validation |
| **SPLIT** | Independent-Harness — ENFORCED at the skills layer (council/AP#7), PARTIAL at the CLI (no per-agent runtime guard → `ag-w3fg`) |
| **PARTIAL** | Progressive-Authorization (L0–L4 ladder → `ag-wrom`) · Tiered-Eval-Data (`ag-fjbu`) · Judge-Plus-Deterministic-Scoring (`ag-xert`) · Dry-Run-Before-Mutation (`ag-r6l3`) · Bounded-Interruptible-Loop (session-scope → `ag-o5xp`) · Non-Ambient-Identity (scoped) |
| **GAP** | In-Workflow-Golden-Capture (`ag-xert`) |
| **DISPUTED** | Fix-Forward vs. clean rollback (`ag-7278`) |
**Headline:** the one invariant AgentOps enforces that the convergence cluster consistently misses is **Knowledge-To-Constraint** — learnings compiled into gates, not prose. That's the sharpest edge.
## Re-run the validators
```bash
cd .agents/operationalized/google-sre-reliability
python3 scripts/validate-corpus.py # OK corpus validation
python3 scripts/validate-operators.py # OK operator validation (14 operators)
python3 scripts/extract-kernel.py >/dev/null # OK kernel v1.0: 17 axioms, 14 operators
```
## How to keep it honest
- When a gap bead closes, flip that operator's `AgentOps-Enforcement` line to ENFORCED and update the scorecard here + in `operator_library.md`.
- When a new convergence signal lands in `docs/convergence/ledger.md`, check whether it adds or sharpens an operator.
- The kernel is versioned (`v1.0`); bump it if axioms/operators change, and keep START/END markers intact (the extractor enforces this).
docs/convergence/operationalized/corpus/distillations/opus/distillation.md
+34
View File
@@ -0,0 +1,34 @@
# Distillation (Opus 4.8) — Google SRE AI Reliability Method
> Single-model structured extraction feeding the [triangulated kernel](../../specs/triangulated_kernel.md). Track A is single-source, so "triangulation" here is across the paper's three internal vantage points (production-ops, eval, SDLC) and a cross-check against the AgentOps convergence cluster, not across multiple distiller models. Disagreements are surfaced, not flattened.
## Method in one line
Wrap a probabilistic agent in a deterministic, human-governed boundary; earn its autonomy against tiered human-verified evals; keep every decision auditable; and move humans from doing the work to architecting the boundary.
## Extracted principles (raw, pre-kernel)
1. The forcing function is **velocity** (~4x); manual review/ops don't scale → restructure, don't add reviewers. (§1, §25)
2. Humans **move up the abstraction ladder** — guardrails, golden data, governance — not preserved manual skill. (§3, §25)
3. **Verification independent of authorship** ("Independent Harnesses") — implementer ≠ tester/reviewer, to kill cross-bias. (§23)
4. **Spec before code**, co-authored and approved. (§24)
5. **Autonomy is earned** through tiered levels (L0–L4); the L2→L3 jump (unsupervised actuation) is the critical, high-rigor gate. (§7, §12, §13)
6. **Eval data is tiered** Bronze/Silver/Gold; Silver calibrated to Gold; measure *true* not *observed* precision. (§14, §15)
7. **Dual scoring**: LLM-as-Judge for reasoning + strict deterministic exact-match for the action. (§16)
8. **Golden data captured in-workflow** (accept/modify/reject at close), no separate chore. (§17)
9. **Reasoning decoupled from execution**: route mutations through a deterministic, caller-agnostic control plane. (§11, §18)
10. **Mandatory dry-run** before any state mutation. (§10)
11. **Bounded + interruptible loops**: rate limits, circuit breakers, stall detection, Red Button. (§9, §20)
12. **Real-time risk eval** auto-downgrades autonomy under elevated risk. (§6, §19)
13. **Non-ambient, least-privilege, attributable identity** for agents. (§8, §21)
14. **Append-only CoT + actuation traces** — full auditability. (§4, §5)
15. **Pulled, grounded context** via MCP/RAG, not ambient or training-only. (§22)
16. **Machine-speed continuous validation** replaces human-paced soak. (§27)
## Single biggest cross-bias to watch
The paper is written from a position of *operating* autonomous production mutation at planetary scale. Two of its principles (raw #9–#13 applied to live infra) are **out of AgentOps scope by design** — AgentOps encodes the same boundary for the *dev loop* (CI as the deterministic plane), not for live-production actuation. Flattening that distinction would over-claim. See kernel UNIQUE/U1.
## The one genuine disagreement
Fix-forward vs. clean rollback at velocity (§26): Google prefers fix-forward; AgentOps' coherent-arc favors clean per-arc rollback. Kept in DISPUTED/D1, routed to `/council` (`ag-7278`).
docs/convergence/operationalized/corpus/primary_sources/google-sre-ai-reliable-operations.md
+37
View File
@@ -0,0 +1,37 @@
# Primary Source (reference stub) — Google SRE "AI Engineering Reliable Operations"
> **This is a reference stub, not the full text.** AgentOps is a public repository; the full verbatim whitepaper is not re-hosted here to avoid republication. Fair-use excerpts (with attribution) live in [`../quote_bank/quote_bank.md`](../quote_bank/quote_bank.md). The complete verbatim archive is kept in the private operator vault.
## Citation
- **Title:** AI in SRE: How Google is Engineering the Future of Reliable Operations
- **Authors:** Ioannis Papapanagiotou, Stevan Malesevic, Chris Heiser & Ruslan Meshenberg (Google SRE)
- **Published:** 2026-05 (Google SRE resources)
- **Canonical URL:** <https://sre.google/resources/practices-and-processes/ai-engineering-reliable-operations/>
- **Retrieved:** 2026-05-29
- **Full local archive (private vault):** `~/learning/2026-05-29-google-sre-ai-engineering-reliable-operations.md`
- **References cited by the paper:** Gemini CLI for outages (cloud.google.com blog); the Google SRE book series (sre.google/books).
## Abstract (excerpt — fair use)
> "Site Reliability Engineering (SRE) is facing a paradigm shift driven by the rapid adoption of AI throughout the software development lifecycle (SDLC)... Human code review cannot scale linearly with machine-generated code volume... By developing autonomous mitigation agents (AI Operator), strict execution guardrails (Actus), and continuous evaluation pipelines grounded in human operational memory (IRM Analyzer), Google is engineering the autonomous control planes required to safely govern high-velocity, agentic software development."
## Section outline (for anchor navigation)
1. Abstract — the 4x-velocity forcing function; reinventing SRE for the AI era.
2. Introduction — planetary scale, costly mistakes, AI as a transformative layer.
3. Governing AI in Production Operations (AI-Ops)
- Key Challenges (Operator→Architect, explainability, data integrity, drift, security, runaway automation)
- The Safety Trifecta (Transparency, Real-time Risk Evaluation, Progressive Authorization)
- Architectural Guardrails (no ambient access, circuit breakers, mandatory dry-run, safe-by-default actuation)
4. SRE AI Autonomy Levels — L0–L4; progression gates; the L2→L3 critical step.
5. Evaluation Data and Memory — human trajectories (IRMA); Bronze/Silver/Gold tiers; true-vs-observed precision; Nightly Evals + LLM-as-Judge + deterministic scoring; in-workflow Golden capture.
6. AI Across the SRE Lifecycle — Detectr (observe); AI Alert (enrich); Incident Hypothesis + Investigation Dashboards + Gemini CLI (L1); AI Operator + Actus (L3 autonomous mitigation, reasoning/execution decoupling, Red Button).
7. Enabling Technologies — production data, RAG, fine-tuning, MCP, agent identity, A2A.
8. The Future of SRE — agentic SDLC; Independent Harnesses; spec-before-code; adaptive progressive rollouts; the Intervening-PR Problem + AI-assisted fix-forward; review up the abstraction ladder.
## The 11 convergence points (as mapped in `docs/convergence/google-sre.md`)
1. 4x velocity breaks human-paced review · 2. Independent Harnesses (no self-grade) · 3. Tiered eval data + judge + deterministic scoring · 4. Knowledge → deterministic boundary · 5. Humans up the abstraction ladder · 6. Reasoning/execution decoupling · 7. Spec before code · 8. Progressive authorization (L0–L4) · 9. Pulled context / MCP / no ambient access · 10. Append-only CoT + actuation provenance · 11. Fix-forward over binary rollback.
See [`../quote_bank/quote_bank.md`](../quote_bank/quote_bank.md) for the §-anchored excerpts that every kernel axiom and operator cites.
docs/convergence/operationalized/corpus/quote_bank/quote_bank.md
+145
View File
@@ -0,0 +1,145 @@
# Quote Bank — Google SRE "AI Engineering Reliable Operations" (2026-05)
> Stable, sequential anchors (§1..§N) over verbatim quotes from the primary source. Every kernel axiom and operator card cites these IDs. Source file: `corpus/primary_sources/google-sre-ai-reliable-operations.md`.
>
> **Tag taxonomy (fixed):** `velocity`, `verification`, `safety`, `autonomy`, `evaluation`, `provenance`, `context`, `abstraction`, `actuation`, `governance`.
## §1 — Abstract
> "As AI coding assistants dramatically accelerate code generation and deployment velocity—with organizations targeting up to a 4x increase in productivity—traditional, manual practices are becoming unsustainable. Human code review cannot scale linearly with machine-generated code volume."
— Source: primary, Abstract
Tags: velocity, abstraction
## §2 — Governing AI in Production Operations
> "an AI agent making an incorrect decision or taking a faulty action in production can lead to immediate and widespread service disruptions. The speed and scale at which AI can operate mean that the blast radius of a failure can be far larger and propagate far more quickly than with human operators."
— Source: primary, Governing AI in Production Operations
Tags: safety, actuation
## §3 — Operator to Architect
> "As AI assumes responsibility for low-level mitigation, attempting to artificially preserve unscalable manual intervention skills is counterproductive. Instead, SREs must move up the abstraction ladder, transitioning from direct incident responders to architects of AI safety. Future human expertise will focus on defining rigid system guardrails, curating 'Golden Data' for evaluation, and governing autonomous agent behavior."
— Source: primary, Key Challenges
Tags: abstraction, governance
## §4 — Explainability
> "Rather than accepting AI models as opaque 'black boxes,' SRE must enforce strict observability over agentic reasoning and execution. By exposing an agent's Chain of Thought (CoT) in real-time UIs and persisting deterministic actuation traces through control planes, every autonomous decision becomes fully auditable, debuggable, and subject to continuous evaluation."
— Source: primary, Key Challenges
Tags: provenance, verification
## §5 — Safety Trifecta: Transparency
> "AI actions and decisions must be observable and understandable. This means AI agents must log their 'chain of thought'—the signals used, the hypotheses considered, the reasons for choosing a particular action, and the confidence level."
— Source: primary, The Safety Trifecta
Tags: provenance, governance
## §6 — Safety Trifecta: Real-time Risk Evaluation
> "Every action proposed by an AI agent undergoes a risk assessment. This evaluation considers the current production context, such as ongoing deployments, error budget status, active incidents, and time of day."
— Source: primary, The Safety Trifecta
Tags: safety, actuation
## §7 — Safety Trifecta: Progressive Authorization
> "AI agents are not granted full production access from day one. We release agents to lower levels of autonomy (human approved) and scale up based on the SRE Autonomy Levels described below."
— Source: primary, The Safety Trifecta
Tags: autonomy, governance
## §8 — Least Privilege / No Ambient Access
> "Agentic systems must not operate with the standing, human-like credentials of their developers... Agent identities must be distinct from human users, strongly authenticated, and granted access only on-demand with the necessary permissions."
— Source: primary, Architectural Guardrails
Tags: safety, governance
## §9 — Agentic Circuit Breakers
> "Systems must implement strict, agent-specific rate limits and automated circuit breakers to prevent runaway loops or excessive resource consumption. Any action performed by an agent must be highly interruptible."
— Source: primary, Architectural Guardrails
Tags: safety, autonomy
## §10 — Mandatory Dry-Run
> "Any system or API intended for agent interaction must support a declarative dry_run=true mode. This allows the agent, the safety framework, and human reviewers to accurately predict the outcome and blast radius of a proposed action before any production state is mutated."
— Source: primary, Architectural Guardrails
Tags: actuation, safety
## §11 — Safe-by-Default Actuation
> "The underlying infrastructure tools must be incapable of single-handedly taking down production, regardless of who or what is calling them... it must route the request through a delegated control plane... It does not care if the caller is an agent or a human; it simply ensures the action aligns with predefined safety principles before actuation occurs."
— Source: primary, Architectural Guardrails
Tags: actuation, safety, governance
## §12 — Autonomy Levels
> "Adopting AI in SRE is not a binary switch; it is a structured journey from standard human-operated tooling to fully autonomous systems... The levels are defined by the degree of automation across key operational functions: Monitoring, Investigation, Approval, Actuation, and Self-Directed operations."
— Source: primary, SRE AI Autonomy Levels
Tags: autonomy, governance
## §13 — L2→L3 Gate
> "This is a critical step, gated by establishing trust and robust safety controls for the system to act autonomously for well-defined scenarios. This involves demonstrating high precision and reliability to overcome human hesitancy... The rigor here is substantially higher, proportional to the risk of unsupervised actions."
— Source: primary, Progression and Appropriate Autonomy
Tags: autonomy, evaluation
## §14 — Evaluation Data Tiers
> "Bronze: Heuristically generated by autolabelers. Silver: Programmatically generated but mathematically calibrated for confidence against Gold data with a minimum quality threshold. Gold: Verified by human experts."
— Source: primary, The Evaluation Data Pipeline
Tags: evaluation
## §15 — True vs Observed Precision
> "Google SRE uses stratified sampling to continuously surface a diverse subset of incidents for manual review, creating Gold data. This Gold dataset mathematically calibrates the Silver dataset, helping to ensure our evaluation pipelines measure True Precision versus Observed Precision, enabling statistically significant safety margins before an agent acts in production."
— Source: primary, The Evaluation Data Pipeline
Tags: evaluation
## §16 — LLM-as-Judge + Deterministic Scoring
> "we employ a hybrid evaluation methodology combining 'LLM-as-a-Judge'... with strict deterministic scoring... a mitigation is only scored as 'correct' if the agent's output deterministically matches the fully actionable, exact parameters of the Golden data (e.g., the specific binary and version), rather than providing a vague, LLM-generated suggestion to 'rollback'."
— Source: primary, Continuous Nightly Evals
Tags: evaluation, verification
## §17 — Golden Data In-Workflow Capture
> "When an oncaller declares an incident mitigated, the system proactively generates structured suggestions of the exact mitigations applied. By simply accepting, modifying, or rejecting these hints during their standard workflow, SREs continuously feed high-quality Golden labels back into the system... without overhead."
— Source: primary, Generating Golden Data
Tags: evaluation, provenance
## §18 — Reasoning/Execution Decoupling
> "By decoupling the AI's reasoning engine (AI Operator) from the execution engine, we ensure that no matter how rapidly AI models evolve, their ability to mutate production remains strictly governed by deterministic, human-controlled safety boundaries."
— Source: primary, Mitigation Safety Verification Agent
Tags: actuation, safety, governance
## §19 — Dynamic Autonomy Downgrade
> "If an agent requests an L3 (High Automation) execution, but the agent detects an elevated risk score or an anomalous production state, it will automatically downgrade the request to L2 (Partial Automation), intercepting the execution and routing an approval request to a human SRE."
— Source: primary, Dynamic Autonomy and Safety Guardrails
Tags: autonomy, safety, actuation
## §20 — Red Button
> "emergency 'Red Button' endpoints that allow SREs to instantly pause all in-flight agentic actions, block new actions, or globally revoke L3 permissions across the fleet during catastrophic, complex outages."
— Source: primary, Post-Actuation Guardians
Tags: safety, governance, actuation
## §21 — Robust Agent Identity
> "every autonomous agent action must be attributed to a unique agent principal with a complete, immutable record that authorized parties can use to reconstruct its activity."
— Source: primary, Enabling Technologies
Tags: provenance, governance
## §22 — Pulled Context (RAG/MCP)
> "Google is standardizing on the Model Context Protocol (MCP)... This allows AI agents to dynamically discover and invoke tools... internal RAG platforms... grounding their responses and actions in the current state of production, rather than just their training data."
— Source: primary, Enabling Technologies
Tags: context, actuation
## §23 — Independent Harnesses
> "SRE mandates the use of Independent Harnesses. The AI agent that generates the source code must be strictly isolated from the AI agent that defines the test cases or reviews the output. This separation prevents the transmission of cross-bias and helps to ensure that untested correctness requirements are caught mechanically rather than assumed by the authoring LLM."
— Source: primary, Scaling Human Oversight
Tags: verification, governance
## §24 — Spec Before Code
> "By co-authoring and approving detailed specifications with AI before code generation, engineers validate the architecture and safety constraints."
— Source: primary, Scaling Human Oversight
Tags: abstraction, verification
## §25 — Review Up the Ladder
> "Traditional line-by-line code review does not scale with a 4x to 10x increase in code volume. Attempting to maintain this practice leads to reviewer fatigue and rubber-stamping. Instead, human oversight must 'shift left' and move up the abstraction ladder. Engineers must focus on reviewing Designs, Intent, and Policies."
— Source: primary, Scaling Human Oversight
Tags: abstraction, velocity
## §26 — Intervening PR Problem / Fix-Forward
> "A simple binary rollback to a 'last known good' version becomes highly risky when dozens of changes have been submitted in rapid succession; rolling back might inadvertently remove critical bug fixes or security patches... as AI accelerates the creation of code, it must also accelerate resolution through AI-Assisted Fix-Forward capabilities."
— Source: primary, The Intervening Pull Request Problem
Tags: velocity, actuation
## §27 — Continuous Production Validation
> "SRE must invest in Adaptive Progressive Rollouts, utilizing sensitive, automated 'continuous production validation' techniques that can evaluate system health at machine speed."
— Source: primary, Rethinking Release
Tags: evaluation, velocity
## §28 — Closing Synthesis
> "by shifting human oversight to architectural intent and building machine-speed compensating controls, SRE is transitioning from operating systems to architecting the safe boundaries within which autonomous agents can continuously innovate."
— Source: primary, Future of SRE
Tags: abstraction, governance, safety
docs/convergence/operationalized/corpus/specs/operator_library.md
+314
View File
@@ -0,0 +1,314 @@
# Operator Library — Google SRE AI Reliability Method, mapped to AgentOps
> Each operator is one executable behavior from the [kernel](triangulated_kernel.md). Cards carry the standard fields **plus** an `AgentOps-Enforcement` line that records — from the 2026-05-29 code+skills audit — whether AgentOps actually enforces it, where, and which bead closes any gap. This is the bridge that makes "are we doing what Google says" a *checkable* artifact, not a claim.
>
> **Enforcement legend:** `ENFORCED` (a mechanism requires/checks it) · `PARTIAL` (mechanism exists but incomplete or convention-only) · `GAP` (documented/desired, not mechanically enforced).
>
> **Scorecard:** 7 ENFORCED · 6 PARTIAL · 1 GAP (of 14). Open beads: `ag-w3fg` `ag-r6l3` `ag-xert` `ag-o5xp` `ag-fjbu` `ag-wrom` `ag-7278`.
---
### Independent-Harness
**Definition**: The agent that produces work is strictly isolated from the agent that tests or reviews it.
**When-to-Use Triggers**:
- Any validation/review phase after an implement phase.
- Any council/judge run scoring produced work.
**Failure Modes**:
- Implementer self-validates in the same context → cross-bias, rubber-stamp.
- "Fresh eyes" asserted in prose but not enforced at runtime.
**Prompt Module**:
~~~text
[OPERATOR: Independent-Harness]
1. Confirm the validator's agent/session id != the implementer's.
2. If equal, abort: spawn a fresh-context validator.
3. Validator sees the artifact + acceptance, NOT the implementer's reasoning trace.
~~~
**Canonical tag**: independent-harness
**Quote-bank anchors**: §23, §4
**AgentOps-Enforcement**: ENFORCED at skills layer (`skills/council/SKILL.md`, AP#7 gate `scripts/verify-gate-claim.sh`, ratchet rule "no self-grade"); **PARTIAL at CLI** — `cli/cmd/ao/rpi_phased.go:66-76` separates phases by invocation but has no per-agent runtime guard → **`ag-w3fg`**.
---
### Spec-Before-Code
**Definition**: Behavior/spec (BDD/Gherkin) is authored and approved before implementation; free-text acceptance is invalid.
**When-to-Use Triggers**:
- Start of any bead/feature before code.
- Acceptance arrives as prose.
**Failure Modes**:
- Coding begins with no failing test / no scenario.
- Free-text acceptance smuggled past planning.
**Prompt Module**:
~~~text
[OPERATOR: Spec-Before-Code]
1. Require Given/When/Then (happy + >=1 edge) before implement.
2. Reject free-text acceptance; loop back to plan.
3. Link each scenario to a test name (the slice's contract).
~~~
**Canonical tag**: spec-before-code
**Quote-bank anchors**: §24, §25
**AgentOps-Enforcement**: ENFORCED — `skills/discovery/references/discovery.feature` rejects free-text; `skills/scenario/SKILL.md`; scenarios↔test linkage CI gate (`validate.yml`, scenario-hash-stability).
---
### Knowledge-To-Constraint
**Definition**: A learning is durable only once it compiles into a gate, test, or rule.
**When-to-Use Triggers**:
- A failure repeats (≥2×).
- A post-mortem produces an "observation."
**Failure Modes**:
- Learning captured as prose advice that decays.
- Compound-notes accumulate without enforcement (the EveryInc gap).
**Prompt Module**:
~~~text
[OPERATOR: Knowledge-To-Constraint]
1. For each durable learning, name the gate/test/rule it becomes.
2. If it cannot become one, it is not yet durable — hold it.
3. Wire the gate; only then mark the learning promoted.
~~~
**Canonical tag**: knowledge-to-constraint
**Quote-bank anchors**: §3 (golden-data curation as governance)
**AgentOps-Enforcement**: ENFORCED — `skills/ratchet/SKILL.md` (Chaos→Filter→Ratchet), `skills/post-mortem/SKILL.md` (observation→repeat→gate→doctrine), CI skills-integrity gate. **This is the invariant the convergence cluster most consistently misses — AgentOps' sharpest edge.**
---
### Progressive-Authorization
**Definition**: Autonomy is earned incrementally against verified success; loops carry explicit stop policies.
**When-to-Use Triggers**:
- Granting an agent a new unsupervised capability.
- Any unbounded loop (crank/evolve/autodev).
**Failure Modes**:
- Full autonomy on day one.
- Loops with no cycle/wave cap.
**Prompt Module**:
~~~text
[OPERATOR: Progressive-Authorization]
1. Start at human-approved; require a pass record before unsupervised.
2. Bound every loop (max cycles/waves; stop on operator marker).
3. State the promotion gate explicitly (what proof earns the next level).
~~~
**Canonical tag**: progressive-authorization
**Quote-bank anchors**: §7, §12, §13
**AgentOps-Enforcement**: ENFORCED bounds (`skills/crank` MAX_EPIC_WAVES=50, `skills/evolve --max-cycles`, `skills/rpi` complexity-scaled gates, session-scope 2-4 PR rule); **but no explicit L0–L4 ladder with named promotion gates** → **`ag-wrom`**.
---
### Tiered-Eval-Data
**Definition**: Eval data is stratified Bronze/Silver/Gold and Silver is calibrated against Gold so the pipeline measures true (not observed) precision.
**When-to-Use Triggers**:
- Building or scoring an eval suite.
- Reporting agent precision.
**Failure Modes**:
- Scoring against unlabeled/heuristic data and reporting it as precision.
- Holdout leakage into the scored set.
**Prompt Module**:
~~~text
[OPERATOR: Tiered-Eval-Data]
1. Tag every eval item Bronze/Silver/Gold.
2. Calibrate Silver against a Gold sample (stratified).
3. Report true-vs-observed precision; refuse to leak Silver/Gold targets.
~~~
**Canonical tag**: tiered-eval-data
**Quote-bank anchors**: §14, §15
**AgentOps-Enforcement**: PARTIAL — holdout-leak deny-by-default exists (`skills/eval-outcomes`, `cli/cmd/ao/eval_outcomes.go`), but tier strata + true-vs-observed naming are undocumented → **`ag-fjbu`**.
---
### Judge-Plus-Deterministic-Scoring
**Definition**: Grade reasoning with an LLM judge AND the final action with strict deterministic exact-match.
**When-to-Use Triggers**:
- Scoring an agent's mitigation/output.
- Gating a release on eval results.
**Failure Modes**:
- Accepting a vague suggestion as "correct."
- Judge-only scoring (non-reproducible) with no deterministic check.
**Prompt Module**:
~~~text
[OPERATOR: Judge-Plus-Deterministic-Scoring]
1. LLM-judge grades trajectory/reasoning against golden.
2. Deterministic check requires exact actionable params (binary/version).
3. Lock judge roster + rubric hash for reproducibility.
~~~
**Canonical tag**: judge-plus-deterministic-scoring
**Quote-bank anchors**: §16
**AgentOps-Enforcement**: PARTIAL — multi-judge consensus exists (`skills/council`, `judge_content_hash`), but the golden-data loader and deterministic-judge endpoint are stubbed in `cli/cmd/ao/eval.go` → **`ag-xert`**.
---
### In-Workflow-Golden-Capture
**Definition**: Harvest human-verified labels as a byproduct of the normal close workflow, not a separate chore.
**When-to-Use Triggers**:
- A bead/incident closes with a verified outcome.
- A human accepts/modifies/rejects an agent suggestion.
**Failure Modes**:
- Golden data requires a dedicated annotation pass (annotator fatigue → no data).
**Prompt Module**:
~~~text
[OPERATOR: In-Workflow-Golden-Capture]
1. At close, emit a structured suggestion of what was actually done.
2. Capture the human's accept/modify/reject as a golden label.
3. Feed it to the eval corpus with provenance.
~~~
**Canonical tag**: in-workflow-golden-capture
**Quote-bank anchors**: §17
**AgentOps-Enforcement**: GAP — no close-time golden-label capture wired (post-mortem/handoff capture learnings, not labeled eval pairs) → tracked under **`ag-xert`** (golden-data layer).
---
### Reasoning-Execution-Decouple
**Definition**: The probabilistic reasoning engine never mutates state directly; it routes through a deterministic, caller-agnostic boundary.
**When-to-Use Triggers**:
- Any agent action that changes durable state.
- Designing a new agent-facing capability.
**Failure Modes**:
- Agent runs raw scripts against live state.
- Domain core imports the runtime/shell.
**Prompt Module**:
~~~text
[OPERATOR: Reasoning-Execution-Decouple]
1. Route mutations through a port; never raw side effects from the core.
2. The boundary enforces safety regardless of caller (agent or human).
3. CI is the authoritative gate on what merges.
~~~
**Canonical tag**: reasoning-execution-decouple
**Quote-bank anchors**: §11, §18
**AgentOps-Enforcement**: ENFORCED — hexagonal "domain never imports shell" (`docs/architecture/ports-and-adapters.md`), CI-as-authoritative-gate, append-only provenancegraph as the deterministic record. Scope note: encoded for the *dev loop* (CI boundary), not live-production actuation (U1).
---
### Dry-Run-Before-Mutation
**Definition**: Every agent-facing mutating interface supports a declarative dry-run that previews outcome and blast radius.
**When-to-Use Triggers**:
- Any `ao` command that writes durable state.
- Any agent action with a non-trivial blast radius.
**Failure Modes**:
- Mutators with no preview → unpredictable blast radius.
- Dry-run on some commands but not all (inconsistent contract).
**Prompt Module**:
~~~text
[OPERATOR: Dry-Run-Before-Mutation]
1. Expose --dry-run on every mutating command.
2. Dry-run prints the exact diff/outcome without writing.
3. Gate: a mutating command without --dry-run fails CI.
~~~
**Canonical tag**: dry-run-before-mutation
**Quote-bank anchors**: §10
**AgentOps-Enforcement**: PARTIAL — present on ~6 commands (batch_forge/promote, harvest, compile/repair); absent on `ao provenance add`, `ao evolve blocked`, `ao ratchet *`; no CI gate enforcing universal coverage → **`ag-r6l3`**.
---
### Bounded-Interruptible-Loop
**Definition**: Agent loops carry rate limits, circuit breakers, stall detection, and an emergency stop; every action is interruptible.
**When-to-Use Triggers**:
- Any long-running or autonomous loop.
- A session shipping many consecutive PRs.
**Failure Modes**:
- Runaway loop / reactive-PR spiral with no stop.
- Stall with no watchdog/fallback.
**Prompt Module**:
~~~text
[OPERATOR: Bounded-Interruptible-Loop]
1. Wire a stall watchdog with timeout + fallback.
2. Cap cycles/waves; stop on operator marker.
3. Provide an emergency stop that halts in-flight actions.
~~~
**Canonical tag**: bounded-interruptible-loop
**Quote-bank anchors**: §9, §20
**AgentOps-Enforcement**: PARTIAL — live stall watchdog (`cli/cmd/ao/rpi_phased_stream.go:456-466`, 30s) + loop caps exist, but the **session-PR-scope guardrail is unenforced post-hookless** (`hooks/session-pr-counter.sh` absent, CLAUDE.md stale) → **`ag-o5xp`**; legacy supervisor coexistence is the known `soc-1gbpz` migration.
---
### Append-Only-Provenance
**Definition**: Agent reasoning (CoT) and actions persist immutably so any decision can be reconstructed.
**When-to-Use Triggers**:
- Any agent decision or actuation.
- A verdict/gate result.
**Failure Modes**:
- Decisions logged mutably / overwritten.
- Provenance as a derived projection treated as source of truth.
**Prompt Module**:
~~~text
[OPERATOR: Append-Only-Provenance]
1. Write events append-only (O_APPEND / hash-chained).
2. Ledger is source of truth; metadata is a projection.
3. Evidence must be reconstructable from the ledger.
~~~
**Canonical tag**: append-only-provenance
**Quote-bank anchors**: §4, §5, §21
**AgentOps-Enforcement**: ENFORCED — `cli/internal/provenancegraph/store.go:102-160` (O_APPEND, hash-chained, idempotent), `docs/provenance/ledger.jsonl` (schema `agentops-sdlc-provenance.v1`, ledger-wins), `scripts/lint-evidence-lines.sh`.
---
### Pulled-Grounded-Context
**Definition**: Context is pulled through explicit, decay-ranked, token-budgeted channels and grounded in current state — never sprayed ambiently.
**When-to-Use Triggers**:
- Session start / phase start.
- Any agent needing prior context.
**Failure Modes**:
- Ambient hooks stacking noise into the prompt (the 2.x delta=0 failure).
- Stale/training-only grounding.
**Prompt Module**:
~~~text
[OPERATOR: Pulled-Grounded-Context]
1. Pull via an explicit query (ao inject), decay-ranked + token-budgeted.
2. Ground in current corpus state, not just model memory.
3. No ambient push; dense and just-in-time.
~~~
**Canonical tag**: pulled-grounded-context
**Quote-bank anchors**: §22
**AgentOps-Enforcement**: ENFORCED — `cli/cmd/ao/inject.go` + `cli/internal/search/*` (1500-token budget, exp decay, utility weighting); hookless-first architecture (`docs/3.0.md`).
---
### Non-Ambient-Identity
**Definition**: Agent principals are distinct from humans, strongly authenticated, on-demand, least-privilege, and attributable.
**When-to-Use Triggers**:
- An agent performs an attributable action (commit, ledger write).
- Granting an agent any standing credential.
**Failure Modes**:
- Agents run with the developer's standing credentials.
- Actions not attributable to a unique agent principal.
**Prompt Module**:
~~~text
[OPERATOR: Non-Ambient-Identity]
1. Use a distinct agent principal, not human standing creds.
2. Stamp every action with the agent id (forensics).
3. Grant access on-demand, minimally scoped.
~~~
**Canonical tag**: non-ambient-identity
**Quote-bank anchors**: §8, §21
**AgentOps-Enforcement**: PARTIAL — agent-identity trailers via bd `prepare-commit-msg` hook provide attribution; standing-credential least-privilege is largely an out-of-session/substrate concern (U1) rather than an in-session AgentOps gate. Tracked as scoped-partial; no bead until a concrete in-session vector appears.
---
### Machine-Speed-Validation
**Definition**: Validation runs at machine speed (continuous/adaptive) as change rate rises, replacing human-paced soak.
**When-to-Use Triggers**:
- Every change to main.
- Rising change volume / progressive rollout.
**Failure Modes**:
- Human-paced review as the only gate at 4x volume → rubber-stamping.
- No automated done-condition per slice.
**Prompt Module**:
~~~text
[OPERATOR: Machine-Speed-Validation]
1. Make CI the authoritative, machine-speed gate (T0/T1/T2).
2. Every slice has an executable done-condition (failing test first).
3. Humans review design/intent/policy, not lines.
~~~
**Canonical tag**: machine-speed-validation
**Quote-bank anchors**: §27, §25, §2
**AgentOps-Enforcement**: ENFORCED — tiered CI gates (`.github/workflows/validate.yml`, T0≤30s / T1≤5m / T2≤15m, all required), coverage floor, complexity budget. Maps A2 (humans up the ladder) to the coherent-arc review model.
docs/convergence/operationalized/corpus/specs/triangulated_kernel.md
+42
View File
@@ -0,0 +1,42 @@
# Triangulated Kernel — Google SRE AI Reliability Method
> The stable, parseable methodology distilled from the primary source and cross-checked against the AgentOps convergence cluster (Anthropic Agent SDK, obra/superpowers, EveryInc) documented in `docs/convergence/`. Consensus axioms only; the one genuine doctrine disagreement is quarantined under DISPUTED. Every axiom cites quote-bank anchors. Operators are defined in `operator_library.md`.
<!-- TRIANGULATED_KERNEL_START v1.0 -->
## Axioms (consensus)
- **A1 — Velocity breaks human-paced practice.** A ~4x rise in code/change volume makes line-by-line human review and manual operations unsustainable; the response is structural, not more reviewers. (§1, §25)
- **A2 — Humans move up the abstraction ladder.** Preserving manual intervention skill is counterproductive; human expertise shifts to guardrails, golden data, and governance of designs/intent/policies. (§3, §25, §28)
- **A3 — Verification must be independent of authorship.** The agent that generates work must be strictly isolated from the agent that defines tests or reviews it, to block cross-bias and catch untested requirements mechanically. (§23)
- **A4 — Intent/spec precedes code.** Specifications are co-authored and approved before generation, validating architecture and safety constraints up front. (§24)
- **A5 — Autonomy is earned, not granted.** Agents start at low autonomy and advance only by demonstrating statistically significant success against human-verified data; rigor scales with the risk of unsupervised action. (§7, §12, §13)
- **A6 — Evaluation data is tiered and calibrated.** Bronze (heuristic) → Silver (calibrated) → Gold (human-verified); stratified sampling calibrates Silver against Gold so the pipeline measures *true* precision, not observed precision. (§14, §15)
- **A7 — Score with a judge AND a deterministic check.** LLM-as-Judge grades reasoning/trajectory; strict deterministic exact-match (e.g. exact binary/version) grades the final action. A vague suggestion is not "correct." (§16)
- **A8 — Golden data is captured in-workflow.** Harvest verified labels as a byproduct of the normal workflow (accept/modify/reject suggestions at close), not as a separate annotation chore. (§17)
- **A9 — Reasoning is decoupled from execution.** A probabilistic reasoning engine never mutates state directly; it routes through a deterministic, human-governed control plane that is safe regardless of caller. (§11, §18)
- **A10 — Mutation requires dry-run.** Any agent-facing mutating interface must support a declarative dry-run that predicts outcome and blast radius before state changes. (§10)
- **A11 — Loops are bounded and interruptible.** Agent-specific rate limits, circuit breakers, stall detection, and an emergency stop ("Red Button") prevent runaway loops; every action is highly interruptible. (§9, §20)
- **A12 — Risk is evaluated in real time, autonomy degrades under risk.** Each action is scored against live context; elevated risk auto-downgrades the authorization level and re-inserts a human. (§6, §19)
- **A13 — Identity is non-ambient and least-privilege.** Agent principals are distinct from humans, strongly authenticated, on-demand, and minimally scoped. (§8, §21)
- **A14 — Every decision is append-only and auditable.** Chain of Thought and actuation traces are persisted immutably so any action can be reconstructed and re-evaluated. (§4, §5, §21)
- **A15 — Context is pulled and grounded, not ambient.** Agents discover and invoke tools through an explicit interface (MCP) and ground answers in current state via retrieval, not training memory alone. (§22)
- **A16 — Validation runs at machine speed.** Continuous production validation / adaptive progressive rollouts replace human-paced soak times as change rate rises. (§27)
- **A17 — Knowledge becomes a constraint.** *(AgentOps extension, consistent with A3/A9.)* A learning is durable only once it compiles into a gate, test, or rule — the deterministic boundary that A9 demands is how learning is enforced, not prose. (cross-ref `docs/3.0.md` ratchet rule #3)
## Operators
Defined with triggers, failure modes, and prompt modules in `operator_library.md`:
`Independent-Harness` (A3) · `Spec-Before-Code` (A4) · `Knowledge-To-Constraint` (A17) · `Progressive-Authorization` (A5, A12) · `Tiered-Eval-Data` (A6) · `Judge-Plus-Deterministic-Scoring` (A7) · `In-Workflow-Golden-Capture` (A8) · `Reasoning-Execution-Decouple` (A9) · `Dry-Run-Before-Mutation` (A10) · `Bounded-Interruptible-Loop` (A11) · `Append-Only-Provenance` (A14) · `Pulled-Grounded-Context` (A15) · `Non-Ambient-Identity` (A13) · `Machine-Speed-Validation` (A16, A2)
<!-- TRIANGULATED_KERNEL_END v1.0 -->
## DISPUTED (disagreement with AgentOps doctrine — not in the consensus kernel)
- **D1 — Fix-forward vs. clean rollback at velocity.** Google asserts that binary rollback becomes *unsafe* at 4x velocity (the Intervening-PR Problem) and prefers AI-assisted fix-forward + feature flags (§26). AgentOps doctrine optimizes for the **coherent-arc PR as the atomic-revert unit** (clean rollback per arc). This is a genuine, unresolved divergence — routed to `/council` at bead `ag-7278`, not silently absorbed.
## UNIQUE (Google-specific, out of AgentOps scope by design)
- **U1 — Production-state actuation** (draining cells, capacity resize, binary rollback on live infra): Google operates the run-time mutation layer; AgentOps deliberately ships no always-on production actuator (`ADR-0009`). Operators A9–A12 are encoded by AgentOps for the *dev loop* (CI gates as the deterministic boundary), not for live-production mutation.
- **U2 — Planetary-scale statistical gating** (A/B-testing SRE practices across population incident volume): AgentOps validates at repo scale via gates + eval suites, not population statistics.
docs/convergence/operationalized/scripts/extract-kernel.py
Executable
+49
View File
@@ -0,0 +1,49 @@
#!/usr/bin/env python3
"""Extract the marker-bounded triangulated kernel; validate markers + minimum counts.
Prints the kernel body to stdout on success. Exit non-zero if markers absent or counts below minimum.
"""
from __future__ import annotations
import re
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parent.parent
KERNEL = ROOT / "corpus" / "specs" / "triangulated_kernel.md"
MIN_AXIOMS = 10
MIN_OPERATORS = 8
def main() -> int:
if not KERNEL.is_file():
print("FAIL: missing triangulated_kernel.md", file=sys.stderr)
return 1
text = KERNEL.read_text(encoding="utf-8")
m = re.search(
r"<!--\s*TRIANGULATED_KERNEL_START\s+(v\d+\.\d+)\s*-->(.*?)<!--\s*TRIANGULATED_KERNEL_END\s+(v\d+\.\d+)\s*-->",
text, re.S,
)
if not m:
print("FAIL: kernel START/END markers absent or malformed", file=sys.stderr)
return 1
vstart, body, vend = m.group(1), m.group(2), m.group(3)
if vstart != vend:
print(f"FAIL: version mismatch {vstart} != {vend}", file=sys.stderr)
return 1
axioms = re.findall(r"^\s*-\s*\*\*A\d+\s*—", body, re.M)
operators = re.findall(r"`[A-Z][A-Za-z-]+`\s*\(A", body)
if len(axioms) < MIN_AXIOMS:
print(f"FAIL: only {len(axioms)} axioms (min {MIN_AXIOMS})", file=sys.stderr)
return 1
if len(operators) < MIN_OPERATORS:
print(f"FAIL: only {len(operators)} operators (min {MIN_OPERATORS})", file=sys.stderr)
return 1
sys.stderr.write(f"OK kernel {vstart}: {len(axioms)} axioms, {len(operators)} operators\n")
sys.stdout.write(body.strip() + "\n")
return 0
if __name__ == "__main__":
sys.exit(main())
docs/convergence/operationalized/scripts/validate-corpus.py
Executable
+97
View File
@@ -0,0 +1,97 @@
#!/usr/bin/env python3
"""Validate the corpus structure and quote bank against the operationalizing-expertise contract.
Exit non-zero on any failure. Pure stdlib.
"""
from __future__ import annotations
import re
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parent.parent
CORPUS = ROOT / "corpus"
TAXONOMY = {
"velocity", "verification", "safety", "autonomy", "evaluation",
"provenance", "context", "abstraction", "actuation", "governance",
}
MIN_PRIMARY_BYTES = 2500 # a reference stub (citation + outline + fair-use excerpt) is valid; full verbatim text is not re-hosted in a public repo
MIN_QUOTE_LEN = 40
MAX_QUOTE_LEN = 900
def fail(errs: list[str], msg: str) -> None:
errs.append(msg)
def main() -> int:
errs: list[str] = []
# Required directories
for d in ("primary_sources", "quote_bank"):
if not (CORPUS / d).is_dir():
fail(errs, f"missing required dir: corpus/{d}")
# Primary sources non-empty and above minimum size
primaries = list((CORPUS / "primary_sources").glob("*.md")) if (CORPUS / "primary_sources").is_dir() else []
if not primaries:
fail(errs, "no primary sources found")
for p in primaries:
if p.stat().st_size < MIN_PRIMARY_BYTES:
fail(errs, f"primary source too small ({p.stat().st_size}B): {p.name}")
# Quote bank
qb = CORPUS / "quote_bank" / "quote_bank.md"
if not qb.is_file():
fail(errs, "missing corpus/quote_bank/quote_bank.md")
return report(errs)
text = qb.read_text(encoding="utf-8")
# Split into entries by '## §N — ...'
entries = re.findall(r"^## §(\d+) —[^\n]*\n(.*?)(?=^## §|\Z)", text, re.M | re.S)
if not entries:
fail(errs, "quote bank has no §-anchored entries")
return report(errs)
nums = [int(n) for n, _ in entries]
# Sequential, no gaps, starting at 1
expected = list(range(1, len(nums) + 1))
if nums != expected:
fail(errs, f"quote anchors not sequential 1..N: got {nums}")
for n, body in entries:
quote = re.search(r'^>\s*"(.+?)"\s*$', body, re.M | re.S)
source = re.search(r"^—\s*Source:", body, re.M)
tags = re.search(r"^Tags:\s*(.+)$", body, re.M)
if not quote:
fail(errs, f"§{n}: missing quote line (>\"...\")")
else:
qlen = len(quote.group(1))
if qlen < MIN_QUOTE_LEN:
fail(errs, f"§{n}: quote too short ({qlen} chars)")
if qlen > MAX_QUOTE_LEN:
fail(errs, f"§{n}: quote too long ({qlen} chars)")
if not source:
fail(errs, f"§{n}: missing source line (— Source:)")
if not tags:
fail(errs, f"§{n}: missing Tags line")
else:
tagset = {t.strip() for t in tags.group(1).split(",") if t.strip()}
bad = tagset - TAXONOMY
if bad:
fail(errs, f"§{n}: tags outside taxonomy: {sorted(bad)}")
return report(errs)
def report(errs: list[str]) -> int:
if errs:
print(f"FAIL corpus validation ({len(errs)} error(s)):")
for e in errs:
print(f" - {e}")
return 1
print("OK corpus validation")
return 0
if __name__ == "__main__":
sys.exit(main())
docs/convergence/operationalized/scripts/validate-operators.py
Executable
+77
View File
@@ -0,0 +1,77 @@
#!/usr/bin/env python3
"""Validate operator cards have all required fields, valid anchors, and an enforcement verdict.
Exit non-zero on any failure. Pure stdlib.
"""
from __future__ import annotations
import re
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parent.parent
LIB = ROOT / "corpus" / "specs" / "operator_library.md"
QB = ROOT / "corpus" / "quote_bank" / "quote_bank.md"
REQUIRED = [
"**Definition**",
"**When-to-Use Triggers**",
"**Failure Modes**",
"**Prompt Module**",
"**Canonical tag**",
"**Quote-bank anchors**",
"**AgentOps-Enforcement**", # local extension: the audit bridge
]
VALID_VERDICTS = ("ENFORCED", "PARTIAL", "GAP")
def main() -> int:
errs: list[str] = []
if not LIB.is_file():
print("FAIL: missing operator_library.md")
return 1
if not QB.is_file():
print("FAIL: missing quote_bank.md")
return 1
known_anchors = {int(n) for n in re.findall(r"^## §(\d+) —", QB.read_text(encoding="utf-8"), re.M)}
text = LIB.read_text(encoding="utf-8")
# Operator cards are '### Name' under the library (skip the doc's own H3 in preamble by requiring fields)
cards = re.findall(r"^### (.+?)\n(.*?)(?=^### |\Z)", text, re.M | re.S)
operators = [(name, body) for name, body in cards if "**Definition**" in body]
if not operators:
print("FAIL: no operator cards found")
return 1
for name, body in operators:
for field in REQUIRED:
if field not in body:
errs.append(f"{name}: missing field {field}")
# Prompt module fenced block present
if "~~~" not in body:
errs.append(f"{name}: Prompt Module fenced block (~~~) missing")
# Enforcement verdict valid
m = re.search(r"\*\*AgentOps-Enforcement\*\*:\s*(\w+)", body)
if m and m.group(1) not in VALID_VERDICTS:
errs.append(f"{name}: enforcement verdict '{m.group(1)}' not in {VALID_VERDICTS}")
# Anchors reference real quotes
am = re.search(r"\*\*Quote-bank anchors\*\*:\s*(.+)", body)
if am:
refs = {int(x) for x in re.findall(r"§(\d+)", am.group(1))}
missing = refs - known_anchors
if not refs:
errs.append(f"{name}: no §anchors cited")
if missing:
errs.append(f"{name}: anchors not in quote bank: {sorted(missing)}")
if errs:
print(f"FAIL operator validation ({len(errs)} error(s)):")
for e in errs:
print(f" - {e}")
return 1
print(f"OK operator validation ({len(operators)} operators)")
return 0
if __name__ == "__main__":
sys.exit(main())
docs/convergence/the-reading.md
+82
View File
@@ -0,0 +1,82 @@
---
title: "The Reading: the industry is converging on the agent operating loop"
description: "The living thesis — the argument (with mechanism, not just receipts) that the industry is independently converging on the structure AgentOps already runs."
permalink: /convergence/the-reading
last_reviewed: 2026-05-29
---
# The Reading
> **Living thesis.** This is the *argument*: the industry is converging on the structure AgentOps already runs — and here is the mechanism driving it, not just the receipts. The dated evidence lives in the [Ledger](ledger.md); per-party deep-dives sit beside it (e.g. [Google SRE](google-sre.md)). This page is the synthesis, updated each time a new signal lands. Tracking bead: `ag-4hf7`.
## The claim
Across labs, vendors, and methodologies, independent teams are arriving at the **same four invariants** — from different starting points, with no coordination:
1. **Velocity breaks human-paced practice.** AI lifts code throughput ~4x; line-by-line human review and trust-based process cannot scale with it.
2. **No self-grade.** The agent that does the work cannot be the one that certifies it; verification has to be an *independent* harness.
3. **Knowledge becomes a constraint.** A learning is durable only when it compiles into a gate, a test, or a rule — deterministic enforcement over remembered advice.
4. **Reasoning core, deterministic boundary.** A probabilistic agent wrapped by a human-governed enforcement layer it cannot bypass, no matter how the model evolves.
AgentOps encoded these as a coherent doctrine early (the [3.0 north star](../3.0.md)). The convergence is not imitation — it is **independent rediscovery**, which is the strongest available signal that a structure is load-bearing rather than stylistic.
## Why it is happening (the mechanism)
This is not a vibe; it is a forcing function. When AI raises code-generation throughput by ~4x, three things break at once:
- **Review can't scale linearly.** You cannot eyeball 4x the diffs. Human attention was the rate limiter, and it just got out-run.
- **Trust-based process collapses.** "A careful senior reviews it" is not a control when the volume is machine-paced. Trust does not parallelize.
- **The bottleneck moves from writing to verifying + contextualizing.** Generation became cheap; *knowing the change is correct, in this context, against intent* became the scarce thing.
Any team that hits this wall is pushed toward the **same destination**, because the constraint is the same: move humans **up the abstraction ladder** (review intent/design/policy, not lines); make verification **independent and mechanical**; make **context a first-class, compounding artifact** so each run starts smarter; and **wrap probabilistic agents in deterministic boundaries** so a confident-but-wrong agent cannot do unbounded damage. Different doors, one room.
## The pattern across signals
What the ledger entries share (updated as rows land):
- **Google SRE (2026-05), production-ops end.** Independently reinvented our ratchet rules (their "Independent Harnesses" = our no-self-grade), spec-as-plan ("co-author specifications before code generation"), eval-data-as-moat (Bronze/Silver/Gold + LLM-as-Judge + deterministic scoring), and the reasoning/execution decoupling (AI Operator ↔ Actus = our domain-core ↔ CI-gates). They reached it from *incident operations*; we reached it from the *dev loop*. Both ends of the SDLC land on the same waist. See [the encoding map](google-sre.md).
- **Anthropic (2025-09/10), the primitives.** The Agent SDK ranks verification *exactly* as we do — **rules-based feedback best, LLM-as-judge last and "less robust"** — which is the reasoning-core/deterministic-boundary invariant stated by the model vendor itself. Agent Skills ship portable, composable context folders: the primitive our compounding corpus generalizes. Anthropic ships the building blocks; we compose the system.
- **obra/superpowers (2025-10).** Independent confirmation of **no self-grade** from the methodology lane: a fresh subagent per task, two-stage review (spec-compliance then code-quality), implementer ≠ validator by construction. v4 (2025-12) split the spec-compliance reviewer out further. The strongest external corroboration that "the agent that does the work never grades it" is load-bearing, not preference.
- **EveryInc/compound-engineering (2025-10).** Converges on **context-as-a-compounding-artifact** ("compound" step so the next agent doesn't re-learn) — but stops at *prose* compound-notes. It is the clean illustration of the gap between *agreeing context should compound* and *compiling knowledge into a constraint*. We are ahead precisely there.
**What the cluster shows:** the convergence is not one outlier — it spans the **model vendor** (Anthropic), the **methodology lane** (superpowers, compound-engineering), and **production ops** (Google), accelerating through late 2025 into 2026. Three independent vantage points, same invariants. The one they most consistently *don't* reach is knowledge-becomes-a-constraint — everyone agrees context matters; few compile it into a gate. That is the sharpest edge to defend.
*(Next signals append here as they enter the ledger.)*
## Where consensus is firm vs. still forming
| Converged principle | Consensus | Note |
|---|---|---|
| Spec/intent-as-plan | **Firm** | BDD/spec-first is table stakes across SDD tools, superpowers, and Google SRE |
| Independent verification (no self-grade) | **Firm** | Now stated by the model vendor (Anthropic SDK ranks LLM-judge *last*), the methodology lane (superpowers fresh-subagent review), and Google SRE — not just us |
| Deterministic gates over trust | **Firm** | CI-as-authority / safe-by-default actuation / "rules-based feedback best" is the shared answer across all three vantage points |
| Context as a compounding artifact | **Firming** | Anthropic Skills + compound-engineering converge on portable/compounding context; few make the *corpus the moat*, fewer still compile it to a gate |
| Knowledge → a constraint (gate/test/rule) | **We're ahead** | The one invariant the cluster consistently *misses* — compound-engineering stops at prose notes; this is the sharpest edge to defend |
| Autonomy ladders / progressive authorization | **Forming** | Google's L0–L4 is the sharpest articulation; ours is implicit (gap: `ag-wrom`) |
| Fix-forward vs. rollback at velocity | **Open** | Google argues rollback breaks at 4x (Intervening-PR Problem); our coherent-arc favors clean revert (gap: `ag-7278`) |
| Eval-data maturity vocabulary | **Forming** | Bronze/Silver/Gold + True-vs-Observed-Precision worth adopting (gap: `ag-fjbu`) |
## Why we're early — and the honest risk
Early is not the same as right-forever, and the moat is not the idea.
**Ideas converge** — that is the whole thesis of this page. So being first to *articulate* "bounded autonomous loops + context-as-moat + deterministic enforcement" buys positioning, not defensibility. As the consensus firms, the *concepts* commoditize. Where defensibility actually lives:
- **The compounding corpus** — the `.agents/` context that gets better every session is owned, not copyable from a README.
- **The encoded loop in execution** — doctrine that is wired into gates, schemas, and the ratchet, not just written down.
The risk to name plainly: if we let the corpus and the encoded loop stagnate and lean on "we said it first," convergence erodes the edge. The ledger is a morale-and-marketing asset; the corpus is the actual moat. Keep them in their lanes.
## How to read a new signal (the rubric)
When a lab, vendor, or methodology ships something, run it through this before adding a ledger row:
1. **Which invariant did they hit?** Name it from the four above (or the supporting shape). "They use agents" is not convergence.
2. **Ahead or behind us on it?** Be honest. If they are ahead (as Google is on fix-forward), that is a *gap*, not a footnote.
3. **Does it expose work for us?** If yes → file a bead, link it from the ledger row.
4. **Update this synthesis.** Add the signal to *The pattern across signals*, and move any cell in the firm/forming table that just shifted.
5. **Add the dated row** to the [Ledger](ledger.md).
---
*Evidence: [Convergence Ledger](ledger.md) · Thesis being converged on: [3.0 north star](../3.0.md) · Competitor map (the inverse axis): [Competitive Radar](../comparisons/competitive-radar.md).*
docs/documentation-index.md
+7
View File
@@ -218,6 +218,13 @@ Bridge / framing docs:
- [vs everything-claude-code](comparisons/vs-everything-claude-code.md) — AgentOps vs `affaan-m/everything-claude-code` (cross-harness lane)
- [Competitive Radar](comparisons/competitive-radar.md) — Current market read and improvement pressure
## Convergence
- [Convergence Overview](convergence/index.md) — The industry arriving at the structure AgentOps runs (vindication, not competition)
- [The Reading](convergence/the-reading.md) — Living thesis: the industry is converging, and here's the mechanism why
- [Convergence Ledger](convergence/ledger.md) — Dated receipts: external parties independently arriving at the AgentOps thesis
- [Google SRE](convergence/google-sre.md) — Encoding map: where Google's 2026 SRE AI whitepaper aligns with AgentOps doctrine, point by point
## Positioning
- [Positioning Overview](positioning/README.md) — Product and messaging foundations
mkdocs.yml
+12
View File
@@ -10,6 +10,13 @@ edit_uri: edit/main/docs/
docs_dir: docs
site_dir: _site
# Operationalized methodology corpora are repo artifacts (kernel + operator library
# + validators + a fair-use quote bank), not website content — kept tracked in the
# repo but excluded from the published site (avoids re-hosting source material and
# keeps internal scaffolding out of nav/search).
exclude_docs: |
convergence/operationalized/
# Keep building even when the knowledge graph links outside docs/ (e.g., ../skills/).
# Strict link checking runs as a separate CI job via tests/docs/validate-links.sh + lychee.
strict: false
@@ -231,6 +238,11 @@ nav:
- vs Superpowers: comparisons/vs-superpowers.md
- vs Claude-Flow: comparisons/vs-claude-flow.md
- vs Compound Engineer: comparisons/vs-compound-engineer.md
- Convergence:
- convergence/index.md
- The Reading: convergence/the-reading.md
- Ledger: convergence/ledger.md
- Google SRE: convergence/google-sre.md
- Reference:
- reference/index.md
- Glossary: GLOSSARY.md