Agent-as-a-Service

Build agents.
The harness is ready.

Embed them in your frontend or backend. Octodus handles the runtime, context, tools, files and usage metering.

Division of responsibility Octodus /v1
Your product

Defines the experience

  • Interface and business logic
  • The agent's role and instructions
  • User data and permissions
Octodus

Runs the agent

  • Runtime and models
  • Context, tools, MCP and secrets
  • Turns, files, usage and trace ID
Your product receivesresultfilesusagetrace_id

What you can build on Octodus.

Don't stand up your own agent runtime. Build the interface and business logic you need on top of a ready execution platform.

Agent-as-a-Service

Sell agent features inside your own product

Your brand, interface and customer relationships stay with you. Octodus runs the agent's tasks through the API and returns the result, files and usage.

Frontend

An agent in your interface

Add a chat, a copilot or a task form. Your backend passes the request to the agent securely, so the API key never reaches the browser.

Backend

An agent in a background process

Start work from your backend on a webhook, a schedule or a product event. Pick up the result once the asynchronous turn completes.

Support

A support agent with customer context

Pass end_user_ref and connect knowledge sources through allowed tools or MCP. The agent can draft a reply, create a file or call an approved action.

Your own role

Any vertical agent

A researcher, analyst, sales assistant, document generator or an agent for your industry. The role is defined by a manifest and a set of tools.

Octodus already has the whole agent harness.

Your team doesn't need to build model orchestration, context isolation, task lifecycle, tools, files and usage tracking separately.

Runtime

Execution and state

Asynchronous turns, terminal states, idempotency and a trace ID for diagnostics.

Context + tools

The agent's environment

Isolated spaces, a manifest, built-in tools, external MCP servers and write-only secrets.

Delivery + usage

Results and economics

Text, generated files, spend per end_user_ref and usage limits.

Your code stays a simple API call.

Create the agent environment, send a task and get back the ID of an asynchronous turn.

Create a space and start a turnBash + jq
BASE_URL="https://dash.octodus.com/v1"
TASK="Prepare a brief"

SPACE_ID=$(curl -sS -X POST "$BASE_URL/spaces" \
  -H "Authorization: Bearer $OCTODUS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"title":"Research agent"}' | jq -r '.space_id')

curl -sS -X POST "$BASE_URL/turns" \
  -H "Authorization: Bearer $OCTODUS_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d "{\"space\":\"$SPACE_ID\",\"text\":\"$TASK\"}"
Response to starting a turn 202 Accepted { "turn_id": "TURN_ID", "state": "queued", "trace_id": "TRACE_ID" }

Next request: GET /turns/{turn_id} until the state is done.

  1. Build the agentSpace, manifest, tools and secrets
  2. Link the userend_user_ref for usage and limits
  3. Start the workPOST /turns and a state check
  4. Return the resultText, files and usage data

You stay in control of every agent.

The public /v1 API uses Bearer API keys. Create a key in the dashboard under Integrations, API Keys. It is shown only once.

Full authentication guide →
Minimal scope

Limit the key to the spaces it creates. This is the recommended mode for integrations.

One space

Bind the key to a single space if the integration doesn't need access to the rest.

Spend limit

Set a daily limit in USD and track actual spend through usage.

When your team is ready to integrate.

Interactive documentation, the OpenAPI schema and focused guides for your team and your tools.

Which agent do you want to embed?

We'll help you define the role, access, tools and a secure way to integrate it with your product.