Kaddo

Kaddo is an open-source Knowledge Driven Development (KDD) toolkit that helps new, pre-AI and legacy projects build a living knowledge layer close to the code. It structures product knowledge, manages the full Work Item lifecycle — from captured intent through implementation handoff, evidence and verification — and keeps knowledge alive as the system evolves.

The CLI prepares and structures context; your LLM agents turn it into product understanding. Token savings are a consequence, not the goal.

KDD Toolkit · CLI + MCP + Admin + Agents · Bilingual (EN/ES) · Open Source

kaddo

# Start a new project
$ npx @kaddo/cli init
$ kaddo bootstrap

# Prepare context for your LLM
$ kaddo scan
$ kaddo add agents
$ kaddo context

# Create a Work Item and go through the lifecycle
$ kaddo create —from roadmap
$ kaddo verify
$ kaddo guard
FYI src/payments/payments.service.ts matches WI-001
    WI-001 was not modified in this diff — consider reviewing it.

From scattered code to observable product knowledge.

Why Kaddo?

Your project already has knowledge. It is just scattered.

In new projects, decisions disappear fast. In pre-AI projects, context was never prepared for agents. In legacy projects, knowledge often lives in people’s heads. With AI, this gets worse: agents build on assumptions when they lack context.

Kaddo keeps the minimum necessary knowledge alive next to the code — without turning development into bureaucracy.

The Knowledge Model

Kaddo organizes knowledge into four layers: Business, Product, Tech and Delivery. Each feeds the next. Agents don’t guess — they read structured context.

Business

Problem, users, value proposition, constraints — why the project exists.

Product

Capabilities, decisions, quality attributes — what the system does.

Tech

Architecture, stack, codebase, ADRs, modules — how it is built.

Delivery

Roadmap, Work Items, build contract, evidence — when and how well it ships.

The Kaddo Lifecycle

Work Items follow the Kaddo-native Build Contract — a lifecycle that ensures every change is traceable from intent to verified delivery:

Captured Intent

An idea or external item becomes a Work Item draft — kaddo create or import from GitHub Issues, Jira or Azure DevOps.

Refinement → Ready

The work-item-agent enriches ACs, scope, affected modules. A human reviews and marks it ready.

Implementation Handoff

Agent-agnostic context assembly: design deliberation prompts, implementation instructions, recommended agent and skills.

Evidence → Verification → Learning

kaddo verify collects evidence, checks ACs against release gates, and captures learnings for future work.

Work Items physically move between directories: draft/ → ready/ → in-progress/ → completed/. The lifecycle is enforced by convention — no lock-in, no platform dependency.

Four Interfaces, One Knowledge Layer

CLI

Deterministic commands: init, scan, context, create, verify, guard, explain. No LLM, no API key. → Commands

MCP Server

Model Context Protocol server — exposes knowledge, lifecycle tools and agent prompts to IDEs and agents. → MCP Server

Admin

Web UI for Work Item management, integration configuration and import provenance. → Admin

Agents

LLM prompt packs: business, product, architecture, work-item, implementation, graph, capsule and more. → Agents

Integrations

Kaddo connects to external work systems through the Integration Adapter Foundation: discovery → import → refinement. Browse external items (GitHub Issues, Jira, Azure DevOps), import as Work Item drafts with human confirmation, then refine through the standard lifecycle. Secrets stay in environment variables and are never exposed.

Knowledge Capsules

For repos you can’t map as modules — other teams, restricted access, integration-only context — exchange Knowledge Capsules: kaddo capsule export shares a minimal summary; kaddo capsule add imports it as External Knowledge in the context pack. No multirepo mapping, no source access.

Choose Your Starting Point

New project

Start with structured knowledge from day one. → New project

Pre-AI project

Prepare an existing repo for humans and LLM agents. → Pre-AI project

Legacy project

Understand before changing risky systems. → Legacy project

See the full loop

The complete end-to-end workflow with expected artifacts. → Full workflow

Prefer to see it first? The Visual Guide maps the whole loop, the CLI/LLM split and Guard as diagrams. Not sure what Kaddo does and does not do? Read the Project scope.

Scale to Multirepo

Kaddo models systems that span many repositories. From the architecture repo you map secondary repos as modules and keep their knowledge close to the code:

kaddo modules map        # register a secondary repo as a module
kaddo modules list       # list mapped modules
kaddo add standards|security|stack|git-strategy   # global, system-wide artifacts

Per-module knowledge

modules map generates module-design, stack, security and standards artifacts under knowledge/tech/modules/<id>/.

Module-aware context

kaddo context and kaddo explain surface mapped modules and their artifact coverage.

Workspace Guard

Opt-in kaddo guard --workspace checks local mapped repos and flags possible drift.

Global artifacts

Standards, security, stack and Git strategy document cross-cutting concerns once.

Self-hosting

Kaddo builds Kaddo with Kaddo. The project uses its own lifecycle to manage Work Items, collect evidence, verify ACs and capture learnings. The knowledge/ directory contains Kaddo’s own product knowledge. This self-hosting validates the lifecycle end-to-end and ensures internal friction feeds back into improvements.

See It in Action

Four reproducible demo repositories ship with committed .kaddo/ and knowledge/ artifacts — each includes a prompt-flow.md with a Mermaid diagram and copy/paste prompt handoffs.

Task Pilot

Greenfield app · new — structured knowledge from day one; full loop.

Loyalty Lite

Existing app · pre-ai — scan + agents + a Guard drift demo.

Old Orders

Legacy MVC app · legacy — understand-before-change; risks & unknowns.

Commerce Stack

Many repos · multirepo — modules map + per-module artifacts.

Browse them in the Examples guide, or explore the Templates that capture minimum sufficient knowledge for each artifact.

Kaddo is a practical implementation of Knowledge Driven Development for AI-assisted software development — it applies KDD principles; it does not claim to have invented them.

Start with a repo that remembers

From new projects to legacy systems, Kaddo keeps product knowledge close to the code — and the lifecycle traceable.

Get started →