A Piece of Pi: Embedding The OpenClaw Coding Agent In Your Product — Matthias Luebken, Tavon
Summary
Matthias Luebken, co-founder of Seven AI, presents a practical walkthrough of embedding Pi — a minimal open-source coding agent SDK — into real product applications. The talk is anchored by the philosophical premise borrowed from Ken Thompson's Unix maxim: write programs that do one thing and do it well. Luebken argues this principle maps directly to how coding agents should be designed and deployed.
The talk opens with a clear demystification of coding agents. Despite OpenClaw's apparent ability to "discover capabilities" and stitch tools together in unexpected ways, the underlying mechanics are simple: an LLM calling tools in a loop. Luebken illustrates this with a real example shared by a colleague — OpenClaw receiving a voice message it had no native support for, yet resolving the problem autonomously by discovering and invoking FFmpeg locally. From the outside it looks like learning; from the inside, it is just another tool call.
Luebken introduces Pi's architecture with a TypeScript-based agent class that accepts context, prompts, and emits events. He walks through a CRM lead qualifier built in three files as a learning exercise, demonstrating how tool calls, hook injection (e.g., blocking updates before authorization checks), and event subscriptions work in practice. He then distinguishes between the core agent SDK and the full coding agent layer, which adds a shell runtime (Bash) enabling execution of arbitrary programs — the mechanism that makes OpenClaw feel magical.
The extension API is covered next, specifically session events and UI interaction. Luebken shows how Pi extensions can drive UI elements like dropdowns and context selectors from within an agent session, and demonstrates a web UI prototype built entirely using Pi's extension mechanism — the same command, same selection logic, different rendering surface. He notes that Pi's current extension framework is still optimized for coding agent use cases and will need further work before it is production-ready for embedded product use cases.
The architectural centerpiece of the talk is a B2B sales pipeline built for a real client. The system monitors an email inbox for incoming RFPs (requests for proposals). An email gateway routes each incoming message to one of several customer-specific agent sessions, with one agent per customer. Each agent is initialized with two markdown documents: an agent harness (agent.md) describing how the agent should use the system, and a customer profile (customer.md) capturing customer-specific quirks, discounts, and access rules. Sessions are persisted and reused so agents can maintain context across multiple interactions with the same customer.
Tools exposed to these agents connect to the company's CRM and ERP systems via CLI interfaces — a deliberate design choice. CLIs are easy for agents to invoke cleanly and give the developer tight control over what data is accessible and how it is structured. The entire agent workflow runs inside a sandboxed environment. The output visible to a human operator is a draft email in their inbox, ready to edit and send. The dashboard shows email threads, associated cases (sessions), and generated drafts. All agent activity — tool calls, results, reasoning steps — happens in the background, invisible to the end user.
Luebken briefly references Nvidia's open-shell sandboxing announcement in the context of OpenClaw as a promising direction for securing coding agents in production. He closes with a direct call to action: coding agents are and will be core building blocks for software systems, Pi is the right minimal tool for tinkering and understanding, and the time to start experimenting is now.
Key Takeaways
- •Coding agents are just LLMs calling tools in a loop — demystifying them is the first step to building useful products on top of them.
- •Pi is a minimal open-source TypeScript SDK ideal for understanding and tinkering with agent mechanics before adding complexity.
- •The core architectural principle is: make your systems easy for the agent — design data access and tool interfaces so the agent can work naturally rather than compensating for complexity.
- •Expose backend systems to agents via CLIs — agents are highly capable at using CLI tools, and CLIs give developers clean control over data shape, access, and security.
- •Use per-customer agent sessions with persistent context (session MD files) so agents retain knowledge across multiple interactions with the same customer.
- •Separate agent harness instructions (general role and behavior) from customer-specific context documents to keep agent configuration modular and maintainable.
- •Pi's hook system enables pre-tool-call interceptors useful for authorization checks, role-based access, and enterprise policy enforcement.
- •Pi's extension API supports UI interaction (dropdowns, selects) from within agent sessions, enabling richer embedded product experiences.
- •The output visible to human operators should be minimal and workflow-native — in the B2B sales pipeline, this means a draft email in the inbox, not a new interface to learn.
- •Coding agents can discover and use tools they were never explicitly taught (e.g., invoking FFmpeg for voice message handling) — this emergent behavior is a feature, not magic.
- •Sandbox agent execution environments in production — Nvidia's open-shell approach is a worth-watching direction for securing coding agent deployments.
Transcript
All right. I was introduced to Pi by um looking into open open claw. There was a conference a meet-up and I said like, "Okay, we're doing open claw." And I wasn't so much interested into like all the craziness things that people are doing, but I was more interested in understanding uh of how these things work. So, I was looking into a Pi and you know, uh understand the the whole world of what Pi is able to do. Um this is the one picture you need to take. Please feel free to take more pictures, u...
Related Sessions
