Skip to content

The ecosystem ​

GAIA is a suite of small engines, not a framework, not a control plane. Each project owns one mechanism, speaks a wire protocol, and composes with the rest. The layers below are the architecture: packaging → engines → orchestration → surfaces, with planes underneath serving the whole stack.

The layers ​

Packaging

Everything installs, updates, and ships through tamias packs. Pluggable adapters fetch content; the store caches it; drivers dispense it to whoever asks.

tamiasentrypoint

The entrypoint: fetch, store, cache, dispense

Package and content manager: every 9aia tool installs and updates through tamias packs.

scarabconfig-and-templates

Config loading & templated content packs

Config expertise: generic config ports plus templated content packs distributed via tamias.

Planes

Cross-cutting services that govern the stack itself: releases and the CI gate ride the same pack machinery as everything else.

tarsireleases

The release plane: changelog to publish

Release plane: changelog, semver bump, tag, and publish exposed as tarsi-serve ops.

buphaci-gate

The gate: CI as tamias bundles

CI integration: push sources queue per-sha pipeline runs on your box, shipped as tamias bundles.

Engines

The machines. Each a small engine owning exactly one mechanism: memory, secrets, coordination, sessions, scheduling, verification. They compose over wires, not plugins.

hyphadistributed-substrate

Distributed substrate: entities across machines

Distributed substrate: a generic entity plane with namespaced ops, snapshots, and locks.

mycorecords

The ledger: durable work memory

Records engine: a myco CLI owns every write to a repo's markdown work ledger.

kudacode-map

Repo memory: verified code maps

Code-map engine: crawls repos into verified per-module cards agents query instead of re-exploring.

mimusverification

The critic: claims verified against code

Verification engine: extracts claims from docs and cards, verifies them against the code, repairs the fixable.

sturncoordination

The WAL: coordination in milliseconds

Ephemeral coordination: claims, ops, and topics over the git object store.

cuorasecrets

Secrets broker: sealed, not spilled

Secrets broker: code carries cuora:// references; values materialize as env vars at run time, audited.

sepiasessions

Session lifecycle: agents, agnostically

Session lifecycle engine: one canonical IR and pluggable store drivers across coding agents.

lasiusworkspace

Git & workspace expertise

Git and workspace expertise: lasius.toml clones and syncs every repo of a GitHub org.

cicadascheduling

Calendars as code: scheduled work

Scheduled-work engine: declare calendars in YAML, plan and apply them against live providers.

Orchestration

Campaigns that drive work across machines: declarative events, nodes, and drivers, with a session plane on every node.

peregrinorchestrator

Campaigns: event-driven orchestration

Orchestration engine: declarative campaigns of events, nodes, and drivers across your machines.

Surfaces

What humans and agents actually see. Products ship tamias drivers; surfaces render their ViewNode IR across CLI, TUI, and web.

pavovisualization

The screen: renders every view

Visualization host: renders ViewNode IR trees emitted by tamias drivers across CLI, TUI, and web.

How a change ships ​

The suite manages its own development. This is the loop, end to end:

  1. tamias: installs and dispenses the packs that carry everything else
  2. myco + kuda: track the work and remember the code
  3. sturn: coordinates agents in milliseconds over the git object store
  4. peregrin + sepia: run campaigns and manage agent sessions across machines
  5. pavo: renders every view the drivers emit
  6. bupha: gates every push through CI
  7. tarsi: cuts the release

Every project has its own docs site (tutorial, how-tos, reference, and explanation) linked from each card above. Start with tamias, the entrypoint.