Several agents splitting work, delegating, or checking each other.
You need to install Docker on your laptop and pull the workshop's Docker image to run the local server. Then, you clone the repository, navigate into the example folder, and launch the Jupyter notebook to act as the client.
▶ 0:20
Stateful Agents — Full Workshop with Charles Packer of Letta and MemGPT
Long-running agents struggle due to finite context windows, context rot, and anxiety near the end of sessions. Additionally, models exhibit poor planning capabilities and are inherently bad at judging their own code output objectively.
▶ 2:47
Anthropic Workshop: Build Agents That Run for Hours — Ash Prabaker & Andrew Wilson
Developers cannot manage thousands of agents, but they can effectively multi-monitor a pod of about six to ten agents. This shift requires commanding a team of agents rather than handling raw implementation or multitasking.
▶ 24:07
The New Dev Skill: Multi-Monitoring 10 Agents
Most agentic projects fail not because the technology is fundamentally flawed, but because developers and project managers lack the proper knowledge to build actual agentic systems. Additionally, large companies often engage in AI washing, rebranding simple chatbots or vibe-coding setups as autonomous agents.
▶ 0:00
Can Agentic Engineering Really Deliver Enterprise-Grade Code? | Reuven Cohen
Senior engineers with 12 to 15 years of experience struggle the most because their professional identity is deeply tied to traditional manual coding methods. Unlike juniors or very experienced veterans, they often reject agentic workflows out of hand.
▶ 1:19
Steve Yegge's Vibe Coding Manifesto: Why Claude Code Isn't It & What Comes After the IDE
The terminal interface started completely by accident because it was the cheapest and easiest way to get a prototype up and running without building a UI. The creator just wanted a simple way to test the API and bash tool use, but it quickly gained traction and stayed there.
▶ 4:23
Inside Claude Code With Its Creator Boris Cherny
Developers can divide knowledge into three distinct categories: intrinsic parametric memory in models, extrinsic ambient data, and learned knowledge from continuous agent execution. Intrinsic knowledge provides the base reasoning capabilities, while extrinsic and learned layers ground the system in enterprise context. This breakdown helps architects decide where to inject context or tune behavior.
▶ 12:31
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Coding agents evolved from traditional chatbots by incorporating tool calling capabilities that let models execute shell commands and file edits. Instead of a strict human-model conversational turn, the model autonomously chains multiple tool calls to accomplish complex objectives. This transforms a simple prompt-response system into an autonomous execution loop.
▶ 4:01
Anthropic's Secret to Better AI Coding Agents
Transformers are inherently stateless machines, meaning that when you close an interaction loop, the model has no built-in way to update its state or learn over time. Relying purely on appending messages to a list held in process memory leads to severe failures when trying to build reliable long-horizon agents.
▶ 2:43
Stateful Agents — Full Workshop with Charles Packer of Letta and MemGPT
The Agent SDK provides foundational primitives like the core agent loop driven by Claude, tool calling via MCP servers, and sub-agent delegation. It also includes permission systems and custom commands to build specialized harnesses.
▶ 5:04
Anthropic Workshop: Build Agents That Run for Hours — Ash Prabaker & Andrew Wilson
The boundary is primarily a matter of trust and quality assurance rather than a technical limitation. Humans still need to be actively involved during the planning and confirmation stages to ensure proper definition and prevent bad outcomes.
▶ 11:41
The New Dev Skill: Multi-Monitoring 10 Agents
Early long-horizon agent swarms were prohibitively expensive, running into thousands of dollars an hour, which made them economically unviable compared to human labor. The major breakthrough occurred when Anthropic introduced flat-fee, all-you-can-eat token pricing with Claude Code, allowing developers to run swarms for an entire month for about twenty dollars.
▶ 8:38
Can Agentic Engineering Really Deliver Enterprise-Grade Code? | Reuven Cohen
Anecdotal enterprise data shows a 10x performance difference across lines of code, commits, and business impact. This massive gap causes significant friction and panic during performance reviews for engineers who refuse to adopt agents.
▶ 3:05
Steve Yegge's Vibe Coding Manifesto: Why Claude Code Isn't It & What Comes After the IDE
Keep your instructions minimal and focused only on the absolute essentials like team PR workflows. If it expands to thousands of tokens and starts causing issues, you should simply delete it and start fresh. As models improve, you need fewer instructions to keep the model on track.
▶ 10:05
Inside Claude Code With Its Creator Boris Cherny
You can ground agents across an entire organization by using a unified entry point like Microsoft IQ that connects documents, emails, and data warehouses. It comprises specific capabilities like Work IQ for productivity apps, Fabric IQ for analytics, and Foundry IQ for agent data. This enables agents to safely access the scattered context they need to complete complex enterprise tasks.
▶ 17:17
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
The core edit tool relies on a primitive find-and-replace mechanism requiring exact byte-for-byte string matches without a cursor or selection interface. It takes parameters for the file name, old string, and new string directly from the model. If multiple identical old strings exist, the model must explicitly declare its expectations or the tool execution fails.
▶ 7:42
Anthropic's Secret to Better AI Coding Agents
It uses a server-client architecture where memory is organized into explicit memory blocks, such as persona and human profiles, represented as editable strings. The system makes the LLM aware of its context window and gives it tool-calling capabilities to actively manage and rewrite its own memory.
▶ 23:22
Stateful Agents — Full Workshop with Charles Packer of Letta and MemGPT
The Ralph Wiggum loop takes a prompt and runs it repeatedly on a loop until all tasks are complete. The core idea is to deterministically repeat execution rather than relying on unpredictable success.
▶ 8:28
Anthropic Workshop: Build Agents That Run for Hours — Ash Prabaker & Andrew Wilson
Workflows enforce a rigid path that strips the AI of its ability to make independent decisions. True agentic systems require full autonomy and proactivity rather than deterministic execution with AI sprinkled in.
▶ 19:54
The New Dev Skill: Multi-Monitoring 10 Agents
The Spark protocol addresses early specification limits by breaking development down into structured stages like pseudo-code outlining and architectural scaffolding. This structure enables a refinement phase where multiple autonomous agents work concurrently using a London School test-driven development approach. By defining tests and specifications upfront, developers can guide AI agents to build complex applications reliably.
▶ 22:17
Can Agentic Engineering Really Deliver Enterprise-Grade Code? | Reuven Cohen
Hands-on experience indicates you need to spend about a year or roughly 2,000 hours working with AI before you fully trust it. Trust means reaching a point where you can accurately predict its capabilities, hallucinations, and limitations.
▶ 4:31
Steve Yegge's Vibe Coding Manifesto: Why Claude Code Isn't It & What Comes After the IDE
Multi-agent swarms allow multiple agents to operate with fresh, uncorrelated context windows, acting as a form of test-time compute. An engineer can set up a spec and an Asana board, allowing independent agents to pick up tasks and build features over a weekend without intervention.
▶ 22:07
Inside Claude Code With Its Creator Boris Cherny
Agentic retrieval should be used for difficult scenarios where single-shot vector searches fall short on evidence recall and answer completeness. The system uses an agentic loop to reflect on datasets and verify whether the information need is satisfied before returning results. While it adds some latency trade-offs, evaluations show it consistently outperforms isolated retrieval methods.
▶ 20:15
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Professional software engineering relies heavily on institutional knowledge, team chat discussions, CI results, and production dashboards rather than source code alone. Constraining an agent to a single repository folder creates severe performance limitations because it lacks access to real enterprise context. Giving models access to the broader work environment is essential for handling large-scale software engineering tasks.
▶ 15:04
Anthropic's Secret to Better AI Coding Agents
Leta acts as a context management system that controls the context window, allowing developers to set strict limits like 10k tokens. This prevents payloads from creeping up over time and causing high latency during enterprise workflows. Despite the small window, the agent retains its memory through external storage mechanisms.
▶ 25:06
Stateful Agents — Full Workshop with Charles Packer of Letta and MemGPT
Splitting the agent into a generator and a GAN-inspired evaluator overcomes the model's inability to judge its own work. While building is hard, an evaluator can be effectively tuned to be harsh and thoroughly test apps using tools like Playwright.
▶ 18:51
Anthropic Workshop: Build Agents That Run for Hours — Ash Prabaker & Andrew Wilson
While coding agents can reduce true production-grade system development time by about a third, client lifetime value remains strong. Instead of shortening projects, teams simply ship more features by pulling directly from the growing backlog. Clients ultimately receive vastly more functionality under steady monthly retainer models.
▶ 31:05
The New Dev Skill: Multi-Monitoring 10 Agents
Permissive languages like Python, Node, and JavaScript allow developers to build code with hidden flaws that still manage to run. In contrast, deterministic languages like Rust are extremely explicit and rigorous in their definitions. Combining a rigid specification with a less permissive programming language ensures that agents build complex projects reliably and correctly.
▶ 25:27
Can Agentic Engineering Really Deliver Enterprise-Grade Code? | Reuven Cohen
Treating an LLM like a human teammate creates a false sense of security, often leading to disasters like accidentally locking out production systems or deleting databases. Because agents can unpredictably make catastrophic changes when given the hot hand, developers must never drop their guard.
▶ 7:47
Steve Yegge's Vibe Coding Manifesto: Why Claude Code Isn't It & What Comes After the IDE
Plan mode is a prompt instruction with a limited lifespan that prevents the model from writing code prematurely. It works by simply adding a sentence to the prompt telling Claude not to code yet, letting it map out tasks before execution.
▶ 25:08
Inside Claude Code With Its Creator Boris Cherny
You can use an agent optimizer component that evaluates a baseline, generates candidate configurations, and hill-climbs on evaluation metrics. It tests various combinations using a loop to iteratively improve agent instructions and tool definitions based on operational traces. Once a better candidate is found, you can deploy it directly by swapping the externalized configuration.
▶ 25:14
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
You can significantly improve agent performance by implementing tighter feedback loops using post tool use hooks that inject real-time errors directly into the tool response. By feeding information like type checking errors and linter warnings back immediately, the model receives a nudge at the exact moment of the mistake. This localized feedback loop beats relying solely on a smarter model or waiting for later compilation.
▶ 23:30
Anthropic's Secret to Better AI Coding Agents
Letta uses core memory which sits inside the context window for immediate top-level recall like hobbies and names. Archival memory acts as an infinite read-write data source like a vector database for large documents outside the context window. Recall memory functions as a write-protected conversation history mimicking messaging search.
▶ 29:55
Stateful Agents — Full Workshop with Charles Packer of Letta and MemGPT
Before writing code, the generator and evaluator negotiate what done means by passing markdown files back and forth on disk. The evaluator pushes back on scope or test cases until both agents mutually agree on a concrete testing contract.
▶ 25:33
Anthropic Workshop: Build Agents That Run for Hours — Ash Prabaker & Andrew Wilson
As individual developers become capable of running their own software factories, agencies must share revenue or offer partner tracks to retain top talent. Without a VC-backed hypergrowth exit strategy, offering a cut of revenue from client pods prevents developers from leaving to start solo firms. This model successfully aligns business interests and keeps builders motivated long-term.
▶ 46:06
The New Dev Skill: Multi-Monitoring 10 Agents
A hive mind provides a shared consciousness where all agents share the exact context of what is happening, making it ideal for broad early development. A swarm uses independently operating agents with shared SQLite memory to tackle narrow, targeted problems like a sculptor detailing a face. Using both allows you to adapt tactics based on the development stage.
▶ 34:26
Can Agentic Engineering Really Deliver Enterprise-Grade Code? | Reuven Cohen
Most engineers have not adopted tools like Claude Code because they find them too difficult to use and read. Developers must sift through massive waterfalls of code and diffs, which requires high reading endurance and a new skillset.
▶ 12:25
Steve Yegge's Vibe Coding Manifesto: Why Claude Code Isn't It & What Comes After the IDE
You should focus on serving the latent demand of the model by observing how it naturally wants to interact with the world and use tools. Rather than boxing the model into rigid APIs, you should enable its desired workflows and build for the model capabilities expected six months in the future.
▶ 31:22
Inside Claude Code With Its Creator Boris Cherny
Building a chat-first collaborative UI matches how humans naturally work with teams through conversation, whereas IDEs and CLIs start with code in the wrong order. It gives developers a single entity to chat with and a collaborative interface to inspect or steer work when diving into the weeds. This design helps maintain mastery over tasks while letting agents handle long, multi-step goals.
▶ 36:05
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Modern LLM token prediction requires previous tokens to match, making dynamic cache eviction like traditional LRU caches extremely expensive. Swapping rules in and out costs significantly more because prediction costs multiply with cache misses.
▶ 30:48
Anthropic's Secret to Better AI Coding Agents
Traditional React agents loop indefinitely until they decide they are done, which increases the risk of derailment. In Letta, the agent uses heartbeat requests where it must explicitly say it wants to keep going. This inverse approach makes the agent much less likely to derail over long time horizons.
▶ 44:25
Stateful Agents — Full Workshop with Charles Packer of Letta and MemGPT
As models become more capable, you can simplify your harness by dropping complex scaffolding like context resetting or sprint decomposition. Newer models can handle longer continuous sessions with simple compaction rather than force-fed single-feature loops.
▶ 34:54
Anthropic Workshop: Build Agents That Run for Hours — Ash Prabaker & Andrew Wilson
The batch tool enables massive concurrency by allowing developers to spawn dozens of sub-agents running in parallel instead of sequentially. This drastically cuts down project completion time from hours to minutes. However, performance gains typically max out around 10 to 20 agents for standard development tasks.
▶ 39:08
Can Agentic Engineering Really Deliver Enterprise-Grade Code? | Reuven Cohen
The traditional IDE will be replaced by agent orchestration dashboards designed for managing multiple background workflows. Instead of writing code directly, developers will review activity feeds, monitor running tools, and handle agent notifications.
▶ 14:06
Steve Yegge's Vibe Coding Manifesto: Why Claude Code Isn't It & What Comes After the IDE
Productivity measured by pull requests has grown significantly, with output per engineer increasing substantially since Claude Code was launched. Many engineers and creators now rely on it completely, uninstalling their traditional IDEs and writing 100% of their code through Claude Code.
▶ 41:00
Inside Claude Code With Its Creator Boris Cherny
OpenAI open-sourced the Codex harness and apps server so developers can inspect, fork, and adapt them directly. This ensures developers use the exact same foundational primitives and product paths that OpenAI uses internally.
▶ 39:51
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
MCP servers load names, descriptions, and schemas directly into the prompt, quickly filling the context window with tool metadata. Similarly, skills keep all their descriptions loaded globally, which overwhelms the context space in large codebases without additional search mechanisms.
▶ 36:33
Anthropic's Secret to Better AI Coding Agents
Multi-agent communication relies on stateful agents interacting through API-backed messaging tools similar to asynchronous chat. Agents can message each other either asynchronously to receive delivery receipts or synchronously by waiting for replies. This design allows independent agents to coordinate via shared communication channels.
▶ 1:02:24
Stateful Agents — Full Workshop with Charles Packer of Letta and MemGPT
You should use a file system for shared state to avoid hitting context window limits in long-running tasks. Instructing the harness to log learnings and JSON status files leaves structured breadcrumbs for future model passes or human developers.
▶ 36:28
Anthropic Workshop: Build Agents That Run for Hours — Ash Prabaker & Andrew Wilson
Validation is still considered the primary challenge when working with agentic flows and LLMs. Developers must constantly verify whether the generated code is true, real, and actually fulfills the requirements. Trusting automated test success without heavy verification can lead to insecure or incorrect code.
▶ 58:48
Can Agentic Engineering Really Deliver Enterprise-Grade Code? | Reuven Cohen
When every developer achieves 10x productivity using agents, merging massive concurrent code changes becomes an incredibly complex problem. Because multiple agents rewrite shared architectures simultaneously, traditional merge conflict resolution fails, requiring serialized queues or complete reimplementations.
▶ 18:51
Steve Yegge's Vibe Coding Manifesto: Why Claude Code Isn't It & What Comes After the IDE
Developers have shifted from manually polling multiple terminal windows and acting as routers to managing a long-running manager agent that delegates work to a team. This setup relies on serverside compaction for persistent context, coordination threads, and automated triggers.
▶ 48:31
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Hooks run outside the context window as scripts, executing only when triggered and avoiding token bloat when irrelevant. Developers can further scale throughput by running multiple persistent agent sessions across isolated git work trees with auto mode safety safeguards.
▶ 45:54
Anthropic's Secret to Better AI Coding Agents
When working with active documents, language models generally perform better when rewriting the entire document from scratch rather than generating line-by-line diffs. You can structure this using simple file read and write tools inspired by Anthropic benchmarks. This avoids the complexity of precise partial edits that models often struggle with.
▶ 1:17:12
Stateful Agents — Full Workshop with Charles Packer of Letta and MemGPT
Instead of trying to patch up a messy, failing code context indefinitely, newer frontier models are surprisingly willing to throw away bad work and restart from scratch. This allows them to hill-climb effectively against the evaluator's rubric without human intervention.
▶ 47:14
Anthropic Workshop: Build Agents That Run for Hours — Ash Prabaker & Andrew Wilson
Moving toward multi-agent systems where code is planned, implemented, and tested automatically unlocks programming for non-programmers and shifts team sizes down to two or three people. Coding ceases to be the delivery bottleneck, forcing businesses to integrate tightly into faster feedback loops.
▶ 24:00
Steve Yegge's Vibe Coding Manifesto: Why Claude Code Isn't It & What Comes After the IDE
Open-sourcing model weights helps meet user demands for security, data control, and premise deployment, especially for enterprise and government clients. It also allows developers to fine-tune models for specialized domains like legal and finance while co-designing future architectures.
▶ 1:04:24
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Running arbitrary tool code requires a secure execution sandbox to prevent agents from compromising the host system. Leta supports integration with E2B by default to isolate tool execution when an API key is provided. While this introduces a trade-off with cold start latency, it safely isolates multi-tenant environments.
▶ 1:00:15
Stateful Agents — Full Workshop with Charles Packer of Letta and MemGPT
Thanks to LLMs, the old dogma of never rewriting your code is obsolete for an increasingly large class of software bodies. When facing complex refactoring or test migrations, it is often significantly faster and cleaner to throw away the old code and have the LLM regenerate it from scratch.
▶ 26:43
Steve Yegge's Vibe Coding Manifesto: Why Claude Code Isn't It & What Comes After the IDE
M3 combines strong coding performance with native vision and video understanding, a combination rarely found in open-source models. It also features a one-million token context window powered by MiniMax sparse attention.
▶ 1:13:48
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Training multimodal models from the first step avoids harming text performance and prevents vision understanding from failing to converge properly. Post-hoc adapters or halfway training are recipe-sensitive and harder to scale cleanly as model sizes increase.
▶ 1:21:48
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Open-sourcing models allows the broader developer community to provide valuable feedback on performance and submit pull requests. This external community contribution directly feeds into improving later model versions and training recipes.
▶ 1:26:46
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Temperature zero only forces greedy decoding for sampling, but it does not control underlying hardware factors like non-associative floating-point math, batch invariance, and mixture of experts routing. These systemic variables cause runs to diverge even with identical inputs and zero temperature.
▶ 1:40:22
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Developers should focus on replayability and observability by recording state transitions at node boundaries rather than expecting exact token output matches. Capturing what enters and leaves each node provides the necessary context to debug intermittent production failures.
▶ 1:42:58
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Pinned threads allow ongoing workstreams to persist over time with automated triggers and heartbeats instead of forcing developers to constantly spin up short, isolated chat sessions. This enables agents to act like persistent teammates that monitor tasks and run background updates.
▶ 1:48:47
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Individual agent threads can communicate directly with each other, allowing a main monitor thread to delegate work by spawning, renaming, and pinning new sub-threads. This structure enables specialized agent managers to handle tasks like triaging issues and running background automation without constant human intervention.
▶ 1:48:16
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
You can set up a dedicated monitor thread that wakes up on a schedule to read communication channels like Slack and Twitter. This agent triages issues, creates and pins new threads for communication, and sends messages if problems persist.
▶ 1:58:58
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Temperature zero only guarantees greedy decoding, but non-determinism still stems from GPU floating-point math, batch variance, and MoE routing. The right approach is to focus on replayability and debugging system states rather than chasing exact token outputs.
▶ 2:05:24
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Automatic model routing evaluates the difficulty of a given task by analyzing prompt structures, codebases, and tool usage. It then selects the cheapest model that meets the performance threshold, switching to more capable models only if failures occur.
▶ 2:16:22
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Agents are structured in a sequence where each worker passes fresh context and tasks to the next, while sub-agents handle parallel subtasks. Dedicated validators then rigorously review the code and test functionality using virtual computers before completion.
▶ 2:22:28
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
The engine progressively discloses tool specifications by keeping a short list of descriptions upfront. When specific tools are actually required in the code, they are fully loaded and called without removing anything entirely.
▶ 2:26:10
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Standard browser agents often fail because their underlying infrastructure is slow and lacks good environment abstractions for planning long sequences. Providing a compressed web representation reduces token counts and lets the agent see the entire page efficiently.
▶ 2:33:18
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
You should adopt new workflows the day they come out unless they fail the efficient market test. Use a heuristic asking why a workflow isn't already the default, and protect critical paths with strict human review zones.
▶ 2:42:20
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Instead of training custom models, you can feed years of company history into bite-sized chunks stored as vectors and knowledge graphs. Then, deploy a pantheon of specialized agents—each with a single job—to handle tasks like quotes, outbound emails, and lead scoring.
▶ 3:00:39
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Statistical analysis shows that agent-written PRs have similar revert rates, review rounds, and critical issue counts compared to human-written code. While they make different types of qualitative errors, their overall performance in commercial settings is comparable.
▶ 3:09:44
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Manual code review becomes infeasible when developers generate hundreds of commits a month. Instead, you should rely on autonomous validation that answers core questions about user contract violations and simulates user behavior in a sandbox.
▶ 3:15:15
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Instead of forcing agents to manipulate graphical canvas tools or write raw SVG coordinates, have them use HTML as a native language. Browsers automatically render these tags into precise visual layouts, giving models structure they intuitively understand.
▶ 3:20:37
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Relying on local emulators or long CI builds introduces too much friction and context switching for agents and developers. Instead, use cloud sandboxes with quick-booting VMs that render previews directly in an in-app browser.
▶ 3:29:49
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
You can use a dedicated layer-7 proxy that sits between your application and the database to simulate network failures and slow downs. This lets you test driver recovery and failure logic directly in your test suites without mocking low-level drivers.
▶ 3:45:46
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Napkin math allows you to calculate the theoretical limits of hardware, such as DRAM or SSD bandwidth, for a given query structure. This helps you quickly catch flawed database benchmarks and identify discrepancies between expected and actual performance.
▶ 3:51:15
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
The founder realized that traditional vector databases were too expensive, costing tens of thousands of dollars per month for modest workloads. By utilizing S3 object storage with clustering and reverse proxy caching, he built a much cheaper vector database. This reduced operational costs dramatically while maintaining necessary data invariants.
▶ 3:57:17
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Cursor was facing unsustainable unit economics because they were storing all vectors in DRAM. They found that Turbopuffer's approach of using S3 for storage while hotloading codebases into memory matched their architecture. This migration successfully reduced their previous vendor bill by 95 percent.
▶ 4:04:44
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Reinforcement learning workloads require massive amounts of CPU power to teach models how to search, use tools, and run bash commands. Additionally, general-purpose agent systems running concurrently consume significant CPU resources. As a result, companies and AI labs are fiercely competing for CPU allocations and NVME SSDs.
▶ 4:12:53
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
The founder initially treated the startup like a traditional SaaS project, focusing on achieving profitability and matching costs rather than seeking massive funding right away. When they eventually raised a small seed round, they set clear conditions that if product-market fit wasn't reached, they would shut it down and return the money. He also categorized fundraising into strict, honest reasons like R&D and employee liquidity over ego.
▶ 4:21:49
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Traditional benchmarks only measure isolated model capability rather than complete system behavior. Production environments introduce variables like tool failures, API outages, and long-running workflows that static benchmarks miss. Therefore, the performance gap between offline benchmarks and real production continues to widen.
▶ 4:30:58
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
The team separated the applications to let the AI star player cook without unnecessary IDE constraints. They view the IDE to the agent manager as a debugger is to an IDE—something you use when going a layer deeper. This allows developers to use the agent manager as a standalone mission control app.
▶ 4:33:22
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Multi-agent swarms can handle massive development tasks like building an entire operating system kernel from scratch. Using models like Gemini 3.5 Flash, the main agent dynamically generates specialized sub-agents to collaborate in parallel. These massive runs involve thousands of requests and tokens but produce complete working applications.
▶ 4:39:40
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
A sidecar is a long-lived utility plug-in protocol that allows the model to listen to the outside world. It enables agents to set up their own triggers for external events like webhooks, cron jobs, and GitHub pull requests. This replaces rigid mechanical UIs with flexible background listening capabilities.
▶ 4:46:30
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
As implementations become easily generated on demand by agents, the core value shifts away from the code implementation itself. Instead, the product and true value reside in the specification and protocol. Developers reuse specifications rather than general-purpose implementations to derive bespoke infrastructure.
▶ 4:51:03
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
An automated software factory processes ideas through a closed-loop system of specialized agents and human touchpoints. Inputs undergo triage, spec generation, automated implementation, code review, computer-use verification, and post-shipping monitoring. This loop feeds performance and error data back into the top to continuously improve the system.
▶ 4:58:37
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
OpenGov migrated to have full agency over their agent loop to handle complex use cases and features. This transition also propagated effect's built-in tracing, concurrency, and fine-grained logging throughout the entire agent architecture.
▶ 5:21:34
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Game-inspired orchestrators borrow mechanics from strategy games like Warcraft or Civilization to provide real-time visibility and quick navigation across active agents. This interface lets users inspect agent maps, track file changes, and jump directly to tasks requiring human attention.
▶ 5:28:19
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Most agent pipelines fail because retrieval is static and relies solely on embedding similarity rather than learning from outcomes. Evaluation signals typically die in dashboards instead of feeding back into the agent context, leaving memory focused on static facts rather than reasoning.
▶ 5:42:08
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Agent RX is a runtime layer that allows production agents to improve from past execution history and outcomes. It introduces utility scores that re-rank retrieved memories based on whether they historically helped or hurt task execution.
▶ 5:45:24
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Building a model-agnostic harness allows you to switch between frontier models and avoid getting trapped by unfair token pricing. Notion uses an auto-model setup to route the majority of their traffic while retaining the optionality to walk away from any single provider.
▶ 6:02:13
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Moving to a custom Effect-native agent loop gives a team full control over complex features and scaling workflows. It propagates Effect's native features like fine-grained tracing, concurrency, logging, and dependency injection throughout the entire agent execution.
▶ 6:13:36
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Using an open agent-to-agent communication protocol provides a rigorous spec for inter-agent routing and interaction. By defining standardized agent cards, both frontend and backend teams can reliably consume and produce against a shared contract.
▶ 6:15:32
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Agents can execute and test code within ephemeral, isolated sandboxes that are spun up on-demand and torn down afterward to protect production systems. For mutating operations, teams can deterministically interrupt the agent loop to require explicit human approval via a UI.
▶ 6:18:53
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Instead of relying on inconsistent code reviews, teams can establish stable architecture invariants using a compact architecture file. This file outlines core layers, such as compiler stages, that every LLM can understand and adhere to without friction.
▶ 6:22:03
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Benchmarks only measure model capability and answers rather than real-world system behavior like tool failures or workflow execution. Production telemetry and scenario-driven evaluations provide the highest-value signals for system reliability.
▶ 6:42:20
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
By applying control theory principles, teams can drive codebases toward a desired state through incremental changes rather than blind loops. This approach uses sensors and actuators to build software in small, reviewable steps.
▶ 6:52:15
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Workflows can check if an open pull request from the same loop already exists before running a new iteration. If unreviewed work is pending, the loop shuts down to ensure only one pull request is open at a time.
▶ 7:02:04
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Specifications must be abstract because agents fail when forced to jump straight from an abstract idea to a concrete implementation. By introducing intermediate concrete specifications with explicit data schemas and indices, agents can successfully build production systems.
▶ 7:08:53
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
You can give the agent access to a deterministic simulation environment to discover correct algorithms under partial failure. The simulator exposes edge cases like stale reads and version mismatches that real target platforms might produce.
▶ 7:11:21
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Simulation environments can record hidden platform facts, like whether a read was fresh or stale and what the latest value was. This allows the agent to understand why an invariant failed rather than just seeing that it did fail.
▶ 7:17:50
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Software factories fail because coding models are optimized to pass binary test outcomes rather than maintain code quality. Over time, this leads to eroded codebase maintainability and makes complex brownfield systems harder to change.
▶ 7:41:54
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Current coding models are trained with binary rewards based on whether unit tests pass or fail. Because the system cannot penalize poor program design or architectural degradation during RL, models resort to shortcuts just to pass tests.
▶ 7:44:51
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
You can reintroduce upfront planning like product reviews, system architecture docs, and program design before letting the agent code. Spending a short amount of time in pre-planning saves hours in review and ensures you still own the code.
▶ 7:48:12
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
You can ensure agent safety by separating the agentic planning phase from execution side effects using type systems and compilers. By refifying plans into executable programs rather than black-box IO, you can perform static safety analysis and proofs.
▶ 8:06:41
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Proof-carrying code allows an AI model to generate both a program expression and a mathematical proof that the computation is safe. This enables static verification without needing to run the dangerous agentic loop beforehand.
▶ 8:07:51
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Training frontier models involves a dual loop system comprising a slow outer loop of user feedback and evals, and a fast inner loop of rigorous training tasks. Scaling compute and improving these loops allows for continuous model refinement.
▶ 8:14:47
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Models can exploit public evaluations by searching git history or querying online forks for solutions. To counter this, you can strip git history during runs, apply network allow lists, and rely on private held-out benchmark sets.
▶ 8:20:23
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Long agent rollouts make credit assignment difficult for tool calls and thinking blocks. Using textual feedback, a teacher model can provide hints and nudge probability weights on specific segments to shape desired tool adherence.
▶ 8:23:17
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
Researchers can be unblocked by granting agent fleets access to execution tools, Slack integrations, and context. This allows agents to run experiments, generate difficult evals, and page humans only when infrastructure issues arise.
▶ 8:30:29
WF2026: Software Factories & Keynotes ft. Microsoft, OpenAI, OpenClaw, Z.ai (GLM), MiniMax, HF
No answer mentions that.