Gobare Agent API

Run a coding agent from your own code. Not a model that writes code back to you — an agent with a computer, that writes files, runs them, and leaves what it built at a URL you can open.

You bring the model key. Gobare does not sell you inference — it runs an agent against a connection your organization owns, on a sandbox Gobare provides. You pay your model provider for tokens and Gobare for the computer.

A minute, start to finish

This asks for something to be built, waits, and prints an address. Nothing is elided — it is the whole program.

curl

SESSION=$(curl -s -X POST https://api.gobare.dev/v1/sessions \
  -H "Authorization: Bearer $GOBARE_TOKEN" -H 'content-type: application/json' \
  -d '{"agent":{"model":"MiniMax-M3"},
       "input":"Build a small expense tracker web page — a form to add an expense, a running total, saved in localStorage. Serve it on port 8000 and keep the server running."}' \
  | jq -r .id)

# The turn appears a moment after the session, so the list is briefly empty —
# and an empty list means it has not started, not that it has finished.
until [ "$(curl -s "https://api.gobare.dev/v1/sessions/$SESSION/turns?limit=1" \
  -H "Authorization: Bearer $GOBARE_TOKEN" | jq -r '.data[0].status // "working"')" != "working" ]; do sleep 5; done

curl -s -X POST "https://api.gobare.dev/v1/sessions/$SESSION/preview" \
  -H "Authorization: Bearer $GOBARE_TOKEN" -H 'content-type: application/json' -d '{}' | jq -r .url

https://s-a23a2eb878db4d8bbefd.gobare.dev

Open it. There is a working page there, served from the computer the agent was given — a form, a running total, saved in the browser. Forty-nine seconds on one run of this, a hundred and eleven on another; the difference is how long the sandbox took to come up.

You need a token for this. It takes a minute and the quickstart has it.

What just happened

Five nouns, and they nest:

• Agent — a named configuration: model, instructions, tools. Optional; a session can carry its own.
• Session — one cloud computer. Its workspace persists between rounds and survives being paused.
• Turn — one piece of work, from your message until it settles.
• Items — the record: messages, tool calls, file changes.
• Events — the same, as it happens: streamable, resumable.
• Artifacts — files it published; they outlive the computer.
• Preview — a port it serves, optionally at a public URL.

The session is the thing to hold on to. Everything else is reached through it, and a session you created yesterday still answers today — its computer may have been reclaimed and rebuilt, and the conversation does not restart.

Why this and not a model API

A model API returns text. You would still be writing the part that actually runs: a sandbox and its lifecycle, an agent loop, tool dispatch, file capture, streaming, resumption after a dropped connection, and somewhere for a person to approve something before it happens.

That list is the product. It is also why there is no sandbox-free mode — for a coding agent the workspace is not an accessory.

What Gobare deliberately does not do: sell you inference, choose your model, or hold your conversation state in your process. The first is why you connect your own key; the last is why a session is a URL you can come back to rather than an object you keep in memory.

Coming from another Agents API? design-decisions.md lists where this one diverges and why — queueing versus steering, durable versus transient events, and what completed does not mean.

Common tasks

Run one task and collect the result	quickstart.md
Put it in a service and keep it running	production-integration.md
Call it from TypeScript, with types	typescript.md
Call it from Python, with types	python.md
Let the agent call your own code	required-actions.md
Be told when it finishes, rather than waiting	webhooks.md
Put what it built on a public URL	preview.md
Look up a field or an endpoint	objects.md · reference.md
Work out why something looks wrong	troubleshooting.md

Base URL: https://api.gobare.dev — https://app.gobare.dev serves the same API and is what the Console uses.

Every page

Page	Read it when
quickstart.md	First time. Token to completed turn, in one page
production-integration.md	It works, and now it has to keep working
typescript.md	You are past curl and putting this in a service
python.md	The same, in Python
AGENTS.md	The client is an agent. The whole build order in one pass, with a check after every step and a self-test at the end
model-credentials.md	You want to connect a model without opening the Console
sessions.md	You want a session to hold your repo, files, secrets or limits
saved-agents.md	You want every session in one part of your product to start the same way
input.md	You want to send the agent a message, a result, a steer or a stop
events.md	You want to watch a session instead of polling it
webhooks.md	You want to be told rather than to watch
preview.md	You want what the agent built to be reachable by other people
tools.md	You want to give the agent your functions, or an MCP server
required-actions.md	You want the agent to call your code
idempotency.md	Your caller retries, and you need it not to act twice
pagination.md	A collection has more rows than one page, or you need to find a session by your own id
troubleshooting.md	Something looks wrong and you want it by symptom, not by endpoint
errors.md	Something returned a code you have not seen
limits.md	You are planning load, or you got a 429
changelog.md	You want to know what changed, and when
design-decisions.md	You want to know why the API behaves as it does

Those pages describe the parts. Guides put them together: six scenarios — long-running work, structured extraction, approvals, dispatch from your own service, showing the agent’s work live, and moving between model providers — each written as a sequence you can copy.

The machine-readable reference is GET /v1/openapi.json — OpenAPI 3.1, no token needed, because it describes the API rather than holding data in it. Take it before you read anything else here: it carries every field constraint and a real example payload for every event type, which is the part prose is worst at. Every /v1 response points at it:

link: </v1/openapi.json>; rel="service-desc"; type="application/json"

That is there for callers who cannot read this page — an agent has the response in front of it and no way to guess a URL, and one header on a call it was already making is worth more than a paragraph it will never see. It is generated from the same route table the server matches against, so it cannot describe an endpoint that does not exist.

How these pages stay true

The product repository is the source. This directory is checked against the code it describes — ceilings against the constants that enforce them, error codes against their statuses, both event vocabularies — so a page cannot quietly drift from the API.

These pages are published as a site at docs.gobare.dev, built from this directory by deploy/publish-docs-site.sh. A copy of the markdown also goes to gobare_tools via scripts/publish-api-docs.sh, which refuses to run if the check above does not pass.

Scope

Gobare brings your own model key. The API does not sell you inference — it runs an agent against a model credential your organization has already connected, on a sandbox Gobare provides. There is no request field for a model provider, because the provider is a property of the credential.

There is also no sandbox-free mode. For a coding agent the workspace is the product, not an accessory, so every session has one.