PERSISTENT AGENT API

■ THE MEMORY LAYER FOR SERVER-SIDE AGENTS.

TURN YOUR API
INTO AN AGENT
THAT REMEMBERS.

Define the agent once on your server: its profile, system prompt, instructions, history and approved lessons. Every API call starts with the context it needs—not another round of setup.

Create your workspace ↗See how it works ↓

One agent ID. Your model provider. Your application controls external actions.

▪ ▪ ▪your-agent.profile01 / SAVED

> meet your new agent

✳

Support agent

Customer support agent

EXAMPLE
Instructions
Saved once
Memory
You choose
Model
Your connected provider
Learning
Approval required
// Every request can be this simple.
{
  "agent_id": "support_agent",
  "input": [{ "role": "user", "content": "Help my customer." }]
}
The same agent, ready for the next request.
01   AGENT PROFILE02   SYSTEM INSTRUCTIONS03   RELEVANT HISTORY04   APPROVED LESSONS

THE MODEL IS ONLY PART OF THE AGENT.

CONTEXT SHOULD NOT
BE REBUILT ON EVERY CALL.

A model can answer well, but it does not know your agent’s role, its decisions or the customer history behind a request. That context should live with the agent—not be reconstructed in every application call.

WITHOUT OSAGENTSREASSEMBLE CONTEXT

Your application rebuilds the agent.

  • Repeat the system prompt
  • Store and search conversation history
  • Decide what belongs in each request
  • Turn feedback into safe, versioned rules
WITH OSAGENTSONE AGENT API

Your agent arrives ready to work.

  • Keep its profile and instructions on the server
  • Retrieve relevant memory automatically
  • Bring forward history only when it helps
  • Review and approve what it learns

You keep control. Bring your model API key. Keep tools inside your application. osAgents manages the persistent agent context between them.

DEFINE ONCE. KEEP BUILDING.

YOUR AGENT IS READY
WHEN YOUR API CALLS.

Your app sends the task.
osAgents brings the context.

[ 01 / DEFINE ]
NAMESupport agentINSTRUCTIONS

Be helpful. Keep answers short.
Ask when information is missing.

↳ Saved to the agent profile

Tell it who it is.

Give your agent a name, a role and clear instructions. Edit them whenever you need.

[ 02 / CONNECT ]
MODEL CONNECTIONYour provider. Your key.
osAgents→Model API
↳ No model training needed

Connect your model.

Bring a supported model provider’s API key. osAgents adds the saved context before calling it.

[ 03 / BUILD ]
YOUR APPLICATIONSend a message.
agent_id: support_agent
input: “Let’s get started.”
↳ Receive the agent’s response

Use it in your app.

Call your agent through the API. Your application stays in charge of tools and actions.

Your application sends an agent ID and a message. osAgents resolves the agent context before the model call.

MEMORY, WITHOUT THE MYSTERY.

THE RIGHT MEMORY.
ONLY WHEN NEEDED.

Chat history, saved preferences and knowledge can live behind one agent ID. You choose what is kept, how long it stays and who it belongs to.

osAgents searches memory privately. The model receives only the relevant pieces—not your entire memory store—and memory never changes the model’s weights.

Chat historyPreferencesKnowledgeApproved lessons
Explore memory ↗
01AUTOMATIC

Relevant context, before the model answers.

For every request, osAgents first narrows memory by workspace, agent, end user and session. It selects the most relevant recent chat turns, facts and approved lessons, then adds them to the model context.

Your message→Private retrieval→Model context
No tool call. No extra step in your application.
02ON DEMAND

A deeper recall, only when it needs one.

If the initial context is not enough, the agent can request recall_memory. osAgents performs another bounded, read-only search and returns the result privately so the model can finish its answer.

Needs more→Private recall→Continue answer
Still internal to osAgents. It is never returned as a customer tool.
One protected memory indexWorkspace → Agent → End user → SessionInspectable · deletable · retention controlled

LEARN FROM FEEDBACK. NOT GUESSWORK.

BETTER HABITS.
WITH YOUR APPROVAL.

Correct an answer. Review a suggested lesson.
Choose whether your agent should keep it.

01 / YOUR CORRECTION

“Please write dates
as YYYY-MM-DD.”

02 / PROPOSED LESSON

Use YYYY-MM-DD
for invoice dates.

AWAITING APPROVAL
03 / APPROVED VERSION

A saved rule for
future invoice requests.

v2 · reversible

Learning updates approved instructions and memory—not model weights. Changes can be tested and rolled back; improvement is not guaranteed.

YOUR AGENT, ON YOUR TERMS.

MAKE IT YOURS.

Shape the profile. See the API payload.
Your application stays in control.

01 / AGENT PROFILE CONFIGURE

Profile changes are held in this browser session.

02 / YOUR API REQUESTAPI CONTRACT

You send the message, not the whole profile.

osAgents adds on the server
Profile
Support agent · Customer support
Instructions
From the saved profile
History
This session
RESPONSE SHAPE
“Happy to help. What does your customer need?”


request.sh
curl https://api.osagents.app/api/v1/osagents/v1/messages \
	  -H "Authorization: Bearer YOUR_OSAGENTS_KEY" \
	  -H "Idempotency-Key: UNIQUE_REQUEST_ID" \
	  -H "Content-Type: application/json" \
	  -d '{
	    "agent_id": "support_agent",
	    "session_id": "customer_1042",
	    "input": [{"role":"user","content":"Help with this order."}]
	  }'
Set your osAgents API key before running.
BUILT FOR YOUR APPLICATION.
ONE REQUEST.
YOUR SAVED AGENT.
No system prompt to paste into every call. For a new run, your application still sends the conversation messages the model needs.
Use an agent ID and, when memory is enabled, a session ID. Receive a response your application can use. Read how session continuity works ↗
Your tools stay yours.
osAgents does not execute your tools. If your agent requests a tool call, your application decides whether to run it and sends back the result.


CONTEXT THAT CONTINUES.
KEEP THE THREAD.
CONTROL THE RUN.
Create a server-managed conversation, then send a new message with its conversation ID. osAgents carries forward the recorded turns without asking your application to resend the whole chat.
Inspect runs, pause or cancel them, and review saved context in your workspace. Files and Markdown skills can be attached to an agent with versioned changes.
Explore conversations and runs ↗
ONE CONVERSATIONSERVER-MANAGED
Conversations
Ordered turns scoped to your agent and end user
Runs
Status and controls visible in the dashboard
Files & skills
Reviewed Markdown, pinned to a version
Tools
Your application approves and executes external actions
Interrupted provider calls can have an unknown outcome. osAgents does not automatically repeat a possibly billed call.


MANAGED TOOLS, WITH A CLEAR BOUNDARY.
LET AGENTS USE CODE.
KEEP EXECUTION ISOLATED.
On the Sandbox plan, an agent can call a tool you reviewed and approved. osAgents executes that exact version in a separate, network-restricted environment and returns its result to the same run.
01 / CONTROL
Approve before use.
An owner reviews the complete source and pins a version. Revoke it whenever you need to.
02 / CONTINUITY
One run, including tool results.
The agent receives the result and continues without your application rebuilding its conversation.
03 / ACCOUNTABILITY
See every execution.
Inspect job status and billed minutes. Idempotent retries reuse the same job instead of repeating an action.


GITHUB TO APPROVED TOOL.
REVIEW THE CODE.
PIN THE VERSION.
Import a public GitHub JavaScript file by repository, path and commit. Preview the complete source, save it as a draft, then approve the exact version for an agent.
Only approved JavaScript runs in Sandbox. Imported Markdown files are instructions or skills, never executable code. Code tools cannot use your provider keys or unrestricted network access.
How GitHub tools work ↗
GITHUB → AGENTOWNER CONTROLLED
01 · Preview
Read the full source at a pinned commit
02 · Approve
Owner authorizes one exact version
03 · Run
Isolated execution with a durable job record
04 · Inspect
Review status and metered minutes
GitHub imports do not grant secret access or unrestricted network access.


PAID FROM THE FIRST ACTIVE WORKSPACE.
START SMALL.
GROW WITH USE.
Choose the capacity and tool execution you need. 
01 / STARTER$20 / month
For a focused agent and early production workloads.
  • 10,000 agent runs each month
  • 1 GB agent memory
  • 5 simultaneous provider calls
  • One active workspace
  • BYOK model providers
Additional runs $3 per 1,000 · memory $8 per GB-month. No managed code execution.
Choose Starter ↗
02 / GROWTH$59 / month
For busier agents and concurrent applications.
  • 50,000 agent runs each month
  • 5 GB agent memory
  • 20 simultaneous provider calls
  • One active workspace
  • BYOK model providers
Additional runs $3 per 1,000 · memory $8 per GB-month. No managed code execution.
Choose Growth ↗
03 / SANDBOX$149 / month
For agents that run reviewed code tools in isolation.
  • 50,000 agent runs and 5 GB memory
  • 20 simultaneous provider calls
  • 1,000 sandbox execution minutes
  • Owner-approved, pinned code versions
  • Isolated, network-restricted execution
Additional execution $0.20 per minute, rounded up per invocation. Run and memory overages match Growth.
Choose Sandbox ↗
All plans use your own model provider key. Provider inference is billed by that provider separately. Sandbox code tools run only after source review and approval.


A FEW THINGS TO KNOW.
GOOD QUESTIONS.
CLEAR ANSWERS.
Do I need to train or fine-tune a model?
No. osAgents uses saved instructions and relevant memory with a connected model. That changes the context sent to the model, not its weights.
Can I bring my own model API key?
Yes. Connect OpenAI, Anthropic, Google, OpenRouter and other built-in providers, or a custom OpenAI-compatible endpoint. osAgents manages the agent profile and context; provider inference charges remain separate.
What does the agent remember?
You choose whether to retain session history and save longer-term facts or preferences. Memories are inspectable and deletable, and separated by workspace, agent and end user.
Does “learning” mean it gets smarter automatically?
No. Feedback can produce suggested lessons. Approved, versioned lessons influence later responses. They do not train the underlying model, and they can be wrong—so evaluation and rollback matter.
Where does my data go?
Enabled profiles and memory are stored in your osAgents workspace. Instructions, messages and selected memory are sent to your connected model provider for inference according to your provider’s terms.
Who runs the tools?
Your application runs customer-hosted actions. Reviewed, approved code tools can run in an isolated osAgents sandbox with a Sandbox subscription. osAgents is not a multi-model router.
Can I use this today? What does it cost?
Create a workspace and choose Starter at $20 per month, Growth at $59 per month, or Sandbox at $149 per month. Sandbox includes Growth capacity plus 1,000 code execution minutes; additional minutes cost $0.20 each. Additional agent runs cost $3 per 1,000 and memory costs $8 per GB-month. 


THE AGENT LAYER BETWEEN YOUR APP AND YOUR MODEL.
SET IT ONCE.
KEEP THE CONTEXT.
Create your workspace ↗