> For the complete documentation index, see [llms.txt](https://help.intangible.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://help.intangible.ai/intangible-mcp-agents/what-your-agent-can-do.md).

# What your agent can do

What an agent connected to Intangible's Model Context Protocol (MCP) server does in Build, Compose and Visualize, how it paces a long job, and where you finish by hand.

Give an agent a loose idea and it builds the set, frames the shots and renders the ones you pick, in your open Studio tab. An agent connected to Intangible's Model Context Protocol (MCP) server drives most of Studio, across Build, Compose and Visualize.

## Start from a loose idea

You don't need a finished brief. Open with a loose idea, such as *"a launch film for our new electric car"*. The agent asks one round of questions before it builds: the purpose, the rough scale, and what matters most. Answer them, and it starts placing.

For a tighter first pass, write the brief yourself. See [Writing a good brief](#writing-a-good-brief).

## What an agent places in a scene

An agent builds from the same four kinds of things you use by hand:

* **Models** are 3D assets from the library, found by meaning. Ask for "a mid-century armchair" and the agent places the closest match.
* **Primitives** are cubes, spheres, planes and other base shapes, for blocking.
* **Presets** are complete spaces, such as a furnished room, placed in one step.
* **Populators** generate many similar objects, such as a forest or a crowd, in one step.

## In Build mode, the agent constructs the set

In Build mode, the agent creates a project and a scene, then fills it. It searches the asset library by meaning, places models and primitives, drops in presets and populators, extrudes shapes, and adds and edits characters. It places fog objects and sets the environment, such as sun position and terrain. Before it adds more, it reads the current scene back.

> Build a small cafe interior: a counter along the back wall, four two-top tables, warm afternoon light through a window on the left.

## In Compose mode, the agent frames the shot

In Compose mode, the agent moves the camera and creates framed shots. It positions the camera for an angle, sets up the shot, and animates objects and camera moves on the scene timeline.

> Frame a low three-quarter shot of the counter with a 35mm look, then add a slow push-in.

Ask for a set of shots and each one arrives as a named card in the storyboard. The board reads like a shot list.

![Compose mode after an agent framed a set of shots, each one a named card in the storyboard](https://1179478100-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FSWrjIqlgVAblx6vHGJiM%2Fuploads%2Fgit-blob-45c60cf34caa5d3014e14ca5e579bf91aca58cb7%2Fmcp-agent-shot-list-01.png?alt=media)

### The vocabulary it frames with

The agent directs the camera in the terms a crew uses. A brief written like a shot list lands well.

* **Framing** runs extreme-wide, wide, medium-wide, medium, medium-close, close and extreme-close. Medium is the default: the subject fills the frame comfortably.
* **Moves** are named: dolly in and out, truck left and right, pedestal up and down, crane up and down, orbit left and right, push in and pull out.
* **Feel** sets the easing on a move: smooth, snappy, gentle or dramatic. Dramatic builds slowly to a punchy arrival. Snappy starts fast and settles.
* **Lens** uses the Compose names: 14mm Ultra-Wide, 24mm Wide, 35mm Standard, 70mm Portrait, 100mm Telephoto, 200mm Super Telephoto. The agent's list stops one rung short of Compose's, which also offers 50mm Normal.

Ask for "a slow dramatic push-in, medium-close, 70mm". The agent acts on every one of those terms.

## In Visualize mode, the agent renders the image

In Visualize mode, the agent renders an image from the shot you composed. These are real renders through the same visualizer you use by hand, and they land on the shot like any other render. See [How the visualizer thinks](https://help.intangible.ai/learn-more/concepts/how-the-visualizer-thinks.md).

> Render the shot, photoreal, golden hour.

Before it renders, the agent generates the shot's auto-prompt and renders from that. The render reflects what's in the set. The agent overrides the prompt only when you dictate one. It also sets the resolution, so "make it 2K" goes in the same message. The aspect ratio is set when the shot is framed, 16:9 unless you ask for another, so say "vertical, 9:16" when you ask for the shot.

## Scene scripts: 3D scenes as code

Twelve chairs placed one tool call at a time was slow, and the spacing drifted. Intangible treats the scene as code instead. The agent writes a **scene script**: code, including math and procedural layouts, that builds the scene. Intangible's MCP server runs it safely in a sandbox. One script does the work of dozens of separate steps.

You don't write the script, and you don't see it unless you ask. Some apps show it in the approval request. What you notice is that "arrange these around the table, evenly spaced, all facing in" lands as one change.

A script can take a seed, which matters for anything scattered. The same seed lays out the same scatter twice, so "same again, but shift it left" keeps the layout.

## How an agent paces a long job

A large scene takes minutes. The agent keeps you informed so a long build doesn't look like a crash.

**It orients you first.** On first contact, the agent sets expectations. Work in two windows: chat on one side, the Studio tab on the other. The order is Build, then Compose, then Visualize. The viewport stays empty while it searches the asset library, and objects land close to where you asked.

**It stops at checkpoints.** On a large scene, the agent places one representative piece, then pauses for you to look. A row of chairs gets built and checked before the other two dozen go in. Correcting one row takes a minute. Correcting twenty-five takes an afternoon.

**It asks before rendering.** Rendering is the slow step, and it uses credits. The agent presents the framed shots and waits for you to pick which to render. If you want all of them, say so.

**It tells you what it can't do.** Some Studio actions aren't in the agent's tools. When it hits one, it should name it and hand you the steps to do it by hand.

## Where you finish by hand

The agent gets a scene about 80 percent of the way, then hands it back. Objects land close to where you asked. Fine positioning, the last nudge on framing and small art-direction calls are faster by hand in Studio than in another prompt.

## Writing a good brief

A good brief names the scene, the objects, the camera angle and the render look. Vague briefs produce vague scenes. A brief that reads like a shot list (set, camera, render style) gets a usable scene in one pass.

You don't have to teach the agent Intangible's API. The MCP server serves a reference for its scene helpers, and the agent looks up the exact call it needs. There's no setup step for you.

## Related

* [Agents & MCP](https://help.intangible.ai/intangible-mcp-agents/intangible-mcp-agents.md)
* [Agent recipes](https://help.intangible.ai/intangible-mcp-agents/what-your-agent-can-do/agent-recipes.md) – three briefs to paste, with what to check after each.
* [How Intangible works](https://help.intangible.ai/learn-more/concepts/how-intangible-works.md)
* [How the visualizer thinks](https://help.intangible.ai/learn-more/concepts/how-the-visualizer-thinks.md)
* [Troubleshooting and FAQ](https://help.intangible.ai/intangible-mcp-agents/troubleshooting-and-faq.md)

*Last updated 23 October 2026. Steps and capabilities may change.*


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://help.intangible.ai/intangible-mcp-agents/what-your-agent-can-do.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
