AI Engineer World's Fair 2026

Agents in Production: How OpenGov Built and Scaled OG Assist

Loading slides…

Read the talk

Agents in Production: How OpenGov Built and Scaled OG Assist

OpenGov’s assistant connects product data and page actions to an Effect-based agent loop, with shared contracts, human approvals, isolated execution and production feedback.

From a talk by Gabe De Mesa

Before you start: Basic familiarity with TypeScript, language-model tool calls and frontend/backend application boundaries will help you follow the implementation discussion.

A rate-code question inside utility billing

How should an assistant answer a question about rate codes when the user is already working inside utility billing? For Gabe De Mesa, a software engineer on OpenGov’s AI agents team, the starting point is the application itself. OpenGov builds ERP software for budgeting, procurement, asset management and permitting, with a mission of supporting more effective and accountable government. De Mesa describes a company founded roughly fourteen years before the talk, now adding an agent interface across its products.

OG Assist is a shared entry point to product-specific capabilities. Its button sits in the navigation bar, while individual product teams supply the tools and skills behind it. In the utility billing demonstration, the user opens the assistant and asks about rate codes. The agent calls tools against that suite’s data, then presents a rate-code table and quick takeaways alongside the workspace. The chat interface is useful because it can reach the information in the product the user is actually using.

OpenGov utility billing interface with an OG Assist sidebar showing a rate-code table and Quick takeaways, beside the heading Software for more effective, accountable government.Open full source frame
OG Assist displays rate codes and quick takeaways beside the utility billing workspace.
1:512:07
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

1:51 · section reference included

From answering questions to acting on the page

OG Assist began when a principal engineer formed an AI agents team and invited De Mesa to join. As the assistant spread across OpenGov’s products, the integrations grew to include both backend capabilities and frontend interactions. The agent could inspect what was on the screen and take action on the page.

The next demonstration asks the assistant to identify what is on screen and highlight possible next steps. The agent considers its available tools, selects a page interaction and highlights a clickable element while explaining it. That adds a different kind of help to the rate-code lookup: the assistant can guide someone through the interface in which the work happens.

3:273:42
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

3:27 · section reference included

Owning the agent loop with Effect

The team chose Effect, an open-source TypeScript library, as its foundation. Its schema facilities serve a role comparable to Zod, while error handling, logging and tracing provide common infrastructure for services. De Mesa credits that combination with helping the team structure its architecture and build the core agent loop.

The first loop used LangGraph, which initially met the team’s needs. As the team grew and its use cases evolved, it moved to an Effect-native implementation so it could directly change the loop for complex features. Owning the loop gave the team control over orchestration while keeping tracing, structured concurrency and logging in the same programming model. The motivation was control over evolving behavior, rather than a reported performance comparison between frameworks.

The demonstrated Effect AI building blocks are a chat abstraction and a language-model abstraction. The application instantiates a chat, passes a prompt to streamText and receives streamed output. Dependency injection supplies the underlying language model, allowing the team to swap it without replacing the surrounding orchestration. The linked Effect v3 AI documentation labels its integrations experimental; the talk’s Chat/streamText demonstration should therefore be understood in its package-version context, rather than as a pinned current API recipe.

4:354:48
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

4:35 · section reference included

A shared contract for frontend and backend

For the boundary around that loop, the team adopted Agent2Agent, or A2A, the open protocol introduced by Google for communication between agents. OpenGov also found it useful as an application contract: backend routes, models and schemas follow the specification. An Agent Card, for example, describes an agent through fields such as its name and description.

That shared specification gives frontend and backend developers the same structures to consume and produce. Instead of independently designing both sides of each interaction, they can align on a common contract. De Mesa also points to A2A extensions, including metadata, and mentions A2UI as a related possibility. Those extension possibilities are separate from the runtime-form demonstration later in the talk; he does not identify that form as an A2UI implementation.

7:417:54
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

7:41 · section reference included

Production feedback and CI evaluations

“Shipping is the start, not the finish.” OG Assist collects feedback through calls and email, but its main in-product mechanism is a thumbs-up or thumbs-down response rating. That gives users a direct way to flag a useful answer or a poor one, and gives the team a signal to investigate and improve future responses.

Automated evaluations complement that feedback. In CI, the team runs prompts against real completions and checks behavior: did the agent call the expected tools, and did it perform the intended task? These checks and user reports feed changes to the tools, skills and harness—the system that runs the agent. De Mesa reports that the combination helps the team improve responses and iterate quickly, without supplying an accuracy score or an evaluation pass rate.

9:169:29
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

9:16 · section reference included

Interrupt before an approval-required action

When a tool call requires human approval, OG Assist deterministically interrupts the agent loop and displays an accept-or-reject interface. The model’s decision to request a tool call does not itself authorize execution. The human explicitly accepts or rejects the proposed action, a boundary De Mesa emphasizes for mutating operations. This applies to calls designated as requiring approval, rather than necessarily to every tool invocation.

A small TypeScript example makes that boundary explicit. The approval function represents the UI decision; while it is pending, execute has not been called. A rejection returns without executing the proposed operation.

typescript

type ProposedCall<T> = {
  name: string;
  requiresApproval: boolean;
  execute: () => Promise<T>;
};

type CallResult<T> =
  | { status: "rejected" }
  | { status: "executed"; value: T };

async function runTool<T>(
  call: ProposedCall<T>,
  requestApproval: (name: string) => Promise<"accept" | "reject">
): Promise<CallResult<T>> {
  if (call.requiresApproval) {
    const decision = await requestApproval(call.name);
    if (decision === "reject") {
      return { status: "rejected" };
    }
  }

  const value = await call.execute();
  return { status: "executed", value };
}

The key property is the placement of the gate in application control flow: approval is a prerequisite for execution, not an instruction the agent is merely asked to remember.

10:3110:51
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

10:31 · section reference included

An isolated place to execute code

Code execution and file creation have another boundary: an ephemeral sandbox. OG Assist provisions these environments on demand so the agent can write code, execute it and create files in an isolated space. The environments are torn down afterward. De Mesa presents this isolation as protection for production systems; the talk does not specify the sandbox provider or its precise isolation guarantees.

The demonstration asks the agent to create a PDF for attendees of AI Engineer Conference 2026 and make it downloadable for sharing. The agent creates the PDF inside the sandbox, and the resulting conference greeting appears on screen. This gives the execution environment a concrete purpose: the assistant can deliver a file, extending its output beyond a chat response.

Blue AI Engineer Conference 2026 greeting artwork beside the heading Room to act, safely and text describing isolated code execution.Open full source frame
The generated conference greeting appears beside the sandboxing explanation.
11:1311:29
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

11:13 · section reference included

Keep a running summary, not just recent messages

As conversations grew, OG Assist encountered token limits and overloaded context, particularly with older models. The team found rolling summarization more effective than continually filling the prompt with the latest messages. A running summary preserves earlier context while a recent-message window retains the immediate conversation.

De Mesa describes summarizing after N messages and retaining a recent window such as N − 5 or N − 10 messages. These are illustrative choices, not a disclosed production configuration. The reason to preserve a summary becomes clear when a user returns to a topic from 100 messages earlier: a recent-only window may have dropped it, while the summary can still retain a useful detail.

Recall then operates over what the summary preserved. When the user asks whether the agent remembers an earlier topic, it can use that retained tidbit to continue the thread. This is memory within the conversation, with the summary carrying context forward; it is not a promise that every detail of the original history remains available.

12:2712:49
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

12:27 · section reference included

Generate choices with a registered form

The next request asks for a long essay, along with suggestions for what it could cover. OG Assist has a registered form primitive, which the agent uses to build a form at runtime and offer selectable topic options. The application supplies a UI capability, and the agent fills it with choices relevant to the current request. That lets the conversation collect a decision through a form instead of requiring another free-text exchange.

14:1114:20
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

14:11 · section reference included

Follow work across service boundaries

“You can’t scale what you can’t see” introduces the observability layer. De Mesa describes how Effect spans feed traces and let the team drill into function calls. Effect provides built-in tracing support, but arbitrary functions do not all become traced automatically: the Effect tracing guide explicitly instruments effects with Effect.withSpan and configures trace export.

The illustrated trace comes from the Effect team. It follows a request through an API, an endpoint and a handler, exposing the nested work behind the request. Timing those spans helps locate bottlenecks; tracing failures across services helps connect an agent error to another team’s API or a platform capability. For an assistant assembled from many integrations, that visibility supports debugging and maintenance across the whole request path.

14:5315:10
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

14:53 · section reference included

Build capabilities from tools and toolkits

Alongside Effect, the team’s other major commitment is to tools and skills. The concrete example is GetDadJoke, drawn from the Effect AI tool-use tutorial. It illustrates how a callable capability becomes available to a language model.

The construction proceeds in three steps:

  1. Define a tool for the operation the agent can request.
  2. Add it to a toolkit, a collection of available tools.
  3. Supply the toolkit to the language model so it can request those operations while answering a prompt.

With a prompt asking for dad jokes about pirates, the model has a relevant tool available to help produce its response. De Mesa presents this pattern as the foundation for OpenGov’s tools and, eventually, skills, though the walkthrough does not introduce a separate skill implementation. The recommendation is to start with these Effect AI building blocks and compose capabilities around them.

16:1916:31
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

16:19 · section reference included

Use agents to build the product

The same approach extends to OpenGov’s own development work. The team uses Claude and Cursor, and builds internal tools and skills alongside those exposed to customers. De Mesa also mentions Claude Agents as part of that workflow. These agents help engineers read, write and review code, then ship it. He describes a substantial acceleration qualitatively, without a productivity benchmark: the team developing the customer-facing harness is also creating capabilities that help it develop that harness.

Terminal screenshot beside Building agents with agents, with text naming Claude Code, Cursor and cloud agents for writing, reviewing and shipping.Open full source frame
Building agents with agents: a terminal example accompanies OpenGov’s developer workflow slide.
17:3817:55
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

17:38 · section reference included

Resources

From the talk

Transcript download
Full transcript

Loading transcript…