``` ╔═══════════════════════════════════════════════════════════════╗ ║ ║ ║ █████╗ ██████╗ ███████╗███╗ ██╗████████╗███████╗ ║ ║ ██╔══██╗██╔════╝ ██╔════╝████╗ ██║╚══██╔══╝██╔════╝ ║ ║ ███████║██║ ███╗█████╗ ██╔██╗ ██║ ██║ ███████╗ ║ ║ ██╔══██║██║ ██║██╔══╝ ██║╚██╗██║ ██║ ╚════██║ ║ ║ ██║ ██║╚██████╔╝███████╗██║ ╚████║ ██║ ███████║ ║ ║ ╚═╝ ╚═╝ ╚═════╝ ╚══════╝╚═╝ ╚═══╝ ╚═╝ ╚══════╝ ║ ║ ██╗███╗ ██╗ █████╗ ║ ║ ██║████╗ ██║ ██╔══██╗ ║ ║ ██║██╔██╗ ██║ ███████║ ║ ║ ██║██║╚██╗██║ ██╔══██║ ║ ║ ██║██║ ╚████║ ██║ ██║ ║ ║ ╚═╝╚═╝ ╚═══╝ ╚═╝ ╚═╝ ║ ║ ██████╗ ██████╗ ██╗ ██╗ ║ ║ ██╔══██╗██╔═══██╗╚██╗██╔╝ ║ ║ ██████╔╝██║ ██║ ╚███╔╝ ║ ║ ██╔══██╗██║ ██║ ██╔██╗ ║ ║ ██████╔╝╚██████╔╝██╔╝ ██╗ ║ ║ ╚═════╝ ╚═════╝ ╚═╝ ╚═╝ ║ ║ ║ ╚═══════════════════════════════════════════════════════════════╝ ``` **A complete ecosystem for AI-assisted development**

115 Rust Modules · 91 Skills · 37 Agents · 9 AI Tools · Knowledge Graph

Live dashboard: multi-workspace sidebar, session preview pane, and tmux-backed persistent sessions

Burndown dashboard: daily activity, per-project & per-model breakdowns, top sessions, live budget tracking, and optimisation hints — all in one view

` or press `[r]` on it in the > Skill Manager. Removal is **per-file and scoped to that unit** — it deletes > only what ainb deployed and can never wipe your config or session history. --- ## ainb — Terminal UI + CLI A Rust-based terminal application for managing AI coding sessions with git worktree isolation, model selection, and persistent tmux sessions. Every operation is **available as both an interactive TUI view and a scriptable CLI subcommand** with JSON output — so humans drive it from a dashboard and agents drive it from shell scripts. ### Feature Highlights - **Multi-provider** — Run Claude Code, Codex CLI, Gemini CLI, or GitHub Copilot in the same workflow, with Sonnet / Opus / Haiku selection per session - **Git worktree isolation** — Each session runs in its own branch and working directory. No cross-contamination, no stash dance - **tmux persistence** — Sessions survive terminal disconnects, SSH drops, and laptop sleep. Reattach any time - **Usage analytics** — Built-in token + session tracking by day, week, provider, and project. Know where your budget went — then cut it with [The Token Optimisation Playbook](https://stevengonsalvez.com/blog/token-optimisation-playbook) - **Easy onboarding** — First-run setup wizard checks dependencies, configures auth, and gets you creating sessions in minutes - **Live log streaming** — Real-time viewer with level filtering and search across all running sessions - **Scriptable CLI** — 30+ commands (every TUI action, plus headless `witr`, `learnings search`, `diff-review --format json`, …) with `--format json` output for every piece of state. **[📘 Full CLI reference →](docs/tui/cli.md)** — a generated, multi-hierarchy man page covering every subcommand. ### Feature Showcase

📊 Unified dashboard Sidebar navigation across Agents, Catalog, Sessions, Recovery, Logs, Stats, Skills, Changelog, and Setup. Keyboard-driven throughout.	🤖 Pick your agent, pick your model Choose between Claude Code, Shell Only, SSH, Codex CLI, Gemini CLI, GitHub Copilot, or Kiro. Model toggle — Sonnet · Opus · Haiku — right below.
🚀 Start a session any way you want Local repo, clone from GitHub/GitLab, SSH into a remote box, or pull from your Favorites. One-key shortcuts: L / R / S / F.	🛠️ Guided first-time setup Re-run the wizard, verify dependencies, configure git paths, set auth, pick your editor — or factory-reset in one click.
📈 Burndown analytics, built in Multi-panel dashboard: daily activity, top sessions, per-project + per-model token attribution, live budget tracking, and inline optimisation hints. The observability layer behind The Token Optimisation Playbook — start with Token Optimisation 101.	🎯 Per-project attribution See exactly which repos and worktrees consume your context budget. Input, cache, output, and session counts per project.
🔍 Warp-style Code Review diff Press g on a session (or run ainb diff-review) for a cohesive review surface — file sidebar, per-file collapsible blocks in one scroll, Dracula syntax highlighting, word-level intra-line emphasis, a line-number gutter with green/red change bars, expandable context, and n/N hunk navigation. Docs →

### CLI — Scriptable Equivalent of Every TUI Feature For agents, automation, and scripts, `ainb` ships a full CLI. Every command supports `--format json` for piping to `jq`. ```bash ainb --help # Top-level overview ainb run --repo . --worktree --tool claude --model sonnet ainb list --format json | jq . ainb logs my-session --follow ainb recover list # Find orphaned sessions ainb config set authentication.default_model opus ainb completion zsh > ~/.zsh/completions/_ainb ``` **20 top-level commands** — `tui`, `run`, `list`, `logs`, `attach`, `status`, `kill`, `auth`, `recover`, `config`, `git`, `favorites`, `init`, `presets`, `usage`, `claudecode`, `completion`, `plugin`, `fleet`, `help` — with nested subcommands for recover / config / git / favorites / presets / plugin / fleet. **[📘 Full CLI reference → docs/tui/cli.md](docs/tui/cli.md)** ### Installation **Recommended — Homebrew (macOS / Linux):** ```bash brew tap stevengonsalvez/agents-in-a-box brew install ainb ``` > Newer Homebrew versions refuse formulas from untrusted third-party taps. If > `brew install`/`brew upgrade` errors with *"Refusing to load formula … from > untrusted tap"*, trust the tap once and retry: > `brew trust stevengonsalvez/agents-in-a-box` The tap lives at [`stevengonsalvez/homebrew-agents-in-a-box`](https://github.com/stevengonsalvez/homebrew-agents-in-a-box) and is auto-updated by the release workflow on every tagged release — `brew upgrade ainb` always pulls the latest.

Other install methods

**One-liner curl install** (any Unix): ```bash curl -fsSL https://raw.githubusercontent.com/stevengonsalvez/agents-in-a-box/main/ainb-tui/install.sh | bash ``` **Cargo** (any platform with a Rust toolchain): ```bash cargo install --git https://github.com/stevengonsalvez/agents-in-a-box --branch main ainb ``` **Windows via WSL2** — native Windows is not supported (`ainb` uses Unix-only APIs: PTY, POSIX file modes). Use WSL2: ```powershell wsl --install # 1. Install WSL2 # Inside Ubuntu/Debian: curl -fsSL https://raw.githubusercontent.com/stevengonsalvez/agents-in-a-box/main/ainb-tui/install.sh | bash sudo apt update && sudo apt install -y tmux ainb ```

Troubleshooting Homebrew

**`Error: Your Command Line Tools are too outdated`** — this is a Homebrew check on the standalone `CommandLineTools` package, separate from a full Xcode install. If you have a recent Xcode but an old standalone CLT, brew picks the older one. Reinstall the CLT: ```bash sudo rm -rf /Library/Developer/CommandLineTools sudo xcode-select --install ``` **`Formulae found in multiple taps`** — if you previously tapped a similarly-named bucket, untap it: ```bash brew untap stevengonsalvez/ainb # only if you tapped this earlier brew install stevengonsalvez/agents-in-a-box/ainb ``` **`Refusing to load formula … from untrusted tap`** — newer Homebrew gates third-party taps behind an explicit trust step. Trust the tap once and retry: ```bash brew trust stevengonsalvez/agents-in-a-box brew install ainb # or brew upgrade ainb ```

### Plugins `ainb` boots a plugin host at startup. Some screens — notably **Analytics / Usage (the burndown dashboard)** — are provided by subprocess plugins that the host discovers and loads automatically. **All plugins are enabled by default**; you only need the controls below to turn them off or scope which ones load.

**How it works (in brief):** a v2 plugin is a **native subprocess** that speaks **JSON-RPC 2.0 over Content-Length-framed stdio** — no wasm, no in-process linking. The host (`ainb-core`) discovers each plugin from `dist/plugins//`, spawns it, and exchanges messages: `plugin/render` (the plugin returns a `WireBuffer` of cells the host blits), `plugin/handle_key`, `plugin/cli_dispatch` (routes `ainb …`), plus reverse `host/snapshot/publish` calls over an **event bus**. Each plugin declares its `[capabilities]` in `manifest.toml`; the runtime denies any ungranted host call with JSON-RPC `-32001`. A plugin screen can render **two ways**: in-process via a `WireBuffer` (host owns the terminal — e.g. **burndown**), or as a **host-embedded foreign TTY** where ainb suspends and hands the terminal to an external interactive program (e.g. **witr**'s `witr -i` browser). Full walkthrough: [`docs/plugins/`](docs/plugins/overview.md). There are four ways to filter plugins, with the following precedence (most specific wins): | Goal | How | Type | |------|-----|------| | All on (default) | *(nothing)* | — | | All off (kill switch) | `AINB_DISABLE_PLUGINS=1 ainb` | env | | Load only these | `AINB_ONLY_PLUGINS=burndown ainb` | env allowlist | | Load all except these | `AINB_DISABLE_PLUGIN=burndown ainb` | env denylist | | Persistent allowlist | `[plugins].enabled = ["burndown"]` in `config.toml` | config | | Persistent denylist | `[plugins].disabled = ["burndown"]` in `config.toml` | config | Resolution order: `AINB_DISABLE_PLUGINS` → `AINB_ONLY_PLUGINS` → `AINB_DISABLE_PLUGIN` → config `enabled` → config `disabled` → default all-on. **Env always beats config**, and an allowlist always beats a denylist. Config lives at `~/.agents-in-a-box/config/config.toml` under a `[plugins]` table — see [`example.config.toml`](ainb-tui/config/example.config.toml) for the annotated block. When a screen's plugin is disabled, the TUI shows a placeholder naming the exact variable that turned it off, rather than hanging. ### Keyboard Shortcuts | Key | Action | |-----|--------| | `j/k` or `↑/↓` | Navigate sessions | | `Enter` | Attach to session | | `n` | New session | | `d` | Delete session | | `r` | Restart Claude in session | | `l` | View logs | | `q` | Quit | ### Platform Support | Platform | Status | Method | |----------|--------|--------| | macOS Apple Silicon | ✅ | Pre-built binary | | macOS Intel | ✅ | Build from source | | Linux x86_64 | ✅ | Pre-built binary | | Linux ARM64 | ✅ | Build from source | | Windows (WSL2) | ✅ | Install script | | Windows (Native) | ❌ | Unsupported — uses Unix-only APIs (PTY, POSIX) | ### Requirements - **tmux** — persistent session management - **git** — worktree operations - **Claude Code CLI** — the `claude` command ### Live window source matrix | Provider | 5h burn | 7d window | Cost | Reset times | Source | |---|---|---|---|---|---| | Claude Code (Pro/Max OAuth + statusline wired) | ✓ | ✓ | ✓ | ✓ | OAuth-grade via Claude Code | | Claude Code (API key) | ✓ | — | ✓ | — | local JSONL fallback | | Claude Code (statusline not wired) | ✓ | — | ✓ | — | local JSONL fallback | | Codex | ✓ | — | ✓ | — | local JSONL fallback | | Other agents | — | — | — | — | not supported | **Why the asymmetry**: only Anthropic publishes rate-limit windows over OAuth, and only the Claude Code CLI exposes them to statusline hooks. Wiring `ainb claudecode statusline` brings the OAuth-grade signal into ainb-tui's Burndown panel and session-window top bar. --- ## Toolkit A portable AI coding agent toolkit: skills, agents, workflows, and configurations that deploy to 9 different AI coding tools from a single source. **[Full toolkit documentation → stevengonsalvez/ainb-toolkit](https://github.com/stevengonsalvez/ainb-toolkit)** ### Supported AI Tools | Tool | Deploy target | Method | |------|--------------|--------| | **Claude Code** | `~/.claude/` | Home directory | | **Codex** | `~/.codex/` | Home directory | | **GitHub Copilot** | `~/.copilot/` | Home directory | | **Gemini CLI** | `.gemini/` | Project directory | | **Amazon Q** | `.amazonq/rules/` | Project directory | | **Cursor** | Project root | Project directory | | **Cline** | Project root | Project directory | | **Roo** | Project root | Project directory | | **Clawdhub** | Project root | Project directory | ### Skills (91) Skills are reusable capabilities that any supported AI tool can invoke.

Workflow & Planning

`plan` · `plan-tdd` · `plan-gh` · `implement` · `validate` · `workflow` · `brainstorm` · `critique` · `discuss` · `expose` · `interview`

Code Quality & Testing

`commit` · `find-missing-tests` · `webapp-testing` · `security-audit` · `security-scan` · `simplify`

DevOps & Infrastructure

`start-local` · `start-ios` · `start-android` · `spawn-agent` · `tmux-monitor` · `tmux-status` · `expose` · `debug-bridge`

Knowledge & Learning

`reflect` · `research` · `research-cache` · `instincts` · `compound-docs` · `prime`

Session Management

`health-check` · `session-info` · `session-metrics` · `session-summary` · `handover` · `recover-sessions` · `plugins`

Swarm Orchestration

`swarm-create` · `swarm-join` · `swarm-inbox` · `swarm-status` · `swarm-shutdown` · `swarm-orchestration` · `swarm-agent-troubleshooting` > Sizing guidance: [Progressive subagents](https://stevengonsalvez.com/tools-tips/progressive-subagents) — score the work before you spawn eight agents.

GitHub & Issues

`gh-issue` · `make-github-issues` · `do-issues` · `merge-agent-work` · `list-agent-worktrees` · `attach-agent-worktree` · `cleanup-agent-worktree`

Design & Frontend

`ui-ux-pro-max` · `frontend-design` · `frontend-slides` · `tui-style-guide` · `tui-screen` · `liquid-glass` · `remotion-best-practices`

Research & Analysis

`crypto-research` · `oracle` · `notebooklm` · `sentry-cli` · `ats-resume-matcher` · `resume-formatter` · `retro-pdf`

Agent Architecture

`skill-creator` · `agent-ops` · `autonomous-loops` · `cost-aware-pipeline` · `media-processing` · `nano-banana-pro` · `sync-learnings`

### Agents (37) Specialized AI agents organized by domain. Each agent has a defined persona, tool access, and area of expertise. | Category | Agents | |----------|--------| | **Universal** | `backend-developer` · `frontend-developer` · `superstar-engineer` | | **Orchestrators** | `tech-lead-orchestrator` · `project-analyst` · `team-configurator` | | **Engineering** | `api-architect` · `architecture-reviewer` · `code-archaeologist` · `code-reviewer` · `dev-cleanup-wizard` · `devops-automator` · `documentation-specialist` · `gatekeeper` · `integration-tests` · `lead-orchestrator` · `migration` · `performance-optimizer` · `planner` · `playwright-test-validator` · `property-mutation` · `release-manager` · `security-agent` · `service-codegen` · `solution-architect` · `tailwind-css-expert` · `test-writer-fixer` | | **Design** | `ui-designer` | | **Swarm** | `swarm-leader` · `swarm-worker` | | **Meta** | `agentmaker` · `reflect` | | **Root** | `distinguished-engineer` · `web-search-researcher` | --- ## Knowledge System A two-tier learning system that captures insights during development and retrieves them across sessions and projects. | Layer | Technology | Purpose | |-------|-----------|---------| | **Fast local** | QMD (Quick Markdown Documents) | Semantic search over structured learning notes | | **Deep graph** | GraphRAG (nano-graphrag) | Entity-relationship graph with community detection for cross-project knowledge retrieval | The `/reflect` skill captures learnings. The `/research` and `/prime` skills retrieve them. The [`reflect`](https://github.com/stevengonsalvez/ainb-reflect-memory) Python library (installed as the `reflect` CLI) manages the knowledge base directly — it lives in its own repo, [stevengonsalvez/ainb-reflect-memory](https://github.com/stevengonsalvez/ainb-reflect-memory), and installs via `uv tool install --upgrade 'git+https://github.com/stevengonsalvez/ainb-reflect-memory.git[graph]'`. **[How the knowledge system works →](docs/knowledge/overview.md)** --- ## Architecture

``` agents-in-a-box/ │ ├── ainb-tui/ # Rust Cargo workspace │ ├── crates/ │ │ ├── ainb-core/ # TUI application (app, components, tmux, git, claude, config) │ │ ├── ainb-plugin-runtime/ # Plugin host runtime │ │ ├── ainb-plugin-protocol/ # Plugin JSON-RPC protocol │ │ ├── ainb-plugin-sdk-rust/ # Rust plugin SDK │ │ ├── ainb-plugin-types-sessions/ # Shared session types │ │ ├── ainb-plugin-burndown/ # v2 analytics plugin │ │ ├── ainb-plugin-notifyd/ # v2 notifications plugin │ │ ├── ainb-plugin-session-reader/ # v2 data-backend plugin │ │ ├── ainb-plugin-cts-v2/ # Conformance test suite (14 axes) │ │ └── ainb-plugin-testkit/ # Plugin author test harness │ ├── config/ # Homebrew formula & packaging │ └── install.sh # One-liner installer │ # reflect (the `reflect` CLI + GraphRAG/QMD engine and its Claude Code plugin) # now lives in a SEPARATE repo: github.com/stevengonsalvez/ainb-reflect-memory # — flattened, with the engine at its repo root and the plugin under plugin/. # ├── plugins/ # Claude Code plugins (root-level) │ ├── ainb-fleet/ # Backs the `ainb fleet` CLI (standup/broadcast/sequence/needs/daemon) │ └── ainb-hooks/ # ainb lifecycle hooks │ # The portable toolkit (91 skills, 37 agents, workflows, utilities, # bootstrap.js, external-dependencies.yaml, catalog.yaml) lives in a # SEPARATE repo: github.com/stevengonsalvez/ainb-toolkit — flattened at # its repo root. `ainb` consumes it as a pinned external source. # ├── ainb-tui/ # `ainb` binary (Rust) — TUI + skill-manager CLI │ ├── crates/ │ │ ├── ainb-cli/ # ainb source/skill/doctor subcommands │ │ ├── ainb-core/ # ratatui app + manifest/lockfile/URI types │ │ ├── ainb-fetch/ # git2 / http / local fetchers │ │ ├── ainb-adapters-source/ # marketplace / manifest / raw / single │ │ ├── ainb-adapters-tool/ # 9 tool adapters (claude/codex/copilot/…) │ │ ├── ainb-diff/ # Diff render + pager driver │ │ ├── ainb-skill-core/ # Manifest/lockfile/URI/paths/error │ │ └── ainb-usage/ # JSONL invocation parser + cache │ └── plans/skill-manager/spec.md # v1 design + acceptance criteria │ ├── docs/ # Documentation hub (Markdown source of truth) │ ├── README.md # Docs TOC │ ├── product/ # What ainb is, value, architecture │ ├── tui/ # ainb CLI reference, FAQ, keyboard shortcuts │ ├── toolkit/ # ainb-toolkit reference (skills/agents/bootstrap) │ ├── plugins/ # v2 plugin overview, user guide, authoring, spec │ ├── knowledge/ # reflect/recall (GraphRAG + QMD) │ ├── contributing/ # Build, CI/CD, release │ └── reference/ # Architecture deep-dive, glossary │ ├── website/ # Website source (Astro + Starlight) │ └── BRIEF.md # Design instruction for stevengonsalvez.github.io │ └── .github/workflows/ ├── ci.yml # Rust CI (fmt, clippy, test, deny, machete) ├── toolkit-validation.yml # Skill Manager & Catalog CI (ainb + ainb-toolkit) ├── release.yml # Cross-platform binary releases └── deploy-pages.yml # Build & deploy the website to GitHub Pages ``` --- ## CI/CD & Quality | Check | Tool | What it catches | |-------|------|-----------------| | Format | `rustfmt` | Style inconsistencies | | Lint | `clippy` (pedantic + nursery) | Logic errors, anti-patterns, code smells | | Test | `cargo-nextest` (Ubuntu + macOS) | Regressions across platforms | | Security | `cargo-deny` (RustSec) | Known vulnerabilities in dependencies | | Licenses | `cargo-deny` | Non-compliant dependency licenses | | Dead deps | `cargo-machete` | Unused crate declarations | | Toolkit structure | Custom validation | Package counts, template substitution, install verification | The Rust codebase enforces `unsafe_code = "forbid"` and runs clippy with `pedantic`, `nursery`, and `cargo` lint groups enabled. --- ## Development ### Building from source ```bash cd ainb-tui cargo build --release ./target/release/ainb ``` ### Running tests ```bash cd ainb-tui cargo test # Unit tests cargo test --features visual-debug # With terminal output cargo test --features vt100-tests # VT100 screen verification cargo nextest run # With nextest (parallel) ``` ### Linting & checks ```bash cd ainb-tui cargo fmt --check # Format check cargo clippy --all-targets # Lint cargo deny check # Security + licenses ``` ### Installing the toolkit Install is **additive** — units are deployed alongside whatever is already in your tool homes; nothing is wiped. Writes to the real tool dirs are opt-in via `AINB_USE_REAL_HOMES=1` (without it, ainb writes to a managed sandbox). ```bash # Register the toolkit as a source (fetches it and reports its unit count). ainb source add gh:stevengonsalvez/ainb-toolkit # Install the units you want into the real tool home dirs. AINB_USE_REAL_HOMES=1 ainb skill install gh:stevengonsalvez/ainb-toolkit/skills/commit # Scope an install to specific tools (passed to every mutating verb): ainb skill install gh:stevengonsalvez/ainb-toolkit/skills/commit --targets claude,codex ainb skill sync # reconcile installed units with the manifest ainb skill update --check # report drift across sources ainb skill update --all --yes # re-fetch + apply ainb skill remove gh:stevengonsalvez/ainb-toolkit/skills/commit # per-file uninstall, never touches config ainb doctor # health-check the deployment ``` > Prefer the TUI? Press `m` for the Skill Manager to browse + install units > with `[i]` and remove them with `[r]` — no manual URIs. See `ainb-tui/plans/skill-manager/spec.md` for the full §8 CLI surface (`source`, `skill`, `doctor`, `usage`). #### v1.1 — Discovery + adoption + promote If you already have skills under `~/./skills/` (Claude, Codex, Gemini, …) or plugins installed via Claude Code's `/plugin install`, you don't have to migrate by hand any more. v1.1 layers a read-only discovery walker + a one-keystroke adoption banner on top of v1. Open SkillManager (`m` on Home) with an empty manifest and `ainb` offers to import what's already on disk — marketplace plugins, orphan skills, the lot — including a conflict matrix when the same name shows up in two places. A new `ainb skill promote --to gh:user/repo` command turns a hand-edited orphan into a git-backed source in one shot: clones the target repo, copies the unit, commits + pushes, and rewrites the manifest URI from `local:` to `gh:`. - [Discovery flow reference →](docs/skill-manager/discovery.md) — walker classes, reconciler conflict matrix, banner UX - [`ainb skill promote` reference →](docs/skill-manager/promote.md) — command surface, locked design, failure modes - [`ainb skill usage` reference →](docs/skill-manager/usage.md) — per-unit invocation counts + last-used in the Detail pane (v1.2) - [`ainb skill sync` reference →](docs/skill-manager/sync.md) — bidirectional home ↔ repo reconciliation with `[s]` keybind (v1.2) - [`ainb skill check` reference →](docs/skill-manager/check.md) — drift detection + Units-panel status column (v1.2) Full spec at `.agents/goals/ainb-skill-manager-v1.1-discovery-spec.md` and `.agents/goals/ainb-skill-manager-v1.2-rollup-plan.md`. ### Contributing 1. Fork the repository 2. Create a feature branch (`git checkout -b feature/amazing-feature`) 3. Commit your changes (`git commit -m 'feat: add amazing feature'`) 4. Push to the branch (`git push origin feature/amazing-feature`) 5. Open a Pull Request --- ## Links - [Website](https://stevengonsalvez.github.io/agents-in-a-box/) - [Releases](https://github.com/stevengonsalvez/agents-in-a-box/releases) - [Homebrew Tap](https://github.com/stevengonsalvez/homebrew-agents-in-a-box) - [Issues](https://github.com/stevengonsalvez/agents-in-a-box/issues) - [Knowledge System Architecture](docs/knowledge/overview.md) - [Toolkit Repository (ainb-toolkit)](https://github.com/stevengonsalvez/ainb-toolkit) --- ## License MIT — see [LICENSE](LICENSE) for details.