33 talks, 9 themes, one fast way through the event — key takeaways, standout quotes, and every recording from Agents in Production 2026.
Worth noting
Prosus built an in‑house agent builder and scaled to ~20,000 created agents (8,000 weekly active), expecting 30,000 in production by March, automating tasks that once required dozens of FTEs.
Quote
AI adoption is never a technical problem; it is always an organizational problem.
Worth noting
Cursor indexes entire codebases (e.g., ~500,000 files) into semantic search, enabling AI to pull relevant context for Brownfield work instead of treating problems as greenfield.
Quote
You have to stay in the driver's seat; you have to make the right decisions architecturally.
Worth noting
Validate agent use cases on reliable closed-source models first; migrate to open-source models for compliance, scale, or cost once proven, while using low‑abstraction frameworks and standardizing core infra (Kubernetes, artifact repo).
Quote
Hosting a model locally is just kind of a pain if you haven't done it a lot before.
Worth noting
Design-space exploration across heterogeneous accelerators and clouds revealed about 760,000 deployment combinations and can identify cheaper, better-performing alternatives to default A100 GPU choices for specific workloads (for example, 1,000-user throughput).
Quote
You're having some kind of a 7.6 lakh combination to choose from.
Worth noting
Adding a DPO/T adapter trained on human-reviewed compliant rejections raised policy-adherence from 45% to 90% within 48 hours in a Google Cloud support ticket pre-qualification agent.
Quote
we boosted that productivity policy adherence score from 45% to literally 90% in less than 48 hours.
Worth noting
They built a modular, agent-per-task microservice platform orchestrated via REST APIs and Kubernetes autoscaling, using a supervisor agent, human-in-the-loop checkpoints, and a sub-100ms speech latency target.
Quote
Each agent is specialized on a given task.
Worth noting
Using an async-actors framework with self-hosted models, they scale from zero to hundreds of GPUs (A10/A10G), achieving near‑real-time (seconds–minutes) throughput and substantially lower costs versus API-based pipelines.
Quote
The main point of my talk today is that pipelines don't scale.
Worth noting
Using a 5-agent structured-dissent swarm (2 believers, 2 skeptics, 1 neutral) produced 92% task-aligned evaluation and reduced human review cost, with analyses taking ~3.5 minutes and costing ~$15 per analysis.
Quote
Single agents fail silently. They are just certain they're right even if they're wrong.
Worth noting
Use realistic automated simulations—mock user, agent, and judge—to run hundreds to thousands of cross‑modal (chat and voice) regression tests integrated into CI/CD, catching modality-specific failures before release.
Quote
You can set up hundreds to thousands of these and run them every time.
Worth noting
Measure 'interruption rate' — the frequency you must step in while an AI coding agent runs — aim to reduce it to enable parallel tasks, greater autonomy, and lower mental effort.
Quote
I do think we are reaching the point when a lot of us are actually reviewing code more than writing code.
Worth noting
Run per-tool eval suites nightly across many LLMs (they run on 15 models) to create CI/CD-like reliability, and enforce generated annotated schemas plus least-privilege authorizations for every tool.
Quote
Operational tools should be tightly scoped and have a set number of outcomes that are verifiable.
Worth noting
Make detailed, phase‑broken plans the primary artifact: use a slow, high‑quality model for planning and debugging, then a fast model to generate incremental diffs, run tests, and commit each phase.
Quote
Plans are really important. Plans are really the new code for me.
Worth noting
Alfred provides a reusable template and runtime (FastAPI on GKE) that orchestrates agents via MCP tools, LightLLM gateway, Langraph workflows, and Langfuse observability, with data checkpointing in AlloyDB and PII masking.
Quote
Agents are normally easy to prototype, but it's hard to run in production.
Worth noting
Unify RAG, memory, and structured data into a single context engine (schema-driven, materialized views) so agents retrieve controlled, observable context rather than direct DB access or many low-level MCP tools.
Quote
We're going to think of context engineering as a unified concept.
Worth noting
Use configurable "tool masks" above raw tool handlers to shrink input/output schemas, add defaults and validation, and version masks—reducing tokens, choice-entropy, and errors to make large-scale agent workflows more reliable and cost-efficient.
Quote
Tools are prompts, and we're generally overlooking the engineering of tools.
Worth noting
Mluda uses testable Python plugin classes as a handover layer so teams can swap data sources, apply validation/PII redaction, and trace each data point from source to user (e.g., add a 'last-10-minutes' plugin for recency).
Quote
we need to separate what you compute from how you compute
Worth noting
They built a "cortex" shared-memory that proactively infers standardized customer attributes, reducing context bloat and enabling consistent recall across agents; early tests with 20+ B2B customers produced senior-quality personalized content within minutes.
Quote
Having access to raw data doesn't mean that I know my customer.
Worth noting
Conditioning query embeddings on intent produced roughly a 35% lift in precision while adding little latency.
Quote
Retrieval here becomes part of a control loop and not an endpoint.
Worth noting
Three tactics—triggered structured docs, materialized table artifacts with schema and endpoints, and letting agents write full code—avoid context bloat and enable reliable autonomous analytics.
Quote
If a single query can answer then it wasn't interesting question to begin with.
Worth noting
Encoding business logic into a semantic layer (served via a steward agent) was key to push SQL agent accuracy past the typical 80% plateau and enabled reliable adoption through Slack/Teams integrations.
Quote
We cannot ship an agent if one of five queries is wrong.
Worth noting
MCP needs standard resumability, redelivery and idempotency plus conformance tests; today many clients are incomplete (only VS Code implements all features), causing dangerous duplicate side effects like double charges.
Quote
Statefulness is a feature and not a bug.
Worth noting
Monitor and mediate agent-to‑MCP traffic with real‑time tool‑call inspection, hooks, and role-based MCP gateways—because tens of thousands of public MCPs and real supply‑chain attacks enable silent data exfiltration and dangerous tool changes.
Quote
Agents are easy to use. MCPS get us data access. But really also a lot of challenges in how we think about this.
Worth noting
Adopt a layered stack: use MCP for tool/data integrations, and A2A (which merged with ACP in late 2025) for agent-to-agent orchestration and discovery to avoid n×m custom integrations.
Quote
We need that same concept, that same TCP IP moment for agents.
Worth noting
Because MCPs can erase identity and grant all-or-nothing access, implement identity-chain tracking, context-aware policy enforcement and detailed audit logs to enable revocation, anomaly detection and forensic replay.
Quote
The agents are already talking to everything. The question is whether you will know what they are saying.
Worth noting
Prevent exfiltration by breaking the “little trifecta”: restrict agent access to private data, filter and sanitize external tool outputs, and require human approval for any tool that can communicate externally.
Quote
Treat the model as an untrusted user of your system.
Worth noting
Prompt injection alone can raise agent compliance from about 5% to 95%, enabling zero-click supply-chain attacks (e.g., malicious npm package injection that stole thousands of crypto wallets and git credentials).
Quote
You only need to know one thing: prompt injection.
Worth noting
Encoding tacit expert rules into a versioned context layer and regression tests raised a healthcare agent's reliability from 73% to 91% without changing the model.
Quote
A benchmark gives you like a Formula 1 engine. Incredibly powerful but fragile.
Worth noting
Automating 10–20% of misinformation reviews with a multi-agent system yields high ROI by reducing human cost while improving precision and recall.
Quote
If a multi-ent system can automate even 10 or 20% of them with high accuracy, that's a very high ROI.
Worth noting
They reduced agent P95 latency from about 30 seconds to about 10 seconds by adding fast-path shortcuts, moving context compaction to async processing, compressing prompts, and using smaller models where possible.
Quote
It's proactive — it doesn't wait for the user; it reaches out at the right moments.
Worth noting
After deploying a limited BI agent, they reached 100% of dealers in two weeks but only 10% engaged; adding contextual buttons, streaming, and interactive UI elements increased engagement and follow-up questions.
Quote
That little flicking cursor is really unintuitive because the user is now expected to understand what the agent can do.
Worth noting
Expect STT 100–300 ms, TTS 200–600+ ms (P90 ~500–1200 ms) and variable LLM first-token latency—so orchestration (regional clusters, provider routing, warm workers) is essential to meet real-time constraints.
Quote
The way we see success is essentially in four pillars: latency, consistency, context and recovery.
Worth noting
Production agents need a dedicated multimodal affect-perception and emotional-modeling pathway—e.g., shallow episodic memory with emotional tags—so they remember prior frustration (e.g., with recursion) and adapt future pacing.
Quote
Emotion isn't optional in AGI development; it's a core part of how humans learn, collaborate, and make decisions.
