AI Engineer
Talks, workshops, events, and training for AI engineers.
Heterogeneous Model Routing Beats Frontier Baselines on Visual Web Tasks
Adrian Bertagnoli of Callosum argues that AI scaling is moving away from monolithic models running on uniform GPU clusters and toward heterogeneous systems that route subtasks across different models, chips and workflows. He points to Callosum results in visual web navigation and recursive long-context reasoning, where mixed model-and-hardware systems reportedly matched or beat frontier baselines while cutting cost and latency, as evidence that agentic workloads should be decomposed rather than sent wholesale to the most capable model.
Agent Interfaces Are Moving From Chat to Web-Native Surfaces
Rachel Nabors argues that chat should be treated as a transitional interface for agents, not their final form. Using her rebuilt Rachel the Great web comic archive as the example, she shows how MCP apps can render HTML, CSS and JavaScript inside Claude as a working comic reader, while WebMCP can expose a site’s existing functions directly to browser agents. Her case is that the web platform already provides the “infinite canvas” for agent software; the task is to let agents inherit it rather than confining them to text conversations.
Agent Swarms Need a Coordination Layer, Not Another Runtime
Lou Bichard of Ona argues that companies building fleets of background coding agents are repeatedly recreating the same missing infrastructure. In his account, runtimes, orchestration and triggers are increasingly solved; the unresolved primitive is coordination — the layer that lets agents track state, hand off work, enforce gates and know when they can move through the software development lifecycle. GitHub, Linear and CI can expose artifacts and signals, Bichard says, but they are not agent-native coordination systems; he suggests the missing layer may need to take the form of a CLI gateway that local and remote agents can call.
Google’s GenAI Stack Turns Multimodal Prompts Into Application Pipelines
Google DeepMind’s Paige Bailey and Guillaume Vernade argue that Google’s generative AI stack is being organized as an application pipeline rather than a set of isolated models. In a three-hour workshop, Bailey showed AI Studio turning multimodal Gemini prompts into inspectable API calls and generated apps with auth and Firestore, while Vernade used Gemini, Nano Banana, Veo and Lyria to illustrate, animate and score The Wind in the Willows. Their case is that builders can now orchestrate prompt, code, media generation and deployment in one workflow, even as the demos exposed seams that still require engineering discipline.
Fast Coding Models Require Smaller Tasks and Continuous Validation
Sarah Chieng of Cerebras argues that fast coding models such as Codex Spark, which she says can generate code at roughly 1,200 tokens per second, require more disciplined developer workflows rather than looser ones. In her account, a 20x speedup over models such as Sonnet and Opus makes old habits — large prompts, unattended agents, delayed validation, and sprawling context — produce technical debt faster than developers can inspect it. Her playbook is to use speed for bounded execution, continuous testing and linting, variant generation, stricter permissions, and external memory that keeps short sessions from losing the plan.
Container Images Turn OpenClaw Setups Into Reproducible Team Baselines
Sally Ann O’Malley of Red Hat argues that an OpenClaw agent setup should be shared as a container image rather than as a bundle of markdown, YAML, copied keys and informal instructions. Her demo uses Podman locally and Kubernetes for distribution, with the same image, separate secret backends, volume-backed state and a curated agent bundle so a personal setup can become a reproducible team baseline.
Android Makes Gemini Nano a Shared System Service for Apps
Google’s Florina Muntenescu and Oli Gaymond argue that Android’s on-device AI strategy depends on treating Gemini Nano as a shared system service, not something each app ships and manages itself. In their account, AICore centralizes the three-to-four-gigabyte model, scheduling, battery management and privacy boundaries, while developers call higher-level ML Kit GenAI APIs. The constraint is reach: those APIs need recent flagship-class devices, so Google is positioning hybrid cloud fallback and LiteRT-LM as alternatives when local Gemini Nano is unavailable or too limiting.
VS Code Unifies Local, Background, and Cloud Coding Agents
Microsoft’s Liam Hampton argues that coding agents should be chosen by the amount of control a developer wants to keep, not treated as a single all-purpose assistant. In a VS Code demo using one repository, he assigns tests to a local Claude agent for hands-on iteration, a front-end build to a background agent isolated in a Git worktree, and open-source documentation to a cloud agent running through GitHub Actions. His case is that VS Code can act as the control plane for these modes, including Copilot, Claude, and third-party agents.
AI-Generated PR Firehoses Are Turning Agent Work Into Infrastructure
OpenClaw maintainer Onur Solmaz argues that high-volume AI-generated pull requests are less a code-review problem than an operations problem. In his talk, he presents acpx, a headless CLI for the Agent Client Protocol, as a way to replace terminal scraping with structured agent workflows that can reproduce bugs, judge implementations, run review loops and emit machine-readable results. He extends the same model to Spritz, a Kubernetes operator for disposable per-task agent pods, making the case for interoperable, isolated agent infrastructure rather than one shared bot or ad hoc maintainer intervention.
Coding Agents Can Tackle AI Systems Engineering With File-Based Skills
Hugging Face’s Ben Burtenshaw argues that coding agents can now take on parts of AI systems engineering when the work is narrow, measurable, and embedded in inspectable repositories. Using examples including an agent-written CUDA RMSNorm kernel with a reported 1.94x H100 speedup, an end-to-end Qwen3 fine-tune, and a multi-agent research lab, he makes the case that the limiting factor is not a better prompt but better primitives: skills, versioned artifacts, benchmarks, managed compute, and open metrics that agents can read, run, and improve.
Any-to-Any Agents Rely on Orchestrated Multimodal Models, Not One Network
Google DeepMind’s Patrick Löber presents “any-to-any” agents as an orchestration problem rather than a claim that one model already handles every modality. In his architecture, Gemini reads and reasons across PDFs, images, audio, video and other sources, then uses function calling to invoke specialized native models for images, speech, live audio, video or embeddings. Löber argues that the useful shift is not generating every possible format, but letting an agent decide when a diagram, spoken explanation or other output is warranted.
Coding Agent Skills Need Live Documentation, Not Cached Product Knowledge
Marc Klingen of Langfuse argues that coding agents can add observability, but often do it first from stale model memory, producing broken or incomplete instrumentation before recovering through current documentation. In a talk on building a Langfuse skill for Claude Code, he says the fix is not to stuff more product knowledge into the agent, but to give it reliable ways to find live docs, expose its intermediate work in traces, and evaluate changes against realistic repositories. The same work, he warns, creates new risks when optimization loops reward shorter paths and remove the documentation-fetching and approval steps that make the skill reliable.
Fine-Tuning Pushed FunctionGemma From 46% to 90% Function-Calling Accuracy
Cormac Brick, a Google AI Edge engineer, argues that on-device agents are becoming practical when developers either use system models such as Gemini Nano through Android AI Core or ship narrow, fine-tuned tiny models with LiteRT-LM. His main example is FunctionGemma, a 270 million parameter function-calling model that rose from about 46% accuracy out of the box to more than 90% on most tested app-intent functions after synthetic-data fine-tuning. Brick presents the tradeoff plainly: system GenAI is easier when it fits, while app-shipped tiny models require more work but can run locally, offline, and with more control.
Retrofitting Sovereign AI Turns Compliance Rules Into Architecture Rework
Bilge Yücel of deepset argues that AI sovereignty is an engineering constraint that has to be designed into a system, not a legal or procurement requirement applied after deployment. She frames sovereign AI around control of data, models, infrastructure, and operations, and shows how retrofits expose hidden dependencies: jurisdiction-crossing data flows, model APIs embedded in application logic, managed services that masked operational work, and systems that cannot be traced or audited.
Every Addition to an AI Agent Can Make It Worse
Ara Khan of Cline argues that agent maturity is less about adding autonomy than about knowing what not to add. In a talk structured around four levels of agent building — from frameworks to state machines, Kanban-managed workflows and cloud deployment — Khan says frontier models increasingly reward simpler prompts, deliberate architecture and visible human control. His central warning is that every extra instruction, abstraction or automation layer can make an agent worse.
Spotify Uses Semantic IDs to Make LLMs Recommend Catalog Items
Spotify’s Shivam Verma argues that LLM-era personalization requires translating both users and catalog items into forms a model can process alongside language. In his account, Spotify combines long-term user embeddings, Semantic IDs that turn tracks and episodes into token sequences, and soft tokens that project a listener’s profile into an LLM’s embedding space. The aim is a generative recommender that can produce catalog-native recommendations without full fine-tuning, while still relying on traditional ranking layers for production use.
UK Government Tests an Insurgent Model for In-House AI Delivery
Eoin Mulgrew of the Number 10 data science team argues that the UK state’s AI problem is less a shortage of use cases than a shortage of technical people with the access, mandate, and proximity to build inside government workflows. In a talk on the No. 10 Innovation Fellowship, he presents the model as a deliberate hack around normal civil-service constraints: market-rate pay, outside recruitment, a highly selective technical process, and authority to enter departments and ship tools that remain with the teams using them.
Gemini Becomes the Prompt Engineer for Google’s Gen Media Stack
Google DeepMind developer advocate Guillaume Vernade demonstrates a gen-media workflow built around Gemini as the orchestrator rather than as a one-shot generator. Using The Wind in the Willows, he shows Gemini reading the full book, producing structured prompts and scripts, and handing them to Nano Banana, Veo, Lyria and TTS models for images, video, music and narration. His broader case is that multimodal production depends less on a single model than on schemas, reference assets, state management, cost controls and prompt handoffs between specialist systems.
Long-Running Agents Need Separate Builders, Evaluators, and Disposable Scaffolding
Anthropic’s Ash Prabaker and Andrew Wilson argue that long-running agents are a harness-design problem, not a matter of writing longer prompts. Their case is that agents can run for hours only when building, judging, planning and state management are separated: adversarial evaluators should test live behavior, work should be decomposed into explicit contracts, and durable state should live outside the model’s context. They also warn that this scaffolding is provisional, because each new model release changes which supports are useful and which have become dead weight.
A Harness Made GPT-3.5 Turbo’s Browser Agent Reliable Without Rewriting the Prompt
Tejas Kumar, an IBM engineer, argues that unreliable AI agents are often not suffering from bad prompts so much as missing harnesses: the deterministic software around a model that bounds its behavior, manages context, verifies outcomes, and handles known failure states. In his Hacker News browser-agent demo, GPT-3.5 Turbo falsely claimed it had upvoted a post after hitting a login wall; without changing the prompt, Kumar added guardrails, trace-based verification, and a programmatic login handler until the same model completed the task reliably.
Incident.io Uses Coding Agents to Debug Its AI SRE
Lawrence Jones, founding engineer at Incident.io, argues that complex AI products now require debugging tools built for agents as well as humans. In a talk on Incident.io’s AI SRE system, which runs hundreds of prompts across telemetry and code during production investigations, Jones describes how the team moved from human trace inspection to agent-addressable evals, downloadable file-system traces, and parallel analysis pipelines to find and fix failures that had become too large to debug manually.
AI Chat Needs Shared Sessions, Not Single Response Streams
Mike Christensen of Ably argues that many AI chat interfaces fail because they tie the user experience to a single streaming connection, not because the underlying model is inadequate. In his account, Server-Sent Events make common product behaviors such as refresh, reconnect, cancellation, multi-tab use and device switching brittle or ambiguous. Christensen’s proposed fix is to treat the AI session as a durable shared resource: clients and agents subscribe to and write into the session, so connections can drop, agents can run concurrently, and humans can join without losing context.
Agentic AI Is Turning Model Quality Into a Systems Problem
At AI Engineer Singapore’s second day, speakers from Google DeepMind, Cloudflare, Arize, OpenClaw, Adaption and other teams made a shared engineering case: as AI systems become more agentic, model quality is no longer separable from the systems around the model. Richard Ngo framed the risk as long-horizon, situationally aware agents whose goals cannot be inspected, while practitioners argued that production AI now depends on continuous evaluation, traces, deterministic execution boundaries, routing, memory, fine-tuning and test-time search. The source’s central claim is that useful and safe agentic AI is becoming a systems problem, not just a model-selection problem.
Playwright Lets Agents Test Feature Requests Before They Write Code
Microsoft’s Marlene Mhangami argues that AI-generated tests can make a codebase look healthier than it is, because agents often write tests that confirm their own implementation rather than validate the user-visible behavior a feature is meant to deliver. Her prescription is to reverse the common workflow: start from the feature request, have the agent write failing Playwright tests against expected behavior, then generate code to pass them. In a GitHub Copilot demo using the Playwright MCP server, she applies that approach to a toy-store search and filtering feature, with the browser showing the agent exercise the product experience directly.