A rare enterprise production record: a self-built agent loop, an A2A contract, sandboxing and humans in the loop, end to end
Agents in Production: How OpenGov Built and Scaled OG Assist - Gabe De Mesa, OpenGov · Gabe de Mesa
18 min total·Actually worth watching closely: ~7 min·3 must-watch clips
- 0:00 – 2:04Listen
What OG Assist is and why it exists
Opens with OpenGov's business context and where OG Assist sits: a single AI assistant entry point embedded across the whole product line.
OG Assist isn't a one-off feature — it's a platform-level bet spanning every product.
Pure background and motivation, no key visuals; fine to listen to while doing something else.▶ Jump to 0:00Speaker · Gabe de Mesa - 2:04 – 5:00Watch
Embedded in every nav bar, plus frontend capabilities
Shows OG Assist as one button in the navigation bar of all products, aware of the product you're currently in, and able to see your screen and highlight the next step.
Frontend capability — seeing the screen, acting on page elements — turns the agent from a Q&A tool into a hands-on guide.
This stretch has real footage of the in-product embed and the screen highlight (124s, 183s and 239s were all flagged worth capturing) — the most visually dense product demo in the talk.▶ Jump to 2:04Speaker · Gabe de Mesa - 5:00 – 7:05Skim
Dropping LangGraph for an Effect-native loop
Explains the decision to move off LangGraph to their own Effect AI agent loop once the team scaled: chat and language model as core primitives, models hot swapped through dependency injection.
Scale is the dividing line on framework choice — built-in schema, logging and end-to-end tracing give more control than an off-the-shelf framework.
The core-primitives explanation at 406s is a code slide; a glance at the shape is enough — the real argument for the migration is in the narration.▶ Jump to 5:00Speaker · Gabe de Mesa - 7:05 – 10:00Listen
The A2A contract and the eval feedback loop
Google's A2A protocol (schemas like the agent card) as the contract both frontend and backend consume and produce; thumbs up / thumbs down in the interface plus automated evals in CI keep iteration fast.
"Shipping is the start, not the finish" — a rigorous spec as contract, and evals against real completions, are the foundation for fast iteration across teams.
Mostly architecture and process argument, with no frames flagged worth watching; good for listening closely.▶ Jump to 7:05Speaker · Gabe de Mesa - 10:00 – 11:40Watch
Humans in the loop and sandboxed execution
Tool calls needing approval deterministically interrupt the agent loop and show a UI for the human to accept or reject; code execution and file creation happen in sandboxes that get torn down at the end.
Humans stay in the driver's seat on mutating operations, and sandbox isolation removes the risk to production systems — trust is designed in.
The approval dialog at 625s and the sandbox-generated PDF at 663s are both concrete on-screen moments; watching them beats hearing them described.▶ Jump to 10:00Speaker · Gabe de Mesa - 11:40 – 14:05Listen
Rolling summarization for long context
A running summary after every N messages while keeping only the most recent few raw ones; recall over that summary is the memory component, reaching back a hundred messages.
Rolling summarization plus recall over the summary — more effective than always stuffing in the latest and most recent messages.
The mechanism is described clearly and completely; you can follow it by ear.▶ Jump to 11:40Speaker · Gabe de Mesa - 14:05 – 16:15Watch
UI on the fly and end-to-end observability
Pre-registered UI primitives like forms let the agent render a personalized interface on demand; Effect tags functions with spans automatically, feeding traces you can drill down through across services.
"You can't scale what you can't see" — observability is the precondition for scaling an agentic system.
The dynamically built form at 855s is worth seeing, and the trace drill-down at 913s makes the observability argument concrete.▶ Jump to 14:05Speaker · Gabe de Mesa - 16:15 – 18:27Skim
Tools and skills are all you need
Walks through Get Dad Joke as the building-block pattern — make a tool, add it to a toolkit, register the toolkit with the language model — the pattern each product team follows, then touches on internal developer velocity.
One shared tool/toolkit building-block pattern is the organizational answer to many product teams powering the same agent.
The 979s example is a code slide; skimming the structure gets you the pattern, and the closing velocity section is fine to just listen to.▶ Jump to 16:15Speaker · Gabe de Mesa