# AI use cases for Cambium (KimGLee/Cambium)

Repo: [KimGLee/Cambium](https://github.com/KimGLee/Cambium) | Use cases: 3 | Page: https://dedupedai.com/use-cases/kimglee-cambium/

Cambium is a Python governance standard and toolset that keeps knowledge repositories maintained by LLM agents scoped, resumable, and under operator control.

This file holds every use case of this repo. Each one starts with a "## " heading and ends with its URL.

- Adopt Cambium governance for a knowledge repository: https://dedupedai.com/use-cases/kimglee-cambium/adopt-governance-for-knowledge-repo/
- Resume an interrupted corpus task without guessing: https://dedupedai.com/use-cases/kimglee-cambium/resume-interrupted-corpus-task/
- Plan a long multi-batch corpus task with a Task Plan: https://dedupedai.com/use-cases/kimglee-cambium/plan-multi-batch-corpus-task/

## How to adopt Cambium governance for a knowledge repository with Cambium

Repo: [KimGLee/Cambium](https://github.com/KimGLee/Cambium) | Difficulty: Advanced | Time: 2 hours | Basis: From the README

Create, validate, and approve one Cambium profile for one knowledge repository.

**Who it is for:** A knowledge-base operator who wants LLM agents to edit a repository under explicit rules and must first approve the governing profile.

**The problem:** Agents editing a shared corpus have no agreed rules, scope, or record of who approved what.

**The outcome:** The repository has one approved profile bound to a recorded Standards identity, and the operator knows which decisions remain theirs.

### Steps

1. Run `python3 Tools/scaffold_profile.py . --profile-id my-profile` as a dry run to preview the candidate profile.
2. Run `python3 Tools/scaffold_profile.py . --profile-id my-profile --apply` to create `profiles/my-profile/profile.toml`.
3. Have the agent use profiles/interview.yaml to answer the open decisions with you, then run `python3 Tools/profile_onboarding_status.py . --profile-id my-profile --json` and `python3 Tools/check_profile.py profiles/my-profile`.
4. Prepare a plan from Tools/schemas/profile_adoption_plan.template.yaml, then run `python3 Tools/apply_profile_adoption.py . --plan <plan>.yaml --upstream-root <upstream-root> --upstream-ref <upstream-ref>` as a dry run. (inferred, check the README)
5. Run the same command with `--apply` added to approve the profile through R09.

### Prompt to paste into your agent

```text
In the Cambium repo at <repo-path>, guide me through creating and checking a candidate profile for the knowledge repository at <target-path>, then stop before adoption. Report the output of profile_onboarding_status.py and check_profile.py and list every decision still unanswered.
```

### Caveat

Copying a template or example does not select a profile, and a successful check does not approve it, so the operator must complete the R09 adoption step explicitly.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/kimglee-cambium/adopt-governance-for-knowledge-repo/

## How to resume an interrupted corpus task without guessing with Cambium

Repo: [KimGLee/Cambium](https://github.com/KimGLee/Cambium) | Difficulty: Intermediate | Time: 30 minutes | Basis: From the README

Check recorded runtime state before any agent writes to a half-finished knowledge corpus.

**Who it is for:** An operator whose agent session stopped mid-batch on a repository that already has Cambium runtime state.

**The problem:** Restarting an agent on a partly changed corpus risks duplicate or conflicting edits.

**The outcome:** The operator sees the recorded task, locks, holds, in-flight batches, and the exact next action before anything is written.

### Steps

1. Run `python3 Tools/check_queue.py . --resume-status` from the repository root before writing anything.
2. Read the reported task, locks, holds, in-flight batches, and recovery state.
3. Follow the reported `next_action` only, and do not run init commands over existing `.cambium/state/`.
4. Run `python3 Tools/check_queue.py .` after the step to confirm the Queue is consistent.

### Prompt to paste into your agent

```text
In the Cambium-governed repo at <repo-path>, run the resume status check and report the recorded task, any locks or holds, and the exact next_action. Do not write any files. Verify that the check reports no errors before you propose the next step.
```

### Caveat

This is only useful after Cambium state exists in the repository, and the README warns not to edit canonical state by hand.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/kimglee-cambium/resume-interrupted-corpus-task/

## How to plan a long multi-batch corpus task with a Task Plan with Cambium

Repo: [KimGLee/Cambium](https://github.com/KimGLee/Cambium) | Difficulty: Advanced | Time: 1 hour | Basis: From the README

Publish a confirmed Task Plan and compile a resumable Queue for large corpus work.

**Who it is for:** A knowledge-base operator starting long-running, multi-batch agent work that must survive interruptions.

**The problem:** Large corpus changes done without a confirmed plan and persistent queue are hard to resume and audit.

**The outcome:** The task identity, scope, Standards, and batch manifests are recorded once, and the Queue is compiled and checked.

### Steps

1. Copy the template with `cp Tools/schemas/task_plan.template.yaml .cambium/deltas/task-plans/TP-001.yaml` and complete it with the operator. (inferred, check the README)
2. Run `python3 Tools/init_state.py . --plan .cambium/deltas/task-plans/TP-001.yaml` as a dry run, then add `--apply`. (inferred, check the README)
3. Run the exact `compile_queue.py` command printed by init_state.py, which carries the Queue revision and SHA256 bound to the Task Plan.
4. Run `python3 Tools/check_queue.py .` and `python3 Tools/render_queue.py .` to verify and view the Queue.

### Prompt to paste into your agent

```text
In the Cambium repo at <repo-path>, help me complete a Task Plan at .cambium/deltas/task-plans/TP-001.yaml for the corpus at <target-path>, then run the dry-run init_state.py command. Report the printed compile_queue command and the check_queue result, and do not apply anything without my confirmation.
```

### Caveat

Cambium does not ship agent dispatch or scheduling, so the Queue records work and evidence but agents still have to be run and supervised by the operator.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/kimglee-cambium/plan-multi-batch-corpus-task/