AI Engineer World’s Fair 2026

Executive readout

The latest AI Engineer World’s Fair was the 2026 edition in San Francisco, held June 29–July 2 at Moscone West, with a June 28 orientation. The event’s own framing was broad—29 tracks, 300 speakers, 100+ expo partners, and 6,000+ engineers, founders, and AI leaders—but its intellectual center was remarkably consistent: the model is no longer the whole product. The durable advantage is increasingly in the system wrapped around it.

The unit of AI engineering is shifting from the prompt or single agent to the loop. The recurring pattern is plan → act → observe → verify → repeat, with different loop levels for a tool call, a task, a product, and a system that improves the other loops.
Harness engineering is becoming a distinct discipline. Context, memory, permissions, sandboxes, logs, tool selection, quality gates, and recovery behavior are now treated as first-class engineering surfaces.
Verification is the counterweight to explosive generation. Evals, traces, error analysis, provenance, and human review are being repositioned as the moat—and as the governance layer that makes autonomy tolerable.
“Software factories” are the dominant enterprise metaphor, but not a settled answer. Some speakers argued for autonomous software production; others pushed back that factories without human comprehension create review debt and brittle systems.
Open weights, local inference, computer use, agent skills, and agentic commerce are moving into the mainstream engineering stack. The event showed emerging practice and strong demos, not a finished standard or a proven recipe for broad ROI.

1. What the event was

The official program positioned AIEWF 2026 as a technical conference for building and operating production AI, not a research-only model showcase. The public site describes 10 parallel engineering tracks plus two leadership tracks on the main conference days, 400+ sessions in the marketing overview, and an online track of recorded talks. The machine-readable schedule currently exposes 561 sessions, while the live schedule page has shown 566; the difference appears to reflect schedule revisions and how expo/workshop entries are counted, so the exact total should not be treated as a settled historical statistic.

The program structure itself is evidence of the field’s priorities:

June 29: hands-on workshops.
June 30: Software Factories, coding agents, search, security, voice, data quality, forward-deployed engineering, and enterprise AI.
July 1: Autoresearch, robotics and world models, memory and continual learning, evals, context engineering, computer use, and post-training.
July 2: Harness Engineering, agentic commerce, local AI, inference, graphs, generative media, finance, healthcare, and AI factories.

The official schedule and open data are the best starting points: overview, schedule, sessions JSON, and speakers JSON.

2. The core concept: build systems around agents

The strongest post-event synthesis came from Latent Space’s Richard MacManus: AI engineering has moved from building with agents to building the systems around them. The important work is no longer simply selecting a model or writing a clever prompt. It is designing a reliable environment in which a probabilistic model can act repeatedly without losing context, violating permissions, or declaring success prematurely.

That environment includes:

a context layer that decides what the model should see;
tools and permissions that limit what it can do;
memory and durable logs that preserve state across runs;
sandboxes for risky execution;
evals and traces that expose failure;
a loop controller that decides when to continue, retry, escalate, or stop; and
human authority over high-risk or irreversible actions.

This is why the 2026 schedule contained dedicated tracks for Harness Engineering, Context Engineering, Memory & Continual Learning, Evals, Data Quality, Sandboxes, Security, and Inference. The conference was treating the surrounding control plane as the product.

3. “Loop engineering” is the event’s most reusable mental model

“Loops” became the event’s headline vocabulary. The organizers opened with “The Highest Loop,” and the program included Loopcraft workshops, autoresearch sessions, self-improving software factories, and sessions about agents that compound.

The most useful interpretation is not that every automation needs to run forever. It is that agents need an explicit feedback structure. A loop without a meaningful observation, evaluation signal, or stopping condition is just repetition.

The attendee discussion that traveled furthest came from Aparna Dhinakaran’s X post, “What the hell is a loop, anyway?” The replies sharpened the distinction between execution loops, human-in-the-loop oversight, task loops, and system-level improvement. One reply summarized the practical concern: high-quality context, verification, and human accountability are what turn a loop into a real operating workflow. Another pointed out that autonomy and reversibility are separate dimensions.

Loop level	What repeats	What proves progress
Execution loop	Tool call, observation, next action	Tool result, state change, local check
Task loop	Retry or refine a task until a condition holds	Acceptance test, evaluator, human review
Product loop	Repeated work across a codebase or workflow	Production outcomes, regression suite, user signal
System/outer loop	Study and improve the inner agent system	Evals, telemetry, experiments, cost and quality trends

The conference’s important qualification was that humans do not disappear from the system. They move upward: setting goals, defining authority, choosing the level of autonomy, reviewing exceptions, and changing the curriculum or skills that agents operate from.

4. Harness engineering: the model is the easy part

The official schedule describes harness failures in very concrete terms: state is not persisted, two runs mutate the same session, a tool call never returns, an approval loses scope, or an internal success never becomes user-visible proof. That is a much more operational definition of AI engineering than “prompt quality.”

The harness concept covers:

Context: what information is retrieved, compressed, or withheld;
Memory: what is durable, episodic, and trustworthy later;
Permissions: what the agent may read, write, execute, or pay for;
Execution: sandboxes, browsers, code runners, queues, and retries;
Observability: traces, logs, cost, latency, tool calls, and failure states;
Verification: deterministic checks, model judges, human approval, and post-generation vetoes;
Continuity: how work resumes after interruption, model changes, context resets, or provider changes.

This is also where “skills” entered the conversation. Latent Space’s recap describes skills as portable, on-demand knowledge that encode workflows, quality gates, and senior-engineer practice. Google DeepMind’s Philipp Schmid framed agents as files: declarative Markdown artifacts can extend capabilities and reduce the need for orchestration code. The implication is significant: organizations may increasingly maintain an operational library of skills, specs, policies, and evaluators rather than only maintaining application code.

There is a risk of “skills hell,” however. The more skills, tools, and instructions an agent receives, the more context selection itself becomes a design problem. The practical advice from the event was to keep skills small, structured, composable, and tied to clear verification behavior.

5. Verification and evals are the new control layer

The conference did not treat evals as a final benchmark slide. It treated them as the feedback mechanism that makes agentic systems governable.

The official session catalog repeatedly returned to:

evals that measure traces and intermediate steps, not only final answers;
error analysis on real production outputs;
meta-evaluation of whether an LLM judge can be trusted;
distribution shift between a static golden set and live traffic;
deterministic quality gates around agent-generated code;
provenance and citation for LLM-built knowledge; and
monitoring for drift, token waste, runaway loops, and tool misuse.

WorkOS’s post-event workshop recap is a useful concrete example: agents were wrapped in hooks that lint, type-check, test, and then send diffs through an adversarial second-model review. The workshop’s deeper point was that an agent should leave behind a verifiable finish line, not just a plausible answer.

Several attendee summaries used “verification is the new moat.” That is directionally right, but it should be read as a thesis rather than a proven market law. The stronger evidence is that multiple independent recaps—Latent Space, WorkOS, the official schedule, and attendees on LinkedIn—converged on the same operational problem: generation has accelerated faster than organizations’ ability to inspect, understand, and trust the result.

6. Software factories versus orchestras

“Software factory” was the main track and the dominant enterprise metaphor. The idea is to delegate more of the software lifecycle to multiple agents while humans supervise the system: selecting repositories, defining work, setting review points, and handling exceptions.

The factory model is compelling because coding agents can now explore repositories, edit multiple files, run tests, debug, and iterate. It also changes the bottleneck. The question is less “can the agent write code?” and more “can the organization operate a fleet of agents without losing product judgment or codebase comprehension?”

The counterargument was equally prominent. Conductor’s Charlie Holtz argued for an “orchestra” metaphor: humans should remain in the flow and direct the agents rather than disappear into a lights-out factory. Other speakers warned that unattended automation can produce review debt, technical debt, or code that passes local tests while becoming harder for people to understand.

The event did not resolve the debate. The practical synthesis is:

automate reversible, well-specified work first;
make high-risk changes pass stronger gates;
define who owns the exit condition;
preserve logs and artifacts so a human can reconstruct what happened;
treat comprehension and maintenance as explicit quality metrics; and
never confuse a sandbox with a software factory—the factory also needs organizational conventions, definitions of done, and judgment.

7. Forward-deployed engineering: the enterprise adoption role

Forward-deployed engineering (FDE) was another major theme. The role sits between software engineering, product development, and customer implementation. Cursor, Sierra, Ramp, Decagon, Cognition, Factory, and others appeared in the program as examples of teams helping organizations implement AI systems directly in their workflows.

The recurring claim was that enterprise adoption is still concentrated among early adopters. The FDE’s job is therefore not merely to install a tool. It is to find the right internal champions, map business context into the agent system, set boundaries, deploy automations, and leave behind a durable operating capability with measurable ROI.

This is an important corrective to “AI adoption” dashboards. The hard part is not counting seats. It is creating a trustworthy loop between organizational knowledge, agent behavior, user feedback, and operational ownership.

8. Open weights and local AI became strategically credible

The GLM-5.2 keynote was the clearest model-level signal. The official schedule listed “GLM-5.2: Frontier Intelligence, Open Weights,” and the accompanying Z.ai materials positioned it for coding and long-horizon agentic work. Latent Space described it as an MIT-licensed open-weight frontier model; that distinction matters: open weights are not the same thing as a fully open training stack or fully open data.

The event’s larger message was not simply “open models are cheaper.” It was that open and local systems can provide:

privacy and data sovereignty;
controllable deployment;
lower marginal cost for repeated verification loops;
model routing and provider optionality; and
the ability to inspect and adapt the system rather than depend entirely on a vendor.

Ahmad Osman’s local-AI workshops made this tangible with comparisons across laptops, phones, DGX Spark-class systems, AMD workstations, and cloud frontier models. His practical qualification was important: local AI still lags the frontier, but the gap has narrowed, and the full experience requires search, tools, harnesses, ingestion, and orchestration around the model.

The right conclusion is not “local replaces cloud.” It is “local becomes a serious tier in the architecture,” especially for private data, high-volume inference, edge workloads, and internal verification.

9. Computer use, multimodality, and the agentic interface

The Computer Use track treated the screen itself as a new API surface. Sessions covered perception agents, browser agents, visual verification, multi-cursor operation, MCP Apps, and the security boundary between a model and the computer it controls.

The emerging pattern is that agents will not only call clean APIs. They will interact with messy human interfaces: browsers, desktop applications, calendars, messaging systems, and visual canvases. This expands coverage but also expands risk. A robust computer-use system needs stable environments, scoped identity, audit trails, visual verification, recovery paths, and evaluation environments that reflect the messiness of real applications.

This is why “computer use 2.0” was less about a flashy demo than about infrastructure: multiple agents sharing a surface, cursor and input arbitration, browser and native-app fallbacks, and a clear account of where the approach breaks.

10. Agentic commerce and vertical AI

Agentic commerce was a new, concrete frontier in the 2026 program. Sessions covered agent wallets, nanopayments, x402 apps, payment protocols, agent identity, and the emerging stack around MCP, A2A, ACP, UCP, and AP2.

The central issue is that an agent that can discover and call services may also need to authenticate, establish authority, evaluate cost, pay, and leave an accountable record. Without identity, governance, settlement, and legal standing, agentic commerce remains mostly an enterprise-internal automation story.

The same verticalization appeared in finance, healthcare, GTM, legal work, document intelligence, and robotics. The event’s message was that the generic agent is becoming infrastructure; the defensible product is the domain context, workflow, data model, evaluation set, and permission structure around it.

11. What people who attended were saying

X / Bird findings

Bird’s public X search found a smaller but higher-signal post-event conversation than the official marketing volume suggests:

Aparna Dhinakaran’s “What the hell is a loop, anyway?” became a discussion point after the event. The replies emphasized context, verification, accountability, stopping conditions, and the distinction between autonomy and reversibility.
Dave Thackeray’s “15 things I learned” framed the event around scaffolding: deterministic code for deterministic work, agents for judgment, humans for authority; semantic routing; smaller deployment models; post-generation vetoes; and spec-driven development.
Wolfram Ravenwolf’s recap was a personal/visual account rather than a technical synthesis, but reinforces the amount of attendee-produced documentation and social artifacts.
Cua’s “Computer-Use 2.0” post shows the event continuing to produce follow-on technical content after the floor closed.
A high-engagement post from Mike Bradley repeated a striking claim attributed to Ahmad Osman: that an RTX 5090 could host GLM-5.2-equivalent intelligence within 18 months. This is a speaker prediction, not an independently verified forecast; treat it as a signal of local-AI confidence, not as a fact.

The X conversation’s tone was not uniformly boosterish. The strongest replies turned the event’s slogans into operating questions: who owns the exit condition, what evidence proves convergence, how do you preserve continuity, and when is a loop unnecessary?

LinkedIn and independent attendee reports

Sidney Hori Hawthorne summarized loops, attention as the scarce resource, verification as the moat, and the unresolved factory-versus-orchestra debate. The post’s 7,000-attendee and 500+-session figures conflict with the organizer’s figures and schedule counts.
Igor Bogdanov found no consensus on harnesses, cost control, drift prevention, or extracting signal from noise. His practical warning was to define the agentic task first and identify what can still be done deterministically.
Kagaya’s participation report described an atmosphere less about “how to use AI” and more about “how to delegate to AI.” It noted that as much as 40% of execution time was being discussed as verification work, alongside the counterargument that unreviewed PRs and agent-induced bugs can make a codebase brittle.

Reddit was comparatively quiet as an independent discussion venue. Search surfaced one direct 2026 post, Edge at AI Engineer World’s Fair in SF, but it was a company recap promoting an X thread and claimed 3,000+ builders. That figure conflicts with the organizer’s 6,000+ event-level figure and should not be used as a reliable attendance count. I did not find a substantial, independent 2026 Reddit thread dissecting the event itself.

That absence is a finding: post-event discourse is concentrated on X, LinkedIn, organizer-adjacent newsletters, company recaps, and released recordings—not on Reddit. Reddit is more useful here as a sentiment and counterpoint check than as the main source of event content.

12. What is actually new versus what is mostly reframing

New or materially strengthened

The operational vocabulary of loop engineering, harness engineering, skills, and software factories has become much more explicit.
Local AI is being discussed as a full deployment tier, not merely a hobbyist model-running activity.
Computer use is being treated as a systems and evaluation problem rather than just a model capability demo.
Agentic commerce is acquiring a concrete protocol, identity, payment, and governance stack.
FDEs are becoming a recognizable organizational role for moving from demos to production.

Mostly a sharper framing of known problems

Evals, observability, retrieval, permissions, sandboxes, and human review are not new categories. What changed is their position in the hierarchy: they are now the main work, not supporting infrastructure.
“Skills” resemble a more portable, operational form of documentation, configuration, playbooks, and code-generation scaffolding. Their value depends on whether they are maintained and evaluated, not on the label.
“Software factories” are an extension of agentic coding and workflow orchestration. The term is useful because it forces discussion of throughput, supervision, and process, but it does not by itself solve quality or accountability.

13. Contradictions and evidence limits

Attendance: official materials say 6,000+; one attendee said 7,000; one Reddit company post said 3,000+. Use 6,000+ as the organizer-reported 2026 figure and treat the others as informal or possibly reused marketing numbers.
Session total: the marketing site says 400+; the open JSON lists 561; the live page has shown 566. Schedule versioning and inclusion rules are likely responsible. Do not present one number as independently audited.
“Open source”: the strongest model claim is about open weights and licensing, not necessarily open data, training code, or full reproducibility.
ROI: attendees repeatedly described production pilots and real infrastructure, but public material does not provide a rigorous, comparable event-wide ROI study.
Autonomy: the event was optimistic about delegation but did not establish that lights-out agent factories are broadly reliable. The more credible consensus was governed autonomy with human authority at the outer loop.
Content completeness: recordings and the online track are valuable, but there is no single peer-reviewed proceedings volume or canonical transcript set. Company recaps are useful but naturally biased toward the company’s product.

14. Bottom line for a leader or builder

The event’s practical lesson is simple: stop asking only which model to use. Ask which work should be deterministic, which work deserves model judgment, what context the system needs, how progress will be verified, what must be reversible, and who has authority when the system is wrong.

If you are building now, the highest-leverage investments are:

A small, explicit loop with clear stop conditions.
A context and memory design that preserves only what the agent can reliably use.
Deterministic checks around probabilistic steps.
Production traces and evals tied to real failure modes.
Skills/specs that encode organizational practice and are maintained like code.
A model-routing strategy that includes open and local options where privacy, cost, or control matter.
Human review based on risk and reversibility, not on a blanket “human in the loop” slogan.

The event was not announcing the end of models. It was announcing the end of the idea that the model alone is the product.