The Human-AI interface for coordinating business logic across systems, services, and time.
→ space or scroll scroll ↓
why now
The future is co-developed with AI.
When people and models build a system together, writing the code stops being the hard part. Knowing what it actually did becomes the hard part.
Debuggability
When a step goes wrong, written by you or by a model, see exactly what it received and returned. Read it; don't reproduce it.
Traceability
Work crosses services, protocols, and days. The record of what happened, and why, has to travel with it.
One interface
HTTP, email, cron, MCP, DNS: each has its own tools today. People and models need one shared surface across all of them.
the model
JSON in. JSON out. Merge.
Every operation, whether a rule, a script, a service, or a model, honors the same contract. That one simple model unifies large swaths of existing computation.
event in
{ "order": { "amount": 1200 } }classify
any language
returns
{ "tier": "vip" }carried to the next step
{ "order": { "amount": 1200 }, "tier": "vip" }No calls between operations. They contribute to a shared document instead.
Gated by a resonator. WHEN … EXEC …: most operations ignore most events.
Any wire, any runtime. If it reads and writes JSON, it can take part.
stacks
Steps run in order. Everything at a step runs in parallel.
Operations stack up into a flow. Everything at the same step fires together, their outputs merge, and the combined document moves on to the next step.
Like line numbers in BASIC, except each line can hold many operations.
stack · opportunities
● event in
visibility
Every step leaves a trace.
What arrived, which operations fired, what each one received and returned, and how long it took. No rerun. No print statements.
Parallelism you can see. Rows that share a step prefix ran side by side.
Plain JSON on disk. One folder per request: grep it, diff it, ship it. Also in the web UI and OpenTelemetry.
Secrets stay out. Any rule can redact or omit fields from its own trail.
protocols
Every protocol becomes JSON.
A protocol head speaks the native wire format, hands the stack a JSON event, and translates the answer back. Same rules, same traces, same tools, whatever the transport.
HTTP
with streaming
WebSocket
sessions
TCP
raw sockets
LMTP
email in
SMTP
email out
IMAP
mailboxes
Cron
and schedules
MCP
agent tools
AI gateway
model traffic
DNS
authoritative
CalDAV
calendars
CardDAV
contacts
WebDAV
files
IPP
printing
wire format → head → { json } → stack → { json } → head → wire format
any language
Any language. The merge doesn't care.
If it reads JSON and writes JSON, it's an operation. Outputs from every language and runtime land in the same document, and show up in the same trace.
Rule
EMIT .status = "ok"
A line of txcl, run by the chassis. No code to deploy.
Nano-op
op://classify
JS or TS compiled to Wasm. Sandboxed, kilobytes.
Service
https://…
Any HTTP handler: Python, Go, Rust, Java, PHP…
Workspace
workspace://ci/exec
A stateful runtime for builds, tests, and agents.
Model
ai://chat
A model is just another operation.
Start as a one-line rule. Grow into a service. The rules around it never change.
built for waiting
People and models are participants, not exceptions.
An operation can say "I'll get back to you." The flow suspends durably, for a slow model, a webhook, or a human approver, and resumes exactly once, days later if need be, surviving restarts.
ai://chat
An AI drafts a reply
+ .draft
mode = "async" · waits 2 days
A person approves it
+ .approved
https://…
A service sends it
+ .sent_at
all reading and writing one shared document
Bundle operations into stacks, and stacks into departments (support, invoicing, onboarding) that run a real business function on your own data.
try it
See it run in two minutes.
txco demo boots a self-contained chassis, one binary, and opens
a guided tour in your browser: web, mail, human-in-the-loop, and MCP.
Install on macOS
Free and open source under the MPL-2.0. Run it on your laptop, your own servers, or our cloud.