Open Source Projects

A reusable system of expert collectives ('trusts') that turns AI assistants into a room with friction — real named figures in plausible settings, a moderator who refuses to skip steps, and a synthesis that names what was traded away. Ships as Cursor and Claude Code plugins, per-skill zips, and a published MCP server (@bahulneel/brain-trust-mcp).

• Composable Agent Skills following the agentskills.io specification: expert-opinion, draft-experts, and ten bt-* workshops and editorials (software systems, codebase tactics, prompt engineering, design patterns, product strategy, organisation design, frontend UX, visual communication, technical writing, science explanation)
• Bounded guest drafting via an MCP-served persona taxonomy of ~80 named figures — closes off invented authority and lets one room draft a witness from another's domain
• Shared protocol fragments (readings, synthesis, persona fidelity) reused across rooms; a new room is one YAML stanza and a paragraph of framing
• Monorepo of brain-trust-core, brain-trust-db, brain-trust-mcp (published as @bahulneel/brain-trust-mcp on npm) and repo-tooling, with releases producing Cursor and Claude Code plugin zips and standalone RPL.md / LRPL.md prompt artifacts
• Spawned RPL (Relational Prompt Language) as a separate, reusable artifact — see the RPL project entry

A Markdown-embedded reasoning framework with associated logic for structuring how an LLM reasons about a user's request. Instead of relying on highly tuned prose and guessing what the model inferred, RPL lets you declare explicit relations, goals, and constraints so reasoning state becomes inspectable, queryable, and continuable across context boundaries. Spawned out of Agent Brain Trust and published as a standalone artifact.

• Stratified relational reasoning — each conversation turn is a stratum, the trace is the continuity mechanism between strata and across sessions
• Grounded in Bloom and the CALM theorem (Hellerstein; Ameloot, Neven & Van den Bussche): the monotonic core needs no coordination, with non-monotonic operations made explicit as agent-judgment points
• Base RPL (eager) and LRPL (lazy extension with memos, satisfactory quiescence, and a small stdlib including $json, $write, $index)
• Prose-first authoring: Markdown is materialised into relations on encounter; relation heads attach to headings only where prose drifts
• Distributed as published RPL.md / LRPL.md artifacts inside the Agent Brain Trust releases, with a normative base specification and tutorials

The active library family and published research for truly relational, data-driven systems — lazy typing, claims, propagator networks, and construction primitives where relationships carry semantic meaning. Maintained under the RelationalFabric GitHub organisation (https://github.com/RelationalFabric); Canon, Howard, and Suss are the first shipped libraries, with Filament, Weft, Warp, and Shuttle as the broader platform surface.

• Filament — meta-level primitives for building domain-specific abstractions
• Weft — navigation and query construction primitives
• Warp — primitives for working with data at rest
• Shuttle — flow and coordination construction primitives
• Published DCSGS whitepaper (Distributed Context-Sensitive Graph Store) — peer-to-peer distributed graph storage with immutable Semantic Log, Native Projection, and ownership-based conflict resolution

Universal type primitives and axiomatic systems for TypeScript. Implements the Lazy Typing pattern: write type-safe code against semantic concepts (axioms) while deferring shape-specific implementations (canons) to runtime configuration, exposed through universal APIs.

• Axioms / Canons / Universal APIs — semantic concepts decoupled from data shape
• Zero-runtime-cost compile-time type assertions (Expect<A, B>, IsTrue, IsFalse)
• Bundled tsconfig, ESLint config and a CLI scaffold (`npx canon init`)
• Transparent ADRs and a public technology radar

A self-contained logical primitive for building truly relational data systems — a computable truth engine that turns ad-hoc boolean validation into first-class, composable propositions, in the spirit of the Curry–Howard correspondence.

• Value semantics and verifiable equality for arbitrary data
• Claims backed by pure, deterministic predicates
• Compositional propositions mirroring domain relationships
• Decouples what is claimed from how it is proved, for a flexible and extensible architecture

Reference TypeScript implementation of RaCSTS (Relational and Causal State Transition System) — serialisable propagator networks that can be paused, inspected, versioned and transmitted across boundaries as first-class values.

• Bidirectional constraints with automatic reconciliation
• Leader-free consensus via Sync; causal ordering via a Hybrid Epoch Clock
• Six standard higher-order relations (mark, linear, map, constrain, reduce, join)
• Full pack/unpack of networks as values for portability and replay