CFS isn't just a spec - it's becoming a working SDK. Records, Links, Views, Tools, Receipts, Policies, Sync, Gates - being implemented in TypeScript and Rust. Open source core planned. We're building context planes that actually work.
A spec document doesn't ship products. You need code that runs. The CFS SDK will be the reference implementation - primitives you can import and build on. We're hardening it with early partners now.
We don't hide complexity behind magic. You get the building blocks and full visibility into what they do. Debuggable, composable, type-safe.
The SDK follows the spec exactly. When the spec changes, conformance tests catch drift. You build on solid ground.
Not a proof-of-concept. Bitemporal semantics, proper error handling, Effect-TS powered TypeScript. Designed for real workloads.
Record Universal envelope for any entity. Stable ID, schema, metadata. The atoms of context.
Link Typed relationships between records. "Closes", "owns", "depends-on". The edges that make context navigable.
View Policy-filtered projections. Same data, different audiences. Engineering sees code, sales sees customers.
Tool Safe, scoped actions. Not "do anything" but "call this API with these permissions." Agents operate within bounds.
Receipt Immutable audit trail. Who saw what, when, why. Every access logged. Compliance without surveillance.
Policy Machine-checkable rules. "Engineers see code, not HR data." Declarative, auditable, enforceable.
Sync Incremental updates between planes. Federate without centralizing. Export, import, replicate.
Gate Constraints that unlock capability. "Prove security review complete before production access." Progress through proof.
Preview API — subject to change during beta
import { Record, Link, Effect } from '@helaix/cfs'
// Create a record for a service
const paymentService = Record.create({
schema: 'helaix.org/service/v1',
data: {
name: 'payment-api',
owner: 'eng/payments',
tier: 'critical'
}
})
// Link it to its repository
const ownsRepo = Link.create({
source: paymentService.id,
target: repoRecord.id,
predicate: 'owns',
metadata: { primary: true }
})
// Everything returns Effect for composability
const program = Effect.gen(function* (_) {
yield* _(Record.persist(paymentService))
yield* _(Link.persist(ownsRepo))
})import { View, Query } from '@helaix/cfs'
// Define a view for engineering context
const engineeringView = View.define({
name: 'engineering',
policy: 'team:engineering OR role:oncall',
includes: ['service', 'repo', 'deploy', 'incident'],
excludes: ['hr', 'finance', 'pii']
})
// Query through the view
const query = Query.build()
.through(engineeringView)
.where('schema', 'matches', 'helaix.org/service/*')
.traverse('owns', 'repository')
.traverse('triggered', 'deploy')
.since('2024-01-01')
// Results come with receipts
const { results, receipt } = await query.execute()Local-first knowledge stores with MCP tool exposure. Your context, encrypted, portable, connected to any AI.
Engineering knowledge graphs that link services, repos, deploys, incidents. Make your org queryable.
Multi-agent systems with proper state, capabilities, and receipts. Coordination that actually coordinates.
Receipt-first architectures where every access is logged. Who saw what, when, with what permission.
@helaix/cfs-core Core primitives: Record, Link, View, Policy. Zero dependencies.
@helaix/cfs-store Storage adapters: SQLite, Postgres, in-memory. Bitemporal by default.
@helaix/cfs-tools Tool primitive + MCP server integration. Safe agent actions.
@helaix/cfs-receipts Audit logging with tamper-evident receipts. Compliance-ready.
@helaix/cfs-sync Federation and replication. Connect planes, preserve sovereignty.
@helaix/cfs-conformance Test suite to verify your implementation follows the spec.
Rust crates coming Q2 2026. Same primitives, same spec, systems-programming performance.
The SDK is in private beta. We're working with teams building real context planes to harden the APIs before public release.
Request Early AccessTell us what you're building. We prioritize teams with production use cases who can provide feedback.
If you want the benefits of CFS without implementing it, our services team can build your context plane for you. Or use Context Plane SaaS for a managed solution.