Built by agents. Readable by humans.

Your coding agent builds your company’s software on SegmentStream: Claude Code, Codex, Cursor or any other. A workspace is one git repository with typed SDKs for the database, the apps, the data and the company agent, and one deploy runs it. The CLI and MCP give agents the same operations and permissions as people.

curl -fsSL https://segmentstream.com/install.sh | sh

macOS and Linux. Then give this prompt to your agent, or point it at /agents.md.

Give this to your agent

Paste one prompt. Your agent does the rest.

It installs the CLI, signs in, reads the platform’s rules and your workspace’s AGENTS.md, builds what you described and deploys it. Every workspace keeps those instructions current with segmentstream sync.

prompt for your coding agent

Build our company's software on SegmentStream.1. Install the CLI: curl -fsSL https://segmentstream.com/install.sh | sh2. Sign in with `segmentstream login` (or set SEGMENTSTREAM_API_KEY), then   pick our organization: `segmentstream org list`, then   `segmentstream org use <organization-id>`.3. Read https://segmentstream.com/agents.md, then the AGENTS.md   in the workspace repository, before you write any code.4. Build this: <describe what your team needs>.5. Deploy with `segmentstream deploy` and tell me what changed.

The building surface

Four SDKs, one per kind of folder, plus the CLI, and the API and MCP server every app serves. Everything a person can do here, an agent can do with the same calls.

Ontology SDK

@segmentstream-cloud/ontology

Entities, actions and roles; REST, OpenAPI and MCP from one model

App SDK

@segmentstream-cloud/app

Email-code sign-in, roles, records and warehouse data for Next.js

Pipeline SDK

segmentstream-pipeline (Python)

Connections, ingestion, models, checks and schedules in Python

Agent SDK

@segmentstream/agent

The company agent: ontology tools as the member, in your team’s channels

CLI

segmentstream

Workspaces, deploys, members, jobs and data from the terminal

MCP and API

/mcp and /api/ontology on every app

REST, OpenAPI and MCP on every app, per caller

Your software on top. Five folders underneath.

A workspace is one git repository with five folders. Each folder is a typed building block, and the platform runs each one: the app, the ontology behind it, the pipelines and warehouse, the connections and the company agent. A CRM, a finance tool or a dashboard is what your agent builds from them.

What you build

CRMleads, deals, clients Financecontracts, revenue Marketingaudiences and campaigns Internal toolsdashboards, approvals Company agentanswers as the member

app/

The app your team opens

Hosting and sign-in

ontology/

Postgres, the API and MCP tools

Ontology MCP and API Roles and permissions

pipeline/

Scheduled pipelines and a warehouse

Pipelines Warehouse AI evaluation

connections/

A vault for every credential

Connections and secrets

agent/

An agent runtime with channels

Company agent

SegmentStreamone workspace · EU or US

Use

Every workspace starts with all of it running: a deployed app with sign-in, a database under the ontology, a warehouse, a vault and the console.

Build

Your agent writes the business part in the five folders, from typed building blocks, and deploys. You review the change like any other code.

Have it built

Or our engineers build the first version with you during a pilot, in your own repository.

See the code →

Quickstart

From zero to a deployed workspace.

A new workspace comes with the starter: an app with sign-in, an ontology, a pipeline and the docs your agent reads. Clone its repository, deploy, and invite your team.

terminal

$ curl -fsSL https://segmentstream.com/install.sh | sh$ segmentstream login$ segmentstream org list$ segmentstream org use org_YOUR_ID     # an organization ID from the list$ segmentstream workspace create acme --region eu --subdomain acme$ segmentstream workspace WORKSPACE-ID clone acme && cd acme# your coding agent builds what your team needs$ git add -A && git commit -m "First version"$ segmentstream deploy$ segmentstream ontology member invite ada@example.com --role sales$ segmentstream ontology mcp            # connect your agent to the app

Workspace

Five folders are the whole workspace.

Each folder owns its dependencies and deploys together with the others. The instructions your agent needs ship in the repository.

workspace repository

acme/├─ AGENTS.md                 # what your agent reads first├─ .agents/skills/           # ontology, app-auth, app-data, connections, ...├─ app/                      # Next.js app: the screens your team opens├─ ontology/                 # entities, actions and roles│  └─ index.ts               # export default defineOntology({ ... })├─ pipeline/│  ├─ ingestion/             # one asset per file│  ├─ models/                # bronze, silver, gold│  └─ definitions.py         # jobs and schedules├─ connections/│  └─ connections.py         # the tools you keep├─ agent/                    # the company agent└─ docs/

What deploy gives you

Deploy the five folders and the platform runs them: the app with sign-in, Postgres under the ontology with its API and MCP tools, pipelines and a warehouse, the connection vault and the company agent. The console shows all of it.

The whole workspace is a git repository you own: the app, the company database, pipelines, connections and the agent. Clone it with git; every push to main deploys that exact commit.

segmentstream.com

The console's source code page at the root of our workspace repository: the agent, app, connections, events, ontology and pipeline folders, the README's project map, and the Clone panel with the CLI command and the git remote, noting that every push to main deploys that exact commit

Developer tools, agent-first

Everything a person can do here, an agent can do too.

CLI

Create and link workspaces, deploy, invite members, run and backfill jobs, inspect lineage and query the warehouse, with JSON output for agents and CI.

MCP and API

Every app serves its ontology at /mcp and /api/ontology. Agents sign in as the person and see only the tools that person's roles allow.

Agent guide

AGENTS.md and docs in every workspace repository: the layout, the platform rules and the commands your agent may run.

Agent skills

Skills for the work agents do most: the ontology, app sign-in, app data, connections, ingestion, models and the agent, versioned in the repository.

Docs that stay current

segmentstream sync brings the guide, docs and skills up to date with the installed CLI, without touching the files you edited.

Your repository

A private git repository per workspace. Clone it with plain git; a deploy runs one exact commit.

What the code looks like

This is the shape of the code in a workspace, from the published SDKs. Your agent writes it; you review it like any other change.

Ontology SDK →

ontology/lead.ts

.actions((self) => ({  win: action({    description: "Mark the lead as won.",    input: Schema.Struct({ lead: self.ref }),    // Requires lead:win: <entity>:<action name>.    handler: ({ input }) =>      Effect.gen(function* () {        const lead = yield* self.get(input.lead, { forUpdate: true });        if (lead.status === "won") {          return yield* new ActionRejected({ message: "The lead is already won." });        }        yield* self.update(lead, { status: "won" });      }),  }),}));

App SDK →

app/src/app/leads/page.tsx

const { items, nextCursor } = await segmentstream.ontology.lead.find({  where: { status: { in: ["new", "contacted"] } },  orderBy: [{ field: "createdAt", direction: "desc" }],  include: { owner: true },  limit: 20,});const { result, validation } = await segmentstream.ontology.lead.actions.changeStatus(  { lead: id, status: "contacted" },);

Pipeline SDK →

pipeline/models/revenue_summary.py

@s.model(    tier=s.Tier.Gold,    partitioning=s.Partitioning.Daily(column="order_date", start_date="2026-01-01"),    schema={"order_date": "date", "customer_count": "int64", "total_revenue": "float64"},)def revenue_summary(customer_revenue: ir.Table) -> ir.Table:    return customer_revenue.group_by("order_date").aggregate(        customer_count=customer_revenue.count(),        total_revenue=customer_revenue.revenue.sum(),    )

Agent SDK →

agent/

// agent/agent/extensions/segmentstream.tsimport { segmentstream } from "@segmentstream/agent/extension";import config from "../../segmentstream.json";export default segmentstream(config);// agent/segmentstream.json{  "channels": {    "telegram": { "connection": "telegram", "policy": "smart" }  }}

Your company's software, in a repository you own.

Every workspace owns a private git repository with the five folders and their full history. Clone it with plain git, keep a copy on GitHub, take it with you. segmentstream deploy, or a push to main, deploys that exact commit. If a deploy fails, production keeps serving the last good one.

One repository, one workspace

acmemain

app/The app

ontology/Entities, actions, roles

pipeline/Pipelines and checks

connections/Connections

agent/Company agent

AGENTS.mdWhat your agent reads first

Commit, then deploy

terminal

$ segmentstream workspace WORKSPACE-ID clone acme$ cd acme# Your agent edits the folders; you review the diff.$ git add -A && git commit -m "Add contract approvals"$ segmentstream deploy

The deploy checks every folder first: the ontology's changes are planned against the live database and tried on a copy, and unsafe changes are refused before anything applies.

Build your company’s own software. Let agents run it.

$ segmentstream workspace create acme --region eu --subdomain acme

▸ Created workspace acme · database, warehouse and a private git repository

$ segmentstream workspace WORKSPACE-ID clone acme && cd acme

▸ your coding agent builds what your team asked for and runs the checks

$ git add -A && git commit -m "First version"

$ segmentstream deploy

▸ app, company agent, API and MCP tools live for your invited members

Start a pilot

Our engineers build the first version on your data in two weeks, at a fixed price.

Or build it yourself with your coding agent:

curl -fsSL https://segmentstream.com/install.sh | sh