Where does OpenHands output actually go?

Into the sandbox workspace — a container filesystem that is not your machine and does not outlive the session unless you mounted something. Anything the agent writes there needs an explicit exit, which is why publishing beats saving a file.

Can OpenHands call an MCP server?

Yes. OpenHands takes MCP servers in its configuration, so Comma can be a tool the agent calls directly from inside the sandbox — it only needs outbound HTTPS.

What about headless runs?

Headless mode is where this matters most: nobody is watching the sandbox, so a run that ends with a published URL is the difference between a result and a discarded container.

Is it safe to give a sandboxed agent a token?

It is safe in proportion to the scope. Give it `reports:write` and it can publish and nothing else; the token is revocable and rate-limited per token.

Can I still get the files out?

Yes, by mounting a volume — but a mounted file still has no URL, no access control and no comment thread. Publishing solves the sharing problem; mounting only solves the persistence one.

Share what OpenHands produced

OpenHands runs in a sandbox, which is the right design and an awkward one for output. The agent clones the repo, runs the tests, works out why the migration fails on Postgres 16, writes it all down — inside a container that is not your machine and, by default, does not exist ten minutes later.

Mounting a volume gets the file out. It does not get the document out: a file on a host disk still has no address, no access setting and nobody to read it.

Publishing is the exit that works

OpenHands takes MCP servers in its configuration, and the sandbox only needs outbound HTTPS to reach one. Add Comma with the endpoint and a token from API tokens — see MCP setup for the shape — and the agent can publish from inside the container.

Then say so in the task, or in the standing instructions the runtime carries:

Work happens in the sandbox; results do not stay there. When you finish a
document a human needs — an investigation, a plan, a test analysis — publish it
to Comma as an HTML report and return the URL as your final answer.

Headless is the case that matters

An interactive OpenHands session at least has you watching the terminal. A headless run on a schedule has nobody:

COMMA_API_TOKEN=... python -m openhands.core.main \
  -t "Reproduce issue 412, diagnose it, publish the write-up to Comma and \
      return only the URL."

The container exits, the workspace evaporates, and the thing that survives is a page. If you would rather not own the scheduler, see routines; if the run belongs in a pipeline, see CI.

Why a page rather than a mounted file

It has an address you can paste into the issue the run was about.
It renders faithfully in a sandboxed iframe — logs, tables, diffs.
It has a comment thread anchored to the finding — see commenting on HTML.
The agent can read the replies on the next run through the same server.

Worth knowing

Scope hard. A sandboxed agent with a broad token is the worst of both designs. reports:write and nothing more — see scoped tokens.
5 MB of HTML per report body.
Rate limits are per token, so a runaway loop is bounded.

Try it

Free — unlimited reports, commenters and revisions.

See MCP setup →