Bots that ship, debug and tune your Modal apps.

Ask in plain words. A team of bots runs the modal commands, reads your logs, metrics and bill, and comes back with the answer and the fix. Nothing in your workspace changes until you approve it.

One request, recorded live: a new bot writes arcade-fifty, you approve the deploy, and 50 Sandboxes each play a different game. Sped up only while bots wait.

The work it takes off your plate.

Six real requests on a demo workspace, each with what the bot showed back. Under each one are the Modal commands it wrote and ran.

Ship a new app from one request

“Make a new bot called Game Shipper that builds and ships Modal apps. Its first job: an app called arcade-fifty where each of 50 Sandboxes plays a different game…”

It wrote and tested the app, deployed it once you approved, and started all 50 games.
Ran 1 Modal command
1. modal deploy bots/3570/arcade/app.py -e can-devafter you approved
Looked up modal.Sandbox.create and modal.Dict.put in the Modal docs before writing the app.
Know which Apps need you

“Chart end-to-end p99 latency for each demo-* app over the last 24 hours, in one chart, and tell me in one line which one needs attention.”

demo-gpu-burn comes first: some of its calls wait minutes for a GPU.
Ran 3 Modal commands
1. modal function metrics demo-llm-api/generate --group calls --since 24h --bucket-size 1h --json -e can-dev
2. modal function metrics demo-gpu-burn/burn --group calls --since 24h --bucket-size 1h --json -e can-dev
3. modal function metrics demo-batch-embed/embed_batch --group calls --since 24h --bucket-size 1h --json -e can-dev
Read the CLI reference for modal function metrics first.
Get the root cause, not just the error

“Find the app here with the most recent errors, read its logs, and tell me the root cause and the fix.”

First tokens slow to 1.7 s every 20 minutes. The cause: no warm containers. The fix: one line.
Ran 10 Modal commands
1. modal app list --json -e can-dev
2. modal app logs demo-gpu-burn --since 12h -e can-dev --timestamps
3. modal app logs demo-batch-embed --since 12h -e can-dev --timestamps
4. modal app logs demo-llm-api --since 12h -e can-dev --timestamps
5. modal app info demo-llm-api -e can-dev
6. modal app logs demo-llm-api --since 20m -e can-dev --timestamps
7. modal function autoscaler settings demo-llm-api/generate -e can-dev
8. modal function info demo-llm-api/generate -e can-dev
9. modal function stats demo-llm-api/generate --since 12h --json -e can-dev
10. modal app logs demo-llm-api --since 2026-11-09T20:19:00Z --until 2026-11-09T20:27:00Z -e can-dev --timestamps
Spend less on Modal

“Looking only at the demo-* apps: what does each one cost per day, and what concrete changes would cut that? Give estimated monthly savings.”

About $440 a month today, and about $325 of it can go without stopping anything.
Ran 13 Modal commands
1. modal app info demo-gpu-burn -e can-dev
2. modal app info demo-batch-embed -e can-dev
3. modal app info demo-llm-api -e can-dev
4. modal app info demo-flaky-ingest -e can-dev
5. modal function info demo-llm-api/complete -e can-dev
6. modal function info demo-batch-embed/embed_batch -e can-dev
7. modal function info demo-gpu-burn/burn -e can-dev
8. modal environment billing report can-dev --start 2026-11-09 --resolution h --json
9. modal function stats demo-gpu-burn/burn --since 6h --json -e can-dev
10. modal function stats demo-llm-api/traffic --since 6h --json -e can-dev
11. modal function stats demo-batch-embed/embed_batch --since 6h --json -e can-dev
12. modal function stats demo-batch-embed/resize_thumbnails --since 6h --json -e can-dev
13. modal function stats demo-llm-api/generate --since 6h --json -e can-dev
Right-size every Function

“Which functions here have slow cold starts or more GPU or memory than they use? Tell me what you would change and why.”

embed_batch asks for 4 CPUs and 8 GiB, and uses 0.02 cores and 0.33 GiB.
Ran 15 Modal commands
1. modal app list --json
2. modal app info demo-batch-embed
3. modal app info demo-gpu-burn
4. modal function info demo-llm-api/generate --json
5. modal function stats demo-llm-api/generate --since 12h --json
6. modal function info demo-llm-api/complete --json
7. modal function stats demo-llm-api/complete --since 12h --json
8. modal function info demo-llm-api/traffic --json
9. modal function stats demo-llm-api/traffic --since 12h --json
10. modal function info demo-batch-embed/embed_batch --json
11. modal function stats demo-batch-embed/embed_batch --since 12h --json
12. modal function info demo-batch-embed/resize_thumbnails --json
13. modal function stats demo-batch-embed/resize_thumbnails --since 12h --json
14. modal function info demo-gpu-burn/burn --json
15. modal function stats demo-gpu-burn/burn --since 12h --json
Catch problems while you’re away

“Set up a routine that checks demo-gpu-burn every 15 minutes: write a check script … that fails when the GPU sat under 20% utilization for most of its last run.”

It wrote the check, proved it on a real run, and has passed 50 runs since. A failure wakes it to tell you.
Ran 1 Modal command
1. modal function metrics demo-gpu-burn/burn --since 60m --bucket-size 1m --jsonin check.py, every 15 min
The bot wrote check.py around this command. A pass is recorded quietly and calls no model.

Watch the full film.

Three and a half minutes in the product: routines, a chief of staff, memory, approvals, and a new bot shipping an app.

See every feature How it works

How it works.

You talk to one main bot, and it runs a team of bots on your workspace. They live in one VM on Modal per workspace and environment, split into two machines by trust.

Pick a trace to follow a request through it.

From a question to a team.

Bots read freely, keep watching, and ask before they change anything.

Ask in plain words.

Ask what failed, what’s slow, or what something costs. The bot runs the same read-only modal commands you would, and answers with the evidence: every command it ran, ready to copy, charts from your metrics, and logs you can follow live.
Turn a question into a routine.

Ask a bot to keep an eye on something and it writes a check: a short script that measures, compares with what you expect, and passes or fails. The check runs on a schedule. A pass is recorded without calling the model; a failure wakes the bot with the evidence, and it tells you.
check.pywritten by a bot
```
# Fail when the GPU sat under 20% for most of the last run.
cmd = f"modal function metrics {FN} --since 60m --json"
url = os.environ["MODAL_WORKSPACE_API"] + "/v1/modal?command=" + quote(cmd)
...
if low > len(vals) / 2:
    print(f"GPU mostly idle in last run: {verdict}"); sys.exit(1)
print(f"GPU busy enough in last run: {verdict}")
```
Checks read your workspace through the assistant’s host, since the bots’ computer holds no credentials. Exit 0 is a quiet pass.
Bots work as a team.

The main bot is your chief of staff. Ask for a new job and it makes a bot for it, writes its prompt and sets up its routines, then asks the others what they’ve found. Each bot keeps its job in PROMPT.md and what it learns in MEMORY.md, plain files you can read and edit. Messages between bots wait in a queue, and every conversation shows beside the bot map.
Changes wait for you.

Bots never change your workspace on their own. A stop, rollback or deploy becomes a card with the reason and the exact command. It runs once, after you click Approve, or never.

Bots that build bots.

The main bot makes a bot for each job, with its own prompt, persistent memory and routines. Bots ask each other through queues that never interrupt, and a request is passed on at most three times.

A routine, start to finish.

Always-on routines run a check the bot wrote itself. A pass is recorded without calling the model; a failure wakes the bot, and any change it proposes waits for your approval.

Built this way on purpose.

Two machines, split by trust
Bots run as root on their computer, so it gets no Secrets. The host keeps the workspace grant and the model key, and even strips them from its own environment so its subprocesses can’t inherit them.
Read-only by construction
A bot asks for a Modal command in the words you’d type. The host runs it only if it is on its list of reads: Apps, logs, stats, metrics, billing. Writes and data contents are refused; changes become approval cards.
Durable before it acts
Before a shell command, a file edit or an approved action runs, its intent is on the Volume. A replacement VM resumes the chat, and a step that was cut off says so instead of silently running twice.
It sleeps when idle
The VM stops about five minutes after you leave and two after its work ends. A Function wakes it every 5 minutes for routines, and opening the tab wakes it in about 3 seconds.
A screen of its own
Each bot gets its own X screen and browser, so several work at once without fighting over the mouse. You watch them live in the tab, and can click in to take over.
Memory with provenance
One plain file per bot, one fact per line, each stamped with where it came from: you, another bot, a routine, or its own measurement. Only your own message makes a line “user”.