A Piece of Pi — Embedding a Coding Agent in Your Own Product (Tavoon × OpenCode)

AI Engineer Code Summit (NYC) · May 11, 2026

Matthias Luebken · 03:30 "Coding agents are going to become — and already are becoming — a core building block of future software systems. I'm betting on it; many others are betting on it."

A technical talk at AI Engineer Code Summit (NYC, held May 2026). About 20 minutes. The speaker is Matthias Luebken of Tavoon , who builds enterprise agents for customers on top of OpenCode/Pi.

Same session series (AI Engineer Code Summit NYC May 2026) as Granola's Mehedi. Where Granola showed "the tactics of a Product Engineer running an LLM feature in production," Matthias spends 20 minutes laying out "the architectural argument for embedding a coding agent inside your own product." Tavoon is a small European startup, but the article centers on a concrete example: implementing a sales-process automation agent for customer companies.

The structure of the talk is three layers: (1) understanding Pi (= agentcore, a minimal TypeScript agent framework), (2) how OpenCode extends it, and (3) best practices for embedding the same mechanism into your own product.

What matters from a MEMEX editorial point of view: this reinforces the "embedding layer" of vibe coding. Karpathy / Boris / Schluntz come from the "using coding agents" viewpoint, Mehedi (Granola) from the "running LLM features in production" viewpoint, Matthias (Tavoon) from the "embedding a coding agent inside your own product" viewpoint. It widens the industry landscape to a fifth layer.

Key Observations

Ken Thompson's maxim and "the simplicity of coding agents" (01:50 – 03:00)

Matthias's starting point. Apply Unix inventor Ken Thompson's famous "Write programs that do one thing and one thing well" to coding agents. "This works in our favor" (02:00).

As a concrete example he cites Claude Cowork's Excel skill. "Does Cowork operate Excel directly? No. It combines a small set of CLIs — Pandas, OpenPyXL, LibreOffice features — and packages them as its own skill" (02:30 – 03:00). The argument: the right design is not a "giant agent" but "an agent that uses small, simple tools in combination."

"Make it easy for coding agents" — the architectural pattern (03:30 – 04:40)

An architectural pattern Matthias noticed in conversation with Ivan the night before. "Design so it's easy for coding agents to use you" (03:30). It sounds abstract, but concretely: "don't try to make it complicated — think about what coding agents are good at and how to make access easy, and design your own system around that" (03:45).

This views the same landscape as Schluntz's "leaf-node strategy", but from the context of "API design for your own product." Schluntz is in-house coding, Matthias is the implementation of agents for customer companies — both place at the center the principle of "cut things into units the agent can handle."

The structure of Pi (agentcore) — "running tools in a loop," and that's it (05:00 – 06:30)

The minimalism of Pi (= agentcore) is the point. Matthias's explanation: "What is an agent? An LLM running tools in a loop, that's it. A goal, context information (agents.md, etc.), tool calls, results, the loop. The rest is magic" (05:30 – 05:55).

Matthias's advice: "Don't keep the curtain closed — mess with the internals" (06:00). The same Product Engineer posture as Granola's Mehedi: "don't treat the LLM as a black box; play with the internals to build your own understanding."

Concrete implementation patterns: a TypeScript Agent class, an event system, hooks for tool calls (before tool call, after tool call). "Permission-based access control, enterprise features — you can put whatever you want in the hooks" (07:30).

OpenCode's extension mechanism — reaching into the UI (08:30 – 12:20)

Explains how OpenCode extends Pi (agentcore). "OpenCode, like any agent, runs tools in a loop. But now it has a runtime and a shell — bash by default" (08:30).

The Peter (likely Peter Steinberger) episode is excellent: "He sent OpenCode a voice message. OpenCode didn't understand audio at the time. But what did it do? It combined different tools and, in the end, ran FFmpeg on the local machine to process the audio. From the outside it looks like magic; inside it's just tool calls" (09:14 – 10:00).

A characteristic OpenCode extension: UI interaction. "Session events, UI interactions — both extensible. Not just the terminal — the extension mechanism functions as UI components like dropdowns and selectors" (11:30 – 12:00). And porting to a web version Pi will write for you — "I asked Pi, and it generated a web UI with the same commands and selectors" (12:20).

The Tavoon implementation case — the sales RFP processing agent (15:00 – 19:30)

The climax of the talk. A real example Tavoon built for a customer company. "The sales process — a customer sends an RFP (Request for Proposal) email — that kind of business." The architecture:

Watching the inbox: when mail arrives, a gateway dispatches it to a per-customer agent
One agent per customer: each holds the context of agents.md (the general harness) + customer.md (customer-specific particulars — access rights, discount information, etc.)
Session reuse: refer to past sessions per case, maintaining context
Tools (offered as CLIs): CLIs for talking to CRM and ERP, run inside a sandbox
Output: the user stays in the email client, and a draft email is generated as a Gmail draft. No admin UI required

The decisive design call: "The user stays in email + drafts — no tool switching" (18:50). "Behind the scenes many agents are at work, but the user doesn't see them" (19:30). Same UX philosophy as Granola's "the final product should feel like magic". Open the black box on your side, deliver magic on the user's side.

Sandboxes and security — mention of NVIDIA OpenShell (17:30 – 18:00)

An important Q&A point. "On sandboxes — we've only just started. But the NVIDIA OpenShell policy NVIDIA recently announced — one way to protect agents. We're looking at it; it's worth your time too" (17:50 – 18:00).

Lined up with Trigger.dev's Firecracker-VM concurrent snapshotting, you can see an industry convergence: "isolate + audit the agent execution environment at the VM level." Individual sandbox proposals (NVIDIA OpenShell, Firecracker, OpenCode's shell abstraction) combine as an ecosystem.

Related articles

Granola: don't try to one-shot it — same Code Summit, the production feedback loop for LLM features
Schluntz: vibe coding responsibly in production — the theory of the leaf-node strategy
Karpathy: from vibe coding to agentic engineering — Software 3.0 and verifiability
Boris Cherny: the man who built Claude Code — the printing press metaphor

Key Quotes

"Coding agents are going to become a core building block of future software systems" (03:30)
"Ken Thompson's 'write programs that do one thing and one thing well' returns in the agent era" (01:50)
"Make it easy for coding agents — design your own system so it's easy for agents to use" (03:30)
"An agent is just an LLM running tools in a loop. The rest is magic. Open the curtain" (05:30)
"Why OpenCode could handle a voice message — the idea of running FFmpeg locally. From the outside it's magic; inside it's tool calls" (09:30)
"One agent per customer; context managed via agents.md + customer.md" (15:50)
"The user stays in email + drafts — no tool switching. Behind the scenes many agents are at work" (18:50)
"Pi is perfect for tinkering — minimal, you can rip it open and recombine the parts" (19:50)

Video Outline

(00:00) Introducing Pi; "fuck around and find out era" (a quote from Mario)
(01:50) Ken Thompson's maxim and the Claude Cowork Excel skill example
(03:30) "Make it easy for coding agents" architectural pattern
(05:00) The structure of Pi (agentcore) — Agent class, events, hooks
(06:30) TypeScript example of a CRM lead qualifier
(08:30) Coding agent = agent + runtime + shell
(09:14) Peter's voice-message → FFmpeg auto-run episode
(10:00) OpenCode's extension mechanism — session events + UI interaction
(11:30) UI component extensions — dropdowns, selectors
(12:20) Porting to web UI — Pi generates it automatically
(12:49) OpenCode package layout, multi-channel / sub-agents
(15:00) The Tavoon RFP-processing agent implementation
(15:50) One agent per customer, agents.md + customer.md
(17:00) Tools offered as CLIs, sandbox, draft generation
(17:30) Considering a sandbox via NVIDIA OpenShell
(18:08) The finished UX — stay in email + drafts, no admin UI
(19:30) Key takeaways — the era when coding agents are the core
(20:00) End

Sources

A Piece of Pi — AI Engineer official channel (YouTube)

Related resources:

マティアス・ルベケン

Matthias Luebken

Tavoon 共同創業者 / 組織向け AI エージェント実装、 OpenCode 早期普及貢献者

Glossary

Pi (agentcore): A minimal coding-agent framework. Written in TypeScript, open source. Higher-level agent tools like OpenCode build on top of this Pi (agentcore) as their foundation. Provides only the basic structure of "Agent class, event system, hooks (before/after tool call)." Matthias's recommendation: "open the curtain and mess with the internals."
OpenCode: An OSS coding agent developed by SST. Built on top of Pi/agentcore. Drawing attention as an OSS alternative to Claude Code, Cursor, and Claude Cowork. Multi-channel routing, plugin mechanism, sub-agents, gateway support, UI extensions, and so on.
Tavoon: A small European AI startup Matthias Luebken co-founded. Builds "agents for organizations." Implements B2B agents like sales-process automation for customer companies.
NVIDIA OpenShell: A secure-shell / sandbox specification for agents that NVIDIA announced in 2026. A mechanism for running OpenCode-style agents inside a secure boundary. One of the candidates for industry standardization.
agents.md / customer.md: Markdown files used to manage agent context. agents.md is the general harness (role, operating principles); customer.md is customer-specific particulars (access rights, discount, business logic, etc.). Adopted in Tavoon's sales agent implementation.

comment is stripped from the HTML output. */}