DevFlow Conf 2027

A field report on running long-lived agents in production: timeouts, retries, poison inputs, and the runbook that finally made the pager quiet. We started with one agent that could file a support ticket and ended up with a fleet of them touching billing, inventory and customer email. Everything that broke, broke at night — a tool call that hung for nineteen minutes, a retry loop that re-sent the same refund four times, and a prompt change that quietly doubled token spend on the busiest queue of the week. This keynote walks through the three incidents that reshaped our architecture and the guardrails we shipped after each one: hard per-step deadlines, idempotency keys on every side effect, a spend ceiling enforced outside the model, and a replay view that lets an on-call engineer see exactly what the agent believed at the moment it went wrong. You will leave with the runbook we now hand to every team before their agent gets production credentials, the four dashboards we page on, and an honest account of which safeguards were worth the engineering time and which ones we deleted six weeks later.

Evaluations are usually treated as an internal chore. We shipped ours to customers instead, and it changed how the whole team argued about quality.

Three years of retrieval architectures, what survived, what did not, and why the boring parts (chunking, freshness, permissions) still decide the outcome.

A twenty-minute look at how Kestrel Compute schedules mixed CPU/GPU workloads, presented by our platinum sponsor.

Caching, batching, routing and quantisation, measured end to end on a real workload. Includes the changes that looked clever and made things worse. Our inference bill grew faster than our traffic for two quarters straight, and the obvious answers — a smaller model, a cheaper provider — were off the table for quality reasons. So we went looking for the money everywhere else: in the cache we were not reusing, in the requests we were sending one at a time, and in the long tail of prompts nobody had read since launch. In this hands-on session we rebuild that programme from scratch against a live workload. You will add a prompt cache and measure the real hit rate rather than the hoped-for one, batch a stream of requests and watch the latency percentiles you just traded away, route by difficulty so the expensive path only handles the requests that need it, and trim context that has been dead weight since the second sprint. We finish with the cost model we now review monthly — cost per resolved request rather than cost per token — plus the two optimisations we rolled back and the graphs that told us to. Bring a laptop; every exercise ships with a workload you can run locally.

Schema drift, partial responses and retries: why validating model output belongs in the same mental model as any other unreliable network call.

Live-coded from an empty file: a minimal, debuggable tool-calling loop with cancellation, tracing and a sandbox, and what each abstraction buys you.

Traces, spans and sampling when the same input legitimately produces different output. What to log, what to redact, and how to make it searchable.