AgentsEngineering
Theme 01
The year of the agent harness
The engineering challenge has shifted from building agents to building the scaffolding around them.
A harness is the infrastructure around a model or agent that constrains and grounds it in a stable, deterministic environment — gateways, auth, tool registries, context management, guardrail layers, compliance verification, and login handlers.
The goal is reliability: making agents do what they're supposed to do regardless of the black box model. In one session, harness components were shown to completely change agent outcomes without modifying a single prompt or model. This means you can use cheaper or even free models while improving performance through the harness.
This is supported by the Claude Code leak: most of the codebase was traditional engineering of deterministic functions. Increasingly, instead of referencing a model or an agent, speakers referenced the agent harness.
The answer is not hardcoding paths or rigid instruction. Agents are probabilistic reasoners operating in open-ended environments: scripting them tightly fights their nature. Instead, describe intent, not means.
"If 2025 was the year of agents, 2026 is the year of harnesses. 2027 will bring dynamic, self-generating harnesses where agents create their own guardrails before executing a task."
ContextEngineering
Theme 02
Context as an engineering discipline
Context is replacing code as the primary lever for agent performance.
Almost every talk touched on the cost of context: what goes in, what gets lost, and what gets wasted. The implication is that managing this is a core engineering discipline.
Prompts, agent skills, specifications, ADRs, QA plans, and other documentation should follow a development lifecycle, not be copy-pasted or left to individuals. The same institutional knowledge that onboards human engineers is what agents need too.
Recursive leverage compounds when agents write skills that write prompts from existing best practices, which are then encoded into repositories, teams, and agent config stacks over time.
Proposed: the Context Development Lifecycle (CDLC)
One speaker proposed a CDLC: generate, test, distribute, observe. Agent skills are analogous to code libraries, follow a standard package format, and are managed including dependencies, registry, distribution, and security scanning.
Practical techniques
- "Grill Me" skill: turn an agent into an adversary that asks 40+ questions before acting to establish shared language and design concepts
- "Ubiquitous Language" skill: scan a codebase or docs for terminology and create a shared markdown table — reduces token usage and improves alignment
- Tokens are the currency, constraint, and optimisation target. Codebases can be optimised for efficiency through prompts and context without touching model weights
- Progressive discovery of context protects the context window — exposing all tools to agents explodes it
- Context graphs preserve background information that gets lost in similarity search
Cloudflare's 2,600 API endpoints would require ~1.2M tokens if exposed as individual tools. They collapsed them into 2 tool calls accepting code as input, reducing to ~1,000 tokens.
EngineeringLeadership
Theme 03
Systems thinking & the shifting role of engineers
Code production is commoditised. The scarce skills are architecture, delegation, and defining the conditions for agent success.
System design and systems thinking are the pinch point. The job is to build systems and structures that make agents successful, define agent personas, and limit how much attention a model needs. Defining "a good job" and success criteria is increasingly critical.
The value of an AI agent system is largely determined before a model even runs — by the quality of the instructions, templates, frameworks, and guardrails humans have designed around it.
Software engineering is absorbing adjacent roles while teams shrink: tester doesn't exist at many companies now, DevOps is following, and product management is starting to merge. Companies are hiring "product engineers" — even at traditional firms like John Deere.
Where AI still struggles
- Agents excel at clearly defined problems, compact API surfaces, tight constraints, and a legible, stable core
- Engineers are still needed for areas with interacting concerns (flags, permissions, billing), or when the context window can't hold the full picture
- Software fundamentals are more important than ever
- Humans still need to define the decision framework for the system: Framing, Guidance, Assessment, Action, Outcome
- Agents benefit from structure: templates, breadcrumbs, guardrails, and opinionated, intent-focused instructions
ArchitectureEnterprise
Theme 04
Enterprise agent architecture
MCP gateways, decoupled components, and sovereignty by design.
MCP gateways as the dominant pattern
MCP gateways are emerging as the architectural equivalent of API gateways. They separate the agent harness from where data lives, handle auth, access control, observability, and act as a single root of trust. This frees individual MCP servers to focus on business logic and reduces the security review bottleneck currently hampering adoption.
Sovereignty and vendor independence
Enterprises need swappable components and architectural pillars. Retrofitting sovereignty onto existing systems is painful. Use consistent interfaces, explicitly type data flows, use YAML serialisation for version control.
At the codebase level
AI struggles with "shallow modules" (lots of tiny blocks with complex interfaces) and performs better with "deep modules" (lots of functionality behind simple interfaces).
Some large tech companies are quietly rebuilding entire internal toolchains. Uber is building custom background coding agents, an AI-enabled MCP gateway with service discovery, retooled on-call systems, and risk-categorised code review. Airbnb, Intercom, Meta, and Microsoft are doing similar work.
The hidden infrastructure challenge: observability
Knowing what an agent did and why remains genuinely hard. LLM traces are semi-structured, deeply nested, and can hit multiple GBs — no existing tooling handles this well. Observability also needs to be built for non-technical audiences.
"If you're in a large company and you're not already building an MCP gateway, what are you even doing?"
EngineeringStrategy
Theme 05
Recursive leverage & compounding feedback
Early investment in context and infrastructure creates accelerating returns.
Early investment in context, infrastructure, and feedback loops creates accelerating returns. Context needs to be shared across teams. When gaps appear, teams adopt the reflex of adding missing context — meaning all subsequent teams benefit across shared agents and skills.
- Agent logs create closed feedback loops: standardised log formats surface missing context that can be distributed. Edge cases in production get added to golden datasets used for future evals
- The feedback loop between research, product development, and customer feedback is tighter than ever. Frontier model research is now entwined with product deployment
- OpenAI used Codex to review all existing prompts and create a skill for "how to write prompts." Now teams use the skill to write prompts that was written by an agent — unique company leverage encoded into repos, agents, and stacks
- Better codebases yield better AI output which yields better codebases — but the inverse is also true. Neglecting code quality creates a downward spiral
TestingEngineering
Theme 06
Testing & evals
Evaluating non-deterministic systems requires fundamentally different approaches — and the industry is still figuring it out.
Single pass/fail determinism doesn't work for AI components. Evals must run multiple times with error budgets — 100% passing isn't realistic. The line between evals and production observability is blurring.
Emerging patterns
- LLM-as-a-judge remains a core eval pattern. Incorporating tool-calling enables better end-to-end testing
- Multiple review agents targeting different aspects, including assessment at individual tool-call and model-call level
- Supplemented with convention tests, deterministic unit tests, linting, and performance testing
- TDD is emerging as the preferred approach — it forces small, deliberate steps which prevents AI from producing large amounts of code before checking feedback
- SDD (spec-driven dev) was much less supported — speakers argued it produces progressively worse code with each iteration
Establish QA plan standards all teams adhere to, covering features, user journeys, and how users engage with apps, APIs, and services. Do this iteratively alongside design and build.
The testing loop doesn't end at deployment. Agent logs, PR feedback, and production failures all feed back into context improvement and eval datasets as a continuous loop.
DesignAgents
Theme 07
Evolving AI UX
Chat is the lowest common denominator, not the destination.
Many speakers argued that code is the universal interface: most consumer apps may eventually be unnecessary because tasks can be accomplished by generating bespoke tools on demand. However, the current interaction model forces the user to do all the work.
This mirrors the limitations of early CLI computing. The CLI was once called the "universal interface" — but ultimately shifted to visual UIs. Chat may be a transitional paradigm rather than a destination.
What's needed
- Purpose-built UIs for multi-agent orchestration with collapsible tool calls, labelled cron messages, agent capability panels, and mentionable knowledge base artefacts
- AI products need to work across devices, survive disconnections, and support concurrent activity — most rely on HTTP streaming which breaks on connection drops
- Design must now cater for three client types: humans, humans in agents, and agents in browsers acting on behalf of humans
"The current way we use computers is absolutely insane. AI should ingest all information and proactively present the next task rather than waiting to be prompted — inverting the relationship so AI prompts humans for decisions rather than humans prompting AI."
Open SourceEngineering
Theme 08
Open source & personal productivity
OpenClaw adoption patterns, security realities, and practical guidance.
Chinese companies are showing significant interest and adopting OpenClaw, a very different pattern to Western companies. Security threats are likely overblown — most advisories are AI generated and have been closed. But they are taken seriously because AI tools are rapidly improving at identifying complex multi-chain exploits.
The risks apply to any agentic system with access to user data, untrusted content, and communication abilities. This is not OpenClaw-specific.
Best practices
- Don't put OpenClaw in group chats
- Personal agents should only be accessible to the individual owner
- OpenAI's view: home users adopting OpenClaw will drive workplace AI adoption
ArchitectureEngineering
Theme 09
Memory and state
Agents operating over time need deliberate memory architecture — session state is not enough.
Multiple talks converged on the same structural problem: agents that work well in isolation break down when they need to operate across time, sessions, or decisions. The missing ingredient is rarely capability — it is memory designed with intent.
A taxonomy of agent memory
The clearest framework: short-term (session state), long-term (persistent knowledge graph), and reasoning memory (decision traces and provenance). Each layer serves a different purpose, and conflating them produces agents that feel stateful but cannot actually learn or explain themselves.
The Outcome stage of decision-making — Remember, Resolve, Defer — feeds back into future decisions. This makes memory a precondition for self-improvement, not just persistence.
Alternative approaches
Stateless agent loops with full session isolation, where state lives externally and is reconstructed on demand, trades continuity for predictability and auditability — a valid design choice depending on the task.
Text itself is a form of state: preserving semantic richness in strings rather than collapsing it into enums is a deliberate memory design decision. How you serialise an intermediate result determines what an agent can do with it later.
Memory in agent systems is not just persistence — it is the mechanism by which an agent improves, explains itself, and avoids repeating mistakes. Treating it as an implementation detail produces agents that are capable in demos and brittle in production.