TypeScript SDK
The fastest path to a product feature
Create threads, stream runs, upload verified files, handle approvals, and inspect durable tasks from a typed server-side client.
Start with the SDKChuskyFor developers
Build the agent
your stack needs.
Bring 6,000+ tools, ongoing agent work, and human approvals behind your product. Use the API or SDK, embed chat on your business site, or connect another agent through MCP and A2A.
Choose your entry point
Put Chusky behind the experience you already own.
Your product owns authentication and its customer-facing experience. Chusky provides the agent execution API; the caller identity and project scopes define whose work and tools the run may use.
REST API
Keep your own application architecture
Call the versioned /v1 API from your server, mobile backend, job runner, or internal service. The same ownership and approval rules still apply.
Read the API guideRemote MCP
Give another agent a governed Chusky connection
Connect a compatible remote MCP host with a project key and stable end-user identity. It can discover and call Chusky operations without receiving provider credentials.
Connect through MCPAgent-to-Agent
Make Chusky part of a wider agent team
Let another agent hand work to Chusky through A2A. Keep the caller identity, permitted tools, and execution limits attached to the job.
Explore the integration surfaceFor the conversations on your site
Your website can be where the work starts.
Embed a Chusky chat widget on your business website so visitors can reach the agent without switching channels. Connect it to the knowledge, tools, and workflows your business allows.
A conversation with somewhere to go.
The widget is an entry point into the agent. Behind it, a request can draw on connected apps, lead to a next task, and remain part of an ongoing workflow.
The same controls behind the chat.
Keep visitor and workspace context separated, limit the available tools, and keep owner approval on important changes. Embedding chat does not give a visitor unrestricted access to your accounts.
Build around follow-through
The job can continue after the first response.
Your interface can be a chat, an internal tool, a business workflow, or another agent. Chusky brings work that can wait, resume, and return a result with its history intact.
Missions and named agents.
Keep steps, budgets, an agreed finish line, and evidence with longer work. Give named agents specific responsibilities and let them hand work between roles.
Events and scheduled work.
Bring email, calendar, HubSpot, and Slack events into configured workflows. Attention Pulse, reminders, and recurring jobs cover the work you want revisited on a schedule.
The integration contract
One request, with a durable identity behind it.
Call Chusky from a trusted server. Your project key identifies the application; your authenticated user ID identifies whose private threads, files, memories, approvals, and connected accounts the run may use.
Keep project keys out of browser code
Derive userId from your own authenticated session
Persist thread and run IDs in your application
Treat a disconnected stream as recoverable, not automatically failed
server.tsTypeScript SDK
import { Chusky } from "@chusky/sdk";
const chusky = new Chusky({
apiKey: process.env.CHUSKY_API_KEY!,
userId: session.user.id,
});
const thread = await chusky.threads.create();
for await (const event of chusky.threads
.runs(thread.id).stream({
input: "Prepare a renewal brief.",
})) {
if (event.type === "run.delta") sendToClient(event.text);
if (event.type === "run.approval_required")
showApproval(event.approval);
}What you get
Addressable state for long-running work.
01
Durable threads and runs
Keep conversation continuity and recover a run after a disconnected client.
02
Long-running missions
Compose dependency-aware work with checkpoints, bounded budgets, waits, retries, and resumable execution.
03
Verified outcomes and recovery
Read current provider state, retain linked receipts, and require exact owner approval for consequential compensation actions.
04
Tool orchestration
Use Chusky capabilities and owner-approved app connections through one agent loop.
05
Human approvals
Pause before consequential actions and bind approval to the exact tool, arguments, owner, and expiry.
06
Files and image workflows
Upload verified files, route owner-scoped images through exact connected-app schemas, and return generated deliverables.
07
Tasks and webhooks
Move long work into durable task state and receive signed completion or failure events.
08
Operations and audit
Inspect run timelines, receipts, verifications, provider-proof status, and safe audit records.
Production background execution and recovery require Redis and QStash to be configured in the Chusky deployment.
Before production
Make the boundary explicit.
A reliable integration is a shared contract between your application and Chusky. Decide which side owns each responsibility before you ship.
Your application owns
- Authentication and account identity
- Product UI and customer permissions
- Business-specific approval decisions
- Storage of thread and run references
Chusky owns
- Agent execution and tool routing
- Durable run state and recovery
- Connected-app boundaries and approvals
- Task, webhook, audit, and usage state