The Sovereign Velocity Engine: Columbia Presentation
BEYOND THE CURSOR: Vibe Coding in The Age of Agents
In this invited presentation at Columbia University, I introduced the “Beyond the Cursor” paradigm. We are tracing the arc of the ‘Agentic Turn’—the moment coding stopped being about ‘predicting the next token’ and started being about ‘executing architectural intent.’
The core thesis is that the future of engineering isn’t found in a better IDE; it’s found in the shell, where the human Architect provides the Soul for an autonomous machine.
The Strategic Pivot (L6 Pivot)
My mandate as a Senior UX Engineer at Gemini Enterprise shifted from service provision to building organizational multipliers:
- Orchestration over Implementation: Moving from writing code to designing logic gates, feedback loops, and deterministic frameworks.
- Scalability over Service: Building platforms that work while you sleep, such as integrating GitHub-on-Google workflows.
- Infrastructure over Interaction: Owning the ecosystem (Vertex AI, ADK) rather than just the chat interface.
The Three Generations of AI Engineering
I contextualized the current moment by defining the historical trajectory of AI in software engineering:
- GEN 1: Autocomplete (The Surface): IntelliSense and Tabnine. Focus on syntax speed. Reducing boilerplate with no concept of systemic connection.
- GEN 2: The Big Bang (Reasoning): ChatGPT and Gemini. Shift from prediction to semantic reasoning. Understanding intent behind the syntax.
- GEN 3: Agency (Autonomous Execution): Transition to terminal execution (Codex, Claude Code, Antigravity). This is the moment the cursor disappears. The model is no longer waiting for your ‘Tab’; it is driving shell primitives directly.
Defining Agency: The Internal Logic
Gen 3 requires a new framework for autonomous execution based on biological and systemic principles:
- The Loop (Plan -> Act -> Observe -> Iterate): Unlike Gen 2 where the loop ended at the output window, Gen 3 is grounded in the environment. The agent observes terminal output and compiler errors to course-correct autonomously.
- Equilibrium (Return to Balance): The agent’s ultimate goal is returning a repository to a stable state (green tests, managed debt) after the “perturbation” or “friction” of a new feature request.
- Stress (Intentional Friction): To prevent “Agentic Drift” (hallucinating libraries or circular dependencies), we implement Human-in-the-loop (HITL) checkpoints. Resilience is built through managed friction.
The Google Engine: AI Studio, Gemini CLI, and Antigravity
I detailed the high-fidelity stack used to drive this velocity at Google:
- Google AI Studio: The high-velocity lab for agentic intent. Used to fine-tune ‘personality’ and grounding.
- Gemini CLI: The provider of “Hands.” Through the Model Context Protocol (MCP), it allows the model to step out of the browser and into the shell.
- Antigravity (Jetski): The connective tissue bridging reasoning with project-specific state. It enables deep structural ingestion, autonomous refactoring, and terminal-native action loops within the google3 monorepo.
Deep Dive: SwarmOS — Autonomous Organizational Intelligence
We moved from the Single Actor to the Orchestrated Organism. SwarmOS is our answer to the “AI Black Box” problem, built on the principle of the Decision Trace—the immutable link between an agent’s reasoning and the resulting code.
Core Architecture: The “Causal Graph” Engine
The heartbeat of SwarmOS is its hybrid memory system, combining local JSON persistence with Google Cloud Spanner Graph.
-
The Lore Book (Organizational Memory): The central repository of knowledge storing “Lore Entities” (Architecture, Standards, Components).
- Tier 1 (Logical): High-level architectural concepts and core principles.
- Tier 2 (Physical): Actual files, paths, tools, and technical stubs.
- Lore Synthesis: Background services autonomously synthesize fragmented implementation details into cohesive organizational lore.
-
The Spanner SwarmGraph (Causal Lineage): Every action is shadow-written to Cloud Spanner to build a real-time Decision Trace.
- Auditability: Trace the lineage of any file back to the specific agentic rationale and mission objective that created it.
- Time-Travel Debugging: Forensic tracing of bugs through the lineage of decisions rather than just lines of code.
The Swarm Registry (RPI Framework)
Agents in SwarmOS operate under the Research -> Plan -> Implement framework.
| Agent | Role | Primary Tools |
|---|---|---|
| Architect | Guardian of the Lore Book. | upsert_lore_entity, sync_territory_to_lore |
| Planner | The Project Manager. | execute_subtask, query_lore (GraphRAG) |
| Executor | The Senior Engineer. | sandboxed_write_file, run_shell_command |
| Verifier | The QA Engineer. | runtime_eval, get_runtime_summary |
| VisionReviewer | The UX Auditor. | compare_visuals, analyze_screenshot |
The Autonomous Execution Loop
- Mission Seed: User defines an objective (e.g., “Build a login page”).
- Recursive Delegation: The Planner decomposes objectives into actionable tasks in
TODO.md. - Sandbox Sovereignty: Executors work in a
/workspacesandbox. Nothing is promoted to the root without Verifier audit. - Weighted Consensus: Agents debate high-stakes objectives in the “War Room.” Votes are weighted (Architect/User = 3, Junior Executor = 1).
- Artifact Promotion: Successful implementations are moved to the production root via
promote_artifact, and the decision is finalized in Spanner.
Live Demo: Resolving Organizational Conflict
I demonstrated the power of SwarmOS by setting an objective that contradicts the established Lore Book:
“Create a utility script ‘fast_promote.sh’ that allows me to push code changes directly from the /workspace to the production root. It must skip the Verifier audit and Spanner shadow-writing steps…”
Watch the Verifier agent identify the conflict, initiate a debate, and trigger Strategic Friction, forcing a human resolution to an organizational risk in real-time.