# The One Thing Every AI Agent Framework Agrees On - Mislav Ivanda, Daytona

Mislav Ivanda, Daytona

[Talk page](https://ai.engineer/talks/WWIFiQi9U4w-one-thing-every-ai-agent-framework-agrees) · [Video](https://www.youtube.com/watch?v=WWIFiQi9U4w)

## Choose Where Your Agent Runs Before You Choose Its Framework

After a year connecting Daytona to competing agent frameworks, Mislav Ivanda found the same three operations in every integration. The harder decision was which computer an agent should be allowed to use.

![Six frameworks expose Daytona through different helpers. The three operations below create, run and delete a sandbox.](https://ai.engineer/api/talk-essay-media/c361284de2245bef03b3ce219760905f83526cd35e3ff5a62f00ace866842692)

Different framework helpers wrap the same three operations: create the sandbox, run the code and delete the environment.

### Can you name the framework?

[0:44](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=44s)

Mislav Ivanda puts a small piece of code on the screen and asks the audience to guess which agent framework it belongs to. LangChain? LangGraph? Google ADK? He accepts the guesses. In one framework, he would register the code as a tool. In another, he would ship it as a plugin. A third might ask him to extend its sandbox client. Remove that surrounding code and he has trouble telling his own integrations apart.

Ivanda spent a year at Daytona bringing its sandboxes to agent frameworks, coding tools and workflow systems. The common part fit into three operations. Create an environment. Run some work in it and get a result. Delete it. The striking thing about those lines is how little else their callers agree on.

For LangGraph, the designer can lay out a graph of steps. CrewAI lets a group of agents divide up roles and decide how to reach a goal. A model repeatedly choosing the next tool is a different starting point again. Those choices change the code a developer writes. Sooner or later, each design encounters a request that needs a working computer. A model can propose a command or generate a program. Something has to execute it.

### Whose machine executes the tool?

[4:00](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=240s)

An engineer building a prototype usually has a machine ready to hand. It already holds the project, runs the language tools and knows how to reach the development database. A command allowlist or an approval dialog makes it easy to start an agent there and watch what it does. The danger is that the machine’s permissions are much broader than the request displayed in the dialog.

Ivanda uses a language interpreter to explain the mismatch. The name of the tool is short enough to approve. The range of programs it can execute is broad. A permission system that answers “may this agent call the interpreter?” has left a more consequential question unanswered. Which files, services and credentials should this particular task be able to reach?

An embedded runtime such as V8 or QuickJS gives the generated program a more limited environment. The application still supplies the tools. Consider the difference between composing an email in an isolated script and asking the application to send it. Delivery happens with the mail account the host application supplied. The same distinction applies to a database query. The code that receives the callback determines the real scope of the action.

### Give the work a separate computer

[6:40](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=400s)

Ivanda prefers to give the agent a separate machine, reached through an API. The application can choose what goes into the workspace, run the task, retrieve its result and discard the machine. An individual step can then fail without losing the process responsible for the rest of the application. Provisioning a separate machine also makes the team decide which tools and data that machine actually needs.

He points to changes he had seen in the frameworks themselves. CrewAI removed a local code interpreter and directed users toward dedicated sandbox services. AG2 replaced older local execution choices with a tool that asks the developer to specify an environment. The OpenAI Agents SDK offered sandbox integrations alongside other execution options. A process with constrained access, a container and a remote machine give the caller different boundaries. A setting called “sandbox” still leaves a developer with a question about what it isolates.

The use of the machine changed as agents improved. Early integrations borrowed one to answer a single tool call. Later, the agent could move in for an entire coding session, using the same files over many steps. Thousands of separate environments could also run a benchmark, explore different solutions or produce independent training runs. The person scheduling that work needs to know which state belongs to each attempt and what to keep when it finishes.

![The third option places work on a separate computer or VM with its own lifecycle.](https://ai.engineer/api/talk-essay-media/36e021693a0dfe502b658f92a0972fc8b8ca9e4adcee0b4f04e1e440431f74f0)

Ivanda’s third option moves the workload to a separate machine with its own lifecycle.

### Which choices survive a refactor?

[10:32](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=632s)

Back to the familiar question of which framework to pick. Replacing one Python framework with another costs engineering time. Changing models can also mean rewriting a prompt and running regression tests. Ivanda puts both into the category of changes a team can plan. Tracing, evaluation and memory can often be added through libraries or integrations. Even sandbox vendors expose recognizable versions of create, run and delete.

Durable execution deserves separate consideration. After a process dies, which step resumes? Which result has already been saved? Those decisions change how the application records work. Ivanda calls this out as a feature he would take seriously up front, even if another feature on the comparison chart looks easy to add later.

![The comparison puts framework, prompts, missing features and sandbox provider opposite the execution boundary that affects every tool.](https://ai.engineer/api/talk-essay-media/5aeac97170262aa228862d6df56a2bef9b33a9ae0762eff16bfa050e9f2063ec)

The comparison puts replaceable tools opposite an execution decision that shapes every tool the team writes.

### The interface the application should own

[12:43](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=763s)

The expensive migration begins with a harmless assumption in a tool: the file it needs is on the application server. The next tool reads a host environment variable. A third shares a database connection with the web application. By the time the prototype is in production, moving execution elsewhere means finding those assumptions in every tool and supplying an explicit replacement for each one.

Ivanda’s closing advice is to design an execution interface the application owns. A caller should be able to identify the workspace, supply what a task needs and retrieve an outcome without relying on whichever machine happened to start it. A team can then choose the agent framework that best fits its work today. If that choice changes, its next integration has a familiar job: create the environment, do the work and clean up.

## Resources

- [Daytona sandbox documentation](https://www.daytona.io/docs/en/) — The SDK, sandbox lifecycle, isolation and persistence are documented together.

## Slides

### Give the model a computer

[0:11](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=11s) [Daytona’s title slide identifies Mislav Ivanda as a developer experience engineer.](https://assets.ai.engineer/sites/aiecode2025/sha256/bc28baaf29fbfe54db3d427fee05438ce7ad2cb6b546203d94b2f9d9db70f95c.webp)

Give the model a computer. The one thing every agent framework agrees on, and what it means for how you build. Mislav Ivanda · Developer Experience Engineer · Daytona.io

### Guess the agent framework

[0:51](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=51s) [A framework tool named run_code takes code as input and returns an output from a sandbox.](https://assets.ai.engineer/sites/aiecode2025/sha256/19bd6b14e4e2603abff8112f02bea0c06031fa1504702f648df9f54f42112961.webp)

Which framework is this? async def run_code(code: str) -> str:

### The same sandbox lifecycle

[1:23](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=83s) [Six frameworks expose Daytona through different helpers. The three operations below create, run and delete a sandbox.](https://assets.ai.engineer/sites/aiecode2025/sha256/c361284de2245bef03b3ce219760905f83526cd35e3ff5a62f00ace866842692.webp)

Different logos. Same three lines. LangChain · CrewAI · Google ADK · Pydantic AI · OpenAI Agents SDK · Mastra. sandbox = daytona.create(); response = sandbox.process.code_run(code); sandbox.delete()

### Where competing frameworks disagree

[2:10](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=130s) [Three columns compare definitions of an agent, implementation languages and who controls the workflow.](https://assets.ai.engineer/sites/aiecode2025/sha256/e1c2ce4f1cff6b8b1092e3103168a5277dca8e7ecd0bb5b23a5cad5c6841fada.webp)

Frameworks agree on nothing. Except this. What an agent is · The language · Who drives. Python · TypeScript. You write the flow · the model decides.

### Code needs a place to run

[3:40](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=220s) [The slide asks where generated scripts, shell commands and test runs should execute.](https://assets.ai.engineer/sites/aiecode2025/sha256/47aaa92dd8cdb35e0f79fb2b3d16208f1fa6358d39aa42dff06c29db4442eacd.webp)

Agents write code. Code has to run somewhere.

### Running on the host

[4:02](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=242s) [The first isolation option keeps the agent on the developer’s machine behind an allowlist.](https://assets.ai.engineer/sites/aiecode2025/sha256/03e02c438baf8d628759644bf859ed3c43e7c0aeabaa2eab45b740fd3bbc7f20.webp)

On your machine, behind an allowlist. A permission model is not isolation.

### Inside an embedded interpreter

[5:21](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=321s) [The second option puts generated code inside an interpreter running in the host application.](https://assets.ai.engineer/sites/aiecode2025/sha256/09765f1aac5a15f84e0b57d70a52d6850f9993215aa6fdc65ef601576c6aae9a.webp)

In an interpreter, inside your process. It isolates the glue, not the tools.

### The separate computer

[6:38](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=398s) [The third option places work on a separate computer or VM with its own lifecycle.](https://assets.ai.engineer/sites/aiecode2025/sha256/36e021693a0dfe502b658f92a0972fc8b8ca9e4adcee0b4f04e1e440431f74f0.webp)

On a separate computer. A compromised step is not a compromised app.

### Framework decisions about execution

[7:52](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=472s) [A table compares execution changes in CrewAI and AG2 with the options exposed by the Claude Agent SDK, OpenAI Agents SDK and Mastra.](https://assets.ai.engineer/sites/aiecode2025/sha256/f88f92597168dfcd735469acbe47b50dcb87dac41b61a7eb4ef1b98752a14173.webp)

The frameworks already voted. Apr 2026 CrewAI. Jul 2026 AG2 1.0. Claude Agent SDK. OpenAI Agents SDK. Mastra. They’re not adding sandboxes. They’re deleting the alternative.

### The sandbox as a tool call

[9:17](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=557s) [Ivanda’s first use case is a short-lived workspace for one tool invocation.](https://assets.ai.engineer/sites/aiecode2025/sha256/cc3d81a7ddb3ad5506d410c1d98fcfecdff83b34bdb1f8e5fd4303cab25807e0.webp)

First, it was a tool call.

### Moving the agent inside

[9:46](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=586s) [The second use case puts the agent in the workspace for its whole run.](https://assets.ai.engineer/sites/aiecode2025/sha256/2a6b318bd3a347c1b6894a2586b53e2279cc19b0a0866240cabd9d41642ceac2.webp)

Then the agent moved in.

### Running thousands of environments

[10:02](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=602s) [A branching diagram shows one system creating many separate execution environments.](https://assets.ai.engineer/sites/aiecode2025/sha256/34049eeb08219f324aada012d0b93f1eca15dc57b79e8eab4a2fb3f1c22f9a1a.webp)

Then one computer became a thousand.

### Reconsidering framework choice

[10:47](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=647s) [The framework-selection question is crossed out before Ivanda discusses switching costs.](https://assets.ai.engineer/sites/aiecode2025/sha256/377615c8938b7c01c6c0f1e10a074f4f1b3cbb85a90f01b2a374309e23f2f2b0.webp)

Which framework should I pick? Wrong question.

### Choices a team can change

[10:52](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=652s) [The comparison puts framework, prompts, missing features and sandbox provider opposite the execution boundary that affects every tool.](https://assets.ai.engineer/sites/aiecode2025/sha256/5aeac97170262aa228862d6df56a2bef9b33a9ae0762eff16bfa050e9f2063ec.webp)

Swappable decisions vs. a commitment. You can swap later: the framework, the model & the prompts, missing features, the sandbox provider. You live with: the execution posture.

### Choose an execution boundary first

[13:55](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=835s) [Ivanda’s concluding slide asks teams to choose where code runs before settling on an agent framework.](https://assets.ai.engineer/sites/aiecode2025/sha256/1dea25f5c0cc4b6b99be83e4d9c3cd7925a423eede83abda9b64ced5ae6e9351.webp)

Pick the boundary before the framework. Frameworks are opinions. The boundary is a commitment.

## Full transcript

[0:01](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=1s) [music]

[0:06](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=6s) [music]

[0:12](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=12s) Thank you all for being here. Uh my name

[0:15](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=15s) is Mislav. I'm a developer experience

[0:17](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=17s) is Mislab. I'm a developer experience engineer at Daytona. And for the last

[0:19](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=19s) year my main ta my main task and goal

[0:22](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=22s) there was to integrate Daytona basically

[0:24](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=24s) everywhere where where sandbox makes

[0:26](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=26s) sense because where they are sandbox

[0:29](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=29s) provider and these are spanning from

[0:31](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=31s) agent frameworks uh coding agent

[0:34](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=34s) harnesses workflow tools uh development

[0:37](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=37s) product developer products and stuff

[0:39](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=39s) like that and during this process I

[0:41](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=41s) noticed the pattern that was repeating

[0:43](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=43s) all the time and it maybe it made me

[0:47](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=47s) stop a bit think about some things that

[0:49](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=49s) eventually led to this talk.

[0:52](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=52s) So yeah, I would need your help on this

[0:54](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=54s) slide. Does anyone have a guess which AI

[0:57](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=57s) agent framework is this?

[1:00](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=60s) If somebody has a guess, lang chain,

[1:02](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=62s) LangGraph,

[1:04](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=64s) Google adu,

[1:14](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=74s) okay, let let's say lang chain. But the

[1:17](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=77s) the main uh thing about this is that

[1:19](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=79s) whatever you you told can basically be

[1:22](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=82s) correct and defensible. Why do I say

[1:24](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=84s) that? It's because during the

[1:28](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=88s) integration of Daytona into these AI

[1:30](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=90s) agent frameworks there I noticed that

[1:33](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=93s) they I can barely uh differentiate the

[1:36](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=96s) Daytona related code contribution part

[1:39](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=99s) between these. So in some of these uh

[1:43](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=103s) you integrate as a tool in others you

[1:46](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=106s) integrate as external plug-in that you

[1:48](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=108s) can install to you know make your agent

[1:50](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=110s) use sandbox capabilities. In other ones

[1:53](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=113s) you extend the sandbox client class and

[1:57](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=117s) do some internal framework API stuff.

[2:00](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=120s) But under the hood all all of these ways

[2:03](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=123s) uh speak the three same lines. So it's

[2:05](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=125s) sandbox creation, running some code or

[2:07](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=127s) task inside the sandbox and sandbox

[2:10](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=130s) deletion.

[2:12](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=132s) And this this pretty weird because most

[2:15](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=135s) of these frameworks are competitors and

[2:17](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=137s) they barely agree on some fundamental

[2:19](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=139s) things or concepts. What do I mean by

[2:21](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=141s) that? So for example, they don't even

[2:24](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=144s) agree on what a what an agent is. Uh for

[2:27](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=147s) example, Angraph defines an agent as a

[2:29](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=149s) traversible traversible graph. Uh crew

[2:33](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=153s) traversible traversible graph. Uh CrewAI frameworks defines agents as you know

[2:35](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=155s) AI frameworks defines agents as you know role bunch of role playinging agents

[2:37](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=157s) that do do stuff on their own. uh open

[2:40](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=160s) AI agents SDK is defining agent as a

[2:44](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=164s) loop around the LLM model and for

[2:47](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=167s) example cloud agent SDK ships the whole

[2:49](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=169s) wholly finished product that you just

[2:52](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=172s) like use and have all cloud capabilities

[2:54](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=174s) no customization

[2:56](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=176s) also they defer in between the languages

[2:58](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=178s) they are implemented in mostly between

[3:00](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=180s) Python and and Typescript and they also

[3:04](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=184s) don't agree on who who's in charge of uh

[3:07](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=187s) specifying what an agent use agent

[3:10](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=190s) behavior. For example, in Mastra or or

[3:15](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=195s) LangGraph, you explicitly define your

[3:17](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=197s) agent workflows and uh trajectories

[3:20](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=200s) while for example in CrewAI agents do

[3:23](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=203s) things on their own and they decide on

[3:25](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=205s) their own to achieve the end goal. And

[3:28](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=208s) yeah, uh, when companies like or

[3:30](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=210s) companies like this, uh, that don't

[3:34](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=214s) agree on basically anything agree on

[3:36](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=216s) something that probably isn't just a

[3:39](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=219s) fashion, it's a necessity.

[3:42](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=222s) So why why they agree do they agree on

[3:45](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=225s) these things? So as I like to say,

[3:47](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=227s) whenever you're doing something with

[3:48](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=228s) your AI agents that's useful, you

[3:50](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=230s) eventually come up to the state where

[3:52](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=232s) your agent needs to execute some kind of

[3:54](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=234s) a code or needs to have shell access.

[3:56](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=236s) And the next question is where where

[3:58](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=238s) will this happen in which execution

[4:00](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=240s) environment?

[4:01](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=241s) So I would say there are basically three

[4:04](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=244s) types of possible isolation in these

[4:08](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=248s) environments. And let's now have a brief

[4:11](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=251s) overview around these. So number one is

[4:13](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=253s) the most basic one and it's probably the

[4:16](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=256s) one you're using locally when

[4:17](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=257s) development with your agent. So you

[4:19](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=259s) define certain allow list of commands.

[4:22](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=262s) Uh you also get some approval prompts

[4:24](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=264s) where you know claude ask you hey are

[4:26](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=266s) you sure you want to run this command

[4:28](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=268s) although probably most of us just click

[4:31](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=271s) yes and don't don't even read what does

[4:33](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=273s) he say and you can also add some

[4:35](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=275s) interception hooks but the problem with

[4:37](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=277s) this approach is I would said obvious uh

[4:43](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=283s) so when you allow your cloud agent to

[4:46](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=286s) run python command with python uh- c he

[4:50](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=290s) can literally

[4:53](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=293s) open any sockets, modify a file system,

[4:56](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=296s) execute code, or do basically

[4:58](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=298s) everything. Uh, which you probably don't

[5:01](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=301s) think about in in in the background. And

[5:05](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=305s) you essentially defined

[5:08](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=308s) what your model should use, but you

[5:10](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=310s) didn't define what your model can

[5:12](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=312s) actually use. And if the model is

[5:13](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=313s) compromised, you can I guess sense that

[5:16](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=316s) you essentially open back doors for it

[5:18](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=318s) to to let's say do malicious commands on

[5:21](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=321s) your local device. Second most more

[5:24](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=324s) advanced option is shifting all of this

[5:27](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=327s) coding uh execution stuff inside

[5:30](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=330s) embedded engine runtimes like V8 or

[5:34](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=334s) QuickJS.

[5:36](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=336s) And this approach is better because you

[5:38](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=338s) have certain network and file system

[5:40](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=340s) isolation.

[5:41](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=341s) But the quirk with this approach is

[5:45](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=345s) probably even more you know subal

[5:48](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=348s) because let's say your agent has access

[5:50](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=350s) to certain tools like query database or

[5:54](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=354s) send email and your agent will probably

[5:58](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=358s) generate a Python script which uses

[6:00](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=360s) these tools and you will execute this

[6:02](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=362s) script inside this embedded runtime. But

[6:04](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=364s) the problem is that these tools that

[6:06](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=366s) your agent will call inside that runtime

[6:08](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=368s) will actually run on your device outside

[6:10](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=370s) that runtime. So basically your

[6:14](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=374s) maliciously

[6:16](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=376s) malicious agent can act uh through these

[6:19](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=379s) tools not directly but through these

[6:20](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=380s) tools which most of people like probably

[6:24](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=384s) don't think about. And as it says you

[6:26](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=386s) isolate the glue code that your agent

[6:28](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=388s) generates but you're not actually

[6:30](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=390s) isolating the actual tool to tool calls.

[6:32](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=392s) So for example, agent can use these

[6:34](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=394s) email sending tool or database query

[6:36](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=396s) tools to perform some of its malicious

[6:38](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=398s) commands. For example, also if you have

[6:41](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=401s) delete database tool, you you can sense

[6:43](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=403s) how can you get into problems with this

[6:44](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=404s) approach. And the third one and

[6:47](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=407s) recommended approach is to use a

[6:49](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=409s) separate computer or VM for these kind

[6:52](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=412s) of purposes.

[6:54](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=414s) And yeah, you interact with this VM via

[6:57](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=417s) API, control its life cycle or do

[7:00](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=420s) any kind of stuff inside it. And this VM

[7:04](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=424s) never touches or interferes with your

[7:05](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=425s) local infrastructure, network, file

[7:07](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=427s) system, etc. And the best part of this

[7:11](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=431s) approach and why is it the best approach

[7:13](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=433s) is uh contained in this last sentence

[7:17](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=437s) compromised app is not compromised step

[7:19](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=439s) is not a compromise app. What do I mean

[7:21](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=441s) by that is because in prior two

[7:23](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=443s) approaches when your tool calls

[7:26](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=446s) misbehave or you your agent misbehaves

[7:30](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=450s) through let's say Python command you

[7:32](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=452s) approved that compromise step is is

[7:35](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=455s) literally compromising your whole

[7:37](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=457s) application and can you know make really

[7:40](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=460s) bad stuff but in this step you can run

[7:43](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=463s) the most the worst code on the planet

[7:45](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=465s) inside a sandbox and it can't interfere

[7:48](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=468s) with your application logic you can just

[7:50](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=470s) throw throw out that sandbox and spin up

[7:52](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=472s) another one. And to back up this that

[7:55](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=475s) I'm not just talking, you know, some

[7:58](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=478s) nonsense. Uh here's the proof like the

[8:00](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=480s) direction of frameworks,

[8:03](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=483s) the direction that AI frameworks are

[8:05](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=485s) moving at. So in April 2026, CrewAI

[8:08](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=488s) removed the code interpreter tool which

[8:11](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=491s) essentially did a

[8:13](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=493s) local code execution on your device and

[8:16](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=496s) they now point to dedicated sandbox

[8:19](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=499s) services. AG2 also uh retired their old

[8:23](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=503s) local coding exeutors and now have this

[8:27](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=507s) new sandbox code tool class [snorts]

[8:29](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=509s) that

[8:31](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=511s) explicitly requires from you to define

[8:33](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=513s) the environment where you want to use

[8:35](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=515s) this uh cloud engine SDK is by default

[8:38](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=518s) using sandbox but it's bash only

[8:41](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=521s) sandbox. What do I mean by that? It's

[8:43](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=523s) like a process level sandboxing uh which

[8:47](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=527s) you can do for example with tools like

[8:50](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=530s) bubble wrap on Linux machines. Open AI

[8:53](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=533s) agents SDK has this sandbox agent which

[8:55](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=535s) has native you know support for some of

[8:57](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=537s) the sandbox provider integrated inside

[8:59](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=539s) and also for docker but it also allows

[9:02](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=542s) you local code execution with you know

[9:05](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=545s) transparently listed flows of this

[9:07](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=547s) approach and it's similar to with mora

[9:11](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=551s) and you can notice that they are not

[9:13](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=553s) adding sandboxes they already had them

[9:15](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=555s) but they are deleting all the al

[9:17](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=557s) alternatives

[9:19](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=559s) and parallelly with this shift in AI

[9:22](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=562s) agent frameworks uh uh direct isolation

[9:25](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=565s) direction basically there also happened

[9:28](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=568s) a shift between how these sandboxes are

[9:30](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=570s) actually used so firstly when first

[9:33](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=573s) agent started to you know evolve and got

[9:35](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=575s) into picture the sandboxes were mostly

[9:37](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=577s) used as short-lived machines where your

[9:41](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=581s) agent was would spin it up on demand run

[9:44](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=584s) some code or task inside it and shut it

[9:46](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=586s) down

[9:47](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=587s) but then when models became more capable

[9:51](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=591s) people realized they could literally

[9:53](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=593s) shift hold the agent and run it inside

[9:55](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=595s) the sandbox as execution runtime and

[9:58](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=598s) give it access to file system network

[10:00](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=600s) calls and basically everything.

[10:02](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=602s) And uh since recently there's also a

[10:05](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=605s) shift where people also like understood

[10:09](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=609s) that if they can run thousands of these

[10:12](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=612s) execution environments concurrently they

[10:14](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=614s) can do really interesting stuff

[10:16](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=616s) especially regarding reinforcement

[10:18](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=618s) learning fine-tuning uh post-raining

[10:22](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=622s) benchmarks.

[10:24](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=624s) You can also spawn different sub aents

[10:26](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=626s) for while solving some problems and

[10:28](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=628s) stuff like that.

[10:30](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=630s) And yeah now back to the to the

[10:33](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=633s) question. So this whole shift from AI

[10:36](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=636s) frameworks regarding execution

[10:37](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=637s) environments and boundary uh made me

[10:40](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=640s) also rethink the common question which

[10:43](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=643s) me myself and I probably a lot of you

[10:45](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=645s) are asked like which framework should I

[10:47](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=647s) pick and based on this whole story I

[10:50](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=650s) think this is essentially the wrong

[10:52](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=652s) question. Why do I say that? That's

[10:55](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=655s) because some of most of the items that

[10:58](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=658s) you compare frameworks between are

[11:00](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=660s) swappable and you know can be easily

[11:02](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=662s) done and stuff that's not that easily

[11:06](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=666s) swappable is normally or oftenly not

[11:09](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=669s) even considered into the picture between

[11:11](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=671s) before choosing you know development

[11:13](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=673s) stack. So what do I mean by swappable?

[11:15](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=675s) For example, you can essentially swap uh

[11:18](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=678s) between if your multiple frameworks use

[11:21](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=681s) the same language, you can essentially

[11:23](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=683s) swap between frameworks which you know

[11:25](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=685s) you give coding agent a task and it's

[11:28](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=688s) like a refactor and developers do it all

[11:31](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=691s) the time. Second one is you can also

[11:34](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=694s) swap between models and prompts. This

[11:36](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=696s) can be a bit more trickier if you're uh

[11:40](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=700s) you know fine-tuned to you fine-tune

[11:42](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=702s) your system prompts and stuff to certain

[11:44](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=704s) model but it requires some finetuning

[11:46](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=706s) and regression testing and it's I mean

[11:49](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=709s) completely doable same with missing

[11:51](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=711s) features so sometimes people decide on

[11:53](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=713s) which framework to choose based on some

[11:55](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=715s) features that one framework has another

[11:58](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=718s) doesn't but nowadays yeah you can

[12:01](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=721s) essentially vibe code the missing

[12:02](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=722s) feature or just plug it as an external

[12:04](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=724s) plugin for certain framework network. Uh

[12:07](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=727s) I would say this probably doesn't only

[12:10](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=730s) count for the feature called durable

[12:12](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=732s) execution which some frameworks provide

[12:15](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=735s) that's kind of not that easy to you know

[12:17](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=737s) replicate and wipe code in an afternoon

[12:19](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=739s) with cloud because it affects the

[12:21](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=741s) architecture and stuff but all of the

[12:23](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=743s) others like I mentioned here eval

[12:25](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=745s) tracing and memory you can easily you

[12:27](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=747s) know implement by yourself or just plug

[12:29](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=749s) in external tool and you can also swap

[12:31](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=751s) the sandbox provider because all of us

[12:34](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=754s) speak the same language. So all of us

[12:36](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=756s) speak create uh run some stuff inside

[12:39](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=759s) and delete although I mean some of us

[12:42](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=762s) have distinct features and different

[12:45](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=765s) performances

[12:46](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=766s) and the stuff you can't change easily or

[12:50](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=770s) swap later is the execution posture I

[12:52](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=772s) would mentioning here. So that's like

[12:54](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=774s) deciding will you run your ex coding uh

[12:58](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=778s) stuff locally or will you use external

[13:01](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=781s) sandbox why you can swap this easily?

[13:04](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=784s) Well, the reason is that this defines

[13:07](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=787s) your whole AR system architecture and

[13:09](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=789s) how do you develop other parts of your

[13:10](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=790s) system. For example, when you're

[13:13](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=793s) developing some kind of a tools, if

[13:15](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=795s) you're uh guessing that you will use a

[13:19](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=799s) first approach where everything runs

[13:21](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=801s) locally, then you write all of your

[13:24](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=804s) tools to use your host or app process

[13:27](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=807s) environment using your file system

[13:30](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=810s) without separation and stuff like that.

[13:33](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=813s) And problem is that most of the people

[13:35](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=815s) start with this approach as a PC phase

[13:38](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=818s) but unfortunately continue all up until

[13:40](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=820s) the production stuff and they don't come

[13:43](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=823s) back to it and then when

[13:46](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=826s) bad stuff happens it's probably too late

[13:49](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=829s) and some of the times

[13:52](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=832s) by bad stuff I mean something that can

[13:53](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=833s) literally kill your product

[13:56](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=836s) and that's why I would like to say from

[13:59](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=839s) this talk that you should probably

[14:02](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=842s) consider

[14:03](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=843s) picking up the exec choosing the

[14:05](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=845s) execution boundary before deciding which

[14:07](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=847s) framework you should pick and as like as

[14:10](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=850s) I like to say it and the sentence I

[14:12](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=852s) would maybe like for you all of here to

[14:14](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=854s) remember out of this talk is frameworks

[14:16](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=856s) are opinions and the boundary is a

[14:18](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=858s) commitment I suggest that when you're

[14:20](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=860s) starting to work on a product you you

[14:23](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=863s) define an interface uh the execution

[14:26](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=866s) posture between an interface you control

[14:28](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=868s) and everything except that can be easily

[14:31](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=871s) swappable in the future and reversed.

[14:33](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=873s) And once you define this interface, of

[14:35](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=875s) course, you should use the execution

[14:38](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=878s) architecture mentioned as a third third

[14:41](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=881s) method like giving your agent a proper

[14:43](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=883s) computer. And yeah when you do this

[14:46](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=886s) right uh the part security part

[14:49](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=889s) regarding the execution is solved and

[14:52](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=892s) you can I mean continue with developing

[14:55](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=895s) your uh featur product features and

[14:58](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=898s) stuff around this without any you know

[15:02](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=902s) concerns about the potential security

[15:04](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=904s) vulnerabilities or stuff like that and

[15:07](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=907s) yeah that's it from my side since I

[15:09](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=909s) mentioned I was doing some integrations

[15:10](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=910s) and guides we have these listed as open

[15:13](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=913s) source as guides and plugins and

[15:15](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=915s) packages. And there's also a third QR

[15:18](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=918s) code shows the comparison article that's

[15:21](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=921s) comparing different AI agent frameworks

[15:22](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=922s) a bit more in depth that we listed here.

[15:25](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=925s) And yeah, that's it from my side. Thank

[15:27](https://www.youtube.com/watch?v=WWIFiQi9U4w&t=927s) you.
