The control plane for software built by AI agents.

English · 中文

AIBA

The problem

Agents write code fast. Every project still rewrites identity, permissions, audit, files, notifications, review access, approvals, forms, reporting, and ten other cross-cutting capabilities.

Teams quickly hit three walls:

• Trust: you can't prove the AI-built code is safe, compliant, or upgradable.
• Speed: each project starts from a template that must be re-customized until it's unrecognizable — and then you can no longer upgrade it.
• Governance: there is no system of record for what the agent changed, why it changed it, whether the evidence still holds, or who approved it.

AIBA is the infrastructure layer that addresses all three.

What AIBA does

AIBA is agent-native capability infrastructure. It is not an admin template, visual page builder, fixed full-stack framework, or prompt library.

Instead of forcing one stack, AIBA gives every AI Agent stable, versioned definitions of application behavior. The Agent adapts that behavior to the project's existing stack and design language; deterministic Core commands inspect, verify, trace, and upgrade the result. Generated code stays owned by the project.

In one sentence: AIBA turns AI-generated code into governed, traceable, upgradable production software.

What you get on day one

• A trustworthy admin or internal tool, built with your stack and your design system, without locking into one template.
• 23 verified building blocks for identity, access, files, notifications, forms, reports, approvals, i18n, data dictionaries, inboxes, tags, workflows, webhooks, audit, and WeChat mini-program review mode.
• Deterministic evidence & provenance: every capability installation is hashed, traced, and reproducible.
• Customization-aware upgrades: you can change the code, and AIBA still upgrades the capability on top of your changes.
• Signed team governance: approvals are bound to exact plans and evidence hashes; tampered plans fail.
• A registry and private distribution path for teams that need to control every capability they install.

For whom

• Independent developers & small teams who use Codex, Claude Code, or other agents and want to ship faster without accumulating unmaintainable AI code.
• Product teams who need to build multiple internal tools or back offices with shared security, compliance, and upgrade guarantees.
• Platform & security teams who need a governance layer for AI-generated application code — what changed, who approved it, whether it still verifies, and how to upgrade it safely.

AIBA starts with the agent-first developer workflow and scales up to the enterprise control plane. The same Core, contracts, and verification engine work from a solo side project to a regulated team.

Capability layers

AIBA ships 23 reusable capabilities, organized for discovery in this order:

Layer	Current catalog
Application foundation	identity, authorization, users, notification, inbox, verification-challenge, data-dict, file-assets, i18n, scheduled-jobs, feature-flags, organization, search, review-access
Platform integration	webhooks, wechat-miniprogram-auth
Business capability	comments-activity, form-engine, import-export, reporting, tags, workflow-approval
Engineering governance	audit
Application solution	secure-workspace

The first four layers are installable packs. The solution layer is a reusable composition, not one of the 23 capability packs.

AIBA currently supports agent-assisted install, deterministic evidence and provenance verification, drift inspection, customization-aware upgrade, signed capability bundles, authenticated private registry fetch, verified caching, and anti-rollback resolution. Optional project governance adds signed, evidence-bound team approvals to install and upgrade finalization.

Three ways AIBA shows value fast

1. Get a Blueprint plan in minutes. Describe your app once and get a deterministic capability graph plus a bounded agent task list — no prompt engineering required.
2. Ship your first verified capability fast. Pick one building block, let the agent adapt it, then verify evidence and provenance before you ship.
3. Upgrades that don't break your custom code. When a new version of a capability ships, AIBA classifies additive, breaking, security-sensitive, and conflicting changes — so you only adapt what's necessary.

A historical external demonstration shows AIBA and Codex building one project from an empty directory. Its example domain is documentation only and is not part of AIBA's protocol or catalog.

Start here

• Try it in minutes: Ten-minute Quick Start
• Use it for real: Five-step best practice playbook
• Understand the model: Capability Model
• Run it yourself: Install

Principles

• Stable capability semantics, flexible implementation.
• Deterministic evidence and provenance verification, AI-assisted adaptation.
• Project-owned generated code.
• Traceable changes and upgradeable capabilities.
• Independent core with thin Agent skill adapters.

Repository

• docs/: vision, architecture, RFCs, roadmap, and task progress.
• packages/spec: language-neutral schemas and TypeScript protocol types.
• packages/core: inspection, capability loading, provenance, and verification.
• packages/cli: the aiba command-line interface.
• packages/registry-server: authenticated read-only reference registry.
• capabilities/: official capability packs.
• solutions/: exact, dependency-ordered application capability compositions.
• integrations/: Agent-specific adapters.
• fixtures/: reference projects used for conformance and attack testing, including a native WeChat Mini Program and an integrated core-capabilities security corpus.

Install

Requires Node.js 22 or newer:

npm install --global @grubbylee/aiba
aiba --version

The scoped package installs the aiba executable and ships the official capability packs and application solutions. Library users can install aiba-core, aiba-spec, or aiba-registry-server separately.

Try the shortest path:

aiba init
aiba create app my-app
aiba plan applications/my-app/app.yaml
aiba add identity
aiba add identity --finalize --agent codex
aiba verify .

More entry points:

• Build a full secure foundation: aiba add secure-workspace --solution
• Browse the catalog: aiba list, aiba show <id>
• Follow the five-step production path: Best Practice
• For teams: signed governance, private registry, behavior proofs, and self-hosting — start with the Capability Model and Self-Hosting guides.

How it works

The shortest loop: describe, plan, adapt, verify, upgrade.

aiba init
aiba create app my-app
aiba plan applications/my-app/app.yaml
aiba add identity
aiba add identity --finalize --agent codex
aiba verify .

add and upgrade prepare bounded operation plans — they do not silently generate code or execute pack content. The agent adapts the capability to the project's stack and design system; Core hashes evidence and records provenance only after verification passes. Capability packs are untrusted data; Core never executes commands from a pack.

compose is read-only evidence and provenance verification. A Solution pins each constituent to an exact version and manifest hash, requires a full dependency closure and correct install order, and re-runs every capability's own verification. A Solution can never weaken an invariant or hide a failed constituent.

Approvals are fail-closed by default when a governance policy is present. Every approval is bound to the exact plan, policy, capability version, and evidence-file hashes; the final receipt preserves policy and approval hashes for later verification.

For runtime behavior claims, use the separate signed test, attest, and verify-behavior flow. Core never executes tests, but it can verify that a trusted runner ran them against the right source snapshot.

More detail: Capability Model, Self-Hosting, Roadmap.

Development

For contributors working inside this monorepo:

pnpm install
pnpm check
pnpm aiba -- inspect .

pnpm check runs typecheck, tests, build, smoke, release-metadata validation, workflow validation, and a clean-tarball consumer test.

Use pnpm aiba -- <command> to run the locally built CLI against any path. Registry operations, signing, governance, and behavior-proof workflows are covered by the dedicated guides under docs/.

License

The CLI, Core, Registry Server, capability contracts, recipes, and migrations are AGPL-3.0-only. The protocol package is Apache-2.0. Some application output may use the additional permission in GENERATED_OUTPUT_EXCEPTION.md; this exception does not relicense AIBA itself or third-party material.