AI Engineer Code Summit 2026 Day 1: From the Agent Loop to Agent Swarms

I spent November 10 at the Hilton Union Square in San Francisco for Day 1 of the AI Engineer Code Summit 2026. The summit runs from November 10 to 12 under the theme “A year of agentic coding,” and the first day is given over entirely to hands-on workshops. These are my notes from the sessions I attended, together with what I think they mean for engineering teams in the Philippines.

The workshops followed a beginner-friendly progression

Taken together, the Day 1 sessions work well as an introduction to AI engineering. They begin with the foundations, which are the agent loop and the harness that surrounds it. They then move to where inference runs and who controls it, then to how coding models are trained, and finally to how a large organization governs many agents and tools at once. By the end of the day the conversation had reached agent swarms, where many agents work in parallel on a single objective.

If you have already built and shipped agents, much of this material will be familiar. It is still a useful way to see the whole stack in one day, and it gives newer engineers a clear sequence for learning it.

Building a coding agent harness from an empty loop

Tejas Kumar, an AI Engineer at IBM, ran the session I found most useful for beginners. He started from a story in his AI Engineer Europe talk, where a bare agent loop reached a login page and reported success anyway. His point was that the model was behaving as expected. The problem was that nothing around the model checked its claim, so the loop ended the moment the model said it was finished.

The workshop then rebuilt the harness in TypeScript, one layer at a time:

One rule held for the entire session: the prompt never changed, and every fix was made in code. I think this is the most transferable lesson of the day. When an agent misbehaves, the first place to look is the harness, because a better prompt asks the model to behave while a better harness makes sure it does.

His closing slide was a useful guide for anyone deciding how much of this to build. The generic machinery of a harness (the loop itself, caching and compaction, sessions that survive a deploy, and streams that resume) is the same for everyone, so it is reasonable to buy it. The registry of tools, the gates, the phases, and the checkpoints and budgets are specific to your domain, and nobody else can write them for you.

Keeping the harness while owning the inference

Francisco Javier Arceo, a Forward Deployed Engineer at Baseten and a contributor to vLLM Agentic API, showed Claude Code and Codex running against open-weight models served from an NVIDIA DGX Spark. The harnesses inspected a real repository, changed code, and tested their work, and the terminal experience looked the same as usual. He then pointed the same agent-facing API at distributed serving stacks such as llm-d and NVIDIA Dynamo.

The deeper part of the session explained how responsibility is divided between the harness and an agentic server. Once the server manages conversation state, retrieval, file search, and compaction, it decides what the agent remembers and what survives when the context window fills up. His argument was that owning your inference means understanding and controlling that execution stack as well as the model.

He framed the session around three ideas:

• The single-agent harness is largely a solved problem, and agent swarms are the next area of work.
• Swarms will run as fleets of cloud agents rather than as one agent on a laptop.
• Teams that own their inference are in a better position to build and operate those swarms.

We have tested this pattern ourselves on a DGX Spark, and I agree that the harness, the model, and the serving layer are becoming independent choices. That independence is useful, but it also means you take on the responsibility for verifying that a session behaves correctly on whichever backend you choose.

Two talks on models and governance

Two other sessions rounded out the day, and I will summarize the key concepts from each briefly.

Post-training coding models at Cognition. Giovanni D'Antonio from Cognition's research team spoke about where post-training for coding is heading. The central idea is that smaller, specialized coding models trained with large-scale reinforcement learning on curated software tasks can do much of the work of larger models at a lower price and higher speed. Cognition's SWE-2 Flash is their example of this approach.

Governing a shared AI assistant at Netflix. Utkarsh Shrivastava, who leads enterprise AI engineering at Netflix, described what happens when many teams build their own MCP servers for one shared assistant. As overlapping tools accumulate, the assistant has more ways to pick the wrong one. Netflix manages this by certifying connectors before they join, benchmarking tool routing against real employee queries, and classifying which actions an agent may take alone and which need a person to approve them first.

Agent swarms currently favor teams with very large token budgets

The theme I keep returning to after Day 1 is cost. Agent swarms and fully autonomous agentic workflows are impressive in a workshop, but they consume tokens at a rate that most organizations cannot sustain. I asked one of the speakers how much he spends on AI tokens. He told me he spends about US$20,000 a month, which is more than ₱1 million a month, and that AI companies subsidize that spending.

A setup that depends on subsidized, nearly unlimited tokens is difficult to reproduce for most individuals and companies with ordinary budgets.

For teams without that kind of budget, the economical choice is to manage context carefully. That can be done through a degree of automation, such as compaction and retrieval in the harness, or by hand, by deciding deliberately what each agent sees. Both approaches reduce the number of tokens spent per completed task, and both depend on the harness discipline that the first workshop taught.

What this means for Philippine teams

Most Philippine organizations we work with, including BPOs, FinTechs, and growing SMEs, cannot spend at that level on tokens, and none of them are subsidized by a model provider. For them, I would read Day 1 in the following way:

Looking ahead to Day 2

Day 1 gave a solid foundation, and I am looking forward to the main-stage talks on Day 2, where I expect the focus to move from how agents are built to how teams run them in production. I will share those notes next. If your team is deciding how far to take agentic coding with a realistic budget, talk to us about our Claude Professional Services.