The difference between a voice agent that feels like a conversation and one that feels like a walkie-talkie is turn-taking: knowing when to listen, when to speak, and — hardest of all — gracefully handling being interrupted. Humans do this effortlessly and unconsciously; making a machine do it is one of the subtlest problems in voice AI. This post is about the conversational dynamics that make an agent feel alive.
The difference between a voice agent that feels like a conversation and one that feels like a walkie-talkie is turn-taking: knowing when to listen, when to speak, and — hardest of all — gracefully handling being interrupted. Humans do this effortlessly and unconsciously; making a machine do it is one of the subtlest problems in voice AI. The dynamics that make an agent feel alive.
You can't manage what you can't see, and AI systems are unusually hard to see into — non-deterministic outputs, per-token costs, quality that's a matter of degree. Because every model call flows through the gateway, it's the one place you can observe all of it: what was called, what it cost, how long it took, and whether it was allowed. This post is about turning the gateway into your AI system's source of truth and its governance point.
You can't manage what you can't see, and AI systems are unusually hard to see into — non-deterministic outputs, per-token costs, quality that's a matter of degree. Because every model call flows through the gateway, it's the one place you can observe all of it and govern it: what was called, what it cost, how long it took, whether it was allowed. Turning the gateway into your AI system's source of truth.
Post 1 said an ontology is meaning a machine can compute with. This post is about the notation that makes that real: RDF, the dead-simple data model that represents any fact as a three-part statement, and OWL, the language that adds the logical rules a reasoner can act on. These are the W3C standards underneath most of the semantic-web and knowledge-graph world, and their core ideas are far simpler and more elegant than the acronyms suggest.
RDF represents all knowledge as triples (subject–predicate–object), so a set of triples is automatically a graph. OWL adds logic — inverse/transitive properties, cardinality, class expressions — grounded in description logic, so a reasoner can derive unstated facts and catch contradictions. The standards under the knowledge-graph world.
Fixing a typo is one tool call; implementing a feature across a dozen files, with new tests and a migration, is a project. As coding tasks grow, a coding agent needs more than a tight edit-run loop — it needs to plan, decompose, track progress, and manage its own context over a long effort. This post is about how coding agents handle big, multi-step tasks, and why planning and decomposition are what let them tackle real work rather than just small edits.
Fixing a typo is one tool call; implementing a feature is a project. How coding agents handle big tasks: decompose into ordered subtasks, plan before acting, track progress, and manage context over a long effort — a hierarchical plan-plus-loop structure that scales from edits to real engineering, and benefits hugely from human direction.
The verifier is the reason eBPF exists in its modern form. Running arbitrary code in the kernel would be reckless; running code the kernel has proven safe is not. The verifier is the static analyzer that stands between your program and the kernel, mathematically checking that it can't crash, hang, or misbehave — and understanding it explains both eBPF's safety and its constraints.
The verifier is the reason eBPF exists in its modern form. Running arbitrary code in the kernel would be reckless; running code the kernel has proven safe is not. The verifier is the static analyzer that stands between your program and the kernel, mathematically checking it can't crash, hang, or misbehave — and it explains both eBPF's safety and its constraints.
Everything about voice AI comes down to one number: how long the user waits to hear a reply. Get it under the threshold where conversation feels natural and the agent is a delight; miss it and no amount of intelligence saves the experience. This post is about the latency budget — where the milliseconds go, and how streaming the entire pipeline turns an additive delay into something that feels instant.
Everything about voice AI comes down to one number: how long the user waits to hear a reply. Get it under the threshold where conversation feels natural and the agent is a delight; miss it and no intelligence saves the experience. The latency budget — where the milliseconds go, and how streaming the entire pipeline turns an additive delay into something that feels instant. With an interactive turn diagram.
Nothing concentrates the mind like a surprise five-figure AI bill from one runaway loop, or one team's traffic spike exhausting the rate limit everyone shares. Because every model call flows through the gateway, it's the one place you can enforce limits and budgets that actually hold — protecting your spend, your providers' rate limits, and fairness across teams. This post is about spending control as a first-class gateway capability.
Nothing concentrates the mind like a surprise five-figure AI bill from one runaway loop, or one team's spike exhausting the shared rate limit. Because every model call flows through the gateway, it's the one place you can enforce limits and budgets that actually hold — protecting your spend, your providers' rate limits, and fairness across teams. Spending control as a first-class capability.
"Ontology" sounds like philosophy, and historically it was — the study of what exists. In computing it means something more concrete and more useful: a formal, explicit description of the things in a domain and how they relate, written so a machine can reason about it. As AI systems increasingly need to ground their answers in structured truth rather than guess from text, ontologies and the knowledge graphs built on them have become quietly essential. This series builds both from first principles.
'Ontology' sounds like philosophy; in computing it's a formal, machine-readable description of a domain's things and relationships. The ladder from schema to taxonomy to ontology, the building blocks (classes, individuals, properties, axioms), and why ontologies give LLMs the verifiable source of truth they lack.
An agent's reasoning is useless without the ability to act, and for a coding agent, acting means tools: editing files, running commands, executing tests, searching code, using version control. The tools define what the agent can do, and their design — what they expose, how safe they are, how reliable their feedback — shapes how well the agent works. This post is about the tools that turn a reasoning model into an agent that changes real software.
An agent's reasoning is useless without the ability to act, which means tools: read/edit files, run commands, run tests, search, version control. Tool design (reliability, clear feedback) largely determines agent quality, and because tools (the shell) can do irreversible things, safety is first-class: least privilege, sandboxing, confirmation gates, and git as the undo button.
An eBPF program's journey — from code you write to logic running in the kernel — has a few distinct pieces: the program itself, the hook it attaches to, the maps it uses to share data, and the load path that gets it safely into the kernel. Once you can name these four things and see how they fit together, eBPF stops being magic and becomes a system you can reason about.
An eBPF program's journey — from code you write to logic running in the kernel — has a few distinct pieces: the program, the hook it attaches to, the maps it uses to share data, and the load path that gets it safely into the kernel. Once you can name these four things and see how they fit, eBPF stops being magic. With an interactive architecture diagram.
The last stage of the pipeline is where the agent finally speaks, and it's where an interaction either sounds human or sounds like a robot reading a menu. Modern text-to-speech is remarkably natural, but for a voice agent it must also be fast and streaming — synthesizing speech as the LLM's words arrive, not after — and it must pronounce the messy real world correctly. This post covers TTS for real-time voice.
The last stage of the pipeline is where the agent finally speaks — and where an interaction either sounds human or sounds like a robot reading a menu. Modern TTS is remarkably natural, but for a voice agent it must also be fast and streaming — synthesizing speech as the LLM's words arrive, not after — and pronounce the messy real world correctly. TTS for real-time voice.
Model calls are slow and expensive, and a surprising fraction of them are repeats or near-repeats. Caching at the gateway turns those into instant, free responses — and because the gateway sees all traffic, it's the one place a cache benefits every application at once. Beyond exact-match caching, semantic caching catches queries that mean the same thing in different words, which is where the real savings live.
Model calls are slow and expensive, and a surprising fraction are repeats or near-repeats. Caching at the gateway turns those into instant, free responses — and because the gateway sees all traffic, it's the one place a cache benefits every app at once. Beyond exact-match caching, semantic caching catches queries that mean the same thing in different words, where the real savings live.