Library Guides
Operate a Predictable Agent Team (Engineers)
Set Up Persistent Memory and Metrics
Give your agent team persistent memory and real signal detection — wiki-backed state, XmR control charts, and evidence that agents act on changes, not noise.
Send a Memo or Update a Storyboard
Communicate across your agent team and keep storyboards current — without managing the wiki infrastructure yourself.
Audit and Auto-Fix the Wiki
Keep the wiki valid against a declarative rule catalogue, auto-fix what is safely fixable, and surface the rest for a human — so stale memory never poisons coordination.
Allocate Collision-Ledger Entries for Parallel Work
Assign stable ids to parallel work without merge collisions — anchored on an append-only issue thread, projected onto a ledger page only when you rebuild.
Chart a Metric and Check Variation
Know whether a metric has actually changed or just varied — natural process limits and Wheeler's detection rules separate signal from noise.
Coordinate an Agent Team (Builders)
Coordinate an Agent Team
Run a lead and N participant agents in one asynchronous session — supervise, facilitate, or discuss — with Ask/Answer/Announce message passing and a single NDJSON trace of everything that happened.
Bridge a Threaded Channel to the Agent Team
Threaded-channel adapters share an intake skeleton, callback registry, durable thread state, and resume-trigger contract — one library, every channel.
Enable Agents on Every Surface (Builders)
Give Agents and Humans the Same Interface
Capabilities that work on every surface — one presenter, one contract, and one formatter shared between CLI and web, with no separate integrations.
Add a Capability to Both Surfaces
Ship a feature to terminal and browser at once — one presenter, one registration, both surfaces.
Build a Web Surface with libui
Assemble the browser side of a shared capability — components, reactive state, a global store, routing, slide decks, and an error boundary that keeps a bad page from blanking the whole app.
Build an Interactive REPL
Give humans and agents the same exploratory loop — one command set that works at the prompt and as one-shot flags, with state that survives between sessions.
Render Templates with Project Overrides
Ship default templates with a package and let each project override any one of them — two-tier Mustache resolution that keeps generated output consistent across surfaces.
Publish a Documentation Site
Turn a directory of markdown into a static site agents and humans can both navigate — directory-style URLs, a companion markdown file for every page, and auto-generated llms.txt, sitemap, table of contents, and breadcrumbs.
Ground Agents in Context (Builders)
Give Agents Typed, Retrievable Knowledge
Agents that can answer relationship questions, look up context, and find related content — backed by typed knowledge infrastructure with no external engines.
Query a Knowledge Graph
Answer relationship questions from an RDF graph index — triple patterns and type-filtered listings, no join logic or SPARQL endpoint.
Look Up Context Fast
Retrieve exactly the context you need from a JSONL-backed index — prefix, limit, and token-budget filters without loading everything into memory.
Resolve a Resource
Give agents rich, typed context from a resource identifier — provenance, access control, and RDF content instead of raw files.
Search Semantically
Find related content by meaning, not keywords — ranked results from a vector index without standing up a vector database.
Integrate with the Engineering Standard (Builders)
Turn Standard Definitions into Queryable Data
Engineering standard YAML becomes queryable data — derive skill matrices, behaviour profiles, and agent configurations programmatically from a single load.
Derive a Skill Matrix or Agent Profile
Go from discipline, level, and track to a complete skill matrix or agent profile — without parsing YAML by hand.
Keep Service Contracts Typed (Builders)
Keep Types Synced with Proto Definitions
Proto changes flow through to JavaScript types, MCP tools, and service endpoints automatically — one source of truth from definition to runtime.
Expose a Proto Method as an Agent Tool
A new gRPC method becomes an agent tool with one config entry — no glue code, no hand-written schema.
Ship a Service Endpoint
Ship a gRPC service with typed contracts, authentication, retries, and health checks — without reimplementing transport.
Run a Predictable Platform (Builders)
Manage Service Lifecycle from One Interface
Services that stay running and problems that surface before they escalate — supervision and observability from one interface.
Start, Stop, or Check a Service
Start, stop, restart, check status, and read logs through one interface — without remembering each service's specific incantation.
Add Observability
Structured, machine-readable logs and spans without configuring a logging framework — drop in a log line or a span and it works.
Prove Agent Changes (Builders)
Prove Agent Changes
Reproducible evidence that agent changes improved outcomes — from dataset generation through evaluation to trace analysis.
Run an Eval
Know whether agent changes improved outcomes — an agent-as-judge eval wired into CI with traceable results.
Run a Benchmark
Prove a skill-pack change improved coding outcomes — run a task family across N runs, grade with hidden tests, and report pass@k.
Automate with GitHub Actions
Run gemba-benchmark in CI with the forwardimpact/benchmark composite action — step summaries, artifact upload, and PR-triggered benchmarks.
Analyze Traces
See exactly what an agent did and why — download traces, query turns, filter by tool or error, and measure token cost.
Generate an Eval Dataset
Go from a DSL file to a complete, validated evaluation dataset — entities generated, prose resolved, output rendered, and results verified.
Distribute Skill Packs (Builders)
Distribute Skill Packs
Stage a skill pack into APM's .apm/ layout so a bare install pulls skills and agents together — one command from a source tree to an installable repository.
Build Tarball and Git-Repo Packs
Build distributable packs in three formats — a flat tarball, an APM tarball, and a static bare git repo — from one set of skill and agent combinations, with byte-identical output across runs.
Publish a Skill Discovery Index
Emit a .well-known/skills/ discovery index so an agent can find and load skills over the web — a per-pack index plus a deduplicated index spanning every pack.
Provision Substrate Identities (Builders)
Looking for product workflows? See Product Guides. For shared gRPC service integration, see Service Guides.