An automation substrate you can drive and observe.
Today: visual flows, scoped API-key access, webhooks, and reliable eventing: durable, signed, replayable. On the path a fuller programmatic platform and integration ecosystem: the substrate other systems build on. We label trajectory as trajectory, and every code sample here is illustrative of shape, not a published contract.
Access today
Per-tenant developer access, in-app.
Each workspace has a developer surface scoped to your tenant: scoped API keys, request logs, usage, and webhook tooling, all self-service inside the app.
Available today
Scoped API keys
Issue and revoke keys scoped to your tenant. Access is governed by the same row-level isolation the rest of the platform runs on.
Request logs
Inspect requests made with your keys (what was called, when, and how it resolved) for debugging and review.
Usage
See activity against your developer access in-app, so you can reason about volume without exporting anything.
Webhook tooling
Register endpoints, observe deliveries, and exercise the reliable-eventing path from inside the workspace.
There is no public, versioned API catalogue to self-serve yet, and onboarding is sales-assisted. So every code block on this page is illustrative of shape: conceptual fields and structure to show how the substrate is organized. None of it is a published endpoint, version, SDK, or auth scheme. Treat it as a sketch of the model, not a contract.
Events & durability
Reliable eventing, and execution that survives a restart.
State changes are committed and emitted through one path: a transactional outbox, an event bus, then your webhook, CRM, and analytics consumers. Deliveries are signed, carry idempotency keys, and a failed delivery lands on a replayable dead-letter path rather than being lost.
Available today
- Transactional outbox
- Events are written in the same transaction as the state they describe: no committed change without its event, no event without its change.
- Signed deliveries
- Each delivery carries a signature your consumer can verify before trusting the payload.
- Idempotency keys
- Every event carries a stable identifier, so a retried delivery is safe to receive twice and apply once.
- Replayable dead-letter
- Deliveries that exhaust retries move to a dead-letter path you can inspect and replay: failure is recoverable, not silent.
- Durable execution
- Runs are backed by a durable workflow engine: work interrupted by a restart resumes on another worker, never losing its place.
event: "outcome.recorded"
id: "evt_8f3c1a"
type: "appointment.booked"
automation: "aut_2049"
contact_ref: "c_0418"
outcome: "booked"
occurred_at: "2026-06-23T14:32:07Z"
signature: "sha256=…"Illustrative only: field names and shape are conceptual, not a contract.
The expression engine
A small but real programmability layer, for non-engineers.
Templated {{ expressions }} are evaluated live at run time against per-contact data and run state. Outbound HTTP/REST nodes call out to your systems through saved, authenticated connections. It is programmability that a flow author can use without writing code.
Available today
Live evaluation
Expressions resolve at run time: greet a contact by name, branch on a returned value, or shape a request body from columns you imported.
Saved authenticated connections
Outbound HTTP/REST nodes reuse stored, encrypted credentials, so a flow can call your systems mid-run without exposing secrets in the flow.
Authored, not coded
The layer is expressive enough to be useful and constrained enough to stay inside flows you can see, version, and audit.
greeting: "Hello {{ contact.first_name }},"
branch_if: "{{ contact.balance > 0 }}"
request_body: "{ ref: {{ contact.account_ref }} }"Illustrative only: shows the idea, not a published expression grammar.
Bring your own stack
The platform orchestrates. It does not resell a carrier.
Connect your own providers across every integration point. Credentials are encrypted and test-connected before a run depends on them. Throughline CX coordinates the work; the underlying services stay yours.
Available today
- Telephony
- Outbound voice runs over your own trunk, on a supported PBX (3CX today). The platform places and governs the call; you own the carrier relationship.
- AI / voice
- Connect your speech provider for multi-voice, multi-language text-to-speech inside flows.
- Connect your email provider to send email as a flow step.
- CRM
- Connect your CRM as a consumer of the event path, kept in sync as outcomes are recorded.
- Webhooks & APIs
- Register endpoints and saved authenticated connections so flows can call your systems and receive signed deliveries.
- Credential handling
- Per-tenant encrypted provider credentials, test-connected on save, verified before any run relies on them.
Where the platform is headed
The substrate other systems build on.
The direction is a fuller programmatic platform and an integration ecosystem: a published, versioned surface and the tooling around it, so the same durable, isolated, event-driven core becomes something teams build on, not just in. It is credible because the backbone is already shaped for it: an event path that fans results out, durable execution underneath, and tenant isolation enforced at the database.
On the path
On the path
Programmatic platform
Today: in-app scoped keys, request logs, and webhook tooling. Headed toward a published, versioned programmatic surface you can build against directly.
On the path
Integration ecosystem
Today: bring-your-own providers, encrypted and test-connected. Headed toward a broader catalogue of integrations and the tooling to extend it.
On the path
Build-on substrate
Today: a durable, isolated, event-driven core you operate. Headed toward a substrate other systems are built on, with the contracts to depend on it.
Get started
Drive and observe the substrate against your own stack.
Developer access is provisioned with onboarding today: sales-assisted, bring-your-own-provider. Tell us what you run, and we'll set up scoped keys, webhooks, and the event path against it.
Reserved
A published API reference, versioned schema catalogue, and SDK and integration listings will be linked here once the programmatic surface is public. Until then we list no endpoints, versions, or SDKs we cannot yet stand behind.