There is a classic tragedy unfolding every single afternoon across thousands of engineering laptops: an AI agent spends forty-five minutes navigating a labyrinthine microservice dependency graph, hits three subtle API traps, discovers a brilliant one-line workaround, passes every test—and then the terminal tab closes.
Poof. Amnesia. Tomorrow morning at 09:00, your colleague’s agent on the very next desk will cheerfully walk into the exact same three API traps like a golden retriever chasing a frisbee into a glass door.
As we kicked off week one of the Google AI Café (Connected Cup) here in Brussels yesterday, between two flat whites and a spirited debate on European digital sovereignty, one architectural question kept coming back to the counter: How do we turn ephemeral individual agent breakthroughs into durable, verifiable institutional memory?
The answer isn’t “dump ten gigabytes of raw JSONL chat logs into a vector database and pray for cosine similarity miracles.” Instead, a remarkably clean three-layer stack has crystallized over the past few months—uniting Dream-RSI, Guillaume Laforge’s Antigravity Brain Visualizer (now at v0.6), the WikiSkill institutional compiler paradigm, the Open Knowledge Format (OKF), and the rapidly evolving skills.md ecosystem.
Let’s unpack how these pieces fit together—and why portable, Git-backed knowledge is becoming the most important asset in modern software engineering.
1. Driving Individual Knowledge: When Agents Dream (Dream-RSI) and Developers Peer Inside (Brain Visualizer v0.6)
Before an organization can curate collective wisdom, an individual agent (and its human pair-programmer) needs a way to make sense of its own execution history. Two breakthroughs attack this problem from complementary angles: autonomous offline introspection and interactive human-in-the-loop debugging.
A. Dream-RSI: History Is the World the Agent Dreams In
In Dream-RSI: Recursive Self-Improvement through Evolving Worlds, researchers asked a deceptively simple question: How can an agent improve its exploration strategy without burning astronomical compute budgets or hallucinating inside an approximate world model?
Their thesis is poetic and ruthlessly practical:
“An agent must dream to recursively self-improve. History is the world it dreams in.”
Instead of training a separate, lossy neural simulator of the environment, Dream-RSI treats the agent’s own accumulated discovery tree—every branch tried, every dead end encountered, every state transition verified—as an exact, zero-hallucination offline replay simulator. During its “dreaming” phase, the agent replays its historical discovery tree at near-zero marginal cost, stress-testing counterfactual exploration policies until it learns how to discover faster before stepping back into the live environment.
B. Guillaume Laforge’s Antigravity Brain Visualizer (Now at Release v0.6!)
While Dream-RSI teaches agents to replay their own trajectories mathematically, human engineers still need X-ray vision into what their coding agent actually did, why it chose tool A over tool B, and where the context window went sideways.
Enter Guillaume Laforge’s Antigravity Brain Visualizer, which just reached Release v0.6. If you haven’t pointed it at your ~/.gemini/antigravity/brain directory yet, stop reading for thirty seconds and run npx @glaforge/antigravity-brain-visualizer.
What makes the evolution through v0.6 such a game-changer for individual developer knowledge?
- Contextual Smart Chat Over Agent Trajectories: Introduced in Guillaume’s deep-dive post, you no longer have to scroll blindly through hundreds of raw
PLANNER_RESPONSEand tool-call steps. You can open an interactive chat panel grounded directly in the active conversation trajectory and ask: “Why did the agent abandon the first database migration approach at step 42?” or “Which files were modified before the test suite passed?” - Single-Pass Gemini Flash Trajectory Analysis & Cost Telemetry (
v0.6): Releasev0.6consolidates multi-step inspection into a blazing-fast single-pass analysis powered by Gemini Flash, surfacing token consumption heatmaps, step latency bottlenecks, and artifact lineages at a glance. - Ad-Hoc Skill Extraction: Once you and the Contextual Smart Chat identify a clever problem-solving pattern inside a messy debugging session, Brain Visualizer helps you extract that hard-won workflow directly into a reusable skill draft.
2. Crossing the Chasm: From Individual Brains to Institutional Knowledge Curators (WikiSkill & OKF)
Here is the catch: an insight trapped inside a single developer’s brain/ folder—or inside an agent’s local replay tree—is still individual knowledge. How do you promote it to institutional knowledge without polluting your team’s repository with brittle, over-fitted prompt hacks?
This is the exact problem solved by WikiSkill: Compiling Agent Experience into Persistent Knowledge for Skill Evolution (arXiv:2608.27454) and standardized by Google Cloud’s Open Knowledge Format (OKF).
Diagram 1 — The 3-stage pipeline turning individual trajectory introspection (Dream-RSI and Antigravity Brain Visualizer v0.6) into compiled institutional catalogs (WikiSkill + Open Knowledge Format) and executable skills.md capabilities.
Why Direct “Trajectory-to-Skill” Synthesis Fails at Scale
Most early self-improving agent frameworks tried to jump straight from raw execution transcripts (transcript.jsonl) to executable skills (SKILL.md). As arXiv:2608.27454 (WikiSkill) demonstrates, skipping an intermediate knowledge layer creates two fatal pathologies in enterprise teams:
- Context Overfitting: An agent turns a one-off incident workaround (e.g., “restart pod X on Tuesday because port 8081 was wedged”) into a permanent procedural rule.
- Knowledge Fragmentation: Ten different skills end up embedding ten slightly contradictory copies of the same underlying domain architecture. When your cloud landing zone or API contract changes, you have to hunt down and patch twenty procedural prompts instead of updating one canonical source of truth.
WikiSkill introduces a compiler architecture that decouples what is true about our system (Persistent Curated Knowledge) from how an agent executes a specific task (Executable Skills).
Enter the Open Knowledge Format (OKF)
To make that middle layer—the Institutional Knowledge Curator—portable across every cloud service, IDE, and agent framework, Open Knowledge Format (OKF) defines a clean, Markdown-first, Git-native specification:
- Dual Human & Agent Ergonomics: Every OKF document combines strict, schema-validated YAML frontmatter (domain taxonomy, ownership, freshness SLAs, upstream references, and dependency graphs) with crisp Markdown prose and architecture diagrams that human engineers actually enjoy reading in code review.
- Native to Google Cloud Knowledge Catalog & Git: Because OKF lives right inside your version-controlled repositories and syncs seamlessly with the Google Cloud Knowledge Catalog, institutional knowledge stops being a graveyard of forgotten Confluence pages and becomes compiled infrastructure.
3. Adjusting to the Constant Evolution of skills.md: Keeping Shared Knowledge Up-to-Date, Trusted, Verifiable, and Traceable
If OKF is the curated encyclopedic cortex of the organization, skills.md is the motor cortex that lets agents act on the world.
Today, skills.md gives agents running across Antigravity, Claude, Codex, Cursor, OpenCode, and MCP hosts instant access to 250+ modular capabilities via a single unified API (POST /v1/run/{skill}). Even more importantly, skills.md introduces runtime primitives that enterprise security teams have been begging for: scoped keys, human approval gates, execution logs, and cryptographic receipts.
Diagram 2 — The four governance pillars uniting Open Knowledge Format (OKF) catalogs with evolving skills.md execution contracts over the long term.
As skills.md specifications, MCP tool schemas, and underlying model capabilities evolve week after week, static documentation rots in days. Combining OKF with WikiSkill compilation and skills.md runtime governance anchors shared organizational knowledge on four non-negotiable pillars:
| Governance Pillar | Why Raw Prompts & Wikis Fail | How OKF + WikiSkill + skills.md Solve It |
|---|---|---|
| 1. Up-to-Date (Living Evolution) | Tribal knowledge and copy-pasted system prompts silently drift out of sync when APIs, SDKs, or policies change. | WikiSkill compilation continuously diffs live agent trajectories (via Brain Visualizer v0.6 & Dream-RSI) against OKF domain invariants, flagging stale assumptions and recompiling downstream skills.md specs automatically. |
| 2. Trusted (Scoped Governance) | Anyone can drop an unvetted SKILL.md into a repo or grant an agent overly broad credentials. |
OKF enforces explicit code-owner curation (CODEOWNERS), while skills.md enforces scoped API keys and mandatory human-in-the-loop approval gates before high-impact operations execute. |
| 3. Verifiable (Deterministic Proof) | You can’t run a unit test on a vague paragraph in a shared doc. | Every OKF artifact validates against strict schemas, and every compiled skill is replay-tested offline against historical failure trees (Dream-RSI) and hermetic evals before promotion. |
| 4. Traceable (Long-Term Provenance) | Six months later, nobody remembers why an agent rule was added or which incident triggered it. | Every OKF update carries Git commit lineage linking back to the exact Brain Visualizer trajectory ID (#conv), while skills.md emits immutable execution receipts for end-to-end auditability. |
4. Let’s Meet at the Google AI Café in Brussels! (Hands-On ADK Hacking This Friday 25th—or Coffee, Tech & Policy Anytime)
Theory and architecture diagrams are great, but nothing beats opening a laptop over a freshly pulled espresso and building these workflows live.
All month long (from September 21 through October 16, 2026), the Connected Cup — Google AI Café is open right here in Brussels’ EU Quarter.
If you want to get your hands dirty turning individual agent trajectories into curated OKF catalogs and production-ready ADK skills, come join me and the team this Friday:
- Hands-On Hacking (
ghacks.dev@ Connected Cup): Introduction to Agents with Agent Development Kit (ADK) - When: This Friday, September 25, 2026 ·
10:00 – 13:30 CEST - What we’ll do: We’ll wire up multi-agent orchestration with ADK (
adk.dev), inspect our agents’ brains with Brain Visualizer v0.6, structure portable domain knowledge in OKF, and connect verifiableskills.mdcontracts.
Can’t make it this Friday morning? No problem at all! The Connected Cup programme runs for four full weeks. Ping me or drop by the AI Café later next week or in October for a specialty coffee and a candid chat about AI architecture, verifiable knowledge, and European tech & policy :-)
- RSVP for Friday Sept 25th (
10:00–13:30) — Introduction to Agents with ADK - Explore the Full 4-Week Brussels Google AI Café Programme
See you near Schuman—bring your toughest agent trajectories, and the coffee is on us!