BASAL
PlatformDevelopers
Quickstart
Get started

Build for BASAL

Teach BASAL new things

Give BASAL new senses, new ways of reasoning, and new ways of making decisions. Every capability you build compounds the intelligence for everyone who uses it.

The architecture

BASAL's core is a pure Document → Knowledge Graph engine. Everything that feeds documents in (connectors) or reads intelligence out (lenses) integrates via typed adapters.

Connect ──► Unfold → Strata → Graph ──► Reason

(senses) (convert) (extract) (project) (faculties)

Capabilities are standalone packages. Each declares a manifest with typed adapters — the engine discovers and loads them automatically.

6 adapter types

SourceAdapter

Feeds documents into the pipeline from external systems — APIs, file watches, database polls.

Google Workspace, Slack, GitHub

ConverterAdapter

Transforms raw formats into UnfoldDocument. Registered with the Unfold conversion engine.

VTT transcripts, DOCX, CSV, email

SignalAdapter

Injects cross-document hints into the extraction pipeline — meeting clusters, entity dedup, topic correlations.

Meeting cluster detection, X bookmark signals

ConfidenceAdapter

Modulates fact confidence scores based on source reliability, identity verification, or domain rules.

Source reliability weights, identity-backed boost

InngestAdapter

Registers Inngest cron jobs and event-triggered functions. Capabilities declare config, the core registers.

Research loop (nightly), innovation grooming (4h)

LensAdapter

Read-only graph analysis. Projects intelligence from the knowledge graph without modifying the core pipeline.

Behavioral profiling, network analysis, NOW projection

Ceremony Protocol SDK

Ceremony protocols define structured multi-agent deliberation. The SDK uses 4 declarative adapters:

TriggerAdapterWhen to run — schedule, event, threshold, or manual
ProtocolAdapterHow to structure phases — discussion, voting, processing, transitions
RosterAdapterWho participates — graph-selected, fixed, rotating, or named pool
OutcomeAdapterWhat to produce — decisions, research questions, kanban updates

Context gathering is declarative — the protocol declares what it needs (org identity, previous outcomes, metrics), and the engine fetches it.

Build a capability in 5 minutes

01Scaffold

basal scaffold my-capability
# Generates: packages/my-capability/{package.json, tsconfig.json, src/manifest.ts}

02Write a manifest

// src/manifest.ts
import type { Manifest } from '@basal/protocol'

export const manifest: Manifest = {
  id: 'my-capability',
  version: '0.1.0',
  name: 'My Capability',
  description: 'What it does',
  adapters: {
    source: mySourceAdapter,
    converter: myConverterAdapter,
  },
}

03Implement adapters

Each adapter is a typed object. The SDK provides interfaces — implement the ones your capability needs.

const mySourceAdapter: SourceAdapter = {
  id: 'my-source',
  sourceType: 'my-capability/document',
  async sync(opts) {
    // Fetch and ingest new documents
    return { synced: 0 }
  },
  async list(opts) {
    // List known documents
    return { items: [] }
  },
}

04Test and run

pnpm test              # Run tests
pnpm basal health      # Verify it loads

The registry auto-discovers your manifest at startup. Invalid manifests are skipped with warnings — never crash.

Reference

Pipeline SDK — 6 adapter types for the extraction pipeline. See packages/protocol/src/adapters/ for the full TypeScript interfaces.

Ceremony Protocol SDK — 4 declarative adapters for multi-agent deliberation. See packages/protocol/src/ceremony/ for the ceremony adapter interfaces.

CLI — Manage capabilities from the terminal:

basal platform list            # List capabilities
basal scaffold <name>          # Scaffold a new capability
basal lens list                # List lens projections
basal lens run <id>            # Execute a lens
Browse platformQuickstart

© 2026 BASAL

DownloadPlatformDevelopersQuickstartPrivacyTermsSecurity