The One Thing Every AI Agent Framework Agrees On

Mislav Ivanda, Daytona15:36 · Nov 2026 · 2,285 views
Thumbnail for The One Thing Every AI Agent Framework Agrees On Watch on YouTube
TL;DR
  1. 1

    Agent frameworks differ in their definitions and workflows, but they converge on creating a sandbox, running code inside it, and deleting it.

  2. 2

    Allow lists and embedded runtimes can restrict some code while leaving tools or the host system exposed to a compromised agent.

  3. 3

    The execution boundary is hard to change later, so it should be chosen before the agent framework.

Summary

Mislav Ivanda compares three places where an agent can run generated code. Allow lists and approval prompts limit which commands are available, but an approved Python command can still access sockets, files, and arbitrary code. Embedded runtimes such as V8 and QuickJS isolate generated glue code, while tool calls can still execute outside the runtime on the host device. Ivanda recommends a separate computer or virtual machine that the application controls through an API. A compromised step can then be discarded with its sandbox instead of reaching the application. He points to changes in CrewAI, AG2, Claude Agent SDK, OpenAI Agents SDK, and Mastra as evidence that agent frameworks are moving toward direct isolation. His advice is to decide the execution boundary first. Frameworks, models, prompts, features, and sandbox providers are easier to replace than the architecture built around where code runs.

Key ideas
01:53

Different agent frameworks reduce sandbox integration to the same lifecycle

Ivanda integrated Daytona across agent frameworks, coding-agent harnesses, workflow tools, and developer products. Although each framework exposes the integration differently, the underlying steps are the same: create a sandbox, run code or a task inside it, and delete the sandbox. This pattern appears across competitors that otherwise disagree about what an agent is and how it should behave. The shared lifecycle is the first sign that execution isolation is a common requirement rather than a framework-specific preference.

02:17

Frameworks disagree about agents, languages, and who controls behavior

LangGraph treats an agent as a traversable graph, while CrewAI uses role-playing agents that act on their own. The OpenAI Agents SDK defines an agent as a loop around an LLM, and the Claude Agent SDK provides a finished product with limited customization. Frameworks also differ between Python and TypeScript. In Mastra and LangGraph, developers explicitly define workflows and trajectories. In CrewAI, agents decide how to reach the end goal. These differences make their agreement on sandboxes more significant.

04:12

Allow lists and approval prompts do not define what a model can really do

The simplest setup uses an allow list, approval prompts, and interception hooks. Ivanda points out that approving a Python command with Python -C can let an agent open sockets, modify the file system, and execute other code. The allow list describes what the model is expected to use, but it does not fully describe what that command can use. If the model is compromised, the local device can become exposed to malicious commands.

05:23

Embedded runtimes isolate generated code while leaving host tools exposed

V8 and QuickJS provide more isolation for code generated by the agent, including some network and file-system separation. The problem appears when that code calls tools such as database queries or email sending. Those tools may execute on the host device outside the embedded runtime. A malicious agent can therefore act through an apparently safe tool. The runtime isolates the glue code, but it does not necessarily isolate the effects of the tool calls.

06:46

A separate computer gives the application a disposable execution boundary

Ivanda recommends running agent code in a separate computer or virtual machine and controlling it through an API. The sandbox can have its own file system and network, without touching the application's local infrastructure. If a step behaves maliciously, the application can discard that sandbox and create another one. His central distinction is that compromising a step inside the sandbox does not have to compromise the application itself.

08:00

Agent frameworks are removing local execution alternatives

Ivanda cites several framework changes. In April 2026, CrewAI removed its local code interpreter and began pointing users toward dedicated sandbox services. AG2 retired its old local coding executors and introduced a sandbox code tool that requires an execution environment. The Claude Agent SDK uses process-level sandboxing by default. OpenAI Agents SDK includes a sandbox agent with support for sandbox providers and Docker, while still documenting local execution flaws. Mastra is moving in a similar direction. The change is often the removal of unsafe alternatives rather than the addition of another feature.

09:35

Sandboxes have expanded from short-lived code runners to full agent environments

Early agent systems used sandboxes as short-lived machines. An agent would create one, run a task, and shut it down. As models became more capable, teams began running the whole agent inside the sandbox with access to a file system and network calls. Ivanda also describes concurrent use of thousands of execution environments for reinforcement learning, fine-tuning, post-training, benchmarks, and spawning subagents to work on problems.

10:45

Framework choice is easier to change than the execution architecture

Ivanda calls 'which framework should I pick?' the wrong starting question. Developers can replace a framework when the language is the same, swap models and prompts with fine-tuning and regression testing, and add missing features through code or external plugins. Evals, tracing, and memory can also be implemented separately. Durable execution is harder to replicate because it affects the architecture. The execution boundary is harder still to change because it determines how tools use the host process, file system, and other resources.

12:46

A local proof of concept can lock production into an unsafe boundary

Teams often start with local execution during a proof of concept and write tools against the host or application process. They may continue with that design into production without revisiting it. Moving later to an external sandbox then requires changing how those tools and other system components work. Ivanda's advice is to choose the execution boundary before choosing the framework, because the boundary shapes the rest of the system and may be expensive to replace after a serious failure.

"When companies like this that don't agree on basically anything agree on something that probably isn't just a fashion, it's a necessity."03:26
Who should watch
  • You are building an agent that will execute generated code, call tools, or access a file system and need to decide where those operations should run.
  • Your proof of concept currently runs agent code locally, and you want to understand the cost of moving to a sandbox before production.
  • You are comparing agent frameworks and need to separate replaceable framework features from the execution boundary that shapes your system architecture.