Socheli turns a single idea — a seed line like "why we procrastinate" — into a finished, ready-to-post social video. Give it a topic and it runs the whole pipeline: research, concept board, hook, script, storyboard, fact-check, a QA council, scene-synced voiceover with karaoke captions, ducked music, graded b-roll, an outro, per-platform packaging, and publishing to YouTube / Instagram / TikTok.

It is built API-first. Everything Socheli can do is reachable over one REST API and one Bearer API key — whether you drive it from code, the terminal, or an AI agent.

   one idea  ──▶  research → script → storyboard → QA → voice + captions
                  → music → b-roll → package → publish  ──▶  premium vertical post

• End to end. From seed to a published, platform-packaged video — no manual editing required.
• Vertical and long-form. Premium 9:16 shorts plus 16:9 long-form output.
• Distributed by design. A control plane dispatches render jobs over MQTT to a fleet of render devices that generate locally and serve finished video from a public media host.
• One key, every surface. The same SOCHELI_API_KEY authenticates the API, SDK, CLI, and MCP server.

Socheli ships as a small, cohesive set of packages — all over the same /v1 REST contract and one API key.

The SDK is the foundation: both the CLI and the MCP server are built on top of it, so all four surfaces share one stable contract and one API key.

Install the SDK, point it at your key, and ship a video:

import { createSocheli } from "@socheli/sdk";

// apiKey falls back to process.env.SOCHELI_API_KEY,
// baseUrl falls back to SOCHELI_API_URL, then https://api.socheli.com
const socheli = createSocheli({ apiKey: process.env.SOCHELI_API_KEY });

// 1. one idea → a render job, routed to a device in the fleet
const { dispatched, job } = await socheli.generate({
  seed: "the science of habit",
  channel: "concept_lab",
  mood: "cinematic",
  voice: true,
  type: "auto", // "auto" also publishes after render; "new" builds only
});

// 2. watch it move through the fleet
const rows = await socheli.jobs();
const mine = rows.find((r) => r.id === job.id);
console.log(mine?.status, mine?.progress.at(-1)?.line);

// 3. grab the finished item and publish it publicly
const [latest] = await socheli.items.list({ limit: 1, channel: "concept_lab" });
await socheli.items.publish(latest.id, { public: true });

Prefer the terminal? The same flow, end to end:

socheli login --key sk_live_xxx --url https://api.socheli.com
socheli generate "why we procrastinate" --channel concept_lab --auto --voice --mood cinematic
socheli jobs            # watch it render on a device in the fleet
socheli publish <id> --public

Or wire it into an agent with MCP:

{
  "mcpServers": {
    "socheli": {
      "command": "npx",
      "args": ["@socheli/mcp"],
      "env": {
        "SOCHELI_API_URL": "https://api.socheli.com",
        "SOCHELI_API_KEY": "sk_live_xxx"
      }
    }
  }
}

Socheli is a strict layer cake with one defining split: tiny control messages flow over a message bus; heavy artifacts never do.

  ┌─────────────────────────────────────────────────────────────┐
  │  Clients (one Bearer API key)                                │
  │   SDK  •  CLI (socheli)  •  MCP server  •  Dashboard         │
  └───────────────────────────────┬─────────────────────────────┘
                                   │  HTTPS  /v1
                                   ▼
  ┌─────────────────────────────────────────────────────────────┐
  │  @socheli/api  —  Hono control plane (api.socheli.com)       │
  │   • Bearer-key auth on /v1/* (health is open)                │
  │   • Reads from flat data/*.json (no database)                │
  │   • Capability-aware scheduler picks the best-fit device     │
  └───────────────┬──────────────────────────────┬──────────────┘
       MQTT job    │ (control plane: dispatch,    │  spawns engine
       dispatch    │  presence, render progress)  │  publish
                   ▼                              ▼
  ┌─────────────────────────────┐    ┌──────────────────────────┐
  │  Render fleet (e.g. a capable Mac)│    │  Publishers              │
  │   • runs the full pipeline   │    │   YouTube / IG / TikTok  │
  │   • renders locally          │    │   from the public URL    │
  └──────────────┬───────────────┘    └──────────────────────────┘
                 │  rsync data/ (mp4) up  (data plane — never over MQTT)
                 ▼
  ┌─────────────────────────────────────────────────────────────┐
  │  Public media host  →  media.socheli.com/<id>.mp4           │
  └─────────────────────────────────────────────────────────────┘

How a video gets made:

1. A client calls POST /v1/generate with a seed.
2. The API derives the job's capability requirements, picks the best-fit online render device, and publishes the job to that device's MQTT topic — returning immediately.
3. The device runs the full engine pipeline locally, streaming progress back over MQTT (a server-side bridge records it into the file store).
4. On completion the device rsyncs the rendered .mp4 up to the server, where it goes live at media.socheli.com/<id>.mp4.
5. Publishing runs server-side from that public URL — to YouTube, Instagram, and TikTok.

A few principles that fall out of this design:

• No database. All state lives in flat data/*.json files (one JSON per content item, plus jobs, fleet, and schedule).
• The control plane never renders. Generation and rendering happen only on fleet devices; the server dispatches and serves.
• Video never crosses the message bus. Only small control messages travel over MQTT; mp4s move over rsync/HTTPS.
• Liveness is inferred. A device that stops heart-beating drops out of routing automatically.

• Website — socheli.com
• API — https://api.socheli.com · Socheli/api
• SDK — Socheli/sdk
• CLI — Socheli/cli
• MCP — Socheli/mcp
• Contact — contact@socheli.com