Powering intelligent agents that do real work.
The orchestration engine for AI agents. From a weekend chatbot to an autonomous enterprise workforce - connect any LLM, give it tools, let it run.
// Stream a conversation with your agent
import { openStreamingChat } from '@orchestration-ai/sdk/streaming';
const chat = openStreamingChat(agentId, 0, {
onChunk: (chunk) => process.stdout.write(chunk),
onResponse: (full) => console.log('\nā Done'),
});
chat.send('Summarise this week\'s sales report.');Platform
One engine, every capability your agents need.
Layered Architecture
Stack context, safety rules, and tools into composable layers within each agent.
Any LLM Provider
Swap between models per layer without changing any logic. Hot-swap in production.
Tool Use via Services
Agents call real APIs, query databases, send emails, and act autonomously.
Event-Driven Triggers
Agents respond to webhooks, emails, and schedules - not just user prompts.
Multi-Agent Teams
Agents delegate to each other, collaborate on tasks, and escalate when needed.
Real-time Streaming
WebSocket streaming for responsive chat UIs and live agent dashboards.
Use Cases
Built for everyone with a problem to solve.
Indie Hackers & Side Projects
Ship an AI-powered feature in hours. Add a support bot, automate workflows, or build an AI co-pilot for your SaaS.
Startups & Product Teams
Embed intelligent agents into your product. Customer onboarding, lead qualification, automated ops - all handled.
Business Operations
Deploy an AI workforce. Receptionists, sales teams, schedulers, and support agents running 24/7.
For Developers
Build with the SDK. Ship faster.
Build applications that give agents tools
Expose services with typed tool handlers. The engine discovers them at inference time and passes them to the LLM.
import { createApp, defineService } from '@orchestration-ai/sdk/app-builder';
createApp()
.service(defineService({
unique_name: "weather",
service_name: "Weather Service",
service_description: "Get weather for any city.",
description: [{
path: "get_weather",
method: "GET",
description: "Returns current weather.",
parameters: {
city: { type: "string", description: "City name" }
},
}],
tools: {
get_weather: async (body) => {
return { temp: "22Ā°C", city: body.city };
},
},
}))
.listen(3001);Stream agent responses in the browser
Authenticate with a passkey from the URL. No access key exposed client-side. Real-time token streaming out of the box.
import { openStreamingChat } from '@orchestration-ai/sdk/streaming';
const passkey = new URLSearchParams(location.search).get('passkey');
const chat = openStreamingChat(agentId, 0, {
onChunk: (chunk) => {
document.getElementById('output').textContent += chunk;
},
onError: (err) => console.error(err),
}, { accessKey: passkey });Send messages between agents programmatically
Use the engine client to delegate work to other agents. Build pipelines, routing agents, and collaborative teams.
import { sendMessages } from '@orchestration-ai/sdk/services';
// Inside a tool handler - delegate to another agent
const response = await sendMessages(
billingAgentId,
0, // layer index
[{ message: `Customer ${email} has a billing question: ${body.question}` }],
context.identity.layerId,
engineClient
);Agent Scripts
Full programmatic control over every inference.
Write JavaScript that runs inside the engine on every call. Intercept messages, rewrite tool arguments, implement tools entirely in code, and clean up responses - without deploying anything.
onPreLayerCall
Rewrite the user's message before it reaches the LLM. Inject live context, enforce rules, or block restricted content.
onPostLayerCall
Transform the model's response before it's returned. Fix formatting, strip unwanted characters, or normalise output.
onPreTool
Intercept every tool call. Audit arguments, inject required fields, or signal that an operation is not permitted.
getTools + onTool
Declare tools and implement them entirely in your script. No service, no deployment - pure JavaScript.
npm Packages
Import any pure-JS npm package. date-fns, zod, lodash - bundled automatically when you save.
import { format } from "date-fns";
// Enrich every message with live context before the LLM sees it
export async function onPreLayerCall(message, context) {
const { plan, name } = await fetch("/api/me").then(r => r.json());
return `[User: ${name}, Plan: ${plan}, Date: ${format(new Date(), "yyyy-MM-dd")}]\n\n${message}`;
}
// Declare and implement a tool entirely in script
export function getTools() {
return [{ name: "current_time", description: "Returns UTC time", parameters: {} }];
}
export function onTool(payload) {
if (payload.tool === "current_time")
return JSON.stringify({ utc: new Date().toISOString() });
}
// Audit and guard every tool call
export function onPreTool(payload) {
if (payload.tool === "delete-record")
return { error: "Delete operations are not permitted." };
return payload;
}Enterprise Ready
Manage your entire AI workforce as infrastructure.
The official Orchestration AI Terraform provider lets you define agents, orchestrations, access control, and storage in code - version-controlled, peer-reviewed, and deployed through your existing CI/CD pipeline.
Infrastructure as Code
Every agent, layer, setting, and permission declared in HCL. Reviewed in pull requests, deployed automatically.
Repeatable Environments
Spin up identical staging and production environments from the same Terraform config. No manual console clicks.
Access Control
Grant and revoke workspace access for team members and service accounts through code, with a full audit trail.
How It Works
Three steps to autonomous agents.
Define Your Agent
Set a model, write context, attach services. Your agent is ready.
Connect Triggers
Wire up emails, webhooks, or schedules that activate your agent.
Let It Run
Your agent reasons, calls tools, and delivers. Monitor everything live.
Pricing
Simple pricing.
Pay only when agents work.
No subscriptions. No per-seat pricing. One day pass consumed per active day for your entire account. Bring your own LLM keys.
- Per active day, whole account
- 3 free passes on sign up
- Unlimited agents & orchestrations
- All LLM providers supported
- Bring your own API keys
Ready to orchestrate?
Start with one agent. Scale to an entire autonomous operation.