← All speakers
On this page

Dominik Kundel works on developer experience and SDKs at OpenAI, building the infrastructure that turns powerful models into usable, controllable software agents. He co-designed and implemented the OpenAI Agents SDK for TypeScript with Kazuhiro Sera and has contributed to Codex, gpt-oss and a Rust library for rendering the Harmony format.

From developer evangelism to AI product leadership

Kundel began as a software engineer at Microsoft before joining Twilio as a developer evangelist. Over nearly nine years, he moved from developer advocacy and tools into product management and ultimately led product and design for Twilio’s Emerging Tech and Innovation organization. His account of that transition describes a career spanning technical education, team building and AI incubation. He also completed an evening-and-weekend MBA at the University of California, Berkeley’s Haas School of Business.

His earlier projects capture a durable interest in removing everyday friction for programmers: node-env-run loads environment variables before executing commands, pkg-install installs Node.js packages programmatically, and vscode-new-file extends file creation in Visual Studio Code. In 2017, he even made a coffee machine programmable with JavaScript.

At Twilio, Kundel helped develop customer memory systems that connected structured customer profiles with unstructured conversations: personalization used existing customer data, while perception extracted useful information from interactions. Those concepts informed AI Assistants, an agent-building approach for customer engagement across communication channels.

He also confronted the organizational difficulty of shipping agents whose reliability, cost and regulatory implications remained unsettled. His team used rough customer-facing prototypes, internal hackathons and low-risk deployments to surface weaknesses early, while the Twilio Alpha sub-brand distinguished experimental releases from mature products. He argued that smaller companies might adopt imperfect agents sooner because the technology added capabilities they otherwise lacked, whereas enterprises measured it against established service standards.

What distinguishes his approach to agents

  • Voice architecture determines the experience. Kundel contrasts chained speech-to-text systems, which provide visibility and reuse existing text applications, with native speech-to-speech agents, which reduce latency and preserve conversational cues. His voice-agent workshop demonstrates a hybrid pattern: a responsive audio agent manages conversation while delegating difficult decisions to a stronger reasoning model. Browser-based WebRTC, short-lived credentials, interruption handling and human-approved tools make that architecture practical.
  • Evaluation and approvals should precede autonomy. He recommends starting with narrowly defined tasks, limited tools and early evaluation. For voice systems, that includes transcript-based guardrails, human review and tracking what users actually heard before interrupting. Consequential tool calls should require approval before execution begins.
  • The harness is essential agent infrastructure. His Codex architecture walkthrough distinguishes the app-server protocol connecting interfaces to the open-source Codex harness from the Responses API connecting that harness to models and tools. Deferred tool loading, bounded skills context, filesystem sandboxing, asynchronous subagents, persistent connections and automatic compaction shape how coding agents perform extended work.
  • Authorization depends on context. Kundel emphasizes contextual authorization: deleting a file may be appropriate when explicitly requested but unsafe when unrelated to the user’s goal. Review mechanisms therefore need to consider both an action’s potential impact and the actual permission granted.

His reflection on his first year at OpenAI places the TypeScript SDK, open-model tooling and Codex within the shift toward agentic software development. His description of GPT-5-Codex makes that ambition concrete: systems that help developers refactor substantial codebases, debug problems and add tests.

Read the topics behind these talks

3 conference talks

Key ideas

Scroll to read ↓

Build a browser voice agent step by step, from typed tools and secure sessions to interruptions, specialist handoffs, reasoning delegation, approval gates, and audio-aware evaluation.

  • What does a voice agent need to accomplish a task?
    0:26 ↗
  • Choose the path from speech to action
    3:26 ↗
  • A fluent refund answer still needs inspection
    8:16 ↗
  • Scope the task, then design the conversation
    12:30 ↗
  • Build a text agent and give it a typed tool
    19:46 ↗
  • Connect a browser agent without exposing the API key
    24:06 ↗
  • Track what the listener actually heard
    32:04 ↗
  • Separate displayed history from session context
    38:03 ↗
  • Keep tools responsive and gate side effects
    49:01 ↗
  • Switch the active agent, preserve the conversation
    54:00 ↗
  • Delegate a riddle to a server-side reasoning agent
    1:00:10 ↗
  • Output guardrails race against playback
    1:08:22 ↗
  • What prompting changes—and what belongs to the application
    1:12:41 ↗
  • Carry context across sessions and respect runtime permissions
    1:18:21 ↗
  • Evaluate the audio, then control when it enters the session
    1:20:41 ↗

Key ideas

Scroll to read ↓

Follow a message through Codex’s harness: context construction, persistent tools, sandbox approvals, faster transport, goal loops, and compaction.

  • What happens when you send a message?
    0:30 ↗
  • Build context without loading everything
    4:18 ↗
  • Keep working while tools run
    7:01 ↗
  • Turn browser actions into persistent programs
    8:12 ↗
  • Match filesystem tools to the model—and constrain execution
    10:08 ↗
  • Approve actions in context
    11:59 ↗
  • When inference is fast, the network becomes visible
    15:32 ↗
  • Continue until a verifiable goal is achieved
    17:25 ↗
  • Carry state forward without carrying the whole history
    19:01 ↗

Key ideas

Scroll to read ↓

Twilio’s emerging technology team learned that incubating AI products requires more than fast prototypes: it requires real usage, explicit expectations, flexible roadmaps and shared learning.

  • What is our plan about AI?
    0:21 ↗
  • Improving the camera, replacing the camera
    2:19 ↗
  • A different baseline for enterprise and small businesses
    4:06 ↗
  • Why explore something that does not pay yet?
    5:30 ↗
  • Connecting conversations to customer memory
    6:58 ↗
  • Let customers use the rough version
    10:11 ↗
  • Release early without promising maturity
    11:42 ↗
  • Own the problem, keep the solution flexible
    15:17 ↗
  • Make learning useful before the product succeeds
    17:32 ↗

References