Appearance
Skill packs
A skill pack is the domain knowledge a Kadmo agent loads before it works on a product: how the app is laid out, which selectors and states each page has, how a role such as QA or Software Engineer works there, and the workflows that repeat common steps. Agents read packs instead of rediscovering your product in every session, and every session can leave the pack better than it found it. This page explains what a pack holds, where packs come from and which copy wins, how your account's own pack repository works, how Skill Discovery grows it, and how changes reach your agents.
What a pack holds
A pack is a folder of plain files in a git repository. Each top-level folder is one domain: a host such as app.example.com, or a knowledge area with no URL, such as billing-rules. Inside a domain, each subfolder is a module, usually one page or one area of the product.
| File | What it holds |
|---|---|
skill-pack.json | The domain's manifest: name, version, title, description, domain, what it requires (a browser, a model) and the roles it serves. |
_skill.md | The knowledge. At the domain root: what the product is, sign-in, navigation, the workspaces and repositories it belongs to. In a module: selectors, data model, states and gotchas. |
_roles/<role>.md | How a role works in this domain or module, for example _roles/qa.md (a test playbook) or _roles/se.md. |
*.yaml | Workflows: repeatable steps an agent or a person can run. |
index.json | At the repository root: every pack it contains, with its version. |
An account repository also has two folders at its root that belong to no domain: _roles/ for account-wide role guides, and _souls/ for personas, the voice a role takes in chat. See Roles and personas.
Each module's _skill.md carries a confidence between 0 and 1 that says how complete it is. A domain's completeness is the mean of its modules' confidence, and from it the app derives a readiness level:
| Readiness | Domain completeness | What the app suggests |
|---|---|---|
| Unknown | no module yet | Run discovery first |
| Discovered | above 0, below 0.90 | Run more discovery |
| QA-ready | 0.90 or more | QA jobs |
| SE-ready | 0.95 or more | QA and SE jobs |
| PM-ready | 0.98 or more | QA, SE and PM jobs |
Readiness is advisory. Below the threshold a job shows a warning, and the dispatch still runs.
Skill access is account-wide: every workspace in the account can use every domain in the account's pack. The links between a domain and your workspaces and repositories come from the domain's own _skill.md and are used for progress and organisation, never as access boundaries.
Four layers, one rule
Packs come in four layers. Each has one home.
| Layer | What it holds | Visibility | How it reaches your agents |
|---|---|---|---|
| The public library | Packs for common sites, tools and crafts, such as GitHub, Slack, Figma and writing | Public, Apache-2.0, at Kadmo-GmbH/kadmo-skill-packs | Every agent installs it and keeps it current |
| Kadmo's agent ops | The global role guides and personas, the workflows the playbooks start, and Skill Discovery | Private to Kadmo, delivered for use with Kadmo | Ships with the app; every agent fetches it with its own token |
| Kadmo's own packs | The knowledge of Kadmo's own products | Private | Kadmo's account only, connected like a customer's |
| Your account's pack | Your knowledge, roles, workflows and overrides of the defaults | Yours | Synced every 5 minutes |
Which copy wins. The app and the agents apply the same rule:
- A workflow defined twice resolves in this order: your account's explicit override, then your account's pack, then the agent ops, then the public library.
- A role guide in your pack extends the default guide of the same role, so you can tailor a role without copying its text.
- Each domain is installed once, with its layer, and a lower layer never replaces a higher one.
- When you edit a default workflow in the app, the save puts a copy into your account's pack, and your copy runs from then on. The shared default is never changed.
- The pack name
agentsis reserved.
The public library
The public library holds packs that any Kadmo agent can use: sites such as github.com, slack.com and figma.com, and crafts such as writing and marketing. It is Apache-2.0, so you may copy a pack into your own repository and change it as you need. Your own packs always come first on your agents.
The agent ops and Skill Discovery are not part of the public library.
Your account's pack repository
Every account has exactly one pack repository. Manage it on Settings › Skill Pack Repository (app.kadmo.ai/settings?tab=knowledge-packs).
The top card shows the pack's name, its source (Portal default, or Own with the git host), when it last synced, and Sync Now. Below it are the source URL and counts of Domains, Modules, Avg readiness and Workflows, then the Account Domains table with each domain's modules, average and minimum confidence, readiness, workspaces, repositories and last discovery.
Repository Source decides where the pack lives:
| Source | What it is |
|---|---|
| Portal default | A pack repository Kadmo hosts and manages for you. A new account starts with one, seeded with an example domain, the se and qa role guides and their personas. The app can always write to it. |
| Own repo (GitHub, GitLab or Bitbucket) | Your own repository. Connect the git host on Integrations first, then pick the Provider, enter the Repository URL (for example https://github.com/owner/repo.git) and the Branch (main by default). |
For your own repository, Portal write access decides whether the app may change it:
| Mode | What a save in the app does |
|---|---|
| Read-only (default) | Nothing: the app clones the repository read-only and its pack editors stay disabled. |
| Commit | Commits and pushes to the tracked branch. Needs a credential that can push, checked when you save the setting. |
| Pull request | Pushes an edit branch and opens a pull request for review. Needs a credential that can push, on GitHub or GitLab. |
Your git credential stays in the app and is never handed to agents. Agents use their own git access.
Switching the source replaces your current pack. The app first test-clones the new source. Then the previous source's domains and modules are removed and must be discovered again, its workflows are archived (automations that start them stop matching until the next sync), the roles and domains are read again from the new pack, and every connected agent clones the new repository on its next sync. The Switch skill pack source? dialog lists these consequences, and you confirm them before anything changes.
Browsing and editing in the app
Settings › Library › Skill pack (app.kadmo.ai/skills) is the pack browser, with four tabs: Overview (source, branch, last sync, counts, and the git change log), Domains (each domain, its roles and how complete each role is), Modules (every module, filterable by domain and readiness, weakest first) and Files (the whole repository at its latest commit, for admins).
An account admin can edit any pack file in the app, and create modules, domains, role guides and workflows. Each save is a git commit authored as you. See Editing in the app.
Capabilities › Skills shows what the agents in a workspace know: your pack's domains and their coverage, the base pack every agent carries, the public catalogue, and the workspace's own Claude Code skills.
Skill Discovery
Skill Discovery is the role that writes your pack for you. A discovery run sends one of your agents through your product and its repositories; it documents what it finds into _skill.md files with their confidence, adds role guides once a module is well covered, and publishes the result to your pack repository.
| How to start it | Where |
|---|---|
| One run on one domain | Capabilities › Skills, under Your pack: each domain row starts an Improve Skill Coverage run. Its menu offers Improve the weakest module, Discover what no module covers and Run with options…. |
| Repeated runs for a workspace | The workspace's edit page, Auto-discovery: set a Target confidence and Max dispatches, and the app keeps dispatching discovery jobs to the workspace's free agents until the target or the cap is reached. Run once starts a single job. |
A workspace needs an assigned agent that can run the Skill Discovery role. The run's output belongs to you and lives in your pack.
Skill Discovery itself is part of Kadmo's agent ops. Every account's agents receive it, at the same version as the runs that start it, and it is never public: it is not in the public library, not in public pack downloads, and not in a new account's repository. You can read what your own agents run, transcripts included. An account's own _roles/sd.md extends it for that account.
How agents get updates
| What changed | When your agents have it |
|---|---|
| Your account's pack (a save in the app, or a push to the tracked branch) | The app re-syncs at once; agents pick the commit up on their next sync, within about 5 minutes. No version bump is needed. |
| Kadmo's agent ops | With a Kadmo release. Each agent checks the ops version on its 5-minute sync and installs a new one when it appears. |
| The public library | With the agent's regular pack update. |
Agents read only the tracked branch, so a change on another branch, or in a pull request that is not merged, reaches no one. See Agents for how agents are provisioned and kept up to date.
Related
- Creating skill packs: the file layout, naming and publishing.
- Roles and personas: how a pack ships a role, and how agents get roles.
- Workspaces: where Auto-discovery is configured.
- Workflows: the YAML a pack ships.