scbrown/tambo

Caboodle is becoming Tambo. The transition release includes both tambo and caboodle, backed by the same CLI. Existing plan and state paths remain compatible. New release archives use tambo-vVERSION-TARGET.tar.gz with a sibling SHA-256 checksum; supported archives contain both commands.

Repository and registry publication, package-manager migration, and installed host verification are separate release steps. The compatibility command stays available for at least one release.

tambo

🧰 Agent Platform Toolkit - installs and configures the quipu stack

Caboodle installs and configures a stack built around Quipu, a governed, bitemporal knowledge store for people and AI coding agents. Shared facts, decisions and work history stay available for your agents to query. Its CLI installs the tools from a reviewable plan and proves each one works; an agent skill guides you through the same workflow.

Why you would want it

• Give your agent memory and code context that survive a session.
• Review one plan, then resume installation if it is interrupted.
• Know each tool passed a functional check before you rely on it.

What the quipu stack is, and three ways to start.

Install

Checksummed archives

Checksummed releases: Linux x86_64, macOS arm64 and macOS x86_64. The installer verifies SHA256 before placing the binary in ~/.cargo/bin.

curl -fsSL https://raw.githubusercontent.com/scbrown/caboodle/main/scripts/install.sh | bash

To pin a release, pass the version to the receiving shell:

curl -fsSL https://raw.githubusercontent.com/scbrown/caboodle/main/scripts/install.sh | CABOODLE_VERSION=vX.Y.Z bash

Add the install directory to this shell’s PATH:

export PATH="${CARGO_HOME:-$HOME/.cargo}/bin:$PATH"

The export lasts for this shell only. To keep it, add the same line once to your shell’s startup file: ~/.bashrc for bash, ~/.zshrc for zsh (the macOS default). For bash:

echo 'export PATH="${CARGO_HOME:-$HOME/.cargo}/bin:$PATH"' >> ~/.bashrc

Apps started outside a terminal, such as the Claude desktop app or an IDE, may not read that file, which is why the agent step below registers servers by absolute path.

Or build the latest release from source with Rust (cargo install --git https://github.com/scbrown/caboodle --tag vX.Y.Z --locked). Either way, caboodle --version prints caboodle X.Y.Z for the release you installed.

macOS with Homebrew

brew install scbrown/tap/caboodle
caboodle --version

Homebrew owns the installed command; Caboodle still composes and verifies the stack. Update it with brew upgrade scbrown/tap/caboodle. To hold the installed version, use brew pin caboodle; resume updates with brew unpin caboodle. The tap channel guide explains the opt-in nightly channel and switching back to stable.

First success in three commands

Run these in a new, empty directory that will stay put. It is caboodle’s own working directory, NOT the repository you want indexed (that comes in Wire it into your agent). retrieval installs Quipu, Camayoc and Bobbin, which the agent step needs. To check prerequisites, Set QUIPU_SERVER to the intended authenticated server and obtain an issued token from its administrator before verification. Install it with caboodle provision-quipu-token --from /secure/issued-token --server . This proves acceptance and creates the canonical credential with 0400/0700 permissions; it refuses rotation of a differing existing credential. Then run caboodle doctor after plan in the same directory (with no plan it checks everything, which needs Go); it exits 0 when ready, and warnings do not block.

mkdir -p ~/caboodle && cd ~/caboodle
curl -fsSLO https://raw.githubusercontent.com/scbrown/caboodle/main/examples/caboodle-intent.toml
caboodle plan --profile retrieval --intent caboodle-intent.toml
caboodle install

Expected stdout on a fresh machine (downloads and progress go to stderr):

plan: caboodle-plan.toml
quipu: applied
camayoc: applied
bobbin: applied
stack configuration: applied
hook bundle bobbin: source tool
hook bundle quipu: source shipped copy
hook bundle NOT registered: `st` (shantytown) is not installed on this host. Install it and rerun `caboodle apply`; verify reports the bundles until then
vocabulary: quechua v0.1.0 cached at ~/.local/share/caboodle/vocabulary/quechua-ns-v0.1.0.ttl (no plan quipu_db to load into)
hook bundle NOT verified: `st` (shantytown) is not installed on this host, so no hook bundle is registered here
quipu credential: canonical file 0400/0700 and authenticated read verified; source: default ~/.config/quipu/token
quipu: verified
camayoc: verified
bobbin: verified

hook bundle lines are expected without Shantytown. Each verified is a passed functional round trip; the walkthrough covers recovery.

Success check: caboodle install exits 0 and prints : verified for every tool in the plan (quipu, camayoc, bobbin for retrieval). Recheck at any time with caboodle verify from ~/caboodle: same lines, exit 0. A failing tool prints : FAILED: … and the command exits nonzero.

The install leaves these in ~/caboodle: caboodle-intent.toml (downloaded above), caboodle-plan.toml (the reviewed plan) and .caboodle/ (install state). Keep the directory; verify, update and a resumed install read it.

On your own code

Full command and configuration reference.

Wire it into your agent

Tambo is a CLI, with an agent skill, not an MCP server. Bobbin, which the retrieval profile installed above, is one. It searches one repository: the code you want your agent to work on, such as your own project’s git checkout. Do not use ~/caboodle, which holds only the plan. Index that repository, then register bobbin from inside it:

cd ~/path/to/your/repo
bobbin init
bobbin index
claude mcp add bobbin -- "$(command -v bobbin)" serve "$PWD"

$(command -v bobbin) and $PWD are expanded once, now, so Claude Code starts the server by absolute path and serves this repository whatever its own PATH or working directory. Registering a bare bobbin fails with ENOENT when Claude Code was not started from a shell that has ~/.cargo/bin on PATH.

claude mcp add uses the default local scope: the server is registered for this project only, so start Claude Code in this repository to see it (claude mcp list there shows bobbin: ... ✓ Connected). Repeat the four lines in each repository you want searchable. bobbin init creates .bobbin/ in the repository and, if the repository has a .gitignore, appends .bobbin/ to it; review that change before you commit. Without bobbin init, bobbin serve exits with Bobbin not initialized and Claude Code reports the server as failed to connect.

MCP (Model Context Protocol) lets your agent call the installed server. Agent setup covers indexing, Yupana, other clients and managed crew registration through caboodle project-settings.

Before you start

Have curl, tar, git, bash, python3 and sha256sum on PATH (brew install coreutils supplies sha256sum on macOS). The everything profile also needs Go. No account or remote server is needed. Installation details cover source builds, installed files and removal; caboodle doctor names missing prerequisites.

What’s next

• Read the book
• Find a topic in the docs map
• Choose your profile

🧺 The stack

Caboodle installs these together and proves each one works; every tool also stands alone.

The Quipu stack is built around a governed, bitemporal knowledge store: shared facts, decisions and work history your agents can query. Quipu can check writes against your rules, records where each fact came from, and answers what was true when.

Contributing

just book
just check
just docs-check

📜 License

MIT