Glossary

An AI system that reads a repository, edits it, runs its checks and reports back, driven from a terminal like Claude Code or from an editor like Cursor. The difference from autocomplete is that it owns a task end to end rather than the next line.

Deciding what to build, writing the specification, delegating implementation to coding agents, and verifying the result yourself. Restructuring my own work this way took shipped output from roughly 60 to 300 commits a month across fifteen production repositories.

Writing the spec before handing work to an agent: absolute paths, constraints, acceptance criteria and the exact verification commands. The spec becomes the unit of work and the diff becomes the receipt, which is what makes parallel delegation safe.

The typecheck, test, build and browser pass that you run yourself before accepting an agent’s work. The agent’s own report is not the gate, and its claim that a failure is pre-existing is not either.

Running several agents at once on independent batches of a job, each with its own spec, then reviewing the diffs at a different altitude than the specs. The specified change is usually right; the bugs hide in what the agent added around it.

Choosing what an agent sees, because what is in its context decides the quality of what comes out. It covers giving the right files, stating the constraints, and knowing when to stop prompting and start reading.

The observation that an issue-tracker ticket has stopped being the instruction that starts work and become the record filed after it. Eighteen months of my own commit history showed tickets covering a flat quarter of the work while the work quadrupled.

The one part of the software lifecycle that language models collapse. Understanding the problem, reviewing, integrating and testing remain, and they become the new choke points when drafts arrive faster than they can be understood.

The largest cost in software is understanding it, not writing it. Every line is a liability until it is proven correct and maintainable, and generated code can raise that cost when reviewers have to reverse-engineer reasoning nobody wrote down.

Documentation written so that language models and agents can consume it becomes the support layer and the onboarding layer at once. The documentation that used to be read by people is now read by the tools people use.

A product that is a thin layer over someone else’s model. To be worth anything it has to own something the model does not: the workflow, the data, the integration, or the distribution.

The set of decisions a voice agent makes about when the caller has finished speaking, when to start speaking, and what to do when both talk at once. Callers forgive a mediocre answer long before they forgive being interrupted, so this layer decides whether an agent feels like a person or an IVR.

Detecting the end of a caller’s utterance so the agent knows it can respond. The naive version is a fixed silence threshold, which is wrong in both directions: too short cuts people off mid-thought, too long adds dead air to every exchange.

Endpointing that reads the words as well as the silence. A model scores whether the transcript so far is a complete thought, so the silence threshold becomes adaptive: short after a clearly finished sentence, long after a pause inside one. In production this one change does more for perceived quality than a faster language model.

The model or rule that produces an end-of-turn probability from audio, transcript, or both. LiveKit ships one as a turn detector; custom detectors can be plugged into the pipeline when the default does not fit a call distribution.

The caller speaking over the agent while it is talking. Handling it means detecting speech on the inbound stream while audio plays out, stopping playback, flushing queued speech, cancelling the in-flight generation, and recording what the caller actually heard before the cut.

A short listener signal such as “mm-hmm”, “okay” or “right” that means keep going, not stop. An agent that halts for every acknowledgment feels broken in a way that is hard to describe but instant to notice.

A lightweight classifier that says whether a slice of audio contains speech. It gates transcription, drives silence-based endpointing, and is what notices barge-in while the agent is speaking.

The time from the caller going quiet to the agent’s first audible word, split across endpointing delay, transcription finalisation, model time to first token, speech synthesis time to first byte, and network transport. People start to feel awkwardness somewhere under a second, so every stage is competing for the same few hundred milliseconds.

How long a language model takes to emit the first token of its reply. In a voice pipeline it is a latency feature rather than a billing detail, and it moves with the model, the output cap, and the provider’s service tier.

A short, natural phrase such as “let me check that for you” played while the pipeline works. It buys the agent a full second and sounds more human than an instant reply, because people vary their response gap with the difficulty of the question.

Deciding, in the first seconds of a connected outbound call, whether a person, a voicemail greeting, or a carrier message answered. It is a probabilistic decision with unequal costs: a missed machine wastes a full pipeline minute talking to nobody, a misclassified human gets dead air or a dropped call.

Detecting the tone that marks the start of a voicemail recording window. It is the one nearly certain machine signal, it arrives last, and an agent that intends to leave a message must wait for it and only then speak.

The two error rates that describe an AMD system: how often a machine is scored as a person, and how often a person is scored as a machine. Tuning only becomes engineering once both are measured over a scenario corpus and compared week to week.

Streaming transcription of the caller’s audio into text the language model can read. It is priced per audio minute and runs continuously, including through silence and hold music, unless gated.

Synthesising the agent’s reply into audio, priced per character or per minute of generated speech. At premium-voice list prices it is very often the most expensive line in a voice minute, which makes voice choice a product decision rather than a procurement one.

The unit economic of a voice agent: telephony, speech-to-text, the language model, text-to-speech, and compute or platform fees, stacked per minute of call. Moving from a managed platform to a self-run pipeline on LiveKit took ours from $0.26 to $0.10.

A hosted service such as Vapi that bundles media transport, telephony, model orchestration and interruption handling behind one API for a per-minute fee. It is the right way to get a first agent into production and the thing you outgrow when conversation quality, debuggability, or per-minute cost become the product.

Open-source WebRTC infrastructure plus the LiveKit Agents framework for running real-time voice and multimodal agents, with SIP for phone calls. Running on it means owning the pipeline: the turn detector, the interruption logic, and the per-stage telemetry.

An architecture where one service owns tenant configuration and call state, and stateless workers execute calls against a typed contract. It turns the voice-agent engine into a replaceable execution layer, so migrating engines becomes adding a second worker rather than a rewrite.

The typed description of one call handed to a worker: providers and models, prompts, tools, transport, recording, voicemail behavior, idle handling, duration limits, transfer rules, and reporting. Unknown providers fail explicitly instead of falling back silently.

The signed, idempotent messages a worker sends back about a call: started, transferred, ended, with end reasons, latency, usage and failure context. They are what let the control plane see a call the same way regardless of which engine ran it.

A test platform that plays scripted, imperfect callers and answering-machine scenarios at a voice agent over real carrier paths, then grades what the agent did. Turn-taking and AMD regressions do not show up in unit tests; they show up as callers hanging up.

The public switched telephone network: the carrier infrastructure a phone number lives on. Everything a voice agent does over a real number eventually becomes narrowband audio on the PSTN, with all the noise, jitter, and carrier behavior that implies.

Session Initiation Protocol, the signalling standard that sets up, transfers and tears down calls between telephony systems. Owning a voice stack means owning SIP: trunking into the media server, transfers to humans, and every carrier’s interpretation of the spec.

The connection between a carrier and your media infrastructure over which phone calls arrive and leave as SIP sessions. On LiveKit it is how a PSTN call becomes a participant in a room where the agent is listening.

The browser and native standard for real-time audio, video and data over the internet. It carries a voice agent’s media between the caller and the agent process, and it is also what makes browser-to-browser encrypted file transfer possible without a server in the middle.

Phone-quality audio sampled at 8 kHz, which strips most of the frequencies a premium synthetic voice is priced for. It is why a voice worth testing on the phone often sounds identical to a cheaper one, and why laptop-microphone testing proves nothing.

Handing a caller to a human after the agent has briefed that human, as opposed to a cold transfer that simply forwards the call. It is one of the transfer rules a runtime profile has to model, with a boundary for what the agent says before letting go.

Interactive voice response: the menu-driven phone system a caller navigates with keypad tones or short phrases. Outbound agents have to traverse them; inbound agents are usually replacing them.

A design where product code talks to a capability such as SMS, voice or verification, and adapters for Twilio, Vonage, Telnyx and others implement it behind a registry. It buys outage failover, pricing leverage and one place for compliance controls, at the cost of an abstraction that only pays once a second provider shows up.

The US carrier registration system for application-to-person messaging over ordinary 10-digit numbers. A business registers a brand and a campaign so carriers know who is texting and why; unregistered traffic is filtered and throttled.

A cryptographic framework in which the originating carrier signs each call with an attestation of how well it knows the caller and the number. It authenticates caller ID against spoofing; it does not endorse the call, so it is hygiene you must have, not a cure for a spam label.

The three STIR/SHAKEN levels. A means the carrier knows the customer and that they are authorized to use the number, B means it knows the customer but cannot fully vouch for the number, and C means the call merely entered its network. Attestation degrades quietly on resold routes and bring-your-own-carrier setups.

The caller name shown next to a number. In the US it is not carried in the call but looked up by the receiving carrier from a database of its choosing, so it varies by carrier and lags changes by days. Register it everywhere, and treat it as best effort.

A per-carrier, per-call verdict rendered by analytics engines from volume, velocity, answer rates, call duration and complaints. There is no place to be approved; you maintain a reputation continuously, and a labeling event announces itself as a sudden per-carrier drop in answer rate.

The standing of a phone number with carrier analytics engines, built from how it has behaved. Fresh numbers at high volume look like spam, so numbers are warmed gradually, kept at consistent modest volume, and registered before traffic is put on them.

Rotating through many numbers to spread calling volume and dodge spam labels. Analytics engines are built specifically to detect it, and it burns every number and range it touches; the fix for a label is the traffic pattern, not a new number.

Dialling from a number that matches the callee’s area code to lift answer rates. Done with a rotating pool of barely used numbers it recreates the snowshoeing signature, so every number in the pool still needs registration, warm-up and clean traffic.

A single submission that registers legitimate business calling numbers with the major US call-analytics engines. It is the first step for any number that will dial outbound, before volume goes on it.

Carrier programs that display a verified business name, logo and reason for the call on the recipient’s screen. It is the stronger successor to CNAM, worth evaluating as it matures, at a real per-call price.

Software that does its work on the user’s own machine, with no account, no server and no telemetry. For document processing it means no image leaves the network; for a browser extension it means the data stays in the browser.

Optical character recognition: turning an image of a document into structured text. Document OCR does it for passports and Indian KYC documents on RapidOCR and PP-OCRv5, packaged for Python, HTTP, Docker and Node.js so the same model serves a script, a service, or a container.

One console and REST surface over the many small operations documents need: conversion, rendering, extraction, splitting, merging. Nineteen such tools behind one API is what PDF Everything is.

An agent workspace for investigating production incidents across observability, CI/CD, cloud, databases and source control, deliberately without write access. It lets an agent look everywhere and change nothing, which is the right shape for the first hour of an incident.

Command-line access to an operations tool, such as Grafana, Elasticsearch, Jenkins, Jira, CubeAPM or Nginx Proxy Manager, so a script or an agent can do what the web UI does. A CLI is the interface an agent can actually use.

Metrics, logs and traces that let you explain what a system did without adding new instrumentation first. In the voice pipeline it is OpenTelemetry spans per call stage; in operations it is the Grafana and CubeAPM tooling an incident investigation reaches for first.

Browser automation that checkpoints its progress, so an interrupted run picks up where it stopped instead of starting over. Playwright for the browser, SQLite for the checkpoint, and exports to CSV and JSON.

Software that runs inside the browser to change or extend what a page can do, built here with WXT and React. Perch stashes and restores tab groups with no account or server; VIN Highlighter detects vehicle identification numbers on any page and links them out.

A starter that begins past the setup: typed configuration, tests, linting, Docker and CI/CD already wired, so the first commit on a new project is product code.

Ready-to-run Docker Compose definitions for the infrastructure a project depends on: databases, queues, search, observability, caches and vector stores. They make a local environment match production closely enough that the difference stops being a source of bugs.

Moving a file directly between two browsers over WebRTC, encrypted so that no server, including the one that introduced the peers, can read it. SafeShare is the working example.