AI Agent Platform
Build and Run AI Agents on SandBase
Define an Agent with models, instructions, Skills, MCP servers, and real-world APIs. Test it in a Session, publish it as a Service, or run it on a Schedule.
- Agents
- Services
- Schedules
- Sessions
- 01AgentsDefine the work
- 02ServicesMake Agents callable
- 03SchedulesRun Agents automatically
- 04SessionsSee the actual work
Platform overview
One Definition, Three Paths, One Record
Build, deploy, schedule, and monitor custom AI agents in a closed loop: every path starts from an Agent definition and ends in a Session.
Test path
- Agent Definition
- Test / Chat
- Session
Service path
- Agent Definition
- Publish Version
- Service
- Session
Schedule path
- Agent Definition
- Starting Message + Time Rule
- Schedule
- Session
01 · Agents
Agents: Define the Work
An Agent is a reusable, versioned task definition and capability combination, set up in five stages: Overview, Instructions, Model, Capabilities and Runtime.
- Model
- The default model the Agent uses. It is a swappable runtime choice, not a permanent binding.
- Instructions
- The goal and working rules the Agent follows.
- Tools and Skills
- Reusable Skills and tools that package steps for recurring tasks.
- MCP Connections
- MCP servers, including workspace MCP, that reach real-world APIs and systems.
- Runtime Profile
- The runtime the Agent's Sessions run in.
- 01OverviewName, purpose and descriptionDone
- 02InstructionsGoal and working rulesDone
- 03ModelDefault runtime modelDone
- 04CapabilitiesTools, Skills and MCP
- 05RuntimeRuntime profile
- Tools
- Skills
- MCP
- Workspace MCP
02 · Services
Services: Make Agents Callable
- Expose a tested, selected Agent version as an HTTP Service.
- Apps, app users, or AI tools can invoke it.
- Each invocation creates a new Session.
- A model override applies to new Sessions; leave it blank to inherit the Agent model.
- Agent
- Market Brief Agent
- Version
- v3 · tested
- Model override
- Blank — inherits Agent model
- Callers
- App · App user · AI tool
Each runNew Session
03 · Schedules
Schedules: Run Agents Automatically
- A Schedule combines an Agent, a starting message, a time rule and a timezone.
- It works without first publishing a Service.
- Each scheduled run creates a Session.
- A model override applies only to new Sessions; blank inherits the Agent default.
- Agent
- Market Brief Agent
- Starting message
- Summarize this week's product news for our category.
- Time rule
- Daily at 09:00
- Timezone
- Asia/Shanghai
- Model override
- Blank — inherits Agent default
Each runNew Session
04 · Sessions
Sessions: See the Actual Work
A Session is one actual run and its continuing work context, not just a log line.
Sources
- Direct / Test
- Service
- Schedule
Each session shows
- Transcript
- Events
- Turns
- Tool and MCP calls with results
- Files and results
- Agent, version, model, source, runtime and environment
Where appropriate, you can continue a Session with more instructions or stop a running task.
Session · ses_illustrative
Market Brief Agent · v3
Status: Running
- Source
- Schedule
- Model
- Default model
- Runtime
- Runtime profile
Transcript
Starting message
Summarize this week's product news for our category.
Agent
Searching recent sources and extracting the key announcements.
Event · MCP tool call
search.query
query: "category product news this week"
Turn 2 · in progress
Files / Results
- weekly-brief.md
- sources.json
Continue this session
Shared capabilities
One Set of Capabilities Across Every Module
Models, Instructions, Skills, MCP and real-world APIs, Runtime and Versions are defined once on the Agent and carried through Services, Schedules and Sessions.
Models
- Agents
- Default model
- Services
- Optional override
- Schedules
- Optional override
- Sessions
- Model recorded
Instructions
- Agents
- Goal and rules
- Services
- Inherited
- Schedules
- Plus starting message
- Sessions
- Followed in transcript
Skills
- Agents
- Attached
- Services
- Inherited
- Schedules
- Inherited
- Sessions
- Used in turns
MCP / Real-World APIs
- Agents
- Connected
- Services
- Inherited
- Schedules
- Inherited
- Sessions
- Calls and results
Runtime
- Agents
- Runtime profile
- Services
- Inherited
- Schedules
- Inherited
- Sessions
- Runtime recorded
Versions
- Agents
- Versioned definition
- Services
- Selected version
- Schedules
- Agent run
- Sessions
- Version recorded
Templates
From Template to Production
Start from a public Agent, make it yours, and move it through the same loop.
- 01
Browse
Find a public Agent or template in the Agent Store.
- 02
Customize
Adjust instructions, model and capabilities for your task.
- 03
Test in a Session
Chat with it and review what it did.
- 04
Publish or Schedule
Publish a Service or create a Schedule.
- 05
Inspect Sessions
Review each run as a Session.
Use cases
What Teams Run on the Platform
Three patterns built from the same modules.
01 · Research
Research and Extraction
Combine a model with search and extraction APIs to gather sources and return structured findings in a Session.
Agent · Search API · Extraction API
02 · Monitoring
Scheduled Monitoring
Attach an Agent to a Schedule with a starting message; each run creates a Session with its report.
Schedule · Skills · Real-World APIs
03 · Customer-facing
Customer-Facing Agent via API
Publish a tested version as a Service and call it from your product; each invocation starts its own Session.
Service · Model · MCP Tools
FAQ
AI Agent Platform Questions
What teams ask before they build and run AI agents on SandBase.
An AI Agent Platform covers the full lifecycle of an Agent: defining it, testing it, making it callable, running it automatically and inspecting what it did. On SandBase these are Agents, Services, Schedules and Sessions.
An AI Agent Builder focuses on defining an Agent — its instructions, model and capabilities. The platform adds what happens next: publishing a version as a Service, running it on a Schedule, and reviewing every run as a Session.
An Agent is a reusable, versioned task definition. A Service exposes a tested Agent version over HTTP. A Schedule runs an Agent from a starting message, time rule and timezone. A Session is one actual run and its continuing work context.
Yes. The Agent has a default model. Services and Schedules can set a model override for the new Sessions they create; leaving it blank inherits the Agent model.
Testing an Agent directly, invoking a Service and each scheduled run all create a Session. The Session records the transcript, events, turns, tool and MCP calls, files and results, plus the Agent, version, model and source.