MIT · no CLA · github.com/SmooAI

Our agents run on this code.
So can yours.

The open-source heart: the same agent engine Smoo AI's own AI teammates run on, MIT-licensed and yours to run. Not a sample repo cut for a launch — the four layers below are load-bearing for a business that has to stay up.

Being straight about the scope: this is the engine, the service around it, the widget on the end of it, and the CLI that ships it — plus the libraries underneath. The sixteen product areas built on top are not open source, and we are not going to pretend otherwise.

Clone itRead the stack

Running right now, on this page

Don't take the README's word for it. Type into it.

These are three instances of @smooai/chat-widget — the package you can install in the next minute — streaming against a live agent over the open protocol. Same code, three accent colors.

Default · dark
Coral · light
Violet · dark
pnpm add @smooai/chat-widget

Four layers, cold to hot

Start as deep as you want. Stop wherever it stops paying.

Link the engine into your own process, or run the whole service, or just drop the widget on a page. Each layer stands on its own, and each one is the same layer we run.

The colour is the distance to a human. Teal is a library nobody talks to; coral is the box your customer types into.

Layer 1 · the engine

smooth-operator-core

Repository

Link the agent loop into your own process, in the language you already ship.

Every AI teammate on the Smoo AI platform runs this loop. It is the deepest layer we have, and it is a library — you link it, you don't call it.

RustTypeScriptPythonGo.NET

Five native ports, not five bindings — each language has its own implementation, kept honest by a shared evaluation corpus. There is no FFI layer to install.

The smallest thing that works

verified against a893804

use smooth_operator_core::{Agent, AgentConfig, LlmConfig, ToolRegistry};

// The engine is a library: a config, a tool registry, and a loop you await.
let llm = LlmConfig::openrouter(std::env::var("OPENROUTER_API_KEY")?)
    .with_model("openai/gpt-4o");

let config = AgentConfig::new("assistant", "You are a helpful assistant.", llm);
let agent = Agent::new(config, ToolRegistry::new());

let conversation = agent.run("What's the weather in Tokyo?").await?;
println!("{}", conversation.last_assistant_content().unwrap_or_default());

Install

cargo add smooai-smooth-operator-core

Layer 2 · the service

smooth-operator

Repository

Run the engine as a service, and talk to it over one schema-driven WebSocket protocol.

This is what answers at wss://ai.smoo.ai/ws — the same binary you can deploy to your own Kubernetes cluster, to AWS serverless, or to a laptop.

TypeScriptPythonGo.NET

Four native clients, generated from one JSON-Schema protocol spec. The TypeScript client is furthest ahead — rich interactions, conversation resume, and capability negotiation are TS-only today, and the other three drop those frames silently rather than crashing.

The smallest thing that works

verified against 67f77c05

import { SmoothAgentClient } from '@smooai/smooth-operator';

const client = new SmoothAgentClient({ url: 'wss://your-host/ws' });
await client.connect();

const session = await client.createConversationSession({ agentId });

// sendMessage returns a turn you can BOTH iterate and await.
const turn = client.sendMessage({ sessionId: session.sessionId, message: 'Hi!', stream: true });

for await (const event of turn) {
    if (event.type === 'stream_token') process.stdout.write(event.token ?? '');
}

Install

pnpm add @smooai/smooth-operator

Layer 3 · the CLI

th

Repository

Drive the whole platform from one static binary — and boot an assistant on your own machine.

Every config value, secret, and feature flag in this monorepo is set through this binary. `th up` boots Big Smooth, an always-on assistant that runs locally on the models you choose.

Rust

One binary answers to two names. The installer symlinks `smoo` next to `th`, and the binary dispatches on argv[0] — so `smoo config …` and `th smoo config …` are the same command.

The smallest thing that works

verified against 7f392875

# Install (macOS / Linux)
brew install SmooAI/tools/th

# …or the one-line installer — a single static binary, no Docker, no Node
curl -fsSL https://raw.githubusercontent.com/SmooAI/smooth/main/install.sh | sh

# The platform side answers to `smoo` (same binary, symlinked by the installer)
smoo auth login
smoo config set DATABASE_URL "postgres://..." --environment production
smoo config list

# Big Smooth — an always-on assistant on your machine, on your models
th up
th code

Install

brew install SmooAI/tools/th

Layer 4 · the surface

chat-widget

Repository

Put the agent on your own site with one script tag, wearing your brand.

The demo further up this page is this component, streaming live against a real agent. Same code, same protocol, three different accent colors.

TypeScriptWeb Component

It is a real custom element, not an iframe — so it inherits your page, and a single accent color themes the whole thing.

The smallest thing that works

verified against df4ba6c

<!-- one script tag, then the element -->
<script src="https://unpkg.com/@smooai/chat-widget/dist/chat-widget.global.js"></script>

<smooth-agent-chat
    endpoint="wss://your-host/ws"
    agent-id="…"
    agent-name="Support">
</smooth-agent-chat>

Install

pnpm add @smooai/chat-widget

The question you actually have

“So where's the catch?”

Fair. Open-core usually means the useful half is behind a wall. Here is the whole arrangement, in the order you'd ask.

What licence, and do I have to sign anything?

MIT, on every repo linked from this page. No CLA, no contributor agreement, no relicensing clause waiting in a future version. Fork it and never speak to us again — that is a supported outcome.

What is actually closed?

The product built on top: CRM, support, campaigns, field service, booking, e-sign, analytics, observability dashboards, and the rest of the sixteen areas. That is the business. The engine, the service, the widget, the CLI, and the libraries are not.

Can I run it without you in the loop at all?

Yes, and that is the shape it was built in. Deploy the service to Kubernetes, to AWS serverless, or to a laptop, and point it at any OpenAI-compatible endpoint — your own, a provider, or a local model. No key of ours is required for the engine to run.

Will the quickstart on this page actually compile?

Every sample above was checked identifier-by-identifier against repo source at the commit printed next to it, and anything that could not be verified was deleted rather than guessed. If one drifts, that is a bug — open an issue and we will treat it like one.

Is it maintained, or was it a launch-week repo?

It is what we are on call for. When the engine breaks, our customers notice before you do — which is the only maintenance promise worth anything.

Underneath all four layers

The boring parts are open too.

Config, logs, HTTP, files, schemas, deploys. Nothing here is a product — they are the pieces we got tired of rewriting. Quickstarts live in each repo, where they get tested.

@smooai/config

Every secret, URL, and feature flag across Smoo AI resolves through this — three tiers (public, secret, feature flags), schema-validated, with runtime clients in all four languages reading the same JSON Schema.

TypeScriptPythonRustGo
Docs

@smooai/logger

The log line every Smoo AI service writes: structured, correlation-ID stitched across services, and enriched with AWS or browser context automatically.

TypeScriptPythonRustGo
Docs

@smooai/observability

Error tracking for browser, Node, React, and Next.js — the open-core companion to our hosted error and metrics dashboards. When something throws in Smoo AI, this catches it.

TypeScriptReactNext.js

@smooai/testing

The CLI and SDK behind our Testing API. Point it at a CTRF report in CI and runs, cases, environments, and deployments land in the dashboards. Every green check in our monorepo goes through it.

TypeScript

@smooai/postgres-kit

Declarative Postgres schemas in Rust. One table spec is the source of truth: it emits DDL, diffs into forward migrations, catches drift in CI, and generates serde/sqlx row types.

Rust

@smooai/clickhouse-kit

The same idea for ClickHouse, built for schemas a tenant defines: an allowlisted type system, generated DDL, forward-only migrations, and drift detection. It backs our analytics platform.

Rust

@smooai/fetch

An HTTP client that survives a bad afternoon — retries with jittered backoff, timeouts, rate limiting, circuit breaking, and schema-validated responses.

TypeScriptPythonRustGo
Docs

@smooai/file

One stream-first interface over local files, URLs, S3 objects, and FormData — so a URL can go straight to S3 without ever landing in memory. Type detection across 100+ formats.

TypeScriptPythonRustGo
Docs

@smooai/deploy

Our shared deploy primitives — reusable SST v4 constructs (WebSocket API, Rust Lambda, DynamoDB, S3 Vectors) plus a Helm/ArgoCD chart. smooth-operator deploys through it.

TypeScript

@smooai/ui

The Aurora design system as shared tokens, CSS, and the Smoo monogram — so a surface rendered from a Rust binary and one rendered from Next.js agree on the same spectrum.

CSSTypeScript

@smooai/client-shared

OAuth, M2M, and password auth plus cross-runtime storage, written once in Rust. It is the login flow inside th, so every command borrows the same one.

Rust

@smooai/utils

The glue in our TypeScript services: Lambda error handling, a production-ready Hono app factory, smart retries, environment detection, and human-readable schema errors.

TypeScript

@smooai/config-typescript

Our shared tsconfig presets — base, Node, React, Next.js, library — so a new package inherits the same strict posture as every other one.

TypeScript

smooblue

A native, multi-column Bluesky deck for macOS — Rust + Dioxus, OAuth + DPoP.

Rust · Dioxus

homebrew-tools

Our Homebrew tap — where `brew install SmooAI/tools/th` comes from.

Ruby

sst

Our fork of SST v4, the framework we deploy on. Tracks upstream with the tweaks our infra needs.

TypeScript · fork

Two ways this ends well

Run it yourself. Or hand us the pager.

Cloning it and never talking to us is a fine outcome — that is what MIT is for. But if you would rather have the agents without the on-call rotation, that is the product, and we would like to hear what you are building.

Clone itLet us run it

Tell us what you're building

Running the stack yourself and hit a wall, or want it hosted with the product on top? Either way, start here.

By submitting this form, you agree to our Privacy Policy and Terms of Service.