Design a complete agent — prompt, model, skills, tools, and policies — in one place.
The Studio is where an agent takes shape. Start from a blank definition or a template, choose a model, attach skills and tools, wire in memory and connectors, and set the guardrails. Everything lives in a single, versioned definition. Compose from reusable parts, preview behavior before you ship, and keep design-time configuration cleanly separated from what happens at runtime.
From blank canvas to publishable agent, without ever leaving the page.
Reusable building blocks — instructions, toolsets, workflows, and composites.
A skill packages a capability once so it can be reused across every agent you build. Skills come in four kinds — instruction, toolset, workflow, and composite — and they compose: small skills snap together into larger ones. Update a skill in one place and every agent that references it inherits the change, so improvements roll out everywhere at once.
Build a capability once. Reuse it everywhere.
Native, HTTP, and MCP tools — governed by per-agent tool policies.
Tools are how an agent acts on the world. Attach built-in tools, call any HTTP endpoint, or connect an MCP server to bring in a whole toolbox. A tool policy sits in front of all of it, deciding exactly which tools a given agent may use and how. Least-privilege is the default, and every allow or deny is explicit and per-agent.
Powerful actions, always inside the lines you draw.
GitHub, Slack, Drive, SQL, object storage, Cloud Run — with vaulted credentials.
Connectors link your agents to the systems they work with. Authentication runs through vault references, OAuth, service accounts, or API keys — never secrets pasted into a prompt. Each connector is scoped to the specific agents allowed to use it, health-checked so you know when something is down, and monitored for how it's being used.
Connect everything. Expose nothing.
Profile, project, episodic, and semantic memory that persists across sessions.
Agents remember. Attach memory stores and context carries from one run to the next — a user's profile, the state of an ongoing project, past episodes an agent has lived through, or a semantic knowledge base it can draw on. Memory can be structured or free-form, and it's always scoped per agent and per tenant so nothing leaks across boundaries.
Context that survives the end of a session.
Execution environments and model selection, defined once and reused.
An environment decides where and how an agent runs — inline, or dispatched to a worker — and which model sits behind it. Point many agents at a single environment and you can change how all of them execute, or swap their model, in one place. Runtime concerns stay separate from the agent's design, so the two evolve independently.
Decide how agents run, separately from what they do.
Every change is a version. Diff it, review it, publish it.
Agent definitions are versioned like code. Compare any two versions to see exactly what changed, then move a version through its lifecycle — draft, review, published — with a clear record at each step. Roll forward to ship an improvement or roll back if something regresses, always with confidence about what's live.
Ship changes deliberately, with a trail behind every one.
Discover public and company-approved agents in a shared catalog.
Once an agent is published, it shows up where your team can find it. Browse public agents alongside the ones your company has approved, see at a glance what each one does and what it needs, and put it to work. The catalog is the bridge between the people who design agents and the people who use them.
The right agent, findable the moment it's published.
Run agents as durable sessions that pause, resume, and recover.
Every run is a durable session. It survives restarts, picks up exactly where it left off, and never loses its place — with at-least-once execution underneath so no step is silently dropped. Pause a session and come back to it later, or let it recover on its own when something fails mid-run. Long-horizon work becomes something you can rely on.
Long-running work that doesn't forget where it was.
Delegate sub-tasks to specialized child agents.
An agent can spawn child agents to take on parts of a larger job — steering them, waiting on their results, and folding the answers back into its own work. Delegate in parallel to move faster, or in sequence when one step depends on another. Each child runs as its own controllable session, so you keep full visibility and control over the whole tree.
One agent, an entire team working beneath it.
Route approvals and tasks to people exactly when a decision needs one.
Some steps shouldn't be fully automated. Agents create tasks, assign them to accounts or roles, and pause until a person reviews, approves, or completes the work — then the session continues right where it stopped. Put an approval gate in the middle of a run, or hand off an entire task for a human to own.
Automation that knows when to ask.
Eval datasets, runs, and gates — measure an agent before you trust it.
Test agents against curated datasets, run evaluations across versions, and gate publishing on the results so a regression never reaches production. When a run fails, the failure context is right there to inspect — the inputs, the outputs, and where expectations diverged — so you can fix it before you promote.
Prove it works before you promote it.
Access records, roles, and a full audit trail on every agent.
Control precisely who can view, run, and edit each agent. Access is granted to accounts or to roles, so permissions scale with your organization instead of being managed one person at a time. Every change is written to an immutable audit trail, and governance exports are ready whenever review or compliance calls for them.
Know who can do what — and who did.
Meter usage, track cost, and enforce quotas per agent and team.
Every session records the tokens it uses and the cost it incurs. Set quotas per agent and per tenant, watch spend as it happens, and stop runaway usage before it turns into a surprise bill. Cost and usage are first-class signals, not something you reconstruct after the fact from a provider invoice.
Full visibility, no surprises on the invoice.
Traces, session events, and exports for every run.
See inside every session — turn-by-turn events, the tools an agent called, traces across a whole run, and aggregates that show behavior over time. Export the activity for governance, feed it into your own dashboards, or replay it to debug exactly what an agent did and why.
Nothing an agent does is a black box.