Agents that work asynchronously in CI or the cloud and come back with a PR.
Engineers can now delegate routine implementation tasks to AI agents, freeing up time to focus on creative work and user experience. With the timeline from idea to product shrinking drastically, product taste and business sense have become much more valuable than raw execution speed.
▶ 1:48
Claude Fable, Claude Tag, and Anthropic's Culture — Cat Wu & Thariq Shihipar ft Simon Willison
Running the agent inside the sandbox simplifies state management because everything is localized, but it creates serious security risks because secrets must live in the box where the unpredictable AI can exfiltrate them. An out-of-the-box architecture separates the brain from the machine, using a worker control plane to operate the sandbox via tool calls, which secures your secrets despite adding architectural complexity.
▶ 12:09
Devin’s 80% Moment: Background Agents, 7x PRs, & End of Hand-Held Coding — Walden Yan & Cole Murray
Uber initially saw a modest 10 to 15 percent bump in diff velocity using synchronous tab completion and IDE chat in 2022 and 2023. Over the past year, the paradigm shifted to peer programming, where developers hand off asynchronous workloads to AI agents and act as tech leads directing these agents. This allows engineers to delegate toil like dead code cleanup and library migrations to focus on creative work.
▶ 3:59
Uber: Leading engineering through an agentic shift - The Pragmatic Summit
You can assign multiple GitHub issues to Copilot directly from the issues page on github.com. The coding agent will pick up those issues to work on them simultaneously in the background.
▶ 0:53
How the GitHub Copilot coding agent works | GitHub Checkout
Claude Tag provides an extra degree of proactivity by autonomously initiating conversations, managing cross-channel memory, and executing long-running tasks. It can spin up its own sandboxes and ping you when a pull request is ready, shifting workflows from single-player sessions to asynchronous, multiplayer collaboration.
▶ 4:02
Inside Anthropic: How Claude Tag Is Changing Agentic Work
Build systems must be re-tooled to complete in under a minute to accommodate the agent's need for fast feedback loops. If a build exceeds this time, developers decompose the build graph to keep the agent operating smoothly. This strict discipline prevents bloated build times and maintains code invariants.
▶ 6:13
Extreme Harness Engineering: 1M LOC, 1B toks/day, 0% human code or review — Ryan Lopopolo, OpenAI
Labs focused their reinforcement learning and reasoning efforts heavily on code generation throughout 2025. This culminated in November models crossing a reliability threshold where they execute instructions accurately almost all of the time. Instead of mostly working code requiring close attention, developers can now rely on agents to build complete applications reliably.
▶ 4:08
An AI state of the union: We’ve passed the inflection point & dark factories are coming
Coding agents have shifted from a peripheral feature to taking center stage across the software development lifecycle. Developers are increasingly leveraging these tools because coding provides an exceptionally valuable and practical use case for AI automation. As a result, agentic workflows are now appearing everywhere in modern tooling.
▶ 8:52
Why AI Coding Agents Are Here To Stay | Patrick Debois
The production team used a computer-controlled camera system called a DijkstraFlex to repeat exact camera movements. This allowed them to shoot models in layers and combine them into seamless shots without humans in the loop.
▶ 0:53
The next era of AI coding
Offload heavy agent workloads to a remote Linux machine rather than your primary computer to avoid bottlenecks. You can set up a server on a separate Linux box that handles your codebases and code servers. This keeps your local laptop free for other tasks without performance drops.
▶ 5:09
You're using AI agents wrong
Claude Tag lives inside team collaboration tools like Slack and is multiplayer by default, allowing multiple team members to collaborate on pull requests together. Additionally, it operates proactively rather than reactively, monitoring channels and handling tasks automatically based on team memory.
▶ 6:56
Claude Fable, Claude Tag, and Anthropic's Culture — Cat Wu & Thariq Shihipar ft Simon Willison
Full VMs are necessary because Docker containers are not true security boundaries and running applications inside Docker introduces nested configuration issues. Full VMs support complex testing workflows, running full applications, and even nested virtualization for Android emulators. However, you can still use Docker for your infrastructure setup since developers are already familiar with it.
▶ 17:35
Devin’s 80% Moment: Background Agents, 7x PRs, & End of Hand-Held Coding — Walden Yan & Cole Murray
As soon as agentic workflows were made available, 70 percent of the workloads pushed by developers were toil tasks. This happened because the start and end states of tasks like library upgrades and migrations are straightforward, leading to much higher accuracy. Because of this success, tackling toil with AI became a top priority for the developer platform.
▶ 6:45
Uber: Leading engineering through an agentic shift - The Pragmatic Summit
As soon as a task is assigned, the agent creates a draft pull request with a basic title and body. As it works, it gradually updates the pull request body with a plan and ticks off completed items.
▶ 1:54
How the GitHub Copilot coding agent works | GitHub Checkout
Developers move away from single-player IDE sessions toward asynchronous, multiplayer collaboration directly inside communication channels like Slack. Instead of stepping through every turn of the agent, developers define success criteria and let long-running agents execute complex tasks and ping teams for reviews.
▶ 11:33
Inside Anthropic: How Claude Tag Is Changing Agentic Work
Developers spawn the coding agent as the primary entry point rather than setting up a predefined environment first. The agent uses provided skills and scripts to boot the necessary local development stack and configure its own environment variables. This approach allows reasoning models to make intelligent choices rather than operating inside a rigid box.
▶ 11:37
Extreme Harness Engineering: 1M LOC, 1B toks/day, 0% human code or review — Ryan Lopopolo, OpenAI
Vibe coding is a hands-off approach where you do not look at or understand the code, making it suitable for personal prototypes. In contrast, agentic engineering is a professional discipline for building production-ready software using autonomous coding agents that write, debug, and test code. This requires deep software experience to ensure the results are safe and deployable.
▶ 8:57
An AI state of the union: We’ve passed the inflection point & dark factories are coming
The rapid advancement of AI technology means that developers must constantly reinvent how they use these tools rather than relying on outdated habits. Sticking to simple code completions prevents teams from embracing new paradigms like agents and specifications. Every six months, a new set of tools unlocks entirely different ways of working.
▶ 11:50
Why AI Coding Agents Are Here To Stay | Patrick Debois
Developers have had to translate high-level thoughts into verbose, step-by-step logic like conditional statements and loops. This manual translation takes huge amounts of time and makes simple features require tens of thousands of lines of code.
▶ 2:39
The next era of AI coding
Burn more tokens by having AI models thoroughly audit the pull request before you set up an environment to test it yourself. This helps catch obvious failures and issues upfront, reducing the chance of hitting a demotivating broken state. Using Linux also helps by allowing you to run parallel tasks smoothly without system friction.
▶ 12:31
You're using AI agents wrong
Newer frontier models possess stronger judgment and creativity, meaning they no longer require rigid examples or excessive hard constraints. Engineers found that over-constraining the model caused confusion, so they replaced restrictive rules with broader context and trusted the model's discretion.
▶ 21:57
Claude Fable, Claude Tag, and Anthropic's Culture — Cat Wu & Thariq Shihipar ft Simon Willison
Testing is a complex problem-solving challenge rather than simple computer use because it requires orchestrating multiple services, managing correct code versions, and triggering specific features. Agents need full codebase context to understand how to run applications together, handle admin states, or use feature flags. In some cases, systems even require orchestrating different frontier models together to solve these end-to-end tasks.
▶ 21:32
Devin’s 80% Moment: Background Agents, 7x PRs, & End of Hand-Held Coding — Walden Yan & Cole Murray
Uber built a central MCP gateway using a tiger team to proxy both external and internal MCPs from service infrastructure. It exposes these services consistently to engineers while managing authorization, telemetry, and logging. Additionally, they provide a registry and sandbox so developers can discover, test, and ensure new MCPs work as expected.
▶ 9:53
Uber: Leading engineering through an agentic shift - The Pragmatic Summit
Yes, the agent can connect to external services like Notion using the Model Context Protocol. This allows it to pull in necessary requirements and context that reside outside of the repository.
▶ 1:36
How the GitHub Copilot coding agent works | GitHub Checkout
Agent execution time horizons are on an exponential trajectory, doubling roughly every four months according to METR research. This increase in capability means agents can handle more multi-step tasks, verify their own work, and earn greater human trust.
▶ 15:55
Inside Anthropic: How Claude Tag Is Changing Agentic Work
The authoring agent is explicitly instructed to evaluate review feedback and given the flexibility to either defer or push back. Without this permission, coding models tend to blindly follow all instructions and can fail to converge with automated PR reviewers. Providing a scoring framework helps the agent prioritize and handle feedback appropriately.
▶ 15:28
Extreme Harness Engineering: 1M LOC, 1B toks/day, 0% human code or review — Ryan Lopopolo, OpenAI
Teams implement the dark factory pattern by using a swarm of agent testers that simulate end users interacting with the system around the clock. To bypass rate limits on real third-party platforms, they use coding agents to build complete local API simulations of external tools. This enables robust, automated quality assurance without anyone directly reading the codebase.
▶ 15:35
An AI state of the union: We’ve passed the inflection point & dark factories are coming
Specifications are becoming more important than code because modifying a spec allows you to regenerate the entire codebase cleanly from it. They act like a guide that aligns both human teams and AI models on the desired behavior and structure. By feeding detailed requirements into the workflow, specifications directly drive the code generation process.
▶ 19:16
Why AI Coding Agents Are Here To Stay | Patrick Debois
Software is designed to serve users simply through buttons and straightforward interfaces, masking the tens of millions of lines of underlying code. Unlike physical structures like Gothic cathedrals, software does not wear its massive structural weight on its sleeve.
▶ 3:17
The next era of AI coding
Use fast or cheap AI models to audit and prioritize your open pull requests and background threads automatically. You can also use thread features like settling or snoozing to clear out completed work or hide distractions from your sidebar. When an AI response is too complex, ask it to simplify the explanation to avoid cognitive fatigue.
▶ 16:26
You're using AI agents wrong
Auto Mode uses a Sonnet-based classifier running on every turn to judge tool calls and conversational context dynamically. It integrates with sandboxing infrastructure to vet network requests on the fly and has been hardened through extensive red teaming.
▶ 31:43
Claude Fable, Claude Tag, and Anthropic's Culture — Cat Wu & Thariq Shihipar ft Simon Willison
Agent memory remains a challenging and largely unsolved retrieval and generation problem because you want the system to learn preferences over time without flooding the context with useless information. Systems like Devin use auto-generated knowledge items where users can quickly approve or reject learned preferences, and agents can update or prune memories when things change. Alternatively, teams explore file-system-based approaches to let agents navigate their own persistent context.
▶ 30:55
Devin’s 80% Moment: Background Agents, 7x PRs, & End of Hand-Held Coding — Walden Yan & Cole Murray
AIFX is a CLI tool introduced to centrally provision, configure, and update agent clients like Cloud Code, Codepilot, or Cursor. It allows developers to easily install and discover MCPs from the registry and apply standard configuration management. This ensures that engineers new to the space immediately get effective prompts, configurations, and connections to background task infrastructure.
▶ 11:42
Uber: Leading engineering through an agentic shift - The Pragmatic Summit
The agent uses tools to explore the repository, runs tests to ensure the code works, and executes linters. This ensures that the generated pull request is clean and ready to go rather than half-baked.
▶ 2:48
How the GitHub Copilot coding agent works | GitHub Checkout
Claude Tag agents are given their own independent permissions and API keys rather than assuming the user's permissions. This allows them to work autonomously on behalf of the team instead of an individual. Consequently, it becomes much easier to audit the agent's actions securely.
▶ 34:15
Inside Anthropic: How Claude Tag Is Changing Agentic Work
The system makes heavy use of git work trees and custom scripts that coach Codex to push PRs, wait for reviews, run CI, fix flakes, and handle merge queues. Because the model excels at resolving merge conflicts, developers can delegate the entire merge lifecycle without synchronous terminal intervention.
▶ 24:27
Extreme Harness Engineering: 1M LOC, 1B toks/day, 0% human code or review — Ryan Lopopolo, OpenAI
You should use AI to rapidly build multiple workable UI prototypes for a single feature. This lets you experiment with different approaches in minutes instead of weeks, shifting the bottleneck from coding to proving which idea works best.
▶ 22:15
An AI state of the union: We’ve passed the inflection point & dark factories are coming
Running long or parallel agent tasks locally can put heavy loads on CPU resources and disrupt workflows when laptops go to sleep. Cloud sandboxes and containerized environments solve this by executing tasks off-machine against specific git commits and creating feature branches. They also allow for better control over network access and tool permissions compared to local execution.
▶ 25:25
Why AI Coding Agents Are Here To Stay | Patrick Debois
Tab accepts used to vastly outnumber agent requests by a factor of ten, but agent requests have grown fifteen times year over year. Consequently, agent requests now significantly exceed tab accepts, reflecting a shift toward larger automated tasks.
▶ 4:25
The next era of AI coding
You can create a short custom skill that instructs the agent to continuously monitor pull requests for automated review comments. The agent will autonomously address the feedback, push new changes, and repeat the loop until all review bots approve. This eliminates manual copy-pasting of comments and background babysitting.
▶ 30:01
You're using AI agents wrong
The team keeps tool cardinality intentionally low, ensuring every tool has a distinct function to prevent confusion. Tool design is treated more like an art or biology rather than a rigid science, often driven by UI requirements like deterministic file editing previews.
▶ 29:58
Claude Fable, Claude Tag, and Anthropic's Culture — Cat Wu & Thariq Shihipar ft Simon Willison
Multi-agent swarms often result in a chaotic world with high conflict potential. Practical usage still relies on a single engine that segregates work so each developer agent operates in isolation on its own machine. While sub-agents work well for scoped tool calls, full multi-agent collaboration creates architectural complexity.
▶ 39:54
Devin’s 80% Moment: Background Agents, 7x PRs, & End of Hand-Held Coding — Walden Yan & Cole Murray
Minion is Uber's formal background agent platform built on top of state-of-the-art agents, CLIs, and SDKs to run agents fully autonomously on internal infrastructure. It runs inside Uber's CI platform with access to monorepos and network infrastructure, and it integrates into workflows via a web interface, Slack, GitHub pull requests, and the AIFX CLI. Furthermore, it provides good defaults per monorepo to increase task success rates.
▶ 14:26
Uber: Leading engineering through an agentic shift - The Pragmatic Summit
Yes, you can highlight code in VS Code, open Copilot Chat, and ask it to open a PR for a refactoring task. The chat interface will trigger the background workflow and provide a pull request URL.
▶ 4:36
How the GitHub Copilot coding agent works | GitHub Checkout
Anthropic found that opinionated memory abstractions and indexed stores were often too restrictive and prone to issues. As models became more capable, agents performed better using native bash, grep, and straightforward file systems. Removing complex memory structures simplified harnesses while letting models handle data effectively.
▶ 36:56
Inside Anthropic: How Claude Tag Is Changing Agentic Work
Teams can internalize small to medium dependencies, like a couple thousand lines of code, in an afternoon by stripping away generic parts and tailoring them to their specific needs. This avoids upstream supply-chain friction and allows the coding agent to review and patch the internalized code with low friction.
▶ 28:24
Extreme Harness Engineering: 1M LOC, 1B toks/day, 0% human code or review — Ryan Lopopolo, OpenAI
Running multiple coding agents in parallel places a heavy cognitive load on developers, leading to quick mental exhaustion. Engineers must establish new personal limits and avoid the temptation to work around the clock just because agents can run asynchronously.
▶ 26:39
An AI state of the union: We’ve passed the inflection point & dark factories are coming
Running multiple agents in parallel allows you to explore different solutions, frameworks, or hypotheses simultaneously. However, this creates a significant code review bottleneck because developers now have to manually compare multiple variations or feature branches. New user interfaces and agent-assisted reviews are emerging to help reduce this cognitive load and simplify merging.
▶ 32:15
Why AI Coding Agents Are Here To Stay | Patrick Debois
At Cursor, 30 percent of internal pull requests are now developed entirely end-to-end by cloud-running agents with no human intervention. Additionally, about 75 percent of code in their enterprise segment is entirely AI-generated.
▶ 5:12
The next era of AI coding
You can add a built-in tailscale share command to start a remote dev server and return a pairing URL. This allows you to test the PR directly in your browser even over a slow network connection. It enables real-time validation without relying on cumbersome in-app previews.
▶ 37:20
You're using AI agents wrong
Claude Tag relies on a simple, file-based approach where each channel maintains its own markdown file for memory. Instances contribute back to this shared memory during sessions to preserve context across interactions.
▶ 50:31
Claude Fable, Claude Tag, and Anthropic's Culture — Cat Wu & Thariq Shihipar ft Simon Willison
Standard virtual machines often use network file systems like S3, making operations like grepping extremely slow due to constant network calls. To solve this, developers build incremental file storage formats where saving and rebooting use work proportional only to the file system diff. This drastically shaves down boot-up times.
▶ 49:39
Devin’s 80% Moment: Background Agents, 7x PRs, & End of Hand-Held Coding — Walden Yan & Cole Murray
Code Inbox is a unified inbox designed to remove noise by displaying only actionable pull requests directly relevant to a user when they need attention. It uses smart assignments based on code ownership, compliance, time zones, and calendar availability to find the right reviewer and tracks strict SLOs for escalations. It also integrates with Slack to batch notifications and respect developer focus time.
▶ 19:28
Uber: Leading engineering through an agentic shift - The Pragmatic Summit
The coding agent is currently available for users with higher premium plans such as Copilot Pro Plus or Copilot Enterprise. GitHub plans to open access wider in the near future.
▶ 6:01
How the GitHub Copilot coding agent works | GitHub Checkout
Teams can build a journey of trust by configuring human-agent interaction gates according to their risk tolerance. They can start by having agents diagnose fixes or create draft pull requests while keeping traditional safety processes in place. Over time, confidence grows, allowing teams to delegate more automated resolution tasks.
▶ 45:48
Inside Anthropic: How Claude Tag Is Changing Agentic Work
Elixir's process supervision and GenServers naturally support process orchestration by spinning up little daemons for every task in execution. When a pull request fails review, the Elixir service completely trashes the work tree and starts over from scratch based on the feedback loop.
▶ 34:39
Extreme Harness Engineering: 1M LOC, 1B toks/day, 0% human code or review — Ryan Lopopolo, OpenAI
We could reach the point where the majority of code is written by AI as early as the end of this year. The primary hurdle is no longer code quality, which is now generally good, but rather learning the non-trivial skills required to use these tools effectively.
▶ 41:06
An AI state of the union: We’ve passed the inflection point & dark factories are coming
Productivity gains depend heavily on task complexity, codebase health, and the programming language being used. Simpler or repetitive tasks yield much higher multipliers, whereas older, legacy codebases with inconsistent standards confuse the AI. Additionally, modern workflows that incorporate feedback loops and specifications perform significantly better than basic one-shot code generation.
▶ 42:24
Why AI Coding Agents Are Here To Stay | Patrick Debois
Engineers increasingly stop touching raw syntax and transition into agent managers. Instead of working alone, they collaborate alongside tens of thousands of autonomous agent colleagues operating in parallel.
▶ 5:55
The next era of AI coding
You can configure a workflow that triggers a preview build for macOS using a specific PR label. Once processed, a preview DMG download appears directly in the thread for you to test on a clean machine. This avoids the friction of building large desktop applications locally from scratch.
▶ 41:21
You're using AI agents wrong
AI models often use workaround patterns like getattr or forced backwards compatibility imports to prevent execution failures, leading to codebase regression. Teams can combat this by implementing strict lint rules using tools like Semgrep to catch patterns such as untyped tuples. Regular human code review and architectural boundaries also keep sprawl in check.
▶ 54:36
Devin’s 80% Moment: Background Agents, 7x PRs, & End of Hand-Held Coding — Walden Yan & Cole Murray
U review uses a multi-layer pipeline featuring general defect bots, best practice plugins, and APIs for external tools to preprocess code comments. It passes these through a review grader to filter out low-value nits and focuses exclusively on high-confidence changes. Finally, it checks for duplicates across different systems and categorizes the comments before presenting them to the developer.
▶ 22:06
Uber: Leading engineering through an agentic shift - The Pragmatic Summit
Dreaming is a research feature that runs automated jobs to review session transcripts and memory stores for discrepancies or stale information. Another agent analyzes these execution traces to find missing context or misleading data, generating hypotheses for improvements. This automated review process paves the way for continual learning and better agent performance.
▶ 50:02
Inside Anthropic: How Claude Tag Is Changing Agentic Work
CLIs should be token efficient and avoid dumping massive walls of text that confuse the agent. Developers can wrap commands or use silent flags so the model receives concise failure states instead of redundant logs.
▶ 50:30
Extreme Harness Engineering: 1M LOC, 1B toks/day, 0% human code or review — Ryan Lopopolo, OpenAI
Running coding agents in YOLO mode, or skipping permissions, prevents them from constantly nagging you for approval before taking actions. This allows developers to run multiple agents in the background autonomously while stepping away from the computer.
▶ 49:26
An AI state of the union: We’ve passed the inflection point & dark factories are coming
Local agents require constant babysitting and bottleneck multitasking, whereas cloud-based agent teams operate autonomously on separate computers for long periods. This enables engineers to manage dozens of parallel tasks, shifting their focus toward thorough code and build reviews.
▶ 7:16
The next era of AI coding
Frequent nightly builds acting as a safety net help catch regressions quickly before they affect a large user base. By pushing changes out every few hours, dedicated nightly users surface bugs immediately through feedback. This minimizes the fear of hitting the merge button on automated code.
▶ 44:48
You're using AI agents wrong
Beyond standard feature engineering, cloud agents are heavily used for automated SRE error triage by ingesting production logs and generating initial pull requests. Non-technical teams like product managers and customer support also use them to fix quick bugs or gather full context directly through chat interfaces. Additionally, continuous security reviews serve as primary workflows.
▶ 1:02:46
Devin’s 80% Moment: Background Agents, 7x PRs, & End of Hand-Held Coding — Walden Yan & Cole Murray
Autocover is a custom agent built on internal LangX SDKs and LangChain designed to automatically generate unit tests. It currently generates and merges about 5,000 tests per month across Uber with a 3x quality rate compared to generic agents. To prevent false confidence, it incorporates a critic engine and operates as an independent test validator for both human and AI-generated tests.
▶ 25:02
Uber: Leading engineering through an agentic shift - The Pragmatic Summit
Monitoring long-running agent tasks wastes time and breaks developer flow. By defining strict success criteria and firing off disposable async workflows, you eliminate the need to babysit the agent.
▶ 53:52
Extreme Harness Engineering: 1M LOC, 1B toks/day, 0% human code or review — Ryan Lopopolo, OpenAI
You can maintain public GitHub repositories containing small client-side tools and AI research projects. When facing a new problem, you can instruct the LLM to inspect the source code of those past projects and combine them to solve the new task.
▶ 1:02:39
An AI state of the union: We’ve passed the inflection point & dark factories are coming
An agent system worked completely autonomously over an entire week to generate three million lines of code and numerous pull requests. The experiment successfully produced a mostly functional prototype web rendering system without any human intervention.
▶ 8:30
The next era of AI coding
Shephard is a campaign management web UI that handles large-scale changes by tracking all pull requests associated with a migration defined simply via YAML files. It automates the generation of PRs using deterministic transformers like Open Rewrite or Minion agents, keeps them fresh on a defined cadence, and integrates with Code Inbox to place them in the correct reviewer queues.
▶ 27:42
Uber: Leading engineering through an agentic shift - The Pragmatic Summit
Fast models excel at spiking out prototypes, exploring ideas quickly, and handling documentation updates. They are also effective for transforming feedback into linters to unblock healing tasks in the codebase.
▶ 59:09
Extreme Harness Engineering: 1M LOC, 1B toks/day, 0% human code or review — Ryan Lopopolo, OpenAI
Having agents write tests first ensures they actually execute the code to catch syntax errors. Automated test suites give you confidence that adding new features won't break existing functionality without requiring tedious manual testing.
▶ 1:09:29
An AI state of the union: We’ve passed the inflection point & dark factories are coming
Uber experienced relatively slow initial adoption of AI tools because developers were unaccustomed to stepping away from traditional IDE workflows and taking risks with new methods. While top-down executive directives had some impact on metrics, sharing peer wins proved far more successful. Key engineering promoters shared examples of successful techniques, which drove a massive organic increase in adoption because engineers trust their peers over directors.
▶ 32:58
Uber: Leading engineering through an agentic shift - The Pragmatic Summit
Frontier is designed to drive AI transformation in enterprises by enabling the deployment of observable, safe, and controlled agents. It integrates seamlessly with existing enterprise IAM stacks, workspace tools, and security tooling.
▶ 1:02:21
Extreme Harness Engineering: 1M LOC, 1B toks/day, 0% human code or review — Ryan Lopopolo, OpenAI
You can start new projects with a very thin skeleton template that includes basic boilerplate and a single test case. Coding agents are exceptionally good at picking up indentation, formatting, and structural patterns from existing files in the repository.
▶ 1:14:51
An AI state of the union: We’ve passed the inflection point & dark factories are coming
The lethal trifecta occurs when an AI agent simultaneously has access to private information, receives external malicious instructions, and possesses an exfiltration mechanism to send data back. Since LLMs cannot distinguish between trusted system text and untrusted user input, attackers can exploit this combination to leak private data.
▶ 1:20:56
An AI state of the union: We’ve passed the inflection point & dark factories are coming
You can split the agent into a privileged agent that executes tasks and a quarantined agent that handles untrusted external inputs. The privileged agent writes structured code plans that are evaluated for tainted data, requiring human approval for high-risk actions.
▶ 1:27:07
An AI state of the union: We’ve passed the inflection point & dark factories are coming
No answer mentions that.