Enterprise Context Fabric — Design Partner Program

Products

Five products. One governed fabric.

Each product runs independently. Download, boot up with Docker, and tell us what you find. The three with runnable scenarios are below — SDK and Appliance ship in the next cohort.

🏗️

Live

ContextECF Fabric

Enterprise Context & Relationship Ledger

Ingests signals from email, calendar, Slack, and CRM into a tamper-evident ledger. Surfaces provenance-stamped context packs wherever your team works — CRM sidebar, calendar, meeting prep.

▶ See scenario ⬇ Download ZIP

⚡

Live

LLM Gateway

5-Layer Inference Control Plane

RunwayClass routing classifies tasks, selects optimal model tiers, estimates costs, and returns decision rationale before making any inference call. Every call logged, every decision attributable.

▶ See scenario ⬇ Download ZIP

🧠

Beta

ACM — Hyper-State Runtime

Agent Continuity Mode

Trajectory-aware runtime that gives AI agents persistent, governed activation state. Every cycle returns a signed receipt — tamper-evident chain, no external dependencies, local or ECL-connected.

▶ See scenario ⬇ Download ZIP

📦

SDK

FabricLedger SDK

Agent Runtime Enforcement SDK

TypeScript SDK for agents and AI runtimes to receive governed activation. Owns ActivationReceipt, RuntimeEnforcementManifest, DeniedCapabilityReceipt contract types. Free developer tier.

View docs Request early access

🛡️

Security

Context Fabric Appliance

Edge Runtime Enforcement

Standalone edge appliance for destination guard decisions, runtime manifest enforcement, masking, denied-capability receipts, and SIEM export. Evaluates every governed action before it executes.

Integration docs Request early access

Scenarios

Three problems we kept hearing. Run the proof yourself.

Below are the exact scenarios we built and ran — the problem, the signal we sent, and what the system produced. Copy the commands. Boot it up. Tell us what you found.

Story 1 of 3 · 🏗️ ContextECF Fabric — Enterprise Context Ledger

Your revenue team walks into renewal calls blind.

CRM has the records. It doesn't have the relationship. When an AE walks into a renewal call, they're piecing context together from six tabs — email threads, Slack history, call notes, deal room — while the customer expects them to already know everything. The signals exist. They're just not connected.

Here's what we ran

We created a MEETING_SCHEDULED signal for an Acme Corp Q3 renewal — two participants, champion engaged, renewal risk flagged, upsell vector present. Sent to the ECL writer with full provenance: source system, event ID, timestamp.

renewal_risk captured upsell_opportunity captured champion_engaged captured

What it showed

Before the call, you know who the champion is, what the risk signals are, and what has changed since the last touchpoint — provenance-stamped, deterministic, tamper-evident. Not a guess assembled by an AI. A ledger entry with a source, a timestamp, and a receipt.

🏗️

Fabric — Context Ingestion

API gateway + ECL writer + migrations, self-contained

# Download the ZIP, then:
$ cd contextecf-fabric-trial/
$ cp .env.example .env
$ docker compose up
#  Migrations run first. Ready when you see "Listening on :8080".

# Verify the platform is healthy:
$ curl http://localhost:8080/health/ready | jq

# Ingest the renewal meeting signal:
$ curl -X POST http://localhost:8080/v1/context/events \
    -H "Authorization: Bearer trial-dev-token" \
    -H "Content-Type: application/json" \
    -d @mock-nce.json | jq

What to look for in the response

01The signals array — do renewal_risk, champion_engaged, and upsell_opportunity map to signal types your team actually tracks?
02The provenance block — sourceSystem, sourceEventId, capturedAt. Can you replace google_calendar with your actual source system and still get a clean receipt?
03The response time — is sub-200ms fast enough for the real-time surfaces your team uses: CRM sidebar, Slack bot, calendar integration?

Tell us what you found. Was the context pack useful? What relationship signals were missing? Did the provenance model fit how your connectors actually work?

Share your findings →

Story 2 of 3 · ⚡ LLM Gateway — 5-Layer Inference Control Plane

Your AI infrastructure is twelve teams picking twelve models with no audit trail.

Every team ships their own LLM integration. Anthropic for some, OpenAI for others, Google for a third. Costs are invisible until the invoice. There's no policy layer. When something goes wrong, no one knows which model did it, under what instructions, with what data. You can't govern what you can't see.

Here's what we ran

We sent a preflight governance request — no API key required. The gateway classified the task domain (code_generation), selected the optimal model tier using RunwayClass routing, estimated cost at scale, and returned the full decision rationale — before making a single inference call.

RunwayClass routing decision returned Model selection + fallback chain shown Cost estimate at 500 calls/day

What it showed

Before spending a single token, you can see exactly how the governance layer classifies your workload, which model it routes to, and what the fallback chain looks like. Add one API key and the same routing logic governs live inference — every call logged, every cost tracked.

⚡

LLM Gateway — Governance Demo

Preflight works without any API key

# Copy the config template (add a key when ready):
$ cp gateway.yaml.example gateway.yaml
$ docker compose up
#  Ready in ~20 seconds. Redis included.

# See governance decisions — no API key needed:
$ curl -X POST http://localhost:8090/v1/preflight \
    -H "Content-Type: application/json" \
    -d '{"estimated_calls":500,
         "task_domain":"code_generation",
         "context_tokens_avg":4000}' | jq

# Add a key — send a governed inference request:
$ curl -X POST http://localhost:8090/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{"model":"claude-sonnet-4",
         "messages":[{"role":"user",
           "content":"Summarise our Q1 pipeline risk"}]}' | jq

What to look for in the response

01The runway_class — A through E represent cost and capability tiers. Does that classification map to how your org thinks about workload types?
02The fallback chain — does the degradation order match your vendor preferences and data residency requirements?
03The cost_estimate at 500 calls/day — try changing estimated_calls and watch it scale. Is the magnitude in the right range for your team?

Tell us what you found. Does the RunwayClass matrix match your actual workload taxonomy? What task domains are missing? Did the cost estimate surprise you?

Share your findings →

Story 3 of 3 · 🧠 ACM — Hyper-State Runtime — Agent Continuity Mode

Your AI agents act. Can you prove what they were authorized to do?

AI agents are making decisions — drafting emails, querying databases, calling APIs. When a compliance officer asks "who authorized this action, under what context, with what constraints?" the answer today is "we think the model did it." That's not an audit trail. That's a liability.

Here's what we ran

We ran two sequential agent cycles on the same trajectory ID. Each returned a signed activation receipt. The second receipt's previous_receipt_hash references the first — forming a tamper-evident chain, persisted locally, with no external dependencies.

Receipt 1: task + signed receipt_id Receipt 2: hash links to Receipt 1 Chain persists to local volume

What it showed

Every governed action is receipted. The chain is verifiable. You can prove what was authorized, in what order, under what context — without trusting any single system, without a cloud connection. The receipts live in your environment. You own them.

🧠

ACM — Agent Activation Demo

Tamper-evident receipt chain, standalone mode

# Start ACM standalone (no Pub/Sub, no Fabric needed):
$ cd acm-trial/ && docker compose up
#  Ready in ~20 seconds. Redis included.

# Cycle 1 — governed agent activation:
$ curl -X POST http://localhost:8095/v1/agent/cycle \
    -H "Content-Type: application/json" \
    -d '{"trajectory_id":"demo-traj-001",
         "task":"Summarise Acme renewal history"}' | jq

# Cycle 2 — same trajectory, watch the chain grow:
$ curl -X POST http://localhost:8095/v1/agent/cycle \
    -H "Content-Type: application/json" \
    -d '{"trajectory_id":"demo-traj-001",
         "task":"Draft renewal email for Alice at Acme"}' | jq

# Inspect the full receipt chain:
$ curl http://localhost:8095/v1/admin/control-tower | jq

What to look for in the response

01The receipt_id and previous_receipt_hash — Receipt 2 should reference Receipt 1. Does the chain break if you modify a receipt manually?
02The trajectory_id linking both receipts — can your compliance team trace an entire agent session from a single ID matching a real case number?
03Run docker volume inspect acm_outbox — receipts persist even if the container restarts. Does that match your air-gap or data residency requirements?

Tell us what you found. Does the receipt schema cover your compliance requirements? What fields would your legal or security team need that aren't there yet?

Share your findings →

Design Partner Program

Run it. Break it. Tell us everything.

Your findings go straight to the engineering team. We aim to respond within 24 hours. Every friction point you hit shortens the path for the next enterprise evaluating this.

Share Your Results

What did you find when you ran it?

We want the honest verdict — what worked, what broke, what surprised you, and what's missing. 180-day trial entitlement included. No credit card, no auto-renewal.

Your name

Work email

Which scenario did you run?

Your verdict

What worked? What broke? What's missing?

May we share your feedback publicly?

Request an Enhancement

Something's missing. Tell us exactly what.

Enhancement requests go into our GitHub issue tracker — visible, trackable, tied to the engineering backlog. If ten design partners ask for the same thing, it moves to the top of the queue.

What makes a good request

Name the specific scenario and the step where you hit the gap
Describe what you expected vs. what actually happened
Tell us the business consequence — what can't you do without this?
Include your environment: Docker version, OS, team size, use case

What to expect

We triage every issue within 48 hours and leave a public comment
Design partner requests are labelled and prioritised separately
If we can't build it, we'll tell you why — no issue goes silent

Open enhancement request →

Design partner benefits

180-day trial on any tier — no credit card
Direct engineering access — not a sales queue
Co-design roadmap influence
First access to each new scenario as it ships

Pricing

Simple, transparent plans.

Design partners get 180 days free on any tier. No credit card. No auto-renewal. Tell us what you think at the end.

Basic

$29_/mo

Individual operators and small teams getting started.

1 user
2 connectors
10K NCEs/month
1K API calls/day
5 GB storage
Community support

Start 180-day trial

Pro

$99_/mo

Growing teams who need shared context and integrations.

5 users
5 connectors
100K NCEs/month
10K API calls/day
25 GB storage
Priority email support
CRM intelligence
Drift detection

Start 180-day trial

Max

$299_/mo

Larger teams with full governance and compliance needs.

25 users
15 connectors
500K NCEs/month
50K API calls/day
100 GB storage
Dedicated support
RBAC + SSO
BYO data plane

Start 180-day trial

Enterprise

Custom

Unlimited scale, air-gapped deployment, custom SLA.

Unlimited users
Custom connectors
On-prem or VPC deploy
AWS / GCP Marketplace
SCIM + SAML
Dedicated CSM
LLM Gateway + CFA + ACM
SLA & audit exports

Talk to us

From Design Partners

Early results.

Collected from design partners who ran these scenarios in their own environments. No staging accounts. No curated demos.

Testimonials appear here as design partners complete their trials and share their findings.
Be the first.

Stop the AI agent stampede.

Five products. One governed fabric.

Three problems we kept hearing. Run the proof yourself.

Your revenue team walks into renewal calls blind.

Your AI infrastructure is twelve teams picking twelve models with no audit trail.

Your AI agents act. Can you prove what they were authorized to do?

Run it. Break it. Tell us everything.

Simple, transparent plans.

Early results.