Start building

Personal Agents · OpenAI Agents API compatible

Your personal Agent, on one account.

Define what it does once. Give it any model, 2,000+ tools and a place to work. Then talk to it from your own code with the OpenAI SDK, using one SandBase key and one balance.

Build your Agent
  • Any model
  • 2,000+ tools
  • OpenAI SDK
  • One balance
agent.pyOpenAI SDK
from openai import OpenAI

client = OpenAI(
    base_url="https://api.sandbase.ai/v1",
    api_key="SANDBASE_API_KEY",
)

agent = client.beta.agents.create(
    model="anthropic/claude-sonnet-5.5",
    instructions="Brief me on AI news.",
)

session = client.beta.agents.sessions.create(
    agent_id=agent.id,
)
Same SDK, SandBase base URL and key.

One account

Everything your Agent needs, already connected.

No model accounts, no tool keys, no servers to keep alive. Your Agent picks up what it needs from the same workspace you already pay from.

  • Any model

    Claude, GPT, Gemini, DeepSeek and more from one catalog. Pick a default and override it per Session.

  • 2,000+ tools

    SandBase MCP brings search, scraping, social data and media models. Add your own MCP servers and Skills beside them.

  • A place to work

    Each Session runs in a managed runtime where your Agent can use tools, keep files and carry on a task.

  • Every run on record

    Sessions keep the transcript, tool calls and files, so you can see what your Agent did and continue where it stopped.

How it works

One Session, from your code to the result.

Your code sends work over the Agents API. SandBase keeps the Session, runs a native agent harness in a hosted sandbox, and gives it the model and tools you chose.

Application

Your code

  • OpenAI SDK
  • HTTP + SSE

SandBase Agents API

  • Agents & versions
  • Sessions & turns
  • Events & history
  • One key, one balance

Built on OpenAgentCore

Hosted environment

Harness

  • Codex
  • Claude Code
  • MiniMax Code

Workspace · shell · files

Model
Any catalog model
Tools
SandBase MCP · 2,000+ APIs
HarnessThe agent loop
Each Session runs Codex, Claude Code or MiniMax Code natively. The harness owns the model and tool loop; you pick it on the Agent.
EnvironmentA place to work
Every Session gets a hosted sandbox with a workspace, a shell and files. Results it writes come back as Session artifacts.
ModelYour choice of model
Any language model in the SandBase catalog. Set a default on the Agent and override it when you start a Session.
ApplicationYour code, unchanged
Send input, stream events and read history with the OpenAI SDK. SandBase keeps the Session state between turns.

Define · Test · Use

From an idea to an Agent you can call.

Shape it in the Console, try it in a Session, then use it wherever your code runs.

  1. 01

    Define

    Write its instructions, choose a model, and attach Skills and MCP connections. Every save is a version.

  2. 02

    Test

    Chat with it in a Session in the Console and watch each tool call before anything depends on it.

  3. 03

    Use anywhere

    Create Sessions from your app, script or backend through the Agents API with your SandBase key.

Compatible by design

The OpenAI Agents API, on any model.

SandBase speaks the Agents API, so existing OpenAI SDK code works by changing the base URL and key. What changes is everything behind it.

Endpointshttps://api.sandbase.ai/v1
  • POST/agentsCreate or update an Agent; each update is a new version
  • POST/agents/sessionsStart a Session from a saved Agent, optionally overriding its model
  • POST/agents/sessions/{id}/eventsSend input or cancel the current turn
  • GET/agents/sessions/{id}/eventsStream the Session live over SSE
  • GET/agents/sessions/{id}/itemsRead the history: messages, tool calls and results
  • Send Authorization: Bearer <SandBase API key> and OpenAI-Beta: agents=v1; the SDK adds the header for you.
  • Text input and cancel events are supported today. Image and function-call events return a clear error until they ship.
OpenAISandBase
Models
OpenAI models
Any model in the SandBase catalog
Harness
Codex
Codex, Claude Code or MiniMax Code
Tools
Tools you wire up
SandBase MCP with 2,000+ APIs, plus your MCP servers and Skills
Billing
Model and container rates
One SandBase balance for models, tools and runs
Console
Code first
Define and test in the Console, then call from code

Open source underneath

Built on OpenAgentCore.

SandBase Agents runs on OpenAgentCore, the open-source implementation of the OpenAI Agents API from MiniMax, released under the MIT License. The protocol your Agent speaks is open, and so is the engine that runs it.

  • Same protocol as the OpenAI Agents API
  • Native Codex, Claude Code and MiniMax Code harnesses
  • Replaceable sandboxes, harnesses and model providers
OpenAgentCore on GitHub ↗

SandBase runs it for you: hosted sandboxes, the model catalog, SandBase MCP and billing on one account.

GET /agents/sessions/{id}/eventsSSE
  1. session.snapshotstatus: in_progress
  2. agent.session.turn.output_text.delta"Three stories today…"
  3. agent.session.turn.output_text.delta"1. A new open model…"
  4. agent.session.turn.completedstatus: idle

Questions

Personal Agent FAQ

An Agent you define once: its instructions, default model, Skills and MCP connections. It lives in your SandBase workspace, keeps its versions, and runs in Sessions you start from the Console or from code.

Yes for Agents and Sessions. Point the OpenAI SDK at https://api.sandbase.ai/v1 with your SandBase API key and use client.beta.agents and client.beta.agents.sessions. Text input, cancel, live event streams and session history are supported; image and function-call events are not yet.

Any language model in the SandBase catalog. Set a default on the Agent and override it when you create a Session; a Session keeps its model for its whole life.

SandBase MCP gives it the catalog of search, scraping, social data and media APIs. You can add your own HTTP MCP servers, with credentials stored write-only, and attach Skills for repeatable steps.

From your SandBase balance: the model tokens your Agent uses and the tools it calls, at the prices shown in the catalog. Every Session and charge appears in Activities.

OpenAgentCore, the open-source, MIT-licensed implementation of the OpenAI Agents API from MiniMax (github.com/MiniMax-AI/OpenAgentCore). SandBase hosts it with managed sandboxes, the SandBase model catalog, SandBase MCP and one balance.

No. The Console is the quickest way to define and test an Agent, but everything it does goes through the same API, so you can create Agents and Sessions entirely from code.

One account.Your personal Agent.

Build your Agent