Chris Chabot

Chris Chabot, Member of Technical Staff, building agent platforms

Getting an agent through a demo is the easy part. I design and build the infrastructure required once agents run unattended and other teams rely on the platform: runtimes and orchestration, SDK contracts, memory, permissioning, and the evaluation and verification that gate releases.

Loose strokes of rust, dark green, plum and ochre cross scraped chalk openings.

Selected work

  1. Verifying a coding agent port without a model in the loop

    A production coding agent of about 340,000 lines of Python, built by my colleagues, moved to TypeScript with one requirement: byte-identical behaviour in everything not specific to the new platform. I designed the method and directed the agents: a formal model, a checklist generated from the syntax tree, clean-context review, then replay.

    designed, directed, reviewed, verified

  2. Putting scripts in charge of agent-run releases

    Releasing an agent-native cloud platform: scripts decide what ships and agents diagnose what failed, the experience an agent has building on the platform is benchmarked and gated like a latency budget, and the largest tenant is reshaped to fit the platform rather than the limits raised.

    designed, verified, operated

  1. Enforcing wire, identity, and approval contracts in an agent platform

    What crosses a boundary has to be checkable data: wire formats, delegated identity and single-use approvals verified where they are used, across five language SDKs, and shared code copied with signed provenance instead of pulled through a dependency chain.

    designed, led

  2. Proving the harness before scoring the agent

    Before asking whether a change helped an agent, I want to know whether the comparison actually contains the change. The tooling here treats each run's configuration as a claim to be checked, and keeps corrections beside the original record rather than over it.

    designed, built

  3. Getting an agent coordinator to brief like a product manager

    What changes when a coding conversation becomes a project that keeps running while you are elsewhere, and what a coordinator and its workers need in order to stay useful when there are a hundred of them.

    designed, directed

  4. Replaying injected memory without breaking extended thinking

    Agent memory has to enforce tenant isolation, surface current facts over stale ones, and stay within the latency budget of the next reply.

    designed, built

  5. Letting an agent diagnose production without giving it a shell

    Agents work best with broad, redacted reads and narrow, reversible writes: a view of production they cannot damage, guardrails kept off the hot path, and a browser whose unboundable parts stay switched off.

    designed, built

Public code

All public projects

Earlier products, open source and standards

  • Apache Shindig for PHP

    Chief author of the PHP implementation of the OpenSocial container; PMC member and committer.

    built, from 2008

  • OpenSocial

    A common API for social applications across participating networks.

    co-authored, contributed, from 2007

  • Portable Contacts

    A simple XML and JSON protocol for address books and friends lists over HTTP.

    co-authored, 2008

  • OAuth 2.0

    The framework for granting applications limited, scoped access to an HTTP service.

    contributed, 2012

  • OpenID Connect

    An interoperable answer to "who signed in?" on top of OAuth 2.0.

    contributed, 2014

  • Google+

    Founding member of the project; led the platform's developer launch and API ecosystem.

    contributed, led, from 2010

All earlier work

Latest writing

  1. Deterministic wakes, reports, and memory for long-running agents

    How deterministic code can own wakes, reports and memory for long-running agents, with event batching and cold resets timed by the prompt-cache lifetime.

    SelectedOrchestrationMemoryAgent systems

  2. Keeping agent guardrails off the hot path

    How to keep an agent's guardrails off the hot path: four ordered checks, a judge that never sees untrusted text, and owner interruptions budgeted like latency.

    SelectedSecurityAgent systemsPerformance

  3. Designing out shared fate in an agent runtime

    Why process-per-agent is affordable once idle agents unload, how to fence a single SQLite writer, and why a plan that resends history makes the cached prefix the cost model.

    RuntimeStoragePerformance

  4. Treating a sixteen-agent build like a production system

    Running a sixteen-lane agent build like a production system: reviewing specifications at their seams, a rival design as adversarial review, and measuring friction from session logs.

    OrchestrationAgent systemsPerformance

  5. Moving a cloud coding agent to a Mac with consumer-driven contracts

    Running a cloud coding agent on one Mac by building shims from its call sites, mirroring upstream unedited, and reviewing each change from the goal and diff alone.

    PortingRuntimeVerification

All technical writing

Latest essay

The boat at night

June 2026

All essays

Dark ink blue and black passes drag diagonally from upper right, opening a crooked chalk strip with an ochre smear and silver-grey scumble.