Cambium AI

Cambium is a whole institute of AI specialists that scout, draft, and check the research work, then stop at human checkpoints so a person, not a model, makes the calls that matter. It is built for everyone the research enterprise runs on, from a solo PI to a sponsored-programs office to a classroom.

In one minute

Cambium is a research institute you run on your own machine. You give it a goal in plain language, it spins up the named specialists the job needs, and it walks the work from a funding call to a checked result. It stops at human gates so you, not a model, own every decision that counts.

• One sentence in, a real research process out: scouts, labs, an independent verification board, reporting, and governance, coordinated by an orchestrator.
• Honesty is plumbing, not a promise. Every concern about AI in research is wired to something that runs: a check in CI, a gate a person signs, a rule that stops the work before it ships.
• It teaches you as it goes. Every build produces a learning packet, and the Cambium Academy turns the core ideas into ten interactive modules.
• It is a Claude Code and Cowork plugin with an MCP server. Any field, MIT-licensed, runs in your own account with no third party in the middle.

Who it is for

Cambium is one governed institute with five ways in. Researchers are one of them, not the whole story. The volume is the machine's; the judgment stays with a named human at every gate.

Why Cambium exists

AI can read a thousand papers, draft a proposal, and run an analysis before lunch. It can also make claims it can't back up, cite papers that were never written, move faster than your judgment can keep up with, and quietly end up authoring the science it was only supposed to help with. In most settings that just wastes time. In research it corrupts the record, and that is a lot harder to undo.

Most tools answer this worry with a policy page. Cambium answers it with plumbing. Every concern people raise about AI in research is wired to something that actually runs.

Cambium keeps coming back to one rule: use AI to expand what a lab can do, but keep a human responsible for whether the work is valid, ethical, and right. Where a control is fully enforced, this README says so. Where it is real but not yet airtight, it says "partial," because overclaiming is the exact thing the project is trying to stop. The longer version lives in VISION.md and the ten-point AI_POLICY.md.

See it run

When a run starts, the institute comes to life in the chat. Agents wake up, do their piece, and report back. Then the whole thing pauses at a gate and waits for you.

Get going in a minute

# 1) Add the marketplace and install the plugin (Claude Code or Cowork)
/plugin marketplace add pkjaslam/Cambium_AI
/plugin install cambium-institute

# 2) Try it with no setup. A full plan, no API key, no calls.
/cambium run example

# 3) Run your own task the Cambium way
/cambium draft an NSF proposal on soil-carbon monitoring in dryland systems

That is the whole setup. /cambium draws a live board of the institute working, sends in the real agents, and stops at each gate with a clickable Approve, Revise, or Reject card. If you just want speed, /cambium-mode drops any task down to solo, with no councils and no gates.

Where it stores run data. Cambium keeps its run state, boards, and records with your project, never inside the installed plugin (which is read-only). By default that is the repo when you are developing from a clone, or a .cambium/ folder in the directory you run from. To put it somewhere specific, set the CAMBIUM_HOME environment variable and everything Cambium writes goes there.

Telling it what you want

The lifecycle, and the eight gates

Cambium covers the whole life of a project, and it puts a human checkpoint everywhere a real decision gets made. The gates aren't there to slow you down. They are where accountability actually lives.

At each gate the run stops, shows you a one-page summary, and waits. A quick "looks fine" doesn't get through. The Learning Gate asks for a real contribution from you, and the system spaces out back-to-back decisions so you can't rubber-stamp a project at full speed.

Human gates are enforced by approval-token checks (in tools/gate_lock.py) and the run contract in each agent's prompt. They are not a hard pipeline halt in the sense of an OS-level lock; a determined user could bypass them. The contract is prompt-level plus logged: every gate decision is written to the contribution ledger and the audit log, so the record is clear. Gate cards render as real clickable Approve, Revise, and Reject buttons (tools/gen_gate_card.py builds the full one-pager), with a type-it fallback if buttons aren't available in your client.

How it's put together

One Orchestrator. Eleven councils. Forty-six specialists, each good at one thing, and none of them grading their own homework. The verification board is independent, and whoever wrote something is never the person who approves it.

The councils are Orchestration, Pre-Award, Partnerships, Faculty, Scouts, Labs, Verification, Execution, Reporting, Support, and Governance. The Orchestrator breaks down your goal, calls in only the councils the task needs, runs them in parallel where it can, merges what comes back into one ranked decision, keeps the findings ledger, and runs the gates. You can always see which named agent is working, and on what.

What we engineered

This is where the work lives. The engineering is traceable to specific files.

Orchestration and task routing. The Orchestrator calls the right councils for each task and merges what comes back. The task router (tools/task_router.py) maps incoming requests to council sets and handles parallel dispatch. The run-board tools (tools/gen_inline_board.py, tools/gen_board_pro.py) render a live agent board in-chat and as a standalone HTML file, so you can always see which agent is active and what it found. tools/run_state.py reprints the board fragment at each phase change so it stays live instead of freezing after the first act.

Human-gate machinery and the audit trail. Gate logic lives in tools/gate_lock.py, which writes approval tokens to the run ledger and blocks downstream steps until they are present. The contribution ledger (governance/GATES.md) records every gate decision: who approved, when, and what the summary said. tools/audit_log.py appends a structured entry for every significant agent action. Records are plain markdown, not cryptographically signed, and the enforcement is prompt-level plus token-checked, not a hard OS lock.

Four-tier evidence contract and integrity audit. Every claim in a run output carries a tier: Proved, Code-verified, Asserted, or Open. governance/validate.py checks submitted ledger entries against the evidence contract and fails the build if a claim exceeds its evidence. It does not auto-verify claims mid-run; it checks what agents submitted against the rules after the fact. tools/finding_audit.py audits the full findings ledger for tier consistency and flags open items.

Memory and a local knowledge graph. tools/memory_recall.py stores and retrieves session context from a gitignored cache. tools/concept_graph.py builds a fully-local knowledge graph over Cambium's own curated records (findings, gates, agents, concepts) using typed edges. Multi-hop queries (neighbors, shortest path, what-supports, what-contradicts) work on top of it. The graph uses networkx when present and a pure-stdlib adjacency fallback otherwise. No external database is required; the graph lives with the project. Writable caches are routed through data_home() in tools/cambium_io.py so an installed (read-only) plugin writes to the user's project directory, not into the plugin itself.

Learning system. tools/learning_delivery.py generates a per-run learning brief and enforces the Learning Gate: a build or analysis run cannot close without producing one. The check is deterministic, but enforcement is prompt-level: closeout.py treats it as a repo-tidy CI signal, not a hard run veto. A deliver subcommand prints the packet straight into the chat instead of only filing it. tools/gen_learning_lab.py produces an interactive per-run Learning Lab as a self-contained HTML file. The Cambium Academy (academy/index.html) is ten interactive modules across three tiers, built on evidence-based instructional design: predict-first, spaced repetition, explain-it-back.

Research-administration tools. tools/ai_disclosure.py assembles an AI-use disclosure and audit summary from records Cambium already keeps (gate decisions, approvers, which agents ran). It documents what AI did and that a human signed off; it does not certify compliance. tools/budget_review.py is a deterministic budget-to-solicitation review that flags issues (F&A cap, cost ceiling, period, required sections, disallowed categories, cost-share) against a solicitation-rules file. Four more generic, advisory helpers round this out: tools/budget_narrative_match.py flags where a budget and its justification narrative disagree, tools/checklist_builder.py turns a solicitation's rules into a submission checklist, tools/proposal_timeline.py backwards-plans a proposal's deadlines and tasks, and tools/solicitation_explainer.py renders a solicitation into a plain-language summary. All are advisory by design: the final call stays with a human in sponsored programs.

Run fidelity and self-inventory. tools/gen_tool_index.py builds tools/TOOL_INDEX.md, an auto-generated inventory of every tool in the repo, so the Orchestrator (and you) can check what already exists before improvising something new. tools/sync_version.py stamps one version number into every manifest and the README badge, with a --check that CI enforces. The run-board GIF is a frozen committed artifact, regenerated only by hand via assets/gen/gen_runboard_gif.py, and the README stats block and capabilities SVG each carry a --check freshness command that CI runs, so the derived numbers stay honest between releases.

Full-stack engineering. Nine skills added in v1.29.0 cover the software engineering lifecycle: ai-application-engineering, backend-api-design, databases-and-data-modeling, software-architecture, software-testing-qa, debugging-observability, devops-cicd, cloud-deployment, and security-engineering. These skills advise and generate code that a human reviews and runs; Cambium does not deploy to production, hold secrets, or perform security audits. Shared conventions and the reasoning behind each skill live in docs/engineering_conventions.md.

Skills and features: built and adopted

Cambium is honest about what is original engineering and what borrows from prior work.

Built in-house

• The council architecture and the named specialist agents (46 agents across 11 councils, each scoped to one role)
• The task router and Orchestrator dispatch logic
• The gate machinery: approval-token checks, the contribution ledger, the audit log, and clickable gate cards with a type-it fallback
• The four-tier evidence contract as an integration: the tier system, the CI validator, and the finding audit
• Memory and the local knowledge graph: session recall plus a structured, multi-hop-queryable graph over run records, deliberately lightweight and dependency-minimal
• The learning system: per-run Learning Lab generation, the enforced Learning Gate, and the ten-module Academy
• The writable-data resolver (data_home()) that makes the plugin work as a read-only install without breaking run state
• The research-administration tools: the AI-use disclosure builder, the deterministic budget reviewer, and the four generic proposal-support helpers (budget-narrative match, checklist builder, timeline planner, solicitation explainer)
• The release-hygiene automation: one version stamped everywhere, visual assets regenerated on push, and an auto-generated tool index

Adopted, with attribution

• Skill-authoring structure (anatomy of a SKILL.md file: trigger-rich description, numbered process, anti-rationalization table, exit criteria, red flags): structural patterns adapted from addyosmani/agent-skills (MIT). Two engineering skills were also adapted from that repository. No verbatim files were copied. Full credit in ATTRIBUTION.md.
• Four-cost loop guard (tools/loop_costs.py): the four silent costs of autonomous loops (verification debt, comprehension rot, cognitive surrender, token blowout) are a framing drawn from Loop Engineering research. The implementation is ours.
• Open Knowledge Format export (tools/okf_export.py): portable run-findings bundles inspired by Google's OKF format. Plain markdown with YAML frontmatter, cross-linked, with a self-contained graph viewer.
• Run-outcome prior (tools/run_outcome_prior.py): a heuristic prior that predicts a run's likely cost and risk from past run history, inspired by V-JEPA-style world-model framing. It is a prior, not a learned world model, and it refuses to fabricate a risk rate on a small sample.
• Local knowledge graph design (tools/concept_graph.py): built after reviewing GraphRAG, Graphiti, MemPalace, and LightRAG and deliberately not adopting any of them. GraphRAG needs a cloud LLM per query, Graphiti and Neo4j need a running database, and all of them break the git-auditable guarantee. Cambium's graph uses networkx when available and a pure-stdlib fallback otherwise.
• Render-video (skills/render-video): calls the separately-installed OpenMontage tool (AGPLv3) across a process boundary. OpenMontage is not bundled; it must be installed by the user. The process boundary keeps Cambium's MIT license clean.
• TaMPER framework (University of Idaho): the disclosure record, FAIR data descriptor, and rules handoff (tools/tamper_record.py, tools/fair_descriptor.py, tools/rules_handoff.py) adapt ideas from the TaMPER framework. Full credit in ATTRIBUTION.md.
• Microsoft Presidio (MIT, optional): the PII and regulated-data screener (tools/pii_screen.py) uses Presidio when it is installed and falls back to a pure-stdlib regex screen when it is not, so the check runs with no required dependency.
• MindRouter (roadmap, not yet adopted): a sovereign, FERPA-safe inference path with the University of Idaho's MindRouter is on the roadmap, listed honestly as not yet wired.

Responsible AI, built in

The honesty here isn't a tone of voice. It's closer to a type system for claims. Every factual statement an agent makes has to carry a tier, and CI (governance/validate.py) fails the build if a claim reaches past its evidence.

Around that contract sit the controls from the diagram above. A citation that doesn't resolve is a release blocker, not a warning. A scanner watches for PII and regulated data. A bias checklist (NIST AI RMF) has to be done before the results gates. A pace check keeps decisions from stacking up. An audit trail records every turn, and a named human signs every gate in governance/GATES.md.

Not every check needs to trust a model, and we say which ones do. Right now 12 of 18 verification checks are grounded in something a skeptic can verify without any LLM: arithmetic that either sums or it doesn't, a citation or DOI that either resolves or it doesn't, against OpenAlex, Crossref, and doi.org. The other 6 are the genuinely hard judgments where a model or a human still forms the call. The full split is in CHECKS.md.

We hold ourselves to the same standard. We graded Cambium against the field's ten most common worries, and it comes out 3 Leads, 6 Partial, 1 Gap. We left the Partials and the Gap in plain sight instead of rounding them up. The enforcement study we pre-registered and ran came back Open: we have not measured a real effect yet on a near-ceiling model, and we shipped the harness and the null rather than dressing it up. The details are in POSITIONING.md, evals/enforcement_study/, and the live evaluation dashboard.

The bridge in web/server/app.py is real and verified end-to-end in simulation mode (the shipped default): streaming, gate pause/resume, and the REST endpoints pass 15 tests via an in-process TestClient, and CI runs them. The live-agent seam (run_agent_live in web/server/engine.py) is deliberately NotImplementedError: no real agent has crossed the bridge yet. Wiring it, the cinematic frontend, and a full offline institute simulation are all roadmap, not built. Cross-institution shared infrastructure (SSO and RBAC) is also roadmap, listed honestly in ROADMAP.md.

Capacity and strength

40 skills, 121 tools, 10 MCP tools, 21 templates (reusable files in templates/, excluding runtime artifacts and the project/ scaffold), and a set of worked examples. All field-agnostic, all runnable.

Those numbers reflect what is in the repo today. The skills cover the full research lifecycle from intake to publish, plus domain specialties (statistics, ML, optimization, health, citations, ethics). The tools cover orchestration, gating, evidence, memory, learning, research-administration, and self-grading, and tools/TOOL_INDEX.md is an auto-generated inventory you can browse instead of guessing what exists. The MCP server exposes ten core operations (plan, provision, roster, doctor, grade, validate, dispatch, fidelity, recall, graph) so any MCP-capable client can drive the institute. The templates give every project a consistent paper trail from RFP brief to closeout checklist.

What they enable: anyone from a solo PI to a sponsored-programs office to a classroom can run a structured, multi-agent, gate-controlled research project without writing any orchestration code. The councils handle parallelism. The gates handle accountability. The learning system means the work also teaches. The test suite confirms the machinery holds under changes.

Learn by doing

A research institute should also teach. The Cambium Academy is ten interactive modules across three tiers. The five Foundation modules cover the ideas you need to run the institute well: the Cambium way, evidence tiers and honest claims, why a human gate beats full autonomy, verifying a result without fooling yourself, and research ethics and data stewardship. On top of those sit Practitioner modules (grant writing, a data-stewardship workshop, reproducibility in practice) and Expert modules (designing custom agents, teaching research with Cambium).

The mechanics are borrowed from evidence-based instructional design: you predict before you see the answer, flip spaced-repetition flashcards, click through the architecture instead of staring at a wall of text, do a small change yourself, and explain each idea back in your own words. External "Go deeper" links point to real courses at Coursera, the Princeton leakage and reproducibility workshop, OHRP, and others. We link out to those, we don't copy them. Every run also produces a per-run Learning Lab, and teaching is enforced: a build or analysis run cannot close without delivering one, straight into the chat.

Two honest limits worth knowing. The Practitioner badge is designed and wired to the course logic, but it does not yet mint automatically from a run's artifacts. And the spacing schedule is stored per browser, not per account, so if you switch devices mid-sequence you'll need to restart. Everything else runs today.

How it stacks up

Cambium isn't trying to be a faster assistant. It's trying to be the part of the lab that keeps the science honest while the AI handles the volume.

For teams

Multi-PI projects get named, institution-scoped approvers, so a gate won't pass unless the right Co-PI signs it (templates/MULTI_PI_ROLES.yml). There's also a model router that sends the hard reasoning to the strongest model and routine work to a cheaper one. Shared infrastructure across institutions (SSO and RBAC) is the honest gap right now, and it's staged out in ROADMAP.md. For the office that actually has to approve this, there's a one-time institution profile (approved funders, data-handling rules, budget ceilings, named approvers) that the validator checks, plus a one-meeting governance approval packet a committee can read and sign. Both live in governance/institution/.

Models and tokens

A common worry is that an institute of agents must be token-heavy. The direction is routing, not more spend. On the roadmap, frontier models would handle the hard, gate-critical steps, and capable open models the routine bulk: summaries, formatting, drafts, retrieval. Most of the volume is the routine kind, and open models can run on your own machine, so most of the work never leaves your environment and never meters a token. The per-task router exists today; the frontier-plus-open mix is on the roadmap.

What's next

Soon: actually run the v1 enforcement study, the powered, human-judged version. The task set, the rater tool, and the analysis are built and waiting on people and budget. After that, more work on reproducibility. Further out: shared infrastructure for multi-institution grants, and a cinematic web front-end that drives the same gated engine. Nothing reaches that list without the same evidence contract pointed back at it.

Recent updates

• 1.44.1: Hotfix: the new UX tests decode child output as UTF-8, fixing the Windows CI legs
• 1.44.0: The run you can always see: same-turn gates and a board that fits the chat
• 1.43.0: Honesty resync: the README matches the code again, and the Academy move-out is committed

Contributing and license

Contributions are welcome. Start with CONTRIBUTING.md, which explains the branch-and-pull-request workflow and the pre-push checklist. Cambium is released under the MIT License.