Projects / AI Voice Agents

From YAML to Self-Serve: AI Voice Agents

Building a voice agent at Gridspace originally meant writing code in a script editor, so customers depended on our engineering services team for every change. I designed a new platform that let customers build, test, and deploy their own agents, cutting launch time from days to an hour or two. Usability testing then revealed the next challenge: making the system transparent enough for non-technical users. This page walks through that full arc.

The yaml editor

Our first voice agent editor was a YAML script editor. The agent matched what callers said to example phrases using semantic similarity, so users had to anticipate the many ways a caller might ask each question.

Originally an internal tool, the editor was built out with features I proposed, like a code outline that linked to specific sections, and “conversation blocks”: reusable snippets of code users could drag into their spec and customize. These made the editor faster to work in, but it was still technical and cumbersome, so customers relied on our services team to build and update their agents.

A Self-Serve Platform

When we created our new agent creation platform, we wanted to solve two problems with the YAML editor: agents were hard to debug and there was no way to train them. The new platform centered on three tools, all managed from Agent Home.

Playbooks define an agent’s workflow as a sequence of explicit steps, like the procedure a call center agent follows, making agent behavior inspectable, editable, and easier to debug. Knowledge Bases hold uploaded documents or crawled websites the agent draws on for information. In Coaching sessions, users role-play calls in the browser or by phone to test their playbooks, and can step in to correct the agent’s information, actions, or dialog, shaping its behavior through example.

usability testing

The new platform cut the time to create an agent from days to an hour or two, but there was still a long way to go.

I ran internal usability sessions where participants completed guided tasks, like setting up an agent for an ice cream shop, while I observed. In a follow-up survey, testers were moderately confident they could build a working agent with more time, but gave their lowest scores to whether a non-technical person could.

The findings shaped three design principles:

Be transparent. Show what the agent does on its own, what the user controls, and how it uses the knowledge base.

Use plain language. Replace jargon like “variables” and “connectors” with words non-technical users understand.

Make capabilities discoverable. Surface features people missed, like correcting the agent during coaching or adding outcome pages.

applying the findings

I turned the testing insights into concrete changes, from platform-wide updates like the global navigation down to details in the Playbook editor. Some refinements shipped, others remained explorations as the team moved on.

  1. Designed a new navigation that grouped related areas together and simplified the voice agent hierarchy, making it clearer where to start.

  2. Added more context to each step in the visual map, showing the script along with icons for data types and integration steps.

  3. Borrowed patterns from online form builders, like searchable dropdowns with icons, to make field types easier to find and understand.

Today

How I’d approach this today

This platform was designed in the early days of LLMs, when agents still needed to follow scripts closely to behave reliably.

Today, instead of scripting each step, I’d create one place to set an agent’s goal, knowledge, guardrails, and actions, then test it live. Each reply shows which rule, source, or action it used and can be corrected in the moment, building in the transparency our testing called for.

Concept, 2026, prototyped in Claude Code