# Build with the Sistava SDK

A planned client library for JavaScript, Python, and other runtimes that wraps the existing employee REST API. It is on the roadmap, not published: today you call employees from code through the REST API guide directly, and the SDK would only make that same integration point faster to reach.

The REST API gives you full access. SDKs make it effortless. Import the library, pass your API key, and start sending messages to employees, triggering tasks, and listening for events with clean, idiomatic code in your language of choice. Each SDK wraps the full API surface with typed methods, built-in authentication, automatic retries, and streaming support.

No raw HTTP calls, no JSON parsing, no error code lookups. Call employee.sendMessage("research this topic") and get a typed response back. Available for JavaScript/TypeScript and Python, with more languages coming based on demand.

Every SDK ships with full type definitions, inline documentation, and working examples for common workflows like sending a message, polling for task completion, and handling webhook events.

The client libraries are on the roadmap and are not on a package registry yet. What is already live is the REST API they wrap, so nothing about your integration has to wait for them. Create an API key under Settings, Technical, Channels, post a message to an employee, and read the reply back with ordinary HTTP calls from whatever language you already write in.

One key covers every programmatic door into the platform. The same Bearer token authenticates the REST API, the MCP endpoint, inbound webhooks, and the email webhook channel, so a service you build against one of them is already authenticated for the others. The message rate limit is shared across those channels as well, which means you plan capacity once instead of once per surface.

When the SDKs land, the work you have already done carries straight over. They call the same endpoints with the same authentication, so adopting one is a change to your HTTP layer, not to your integration. What changes is how much code you own: typed methods, retry handling, and streaming stop being yours to maintain, and your IDE starts checking the call before you run it.

This is the layer agencies and product teams build on. Instead of standing up agent infrastructure, wiring model providers, managing tool connections, and building your own safety checks, you point at a workforce that already has all of that and spend your engineering time on the part of the product only you can build.

## Client Libraries for JavaScript and Python

Sistava provides official client SDKs for JavaScript and Python, the two most common languages for building AI-integrated products. The SDKs wrap the REST API with idiomatic interfaces, type safety, automatic retry logic, and built-in authentication handling so you can get to productive code faster without reading the full API reference first.

The JavaScript SDK is available as an NPM package and works in both Node.js and browser environments. The Python SDK is available via PyPI and includes async support for use in async frameworks like FastAPI and Django Async. Both SDKs are versioned in sync with the API and maintained by the Sistava team.

## Type-Safe, Idiomatic Interfaces for Every Operation

SDKs are not thin HTTP wrappers. Each operation is modeled as a typed method with documented parameters and return types. Your IDE provides autocomplete, parameter hints, and compile-time checks so integration bugs are caught before runtime.

Error handling follows each language's conventions: typed exceptions in Python, rejected promises with error types in JavaScript. Rate limit responses are handled automatically with configurable retry policies so your code does not need to implement backoff logic.

## Build Products and Internal Tools on Top of Sistava

SDKs lower the barrier to building products on top of Sistava significantly. Instead of building agent infrastructure, managing LLM APIs, handling tool integrations, and implementing safety systems from scratch, teams integrate Sistava as the workforce layer and focus on their product's unique value.

This is the path for agencies building AI-powered client solutions, SaaS companies adding AI workforce capabilities to their products, and enterprise teams building internal AI tooling. The SDK layer means the integration work is measured in hours rather than months, and you inherit Sistava's safety, monitoring, and scalability as part of the deal.

## How It Works

**Official JavaScript and Python SDKs wrap the Sistava REST API so you can control your AI workforce from your own codebase with full type safety.**

Install the SDK, authenticate with your API key, and you have typed access to every resource on the platform. Create tasks, read messages, manage employee configuration, and stream real-time events, all from your application code. The JavaScript SDK ships with full TypeScript types. The Python SDK uses Pydantic models. Both handle authentication, retries, and error normalization automatically.

SDKs are the right choice when you are embedding Sistava deeply into your product. Build a custom interface, trigger agents from your backend services, or automate employee management as part of your deployment pipeline. The SDK tracks the REST API exactly, so every capability available in the web app is also available in code.

Until the client libraries publish, the REST API is the shipped integration point and it is documented in the channels guide. Teams building on Sistava today authenticate with a Bearer key, post a message to an employee, and get the reply back on the same request. Because the SDKs are a convenience layer over that surface, building against the API now is building against exactly what the SDKs will call later.

## Use Cases

### Frontend team embeds AI employee in their React app

The JavaScript SDK drops into any React or Next.js project, giving the app access to the full AI workforce in a few lines of code.

### Backend team automates AI tasks from Python services

The Python SDK lets backend services trigger AI agents, retrieve results, and handle callbacks inside existing Django or FastAPI code.

### Mobile team adds AI employees to iOS and Android apps

SDK clients abstract authentication, streaming, and error handling so mobile developers focus on the user experience, not the API layer.

### Data team runs AI agents from notebooks and scripts

Data scientists call AI employees from Jupyter notebooks or Python scripts, integrating agent outputs directly into analysis pipelines.

## Comparison

| Before | After |
|---|---|
| Calling the AI workforce requires hand-rolled API clients. | Official SDKs handle auth, retries, and streaming out of the box. |
| Every team builds its own integration from scratch. | One SDK import gives any team full access to the AI workforce. |
| Type safety and autocomplete are missing for API calls. | Typed SDK clients give developers autocomplete and compile-time safety. |
| Error handling and edge cases in API calls vary by team. | The SDK standardizes error handling across every integration. |

## FAQ

### What can I do with the SDK that I cannot do with the REST API directly?

The SDK adds type safety with TypeScript definitions, automatic token refresh, retry logic for transient errors, and idiomatic async patterns. For most teams it reduces boilerplate significantly and makes the integration easier to maintain.

### Which languages are supported?

JavaScript with TypeScript types on NPM and Python on PyPI are the first two client libraries, arriving in that order. Both are maintained by the Sistava team and versioned in sync with the API. Additional languages follow based on demand.

### Can I use the SDK to hire and configure AI employees programmatically?

Yes. The full employee lifecycle is available via SDK: create, configure skills and duties, assign tools, activate, message, and deactivate. This enables automated workforce provisioning as part of your infrastructure or customer onboarding pipelines.

### Is the SDK open source?

Yes. The SDK source is published on GitHub when it ships, so you can inspect the code, submit issues, and contribute. Enterprise customers can also fork and extend it for custom integrations.

### Is there a JavaScript or Python SDK to integrate Sistava?

Official JavaScript and Python SDKs are on the way and will wrap the REST API with typed methods, making it straightforward to embed AI employees into your existing applications. Both are versioned and kept in sync with the API. Until they publish, the REST API itself is live and is what the SDKs call.

### Can I install the Sistava SDK today?

Not yet. The JavaScript and Python client libraries are on the roadmap and are not published to NPM or PyPI at the moment. The REST API they wrap is live now, so you can build the same integration today with plain HTTP calls and adopt the SDK later.

### How do I call my AI employees from code while the SDK is still coming?

Use the Sistava REST API. Create an API key under Settings, Technical, Channels, send a message to an employee with a Bearer token on the request, and read the reply back. The same key also works for the MCP endpoint, inbound webhooks, and the email webhook channel.

### Will I have to rewrite my integration once the SDKs are published?

No. The SDKs call the same REST endpoints with the same authentication, so adopting one replaces your HTTP plumbing and leaves the rest of your integration alone. Anything you build against the API now keeps working either way.

> The Python SDK let us wire Sista into our existing backend in a day. We create tasks programmatically and stream results back to our users as if it were our own AI layer.
>
> Chioma E., Backend Engineer · SaaS company

## Where Build with the Sistava SDK fits

Build with the Sistava SDK is part of How you plug them into your systems.

Build on your AI workforce with a full REST API, client SDKs, and webhooks in both directions. Expose any employee as an MCP server for Claude, Cursor, and Windsurf, or as an A2A agent for cross-platform agent collaboration. Everything the UI can do, the API can do.

- [How you plug them into your systems](/en/features/developer): Programmatic access to your workforce.

## Read the guide

- [Guide: Build with the Sistava SDK](/en/guide/channels/sdk)

## More in Developer API

- [REST API](/en/features/developer/channel_api): Every AI employee is reachable over a REST API: send a prompt to POST /api/v1/chat with the employee's ID and get their response back as JSON, running through the same execution pipeline as web chat with full access to that employee's skills, tools, and memory. Requests are synchronous, blocking for up to five minutes, and authenticate with a Bearer API key shared across every programmatic channel (REST API, MCP Server, A2A, Webhooks, Email). The channel is off by default and must be enabled from Settings > Technical > Channels before it accepts requests.
- [Webhook Inbound](/en/features/developer/channel_webhook): Send a POST request to a single endpoint whenever something happens in one of your other systems, and your AI employee picks it up and acts on it in the background. You get a 202 response immediately; there is no waiting for a reply. The same employee that answers you in chat can react to a failed deploy, a new order, or a support ticket the moment it fires.
- [Let Other AI Clients Use Your Employee](/en/features/developer/channel_mcp): Connect Claude Desktop, Claude Code, Cursor, Windsurf, ChatGPT, or any Model Context Protocol client directly to your AI employees. Generate an API key, add one config block, and your coding tools can send prompts to any employee by ID and get a real response back. No custom integration code required.
- [Let Other AI Agents Work with Your Employee](/en/features/developer/channel_a2a): Turn your workforce into an agent that other AI agents can call directly. Any client that speaks Google's A2A protocol can discover your employees, hand them a task, and get the result back, all without touching your web UI or writing REST API glue code.
- [Outbound Webhooks](/en/features/developer/outbound_webhooks): Connect a webhook URL, your own backend, a Zapier or Make scenario, a Slack incoming webhook, anything that accepts an HTTP POST, and your employee gets a tool it can call on its own during a task. It sends a JSON payload to that URL, so the rest of your stack finds out the moment the work is done instead of you checking manually. Because the call sends data outside Sistava, each send waits for your approval by default, the same as an outbound email.

## Explore

- [Every feature](/en/features)
- [Hire an AI employee](/en/market)
- [Pricing](/en/pricing)