Define a model. Validate it before it runs.

Reach every live surface with one ID

Each surface below is an MCP server behind the platform's own sign-in. A hosted assistant adds the address as a custom connector and signs in as you; a person building or operating on the platform signs in once from a terminal with platform login --env dev for the compass-platform.dev surfaces and platform login --env prod for those on compass-platform.com, then lets platform agent compose the same servers for Claude Code or Codex. The table is rendered from the service catalogue, so it cannot say more than the catalogue does.

First workflow Connect Decisions and Tickets, ask the assistant to inspect one open decision, rule it yourself in the Factory, then have the assistant open the ticket that ruling implies. The getting started journey walks the same path with prompts you can paste.

Find the import for your app

The package root exports SDK_VERSION and SURFACE. Check where an import can run: in any JavaScript environment, in the browser, on the server, or during a build.

import { SDK_VERSION, SURFACE } from "@platform/sdk"

// Show the first three available imports.
console.log("Compass Platform SDK", SDK_VERSION)
for (const entry of SURFACE.slice(0, 3)) {
  console.log(entry.specifier, entry.runtime)
}

Compass Platform SDK 0.1.0
@platform/sdk/domain universal
@platform/sdk/domain/core universal
@platform/sdk/domain/schema universal

Next: define an order using the domain core.

Define an order and its rules

Describe the states an order can have and the changes it accepts. Use @platform/sdk/domain/core to check the definition before connecting it to storage or other services.

1. DefineCheck the model
2. CompilePrepare an inert plan
3. BindResolve approved functions

Save this as order.domain.ts in a Platform workspace package that depends on @platform/sdk, then run bun order.domain.ts. It prints Order without creating records, making network calls, or granting permission.

import type { DomainDefinitionJSON } from "@platform/sdk/domain/schema"
import { bindDomain, compileDomain, defineDomain } from "@platform/sdk/domain/core"

export const orderDomain = {
  schemaVersion: "domain-def@5",
  name: "Order",
  version: "1.0.0",
  description: "An order that can be placed once.",
  types: {
    OrderState: { status: "'open' | 'placed'" },
    Open: { status: "'open'" },
    Empty: { "+": "reject" },
  },
  aggregates: {
    Order: {
      description: "One order, identified by orderId.",
      urnPattern: "urn:shop:order:{orderId}", identity: "{orderId}",
      state: { type: "OrderState", initial: { status: "open" } },
      commands: {
        place: {
          description: "Place an open order.", inputType: "Empty",
          cases: [{ when: "Open", emit: [{ type: "Placed", payload: {} }] }],
        },
      },
      events: {
        Placed: { description: "The order was placed.", type: "Empty",
          apply: [{ op: "set", path: "status", value: "placed" }] },
      },
    },
  },
  resources: {},
  authz: {
    scopes: {},
    policies: {},
    defaults: { unauthenticatedAccess: "deny", missingRolesBehavior: "deny" },
  },
} as const satisfies DomainDefinitionJSON

const definition = defineDomain(orderDomain)
const compiled = compileDomain(definition) // no I/O and no authority
const bound = bindDomain(compiled, { maps: {}, resources: {}, events: {} })

console.log(bound.compiled.source.definition.name) // Order

Order

Next: see what happens when you place the order.

Authority boundary A compiled domain is inert until you bind approved effects. Binding is not permission to act. The core preserves scope and confirmation metadata; it does not enforce caller authorization or human approval. Application adapters must enforce those gates and own network calls, identity, clocks, persistence, and external tools.

See a command change state

An aggregate keeps state and the rules that change it together. Here, an open order accepts place, emits Placed, and becomes placed. The pure kernel simulates that transition without writing to a store. A second place is refused by the state rule.

1. OpenAccept place
2. Placed eventApply the declared change
3. PlacedRefuse another place

Save as simulate.ts beside order.domain.ts and run bun simulate.ts. After the imported example's Order line, it prints open → placed.

import { apply, compileDomain, decide, defineDomain, initialState } from "@platform/sdk/domain/core"
import { orderDomain } from "./order.domain"

const plan = compileDomain(defineDomain(orderDomain))
const initial = initialState(plan, "Order")
if (!initial.ok) throw new Error(initial.error.code)
const decision = decide(plan, "Order", initial.value, {
  name: "place", input: {}, identity: "example-1",
})
if (!decision.ok) throw new Error(decision.error.code)
let state = initial.value
for (const event of decision.value.events) {
  const next = apply(plan, "Order", state, event, {
    occurred_at: "2026-09-08T12:00:00.000Z", // explicit simulation time
  })
  if (!next.ok) throw new Error(next.error.code)
  state = next.value
}
console.log(initial.value.status, "→", state.status) // open → placed

Order
open → placed

Next: check a definition received as JSON.

Check a definition received as JSON

Use parseDomainDefinition(input: unknown) for data supplied by a caller. If the definition is valid, you receive a normalized copy. Otherwise, each error identifies the field to fix.

Save beside the previous example as parse-domain.ts. Run bun parse-domain.ts: the imported example prints Order, then this script prints the canonical JSON. The example uses the order definition as its input; replace that stand-in with your caller's input.

import { compileDomain, parseDomainDefinition } from "@platform/sdk/domain/core"
import { orderDomain } from "./order.domain"

// Stand-in for JSON supplied by your caller. Replace with their input.
const receivedText = JSON.stringify(orderDomain)
const input: unknown = JSON.parse(receivedText)
const parsed = parseDomainDefinition(input)

if (!parsed.ok) {
  for (const diagnostic of parsed.error.diagnostics) {
    console.error(diagnostic.code, diagnostic.path, diagnostic.message)
  }
  throw new Error("Domain definition is invalid")
}

// Review any diagnostics before connecting the model to services.
for (const diagnostic of parsed.value.diagnostics) {
  console.warn(diagnostic.code, diagnostic.path, diagnostic.message)
}
const compiled = compileDomain(parsed.value)
// The compiled result remains inert until an approved catalog is bound.
console.log(compiled.source.canonicalJson) // canonical definition JSON

Prints Order, then the validated definition as canonical JSON.

Next: connect a tool to its view.

Connect an MCP tool to its view

An interactive MCP result is two related contracts: the tool advertises a predeclared UI resource, and the host reads that resource when it renders the result. Structured data must remain useful even when the visual is unavailable.

Metadata shape only. This fragment does not register a tool or resource and cannot render a widget by itself. Your MCP adapter must serve the declared resource, and the client must support MCP Apps.

interface InteractiveToolMetadata {
  _meta: {
    ui: { resourceUri: `ui://decisions/briefing.html` }
  }
}

const metadata: InteractiveToolMetadata = {
  _meta: { ui: { resourceUri: "ui://decisions/briefing.html" } },
}

Metadata only · no widget rendered

Use the root workspace today

Platform applications currently consume the SDK through the repository's single Bun workspace. Do not create a nested workspace or import an implementation package as a competing application-facing authority.

Forge, the platform's Git service, holds your repositories under your platform sign-in: git.compass-platform.dev.

Updating an existing integration? See the release notes for the import contract, compatibility guidance and checks.