What are managed AI agents?

AI agents use models to reason about a goal, decide what actions to take, and use tools to perform those actions. Rather than producing a single response, an agent can work through a task iteratively.

For example, imagine asking an agent to analyze a dataset and create a report. The agent might first inspect the available files, write code to analyze the data, execute that code, review the results, correct an error, create a visualization, and finally generate the report.

This process is often described as an agent loop. In simple terms, the agent follows a cycle:

1. Reason: Determine what needs to happen next
2. Act: Use a tool, execute code, retrieve information, or take another action
3. Observe: Evaluate the result of that action
4. Repeat: Continue until the task is complete or additional input is needed

Running this loop requires more than access to an AI model. The agent needs an environment where it can take actions and keep track of its work. Depending on the task, that might include code execution, files, APIs, databases, web access, or other tools.

A managed agent platform provides more of this environment for the developer. It can also handle infrastructure needed for longer-running or background tasks, where an agent may need to continue working beyond a typical request-response API call.

Exactly what is managed depends on the platform, but most managed agent systems address some combination of the infrastructure required to let an agent act.

This can include:

• Execution: Running the agent loop and coordinating its actions over multiple steps
• Tools: Giving the agent controlled access to capabilities such as APIs, web search, code execution, custom functions, or Model Context Protocol (MCP) servers
• State: Keeping track of relevant information as the agent progresses through a task or across interactions
• Files and data: Providing a workspace where the agent can read, create, and modify information while it works
• Sandboxing: Isolating agent activity, particularly when the agent can execute code or modify files
• Credentials: Allowing the agent to authenticate with external services without exposing credentials unnecessarily
• Background execution: Supporting tasks that take longer than a normal API request or need to continue running asynchronously

These capabilities make up part of the infrastructure around the model. The model provides the reasoning capabilities, while the surrounding system gives the agent ways to interact with the world and continue working toward a goal.

The main difference between managed and self-managed agents is who is responsible for operating that surrounding infrastructure.

With a self-managed agent, developers have more direct control over the system. They can choose how the agent loop works, where code executes, how tools are connected, how state is stored, and how the application is deployed. This can be useful when an application has specialized security, networking, compliance, or infrastructure requirements.

It also means developers need to build or integrate more of those components themselves.

With a managed agent, the platform takes responsibility for more of the execution environment and operational infrastructure. Developers still define what the agent should do, which model it should use, what tools it can access, and what constraints it should operate within, but they don't necessarily need to build the entire system that allows the agent to perform those actions.

Consider a coding agent that needs to update an application. It might inspect a repository, edit several files, install a dependency, run tests, identify a failed test, make another change, and run the tests again. With a self-managed approach, the developer needs to provide and operate the environment where those actions happen. With a managed approach, much of that environment can be provided as part of the service.

The choice ultimately depends on how much control developers need and how much infrastructure they want to operate themselves.

Agent frameworks and managed agent platforms solve related problems, but they aren't necessarily the same thing.

Agent frameworks provide software abstractions for building agent behavior. They can help developers define tools, coordinate workflows, route tasks, manage prompts, or determine how multiple agents work together.

Managed agent platforms focus more on the environment where the agent runs. They can provide the infrastructure needed for agents to execute tasks, maintain state, use tools, and work with external systems.

In practice, these categories can overlap. A framework can be used with infrastructure that developers operate themselves, while a managed service may provide both tools for defining an agent and an environment for running it.

A simple way to think about the distinction is that an agent framework can help you build the agent, while managed agent infrastructure can help you run it.

Managed agents are particularly useful when a task requires an AI system to take multiple actions rather than simply generate an answer.

Common use cases include:

• Software development: Inspect code, make changes, execute commands, run tests, and iterate on failures
• Research: Search multiple sources, collect information, analyze findings, and create a structured report
• Data analysis: Work with datasets, write and execute analysis code, generate visualizations, and summarize results
• Document workflows: Read and transform files, extract information, and create new artifacts
• Business processes: Connect to APIs and other tools to complete workflows that span multiple systems

The common thread is that the model needs somewhere to act. As a task requires more tools, files, code, external systems, and intermediate steps, more infrastructure is needed around the model to support that work.

Managed Agents in the Gemini API provides a managed environment for building agents that can work through complex, multi-step tasks.

Instead of requiring developers to build the complete environment around an agent themselves, Managed Agents can provide an isolated workspace where an agent can reason about a goal, execute code, work with files, and use tools as it progresses through a task. Developers can customize the agent with their own instructions and connect it to the tools and information their application needs.

For example, a developer could give a managed agent a set of files and ask it to analyze the information and create a report. The agent could inspect those files, write and execute code as part of its analysis, evaluate the results, correct errors, and create new files as output. The developer defines the goal and the resources available to the agent, while the managed environment supports the intermediate work required to complete it.

Managed Agents can also connect to external tools through custom functions and remote MCP servers, allowing agents to interact with other applications and services.

This creates a different abstraction from a standard model API call. With a model API, the developer sends input to a model and receives an output. With a managed agent, the developer can provide a goal and give the agent an environment where it can take multiple actions to accomplish it.