← Selected work

The rise of functional agents

A one-hour live session on functional copilots, with a demo built to be repeatable and the skills released so the audience could build their own that evening.

Context
CopilotKit
Contribution
Talk, deck, live demo, skills & starters
Period
November 2026
Explore
Skills and starters on GitHub ↗
Full session · 58 minutes · 720p copy of the X broadcast, re-encoded for the web, with captions. Nathan Tarbert opens; the talk starts at 8:09, the Open Harvey demo at 39:44, CLiF at 46:55 and the Q&A at 53:28.Open video ↗
live on Zoom and X, with a demo built for it
58 min
animated slides, published as code and PDF
41
Claude Code skills released, with four starters
5

Session: November 5, 2026, 10am PT, hosted by CopilotKit on Zoom and streamed to X and LinkedIn. Over a few hundred people registered, by Nathan’s count at the top of the recording; the opening poll put the room at roughly 60% engineers, 20% leaders and 15% designers. Slide, skill and starter counts from the two public repositories on November 6, 2026. Every company, person and contract in the demo is fictional. Open Harvey is an open-source demo built with CopilotKit, not affiliated with or endorsed by Harvey.

On November 5, 2026, Nathan Tarbert and I ran a CopilotKit live session called The rise of functional agents. A functional copilot is an agent built for one business function (legal, HR, finance, IT, support) that takes one real workflow from the first question to an approval-ready result, with the people who own it in control. I wrote the talk and the 41-slide deck, built the Open Harvey demo and its OpenBot twin, and released the five Claude Code skills and four starters so anyone could build their own in an afternoon. The recording, the deck, and a transcript live on this page so they do not depend on the broadcast staying up.

One function, one workflow, a person on every call.

Coding went first: Cursor forked an editor and put the agent where developers already work. Legal, support, healthcare and finance followed, and inside companies, developers are now being asked to build the same thing for their own functions. The session’s frame was the gap between a chat assistant and a functional copilot: not answering questions about contracts, but reading the open matter, checking every playbook rule with a citation, drafting the redlines in the review table, routing approvals by rule, and proposing a rule when the same send-back keeps coming back. The upside is hours back every week. The catch is that it cannot go off the rails, so the hour was built around that.

One story carried the whole hour.

Instead of a feature tour, the talk follows one contract from Thursday morning to signed on Friday. Maya Chen, senior counsel at the fictional Northstar Software, gets Acme Cloud’s master services agreement: 14 sections, $240,000 a year for three years, pricing that holds until next Friday. The copilot proposes a 17-task plan and runs nothing until she approves it, works the checklist down in front of her with every finding cited to the passage, finds seven deviations, drafts a redline for each, and works out the three approvers from the rules. Security sends it back for the same missing evidence for the fourth time, and the copilot proposes the rule nobody had written down. The general counsel publishes it, and that afternoon the next contract gets the task without anyone asking. Every number and route comes from tested code, never from the model.

From a role to a copilot, in five steps.

The method is a small suite of Claude Code skills with one entry point. /user-map researches the role, its software and its jobs to be done. /agent-context maps what the agent can see and reach, from the open matter in the app out through local files, server tools, org systems over MCP, people in Slack or Teams, coworkers on OpenBot, and memory. /functional-copilot interviews you, writes a spec on the seven-layer functional agent stack, and writes no code until you approve it, then adapts a starter. /deploy prepares the host and stops at “needs your yes”. /secure-governance runs the pilot-to-production checklist: six items to a safe pilot, sixteen to production. Each step ends in a page you keep open. In the app, four CopilotKit hooks do the work: what the agent sees, what it can do, what it shows, and what waits for a person.

A live demo that cannot drift.

Open Harvey, the contract-review copilot, is a Next.js app on the CopilotKit runtime and AG-UI with one built-in agent. For the session it ran on a scripted stand-in model: the runtime, the AG-UI events, the tools and the cards are the real ones, only the model is scripted, and it paces the checklist at about 0.6 seconds a task so the audience can watch it work. The same app runs on a real model with a key. Its unit tests cover every finding, number and route, and one test plays the whole demo against the mock with the real tool handlers. Live, I had switched the agent process off by accident a minute before the demo; it was back up in two, and because the run was scripted it could not drift once it started. The point I made over the demo was trust: a professional needs to see the plan before it runs and the work as it happens, not a finished contract in a dropdown. A second starter packages the same copilot as a coworker in OpenBot, with a tested MCP server that owns every finding, an ask-first rule before anything is resubmitted, and an audit trail. The headcount starters apply the same blueprint to HR and finance.

Then make it safe to ship, and let it learn.

The production half of the hour covered where each piece runs (the browser, your cloud, a sandbox only if the agent runs code it writes, and Intelligence for threads and memory), governance in code rather than in the prompt (named approvers, routing by rule, an audit trail in the approver’s own words), and what OpenBot ships for enterprises: SSO, roles, a gateway that fails closed, ask-first rules, audit, logs to your SIEM, encrypted secrets, your own hosting. It closed with CopilotKit’s answer to “it’s live and not working as well as you want”: Continual Learning from Full-Stack Trajectories, which adds the user’s side of the work to the agent’s trace, because only the full stack shows what actually worked.

The deck is code, and everything is public.

The slides are 41 HTML sections in a small static player I wrote for them: sandboxed embeds for the canvas and SVG animations (the agenda wave, the dot-matrix numbers, the context rings, the pulses travelling along the AG-UI line), inline icons, connectors drawn in slide coordinates, and builds that step on a key press or play on their own. An export mode lays every slide out as a page with each animation on its still frame, and a script prints that to the PDF. The deck, the player, the PDF and a 72-second tour of the animations are in one repository; the skills, the starters, the story and the decision checklist are in the other. This page keeps its own copy of the recording and a Whisper transcript.

Next projectSpace concept film