Aether SDK

The Problem

Every integration project rebuilds the same plumbing: entity models, sync loops, webhook handling, secret management, tenant separation — rewritten per tool, per client, per project. The plumbing is never the product, but it is always the risk.

The use case that led to this build was a credit union whose HR systems of record — UKG and Xperience — had to keep three learning platforms (Docebo, LinkedIn Learning, Axonify) and an analytics layer (Tableau) in step. New hires were provisioned by hand, data was normalized by hand, and terminations reached some systems but not others. Aether SDK is the substrate that makes the next integration a connector, not an application: one canonical entity model, one adapter interface, tenancy enforced from core to storage.

Two Flows, One Identity Chain

The demo is honest about how the engine actually works: a sync carries one typed canonical entity to many targets, and each direction is its own flow.

• People out. A new hire lands in UKG and becomes a canonical corporate.employee record. One governed sync fans it out to Docebo, LinkedIn Learning and Axonify. Axonify rate-limits; the other two succeed and stay succeeded. Retry only the failed target — the same request, run and idempotency key, and the missing identity link is created without duplicating the good ones. A seeded termination run shows the same path deactivating a leaver everywhere.
• Learning in. Course completions flow back from the learning platforms as canonical learning.course records and out to Tableau. The completion's audit event fans out to every webhook subscriber; the HR-receipts delivery backs off, exhausts, and lands in a dead-letter queue — inspectable, then replayed with the same event, subscription and payload identity. Audit, metering, overview and health all move as consequences.

The engine runs the stages itself; the operator's only verbs are the ones a real operator has — validate, start, retry, replay, invite, subscribe. Nothing on a product screen asks you to simulate anything.

Governed by Design

• Tenancy as an invariant, not a convention — every entity, run, event, delivery and secret reference carries a tenant id enforced from core to backend; cross-tenant and missing resources return the same stable not-found.
• Credential references, never values — connectors store a reference into a tenant-scoped secrets backend; webhook signing secrets are write-only; rotation replaces the reference.
• Per-target outcomes — a multi-target write records success, failure and remote identity per target; partial success is a first-class result, not an exception.
• RBAC read-scope, actually enforced — Platform Admin, Integration Operator, Auditor and a Developer scoped to two connectors: switching persona changes what you can reach and mutate, not just what you see, and denied deep links say which permission is missing.
• Everything derives from the same graph — the overview's numbers, the hourly throughput chart and its drill-down, the phone companion's pulse and the settings page's usage meter are projections of one fixture graph; a hand-typed count fails the build.

Agents Act Through the Same Path

An integration substrate is the layer an AI agent needs most and trusts least: it is where an agent's decisions turn into writes against real systems. Aether treats the agent as a governed actor rather than a privileged script. There is no LLM inside the engine; the engine is what the agent acts through.

• Agent as a first-class actor — the runtime's actor model has an agent type beside user, service and system. An agent's credential carries its roles, so the same RBAC that scopes a human operator scopes the agent; nothing is bypassed because a program is calling.
• Run provenance on every event — an agent session names its run, and that run id is stamped on every audit event it produces: previews, syncs, per-target outcomes. "What did the agent touch?" is one filter, not a forensic exercise.
• Preview before commit — an MCP tool resolves and diffs every target of a sync without performing a write, returning what would happen: create or update, field by field, with writes_performed: false in the response and a sync.previewed event in the trail. An agent can show a human the consequence before it commits; a human can say no.
• Retry-safe by construction — the agent supplies the idempotency key, so its retries replay the same operation instead of writing twice. The journal that protects a human's retry protects the agent's.
• MCP-native, one runtime — MCP is a transport over the same AetherRuntime as HTTP, the CLI and the operator surfaces: same services, same audit, same tenancy, same metering. The cockpit's provisioning agent run — previewed, then written, every event under its run id — is exactly what the engine records.

What is deliberately not claimed: a human approval gate between preview and commit is designed and on the backlog, not shipped. The preview is the substrate for it; the approval is the operator's, out of band, until it is a feature.

Architecture

Built Like a Product

The cockpit ships behind a real gate suite: unit and component contracts (every displayed figure must derive from the records; no raw timestamp or absolute date may render; no engine verb may appear on a product screen), a fixture-coherence gate that fails the build if the generated month of history stops telling one story, end-to-end journeys for both signature workflows on desktop and phone, and white-glove, mobile and viewport sweeps across twenty screen sizes. The phone is a deliberately scoped companion — pulse, runs, recovery queue — with authoring left to the desk and labelled as such.