AssistMe Agent SDK
A model-agnostic, production-grade SDK for building AI agents
AssistMe Agent SDK
The AssistMe Agent SDK is a lightweight, model-agnostic framework for building AI agents that can reason, use tools, collaborate, and operate safely in production environments.
Why Another Agent SDK?
Most agent SDKs are tightly coupled to a single model provider. When you build with them, you're locked in — to one company's API, pricing, rate limits, and roadmap. If a better model launches tomorrow, you're stuck rewriting.
The AssistMe Agent SDK takes a different approach:
- Model-agnostic — Swap between Claude, GPT, Gemini, Llama, or any provider with a single line change. Your agent logic stays the same.
- Company-agnostic — No vendor lock-in. You own your agent architecture.
- Production-first — Built-in guardrails, observability, human-in-the-loop, and sandboxing are first-class citizens, not afterthoughts.
- Minimal primitives — Core concepts:
Agent,Tool,Guardrail,Memory,Session,Runner. Everything else composes from these.
Quick Example
import { Agent, Tool, Runner } from 'assistme-agent-sdk'
import { claude } from 'assistme-agent-sdk-provider-claude'
import { z } from 'zod'
// Define a tool
const searchTool = Tool.create({
name: 'web_search',
description: 'Search the web for information',
parameters: z.object({
query: z.string().describe('The search query'),
}),
execute: async ({ query }) => {
const results = await fetch(`https://api.search.com?q=${query}`)
return results.json()
},
})
// Create an agent
const researcher = new Agent({
name: 'researcher',
model: claude('claude-sonnet-4-6'),
instructions: 'You are a research assistant. Use web search to find accurate, up-to-date information.',
tools: [searchTool],
})
// Run the agent
const result = await Runner.run(researcher, {
messages: [{ role: 'user', content: 'What are the latest advances in quantum computing?' }],
})
console.log(result.output)Core Concepts
| Concept | Description |
|---|---|
| Agent | The core primitive — an LLM with instructions, tools, and guardrails |
| Tool | A function the agent can call to interact with the world |
| Guardrail | Validation logic that runs on inputs and outputs |
| Memory | Persistent state across conversations and sessions |
| Session | Persistent, resumable, and forkable conversations |
| Runner | The execution engine that orchestrates agent runs |
Architecture at a Glance
User Input
│
▼
┌─────────────────────────────────────────────┐
│ Runner │
│ ┌─────────┐ ┌──────────┐ ┌────────────┐ │
│ │ Input │ │ Agent │ │ Output │ │
│ │Guardrail │→ │ + Model │→ │ Guardrail │ │
│ └─────────┘ │ + Tools │ └────────────┘ │
│ │ + Memory│ │
│ └──────────┘ │
│ ↕ │
│ ┌──────────┐ │
│ │ Provider │ │
│ │ (Claude, │ │
│ │ GPT, …) │ │
│ └──────────┘ │
├─────────────────────────────────────────────┤
│ Observability │
│ (Traces, Logs, Metrics) │
└─────────────────────────────────────────────┘
│
▼
Agent OutputDesign Principles
-
Simplicity over abstraction — Write agents in plain TypeScript/Python. No DSLs, no YAML configs, no magic decorators. Control flow is just code.
-
Composability — Agents can call other agents. Tools are just functions. Guardrails are just validators. Everything plugs together naturally.
-
Transparency — Every agent run produces a full trace: what the model thought, which tools it called, what guardrails checked, how long it took. Nothing is hidden.
-
Safety by default — Input guardrails, output guardrails, tool sandboxing, and human approval gates are built into the core, not bolted on as plugins.
-
Provider freedom — Your agent code doesn't change when you switch models. The provider abstraction handles all the differences.
What's Next?
- Installation — Get the SDK set up in your project
- Quick Start — Build your first agent in 5 minutes
- Agents — Deep dive into the Agent primitive