← All speakers

Bio, Work & Ideas

Damien Murphy

Conference affiliation: Bench Computing · 2025

Damien Murphy is a full-stack and applied AI engineer who builds real-time voice agents and autonomous business workflows. After working as a senior applied engineer at Deepgram, he joined Bench Computing as a founding engineer, applying lessons from conversational AI to enterprise systems that coordinate specialized agents, external services, and sensitive business data.

At Deepgram, Murphy worked directly with customers deploying speech recognition, language models, and text-to-speech in production. His voice-agent workshop demonstrates a browser-based ordering assistant that streams microphone audio over WebSockets and uses model-generated function calls to update orders. Its public client and server expose the complete architecture: browser audio capture, speech playback, order management, and an Express backend. He also collaborated on a podcast-processing automation that combined transcription, summarization, and synthesized speech.

By the 2025 AI Engineer World’s Fair, Murphy had joined Bench Computing, where his focus expanded to multi-agent business automation. His A2A and MCP workshop shows how a host agent can process meeting transcripts, delegate tasks, create GitHub issues, post Slack messages, and research companies.

  • Conversational timing is a product requirement. Murphy treats interruption handling, audio bandwidth, geographic deployment, and time to first token as fundamental design constraints. His emphasis on semantic endpointing recognizes that hesitation, backchanneling, and genuine completion require different responses.
  • Specialized agents prevent context overload. Murphy assigns narrow responsibilities to subordinate agents, allowing them to process verbose records or tool responses and return concise results. This context isolation for specialized agents reduces latency and limits unnecessary exposure of intermediate data while supporting parallel execution when tasks are independent.
  • Protocols must justify their complexity. He distinguishes MCP, which connects models with tools and context, from A2A, which supports discovery and delegation between independently managed agents. When developers control the entire system, he favors direct function calls; protocols become useful when third-party integrations or remote agents require a shared interface.
  • Cost and safety depend on operational details. Murphy evaluates prompt caching and context management against actual usage patterns, routes simpler tasks to less expensive models, and anticipates silent integration failures. His safeguards include user-scoped OAuth permissions, synthetic accounts for realistic testing, verification of external actions, and human confirmation for consequential changes.

Read the topics behind these talks

2 conference talks

Key ideas

Scroll to read ↓

Build a webhook-driven agent workflow, then follow the practical problems it exposes: silent tool failures, context growth, authorization, task dependencies and integration gaps.

  • What makes an agent capable of completing business work?
    0:37 ↗
  • Separate remote delegation from tool access
    2:41 ↗
  • Use a protocol where it earns its complexity
    7:52 ↗
  • Configure the workshop application
    10:54 ↗
  • Turn a meeting transcript into concrete actions
    14:09 ↗
  • Advertise a small capability surface and inspect it
    19:37 ↗
  • Follow the webhook through the live run
    24:23 ↗
  • Keep the host’s context proportional to the answer
    31:15 ↗
  • Cache for likely reuse, not merely because context grew
    34:50 ↗
  • Make discovery, execution and privacy explicit
    39:00 ↗
  • Separate evaluation evidence from access control
    44:42 ↗
  • Control trust boundaries and task dependencies
    48:52 ↗
  • Send a task, then choose a model for the work
    54:35 ↗
  • Absorb verbose work without losing the ability to revisit it
    59:12 ↗
  • A useful agent can hide a better data-processing system
    1:03:11 ↗
  • Know which decisions and state the application owns
    1:07:34 ↗
  • Wait for humans, bound conversations and test real writes safely
    1:12:14 ↗
  • Move from webhook tasks to explicit flow control
    1:17:14 ↗
  • The final boundary is the integration code
    1:21:42 ↗

Key ideas

Scroll to read ↓

A browser-based drive-through agent exposes the engineering behind real-time voice: streaming audio, backend tools, interruption handling, conversational memory, and regional scaling.

  • Audio in, an order out
    0:27 ↗
  • The latency between three services
    4:26 ↗
  • A Krabby Patty and a kelp shake
    7:07 ↗
  • Connecting the browser, agent, and backend
    8:56 ↗
  • An add-only agent cannot fully modify an order
    13:14 ↗
  • Inspecting the conversation as it happens
    15:26 ↗
  • Capturing, buffering, and interrupting audio
    18:08 ↗
  • A new voice does not add a new capability
    22:34 ↗
  • A pause is not always the end of a turn
    26:17 ↗
  • Keeping the conversation moving
    30:42 ↗
  • Stopping playback when the user speaks
    38:54 ↗
  • Reconciling memory and checking commitments
    40:17 ↗
  • Voices, languages, and choosing what to automate
    43:05 ↗
  • Monitoring an agent and absorbing peak demand
    46:44 ↗
  • Recognizing speech more frequently
    50:17 ↗
  • Building the swarm from narrow responsibilities
    52:44 ↗
  • Where the models run and where the audio enters
    56:51 ↗
  • Custom speech models need carefully prepared data
    1:00:38 ↗
  • Diarization needs enough speech to distinguish people
    1:02:50 ↗
  • The lower limit of useful latency
    1:05:49 ↗

References