AI Engineer
Talks, workshops, events, and training for AI engineers.
Graph-Shaped Skills Turn Agent Decision Traces Into Governed Procedures
Zachary Blumenfeld of Neo4j argues that agents become more predictable and governable when their procedures are represented as graphs, not left as instructions for a model to interpret. In his account, these graphs can encode decision steps, tool calls and escalation rules, while linking them to the data and past traces behind a decision. A loan-approval demo shows how Neo4j compiles policy and successful runs into a reusable procedure that constrains routing and makes each step inspectable.
AI Writing Tools Can Help More People Publish Work Worth Reading
Zack Proser, an engineer on WorkOS’s applied AI team, argues that the greater risk of AI is not a flood of low-quality writing but the stories people never publish. He built Blogbot to turn colleagues’ briefs and source material into drafts that are usually 85–90% complete, while leaving them to edit the work and put their names on it. For Proser, faster production can preserve craft when people supply the judgment and remain accountable for what they publish.
Teams Can Reserve Human Review for Risky Pull Requests
Nick Nisi, who leads developer and agent experience at WorkOS, argues that as code generation accelerates, routine human review is becoming a bottleneck. His fruit-fly demonstration tested whether a simulated brain could distinguish bugs from harmless changes and toss-ups; it scored 88.3% on 301 unseen changes, with 19 abstentions. Nisi’s broader proposal is to automate routine checks and send people the changes that are risky or require judgment about why they should happen.
AI Engineers Are Building Systems That Evaluate and Improve Agent Work
Aparna Dhinakaran of Arize AI argues that the AI engineer’s job is shifting from building individual features to building systems that can build, evaluate, monitor and improve them. As companies put more agents to work, she says, engineers must create the loop around them: telemetry agents can inspect, evaluations that test unpredictable outputs, and checks that establish whether those evaluations match human judgment. She uses Arize’s Signal, an always-on agent that investigates traces and can open pull requests, to show how that loop works in practice.
Coding Agents Shift Engineering’s Bottleneck From Code to Product Judgment
Laurie Voss, head of developer relations at Arize AI and co-founder of npm, argues that coding agents have made code cheap to produce without making software delivery equally fast. As agents generate more code, the bottleneck shifts to review, operations and security; the work least suited to automation, he says, is discovering what people need and defining what a good solution looks like. Voss calls the engineer who does that work a product engineer, and warns that the shift is already narrowing the traditional entry-level path into the profession.
At Arca, Agents Own Client Goals Across Days of Work
Aman Singh, who leads AI at Arca, argues that an AI-native financial-services firm should assign agents responsibility for client outcomes, not use them merely to assist employees. Arca’s agents track signals such as emails, calls and account events, carry work across delays and changing circumstances, and bring people in when a decision or action requires them. Singh’s longer-term aim is for the firm to steer its business by setting goals for agents, which then prepare and advance the work—including prompting employees to act.
AI Agent Security Depends on Limits Beyond the Sandbox
Andrey Rybka of Bloomberg argues that a sandbox alone cannot contain an AI agent with broad access to tools, data and services. Incidents he describes include an agent that escaped its sandbox and took 17,600 actions, hidden instructions that triggered data theft, and a separate agent that deleted a production database. His central prescription is to limit each agent’s authority and reach with layered controls, including short-lived, scoped credentials and checks on the actions agents can take.
GPU Capacity Still Trades Through Private Quotes and Bespoke Contracts
Compute capacity still trades largely through private quotes, brokers and bilateral contracts, Affaan Mustafa of Jump Trading says, with larger commitments negotiated out of public view. He argues that falling token prices have not necessarily lowered compute costs: cheaper inference can drive more usage, while chips, power, data-center space and capital shape the price of capacity. The financing gap is sharpest for mid-size companies, whose demand may grow unevenly while suppliers need long-term commitments and upfront payments can consume scarce runway.
GPU Forward Curves Point to Rising H100 and B200 Prices
Carmen Li, CEO of Compute Exchange and Silicon Data, argues that buyers should procure GPU capacity through a neutral exchange rather than negotiate separately with hundreds of providers. Drawing on her experience as an energy-options market maker, she says an exchange can verify buyers and sellers, compare offers and support reserved and forward contracts without owning the GPUs it trades. Li also points to Silicon Data’s forward curves, which she says indicate that the market expects H100 and B200 prices to rise.
AI Made Vanguard’s Legacy Ledger Research Queryable in 15 Minutes
Vanguard’s cash-ledger modernization required teams to move data, producers and consumers from a mainframe to the cloud while the system handled up to 30 million service calls a day. Gareth Yoder, who leads the cash program, says the migration’s research bottleneck eased when Vanguard made its COBOL code and database metadata queryable through AI tools: a question that once took a mainframe engineer seven days to answer could be resolved in 15 minutes. His broader case is that modernization also depends on usable migration documentation, incremental adoption and observability.
Coding Agents Need Executable Proof Before They Can Call Work Done
WorkOS’s Nick Nisi and Zack Proser argue that coding agents should have to prove they are done by running checks against the behavior they changed. In their workshop, a waitlist form displayed a success message but lost the submitted email on reload—a failure a confident completion report and passing build could miss. They show how repeatable checks, retained evidence tied to the current code and clear failure guidance can give agents a basis to fix problems before handing work to a human.
AI Agent Evals Turn Confident Errors Into Measurable Failures
Laurie Voss, head of developer relations at Arize AI, argues that teams cannot tell whether an AI agent is improving by checking a few outputs that look plausible. In her workshop, she builds an evaluation loop around a financial analyst agent that combined analyst percentages from separate search results into a supposed consensus, producing figures that totaled 116%. Tracing exposed how the agent reached that answer; evaluations tested its outputs. Voss’s approach also checks those evaluations against human judgment before using them to guide changes and CI release checks.
The Highest Loop Is People Creating the Next Loop
In The Highest Loop, Shawn Wang argues that AI engineers need to move between levels of work, from debugging tokens and tool use to improving larger goals and automations. He extends that stack to human organization, from small teams to wider communities, and casts AI Engineer World’s Fair as a place where builders can decide what processes to create next. For Wang, the highest loop is the one that brings people together to make new loops.
Private Document Processing Requires Controlling the Agent’s File Access
Filip Makraduli of Superlinked argues that sensitive document processing should happen before a coding agent sees the file: open models running on infrastructure the user controls can handle OCR, extraction and redaction, then return a smaller artifact for the agent to use. His Obsidian and MCP workflow is designed to reduce exposure to external model APIs and avoid spending context on raw documents, while letting teams choose or adapt models for specific tasks. But a private processing path does not alone guarantee privacy if the agent can read the original file first.
AI Gateways Let Teams Change Models Without Rebuilding Their Stack
As AI budgets face closer scrutiny, Remy Guercio of Tailscale argues that standardizing on one vendor is not a lasting answer to rising costs or AI lock-in. In his account, teams need room to change models, connectors, interfaces and execution environments without replacing the whole stack. An AI gateway, he says, can preserve that choice while giving organizations a central way to manage access, set model-specific budgets and inspect what agents do.
AI Agent Policies Need Runtime Enforcement at the API Gateway
Sam, CTO at Gravitee, argues that prompts and policy files cannot govern what an AI agent does once it can reach an API: enforcement has to sit in the infrastructure between the agent and the services it can call. In a live hotel-booking demonstration, he showed a gateway denying destructive actions and bulk access to guest data, while also limiting repeated requests, caching similar questions and rejecting oversized prompts before they reached a model.
The Codex App Server Lets Applications Build on the Agent Harness
OpenAI’s Codex App Server gives developers access to the harness behind Codex so they can build interactive clients beyond OpenAI’s own app and IDE extension. Dominik Kundel, who works on Codex developer experience, argues that developers can tailor those clients with their own instructions, tools and per-thread settings while retaining Codex’s underlying system guidance. He recommends bundling a specific server version with each client, rather than relying on users’ installed CLI, as the protocol evolves.
AI-Generated Pull Requests Shift the Bottleneck to Validation
Ali-Reza Adl-Tabatabai, co-founder of Gitar, now part of Sonar, argues that AI-generated code is shifting the bottleneck in software delivery from writing code to validating it. More and larger pull requests put pressure on CI and code review, leaving teams to slow delivery or risk rubber-stamping defects, he says. His proposed response is agentic validation: software that reviews pull requests, diagnoses and fixes CI failures, and can approve and merge changes under rules set by the team.
Gemini Managed Sandboxes Give Agents Persistent Cloud Environments
Philipp Schmid of Google DeepMind argues that AI agents should run in managed cloud sandboxes rather than on a developer’s machine. In his account of Google’s Gemini API, the Interactions API represents work as a sequence of steps, while the Antigravity agent runs code, uses tools and retains files in a persistent environment started with an API call. Schmid’s case is that Google can handle the agent loop and infrastructure, leaving developers to provide the request, tools and working context.
Agent Improvement Depends on Linking Production Traces to Offline Evals
Marc Klingen, Langfuse’s co-founder, argues that improving agents is becoming less a matter of rewriting prompts and more a matter of building a feedback loop around them. AI can increasingly inspect production traces, propose fixes, and test them against datasets and evaluations, reducing work that teams once did manually. But Klingen says people still need to set the goals and judge what counts as a meaningful improvement; in a Langfuse changelog-writer demo, an agent identified internal jargon and tested a revision before it was submitted for review.
The Scheduler Can Bottleneck Inference Without Doing the Heavy Compute
Charles Frye, who works on inference at Modal, argues that an inference engine’s central challenge is not generating tokens but serving them efficiently for the workload at hand. The scheduler can limit performance even though it does far less computation than the GPU, because it decides which requests reach the accelerator and how they are batched. Frye traces how workload demands, cache management and host-side overhead shape latency and throughput, and why operators need evidence from the deployed system to diagnose problems.
AI Agent Traces Turn Production Failures Into Fixes
Laurie Voss of Arize AI argues that teams cannot manage AI agents by reading traces one at a time: traces show what an agent did, evaluations identify failures, and recurring patterns can guide fixes. In a workshop demonstration, a toy-store agent could not find toys under $6 because its search tool lacked a price filter. Voss used traces to diagnose the gap and a coding agent to add the feature, while emphasizing that regression evaluations are needed to check fixes against behavior that already works.
A Financial Agent’s 13 Rejected Reports Exposed a Judge Without Research Context
Laurie Voss of Arize AI argues that reliable AI agents require more than trying a few prompts and deciding the results look good: teams need to inspect traces of what agents actually did and define success before automating evaluation. A financial-analysis agent in her workshop produces reports that expose the limits of a judge grading from its own knowledge: it rejects all 13, while a faithfulness check given the agent’s research context finds six faithful and seven unfaithful. Voss uses focused evaluators, human comparisons and repeated tests on saved failures to guide changes before and after deployment.
Gemma 4 Brings Open Models to Browser and Mobile Devices
Paige Bailey of Google DeepMind argues that open models are becoming practical to run on ordinary hardware, including in a browser or on a phone, without sending data to a remote API. Her example is Gemma 4, a family ranging from 2 billion to 31 billion parameters that organizations can download, adapt and fine-tune; which version is useful depends on the device and its constraints.