We attended the AI Engineer World's Fair in San Francisco last week. This is our wrapped for the conference: the ideas that stuck with us across software factories, agent memory, inference hardware, verification loops, and the business realities of AI.
The throughline was clear: the work is moving from prompting individual models to designing the systems around them. Memory, search, verification, orchestration, safety, infrastructure, and cost all now matter as first-class engineering surfaces.
Software Factories
The core phrase was: "Build the product that builds the product."
The salty version of the lesson is that for agents, you should avoid fixing every issue yourself. The more scalable move is to improve the system that coordinates, constrains, verifies, and learns from more agents.
Factory efficiency, as framed by Warp.dev, is:
software shipped / (token cost + human cost)
Key takeaways:
- Automation turns repeated work into reusable systems.
- Context and skills make agents more reliable than raw prompting.
- Human-in-the-loop checkpoints keep judgment where it matters.
- Self-improvement lets the factory get better as it ships more software.
Loop Engineering
Peter Steinberger's point was that the scarcest resource is now attention. HumanLayer framed this through agentic control loops: instead of thinking about one prompt and one answer, think about a controller, actuator, system, sensor, desired state, current state, and disturbances.
Prompting is not enough. Reliability comes from the whole feedback loop.
Key takeaways:
- The controller decides what change should close the gap between desired and current state.
- The actuator is the agent applying the change.
- The system is the codebase, repo, app, or production environment being changed.
- The sensor is the evidence layer: tests, ESLint, static analysis, CI results, logs, runtime telemetry, and security scanners.
- Disturbances are always present: other merges, dependency updates, new traffic, flaky tests, and changed APIs.
Addy Osmani's Talk
Addy Osmani gave one of the talks that stuck with me most. His biggest warning was that half of AI-generated code is not reviewed. He emphasized that shipping with intent still matters, and that responsibility for AI-generated code ultimately falls on the developer.
He was also bullish on the idea that we will write less code directly and spend more time designing the systems that write code for us.
Key takeaways:
- Do not protect the old loop just because it is familiar.
- Engineering is moving up a level: from boilerplate, first drafts, and routine fixes to owning loops, evidence, systems, and consequences.
- This requires more engineering judgment, not less.
- The better question is not "what can AI not do?" but "what can only a human be answerable for?"
Anthropic
Fable 5 is much more capable, which means it can go in many directions to solve a problem. That makes it powerful, but it also makes it more likely to stray from intent than previous models.
The practical lesson was to give stronger models stronger steering.
Key takeaways:
- Brainstorm and prototype: ask the model to create options, such as an HTML page with different design directions, before approving a path.
- Blindspot pass: ask the model to identify unknown unknowns so you can prompt better.
- Interviews: have the model ask one question at a time and prioritize questions where your answer would change the architecture.
- References: provide an existing implementation or design and ask the model to read it before reimplementing the pattern.
-
Implementation notes: ask the model to keep an
implementation-notes.md; when it deviates from the plan, it should choose the conservative option, log the deviation, and continue. - Quizzes: ask for an HTML report explaining the change, then have the model quiz you so you can verify that you understand how the change works.
Mike Krieger, co-founder of Instagram, also emphasized that there is still substantial room for model improvement. He was optimistic about startup opportunities because model companies cannot focus entirely on every specific problem.
Verification
Critical verification loops were a recurring theme. Sonar described this as an Agent-Centric Development Cycle, or ACDC: a way to structure agent work around evidence instead of vibes.
The model proposes and changes code, but the loop has to keep asking whether the change is actually correct. That means specs, evals, guardrails, tests, code review, and product review all become part of the agentic system.
Key takeaways:
- The agentic loop needs specs, evals, codebase understanding, constraints, generation, and real-time verification.
- The CI loop needs PR automation, multi-layered review, fix agents, and consistent pass/fail gates.
- The strongest systems make verification part of the work, not a separate cleanup step at the end.
Erik Meijer (Leibniz Labs)
Erik Meijer's Leibniz Labs talk focused on safety around agent access and autonomy. The surface area that agents can reach is everything, and there is no fully verifiable way to restrict access to what an agent is able to do once it is operating in the real world.
Their framing was to have the agent propose a computation that can be checked before real-world action happens, instead of directly letting the agent perform the action.
Key takeaways:
- Agent safety is not just a permissions problem.
- The safer shape is proposal, checking, constrained execution, and observation.
- This becomes more important as agents get access to tools that affect real systems.
Memory
The most useful framing I heard was the split between the filesystem camp and the database camp. Files are strong because LLMs already know how to open, read, write, and grep them. Databases are strong because they bring durability, ranking, relations, scale, security, backup, and features like Data Guard or AI Vector Search.
The pragmatic architecture is not either/or. Use files for what the agent actively sees and manipulates, and use a database for what needs to persist, rank, relate, or survive across runs.
Key takeaways:
- Short-term memory includes semantic cache, working memory, and the LLM context window.
- Long-term memory includes episodic traces, procedural memory, and semantic knowledge.
- Shared memory matters when agents need to coordinate across sessions, teams, or long-running work.
- Files and databases solve different problems: files are legible to agents; databases are better for persistence, ranking, security, and retrieval.
Search
A search tool is not enough. A model cannot search for a gap it does not know it has.
The important design move is the trigger: a rule that tells the model when the answer likely lives outside its weights. For example, when a diff bumps a dependency or version, the agent should search upstream for breaking changes and ground the review in what it finds.
Key takeaways:
- Search needs policy, not just tool access.
- The policy should define when to search, where to search, and how to cite or ground the result.
- The highest-value triggers are moments where stale model knowledge is likely: dependency upgrades, API changes, new security advisories, and unfamiliar code paths.
Homa Transport Protocol
TCP and RDMA are not optimized for the end-to-end serving objective of LLM inference: maximizing throughput while still meeting very low latency and tail-latency targets.
Homa's fundamental unit is a Remote Procedure Call (RPC), with a request message from client to server and a response message from server to client.
Key takeaways:
- Message lengths are explicit, which gives congestion control more useful information.
- Shorter messages can be prioritized through shortest-remaining-processing-time-style scheduling.
- Short messages can bypass longer ones, which matters when tail latency is the thing you are optimizing.
Link to project: https://github.com/PlatformLab/HomaModule
Business Metrics
Amplify Partners shared a useful view of how businesses are evaluating AI infrastructure. Quality and accuracy are the top reasons businesses choose a model, ranking above capability, cost, privacy, developer experience, reliability, and ecosystem.
At the same time, there is no single agreed-upon biggest challenge in the stack. The pain is spread across evaluation, orchestration, agentic logic, inference, security, guardrails, safety, model quality, context, retrieval, observability, and debugging.
Key takeaways:
- Quality and accuracy are still the primary model-selection criteria.
- Most AI spend goes to inference and serving, followed by observability and tracing.
- Fine-tuning appears to be the clearest "not yet there" layer.
- Cost is now a product constraint: 76% of people adjust AI usage ambition based on cost.
Cost
Artificial Analysis showed that the weighted average cost is increasing over time with each new release. They also shared that the monthly AI cost for one individual can now reach about half the cost of one developer's annual salary.
Key takeaways:
- Cost is no longer a background infrastructure concern.
- Pricing affects product ambition, agent design, and how much autonomy teams can afford.
- The slides for the talk were taken directly from the Artificial Analysis website, so the underlying data points are searchable there: https://artificialanalysis.ai/
Latent Space Live Podcast with Etched
I attended a live recording of the Latent Space podcast with Etched. Etched is building frontier inference clusters, and the major shift is that they are unifying the entire supply chain and hardware stack.
Key takeaways:
- Etched is bringing chips, racks, software, and manufacturing methods in-house.
- The inference layer is becoming vertically integrated for teams pushing the frontier.
- Hardware strategy and model-serving strategy are increasingly inseparable.
Top comments (0)