Agentic Engineering — The Video Signal

Aug 10, 2026 · 37:15

Engineers… Your Software Factory NEEDS Agent Sandboxes to SCALE (exe.dev)

The video argues that traditional methods of running AI agents—such as allocating a small corner of a local machine or relying solely on containers/CI/CD—create bottlenecks. To achieve true scale and autonomy in an 'AI developer workflow' (ADW), the entire software factory must be moved into dedicated, isolated agent sandboxes (e.g., using exe.dev). This architecture enables complex workflows like running 'Best of N' comparisons across multiple model configurations while maintaining zero blast radius via disposable keys.

Key takeaways

The Bottleneck Problem
If an engineer is 'in the loop,' they are the bottleneck. True scaling requires moving beyond local compute limitations by giving every agent its own isolated computer, achieving isolation, scale, and autonomy.
Three-Tier Architecture for Scale 23:25
The recommended architecture involves an Out-loop orchestrator (on the engineer's machine), an In-sandbox orchestrator (on each VM), and the core Software Factory/ADW agents running inside the sandbox. This allows the top-level agent to kick off work and then go quiet, only requiring human intervention at planning and reviewing stages.
Best of N Pattern 17:05
Sandboxes enable running 'Best of N' patterns by simultaneously executing the same prompt/workflow across multiple agent configurations (e.g., Default, Frontier, Deepest, Open Weights), allowing for comparison and selection of the optimal outcome.
Security and Isolation 27:50
Sandboxes provide critical security by ensuring a 'bounded blast radius.' Agents use ephemeral resources, such as OpenRouter provisioning keys with hard spend caps, which are revoked upon teardown, preventing unauthorized access to production systems (e.g., AWS).

Watch on YouTube Full article

Aug 3, 2026 · 29:53

My Super Simple Software Factory (For Agentic Engineers)

The video introduces the concept of a 'Software Factory'—an advanced system for agentic engineering that moves beyond relying solely on autonomous agents. The core thesis is that combining **Agents + Code** provides significantly more leverage and reliability than agents alone. This factory automates the entire Software Development Life Cycle (SDLC) by integrating deterministic code checks, ensuring repeatability, observability, and scalability across complex AI developer workflows.

Key takeaways

Agents Plus Code is Superior
The most significant advancement in agentic engineering is the combination of agents with explicit, deterministic code. This structure ensures reliability, cost control, and verifiable output, mitigating risks associated with pure AI orchestration.
Three Core Design Principles 2:00
The Super Simple Software Factory is built on three non-negotiable principles: **Observable** (full visibility into every phase, prompt, and cost breakdown); **Customizable** (using a single YAML config to control the core four elements: context, model, prompt, tool); and **Reusable** (deployable across any codebase via an `/install` command).
Scaling Compute for Impact 3:50
The system is designed to scale compute power by orchestrating complex, multi-step workflows (e.g., Plan $ ightarrow$ Build $ ightarrow$ Test $ ightarrow$ Review) that operate without constant human intervention.

Watch on YouTube Full article

Aug 3, 2026 · 10:46

Agentic Engineering vs Software Engineering: Beyond Vibe Coding

Software engineering is undergoing a fundamental shift from writing explicit, deterministic instructions to defining high-level goals and orchestrating autonomous AI agents. Agentic Engineering treats AI systems as collaborators capable of multi-step workflows, requiring the human developer's role to evolve into that of an architect who supervises, constrains, and validates probabilistic outputs rather than manually executing every task.

Key takeaways

The Shift in Effort
Traditional software engineering requires writing explicit instructions (deterministic logic). Agentic Engineering allows developers to define goals, while AI agents handle the execution, changing where the core engineering effort is applied.
Defining Agentic Engineering 3:42
Agentic refers to an organization of agents that write code, while the human developer maintains a 'human in the loop' to oversee and validate the output as the multi-agent system iterates through subtasks.
The Coding Spectrum 5:01
Coding methods exist on a spectrum based on human agency: Traditional SE (full control) $ ightarrow$ AI-assisted coding (snippets/refactoring) $ ightarrow$ Vibe coding (natural language intent) $ ightarrow$ Agentic coding (autonomous planning/execution) $ ightarrow$ Agentic engineering (designing environments for autonomous systems).
Increased Value of Oversight 8:44
As agentic systems become more autonomous, the value of human oversight increases significantly. Engineers are now responsible not only for writing code but also for ensuring reliability across probabilistic workflows.

Watch on YouTube Full article

Jul 27, 2026 · 34:30

Is Anthropic STEALING Your Data? (While You PAY FOR IT)

While Anthropic's Terms of Service state that they do not own user outputs and are not 'stealing' data, the video argues that users pay twice: once with cash, and again with proprietary Intellectual Property (IP). The core risk is that AI labs use anonymized aggregate usage data to create a detailed 'market map,' allowing them to identify profitable vertical domains and subsequently compete directly with their customers. To mitigate this, engineers must prioritize 'AI sovereignty' by moving up the 'sovereignty ladder'—ideally by self-hosting open-weights models on rented GPUs to own the model, traces, and learning loop.

Key takeaways

The Double Payment Model
As noted by Satya Nadella, users pay for intelligence twice: once with money, and again with proprietary knowledge (IP) that must be revealed to make the AI useful. This IP is the primary asset at risk.
Data Usage Creates a Market Map 3:38
Anthropic and other model labs use anonymized aggregate data (via systems like Cleo) not for direct theft, but to build market intelligence. This map shows profitable trends in domains like coding, design, and life science, enabling the platforms to compete with their users.
IP Agents vs. Commodity Agents 22:05
Engineers must distinguish between 'commodity agents' (boilerplate/CRUD work) and 'IP agents' (unique business know-how, domain logic, or highly asymmetric workflows). Only the latter requires active defense against platform dependency risk.
The Sovereignty Ladder Solution 28:46
To protect IP, users must move up the sovereignty ladder: Tier 4 (Hybrid Private) is the optimal solution, involving running open-weights models on rented GPUs while owning the model and all traces/evals. This minimizes dependency risk from single AI labs.

Watch on YouTube Full article

Jul 20, 2026 · 26:22

Engineers... STOP Picking GPT-5.6 Sol OR Claude Fable 5… FUSE THEM

The video argues that in agentic engineering, the optimal approach is not to choose a single 'winner' model (e.g., GPT 5.6 Sol vs. Claude Fable 5), but rather to implement Model Fusion. This involves building custom agent harnesses that coordinate multiple state-of-the-art models working together. The process utilizes specialized commands—`/opinion` for diverse perspectives, `/fusion` for consolidating results, and `/auto validate` for intelligent on-the-fly review—to significantly outperform single-agent workflows.

Key takeaways

Model Fusion: AND, Not OR
The most powerful approach is combining the compute and intelligence of multiple models rather than selecting a single winner. This pattern combines concepts previously known as architect editor, prompt chaining, and agent chaining.
Three Core Commands for Orchestration 2:00
A custom fusion harness uses three commands: `/opinion` (to gather multiple perspectives), `/fusion` (to combine and consolidate results), and `/auto validate` (for intelligent on-the-fly validation, addressing the review constraint of agentic engineering).
Value of Fusion vs. Single Agent 5:45
Fusion allows agents to identify consensus, divergence, and discarded information, providing a comprehensive view that is critical for high-stakes strategic decisions.

Watch on YouTube Full article

Jul 13, 2026 · 34:18

FORGET Loop Engineering. Agentic Engineering is about THIS

The video argues that 'Loop Engineering' is an insufficient and inaccurate mental model for modern software development with AI agents. The superior approach is **Agentic Engineering**, which focuses on building complex AI developer workflows (ADWs) within a 'software factory.' These ADWs orchestrate three core actors of value creation—Engineers, Agents, and Code—to automate the entire development lifecycle, from planning to deployment, thereby scaling impact and accelerating development far beyond what simple loops can achieve.

Key takeaways

Shift Focus from Loops to Workflows
Loop engineering is a poor rebrand of the Software Development Life Cycle (SDLC). The focus must be on building comprehensive AI developer workflows that combine code execution with agents, rather than focusing solely on iterative loops.
The Three Actors of Value Creation 2:00
Successful agentic engineering requires understanding and strategically placing three actors: the human engineer, specialized AI agents, and deterministic code. Code is highlighted as the most reliable actor because it costs zero tokens and runs consistently.
Scaling Developer Workflows 4:00
Advanced workflows move beyond simple loops by integrating multiple validation steps (e.g., linting, type checking, formatting) and scaling compute through specialized sandboxes for parallel execution. This process is the core of building a 'software factory.'
Meta-Engineering: Building the System 8:00
The most valuable engineering effort is not working on the application layer, but performing meta-work on the agentic layer—building the system that orchestrates and manages all other components (the 'system that builds the system').

Watch on YouTube Full article

Jul 6, 2026 · 30:29

SEE CMUX SOLVE Multi-Agent Orchestration (Claude Code and Pi Agent)

This video explores advanced multi-agent orchestration patterns and the critical need for 'agentic access' to improve agent performance. The speaker argues that simply running many agents in a loop ('vibe coding') is insufficient; true progress requires visibility and programmatic control over the entire process. Cmux is presented as a tool that solves three major problems: lack of programmatic access, inability to monitor/improve agents, and slow manual setup time for large agent teams. The core architectural pattern recommended is three-tier orchestration (Orchestrators prompt Leads, who prompt specialized Experts).

Key takeaways

Agentic Access is Paramount 2:03
An agent you cannot see or programmatically interact with cannot be improved. This principle distinguishes 'agentic engineering' from simple 'vibe coding.'
Three-Tier Orchestration Pattern 0:45
The recommended structure for multi-agent teams is: Orchestrators prompt the Leads, and Leads prompt specialized Agent Experts.
Scaling Compute to Scale Impact 6:20
Multi-agent orchestration allows scaling compute by running multiple diverse agents (e.g., Claude Code, Codex, Pi agent) in parallel on the same problem, ensuring visibility into all attempts.

Watch on YouTube Full article

Jun 29, 2026 · 26:20

GLM-5.2 vs MiniMax-M3: Opus Has REAL COMPETITION (Model Stacking)

The video argues that proprietary models like Opus 4.8 face real competition from open-weight alternatives such as GLM-5.2 and MiniMax-M3. The core thesis for build engineers is not to select a single model but to implement a resilient 'model stack.' This strategy involves strategically choosing models across three tiers—State-of-the-Art (SOTA), Workhorse, and Lightweight/Local—to optimize the trade-off between performance, cost, and speed for both engineering agents and product deployment.

Key takeaways

GLM 5.2 vs MiniMax M3: Performance vs Cost 17:54
GLM 5.2 is highlighted as the better model in terms of raw performance (A-tier), while MiniMax M3 is considered the better deal due to its optimized cost structure, making it ideal for high-volume product agents.
The Three-Tier Model Stack Framework 2:50
Engineers should categorize models into three tiers: State-of-the-Art (e.g., Opus 4.8, Fable 5), Workhorse (GLM 5.2, MiniMax M3), and Lightweight/Local (Qwen 3.6). This framework guides decision-making based on the required trade-off.
Resilience through Open Weights 6:49
Due to concerns about vendor lock-in or potential service shutdowns (e.g., Fable), relying solely on closed-source models is risky. Utilizing open-weight models like GLM 5.2 and MiniMax M3 ensures greater control and ownership over the AI infrastructure.

Watch on YouTube Full article

Jun 22, 2026 · 1:02:49

PLANS For Fable 5: Rebuilding My /Plan Skill for Mythos Class Models

This deep-dive devlog details the rebuilding of a comprehensive `/plan` meta skill (`PlanF3`) designed for next-generation Large Language Models (LLMs) like Fable 5 and Mythos class models. The core thesis is that superior engineering results depend on rigorous, upfront planning—a concept termed 'great planning is great engineering.' By investing heavily in structured templates, the speaker creates a meta skill that forces agents to output highly detailed, standardized plans in HTML format, thereby improving performance over speed or cost (the 'trade-off trifecta'). The resulting plan acts as a living artifact for the entire codebase, integrating complex workflows like image generation and agent-to-agent communication.

Key takeaways

The Importance of Planning in Agentic Engineering 2:00
Planning is identified as the single most critical tool an engineer has. The speaker warns against outsourcing thinking or planning to models, arguing that detailed, structured plans are necessary for end-to-end control and reliable results at scale.
The PlanF3 Meta Skill Architecture 4:00
The new skill is designed to be a 'meta skill'—a prompt that creates other prompts or skills. It mandates structured output in HTML format, which is preferred for its ability to convey rich information and utilize tokens efficiently across the 'trifecta' of users: human engineers, engineering teams, and AI agents.
Structured Planning as an Artifact 7:30
The plan is treated as a living artifact containing mandatory sections like Purpose, Problem, Solution (P/S/R), Relevant Files (existing and new), Implementation Phases (with embedded checklists), Testing Strategy, and detailed Metadata Headers (tracking agent name, session ID, back/forward references).
Advanced Workflow Integration 11:20
The skill is modularized into dedicated workflows: `create plan`, `update plan`, `update references`, `build plan`, and `image generation`. This structure allows for complex, multi-step processes (e.g., running a build cycle that updates status markers in the plan).

Watch on YouTube Full article