skillos

Mission anchor: skillos is ZestStream's Skills Operating System: the capability control plane for AI-native pods. It turns skill libraries, Jeffrey's substrate, research-triad signal, and fleet outcomes into reliable, safe, validated, self-improving capability loops.

I'm Joshua Nowak. I build things that work.

I help SMB owners buy their time back.

Last month, your marketing person walked out the door

With them went the email cadence. The lead-routing logic. The answer to "why do we always send the welcome email Tuesday morning?"

You can hire a replacement. You can't hire back what they knew.

That is the problem skillos is built around. Most small and mid-sized businesses already have skills. They are trapped in the head of the person who holds the process together, in five SaaS tools that do not talk, in the checklist nobody trusts, or in the judgment call an experienced operator makes without writing it down.

Anthropic made the idea legible with its open Agent Skills standard. Jeffrey Emanuel made the raw operator stack real. skillos can run a portable public path on its own, and it can sit on top of Jeffrey Emanuel's stack when those tools are installed. Its job is to inventory the skills, classify their risk, route findings, harden repeated work into packs, and keep receipts when the system improves itself.

The arc is simple: turn company know-how into tested skills before it walks out the door.

The foundation is Jeffrey Emanuel's substrate

skillos does not pretend to have invented the floor it stands on.

Jeffrey Emanuel (@Dicklesworthstone) built the load-bearing tools I rely on: jsm for skill distribution, br for beads, ntm for multi-agent panes, cm/cass for memory, caam for account isolation, dcg for destructive command guardrails, ubs for quality scanning, Agent Mail for cross-agent coordination, plus the Frankensuite and connector work that keeps the stack honest.

My work here is the layer that makes those pieces useful for ZestStream and, eventually, for clients who do not want to operate the raw stack themselves.

Boundary rules are part of the product:

• skillos never edits JSM-managed skill content directly.
• skillos never runs jsm push for ZestStream-authored skills.
• Jeffrey's tools stay attributed to Jeffrey.
• Drift in the substrate gets reported and routed; it does not get silently patched around.

What skillos is

skillos is the capability control plane I use to turn agent work into durable company memory.

┌──────────────────────────────────────────────────────────────────┐
│  ZestStream worker pods                                          │
│  client repos · product repos · research panes · operator loops  │
│  Workers do the work. They ship outcomes and emit findings.      │
└────────────────────────┬─────────────────────────────────────────┘
                         │   findings, outcomes, callbacks
                         ▼
┌──────────────────────────────────────────────────────────────────┐
│  skillos                                                        │
│  Inventory. Routing. JSM safety matrix. Pack synthesis.          │
│  Research-triad ingestion. Validation. Receipts.                 │
└────────────────────────┬─────────────────────────────────────────┘
                         │   hardened skills, packs, doctrine
                         ▼
┌──────────────────────────────────────────────────────────────────┐
│  Jeffrey's substrate                                             │
│  jsm · br · ntm · cm/cass · caam · dcg · ubs · Agent Mail        │
│  flywheel-connectors · eidetic-engine · frankensqlite            │
└──────────────────────────────────────────────────────────────────┘

Workers work. skillos improves the engine around the work.

That distinction matters. A worker fixing a bug for a client is useful once. skillos asks whether the failure should become a skill update, a code pack, a guardrail, a bead, a launchd job, or a lesson that keeps the next repo cleaner.

Two stories from the trenches

A regional gym

Marketing person quit. Five disconnected tools: Canva, Mailchimp, Teams, Google Workspace, WordPress, ClubReady. A lead would land on the website, get forwarded to three email addresses, and die there. No CRM connection. No auto-response. No follow-up. No record that the lead ever existed.

I rebuilt the workflow with n8n and a curated stack of skills. Lead capture. Lead routing. Welcome cadence. Tour booking. Follow-up. Re-engagement. Each move became reusable. The next pod does not rediscover the same workflow from scratch.

What looked like "we lost our person" was really "the business never wrote the work down in a form a machine could run."

A regional insurance carrier

HubSpot plus four other systems. None of them talk. Adjusters carry one part of the process in their heads. Underwriters carry another. Ops carries the rest. Red flags only get caught by people who have seen them before. Duplicates pile up across the book.

I am building an aggregation layer powered by an AI swarm running curated and custom skills. It sits in the middle. Global search across the systems. Red-flag identification before the policy goes out. Dedupe across the whole book.

Each move is a reusable skill. The next insurance client gets the playbook on day one instead of day ninety.

How it works

skillos has four jobs.

1. Inventory the real skill supply. The JSM intake loop maps Jeffrey's skill surface into a local safety ledger. The current checked ledger has 145 mapped rows in state/jsm-surface-mapping.jsonl. My local machine currently exposes 103 skillos-jsm-* shim executables under ~/.local/bin/. Those are receipts, not slogans.

2. Route findings into work. Worker pods emit findings. skillos classifies them, checks whether the library already covers the issue, and routes the result to a bead, a pack update, a doctrine rule, or a no-op receipt.

3. Turn repeated work into packs. The local pack registry currently reports 131 code packs through skillos list-packs --json; recurring pattern mining is backed by 38 query patterns in DEFAULT_QUERY_PATTERNS. The number is less important than the behavior: repeated implementation shapes become inspectable packs with provenance instead of staying in scrollback.

4. Keep the repo honest. Dirty worktrees, stale shims, risky JSM mutations, missing receipts, weak evidence, and undocumented process gaps should become routed work, not daily background noise. That is why /git-repo-janitor belongs in the foundation: flagging dirt is observation; responsibly cleaning or routing it is the control plane doing its job.

Honest state

skillos is alpha. The JSM intake loop, skill inventory, pack registry, routing machinery, status surfaces, and several proof loops are real. The commercial-ready proof is not done until the evidence is stable enough for Joshua signoff and client-facing use.

The old README tried to inline the whole rev-7/rev-8/rev-9 spreadsheet. That belongs in the roadmap, not the front door. Current phase detail, dependencies, and exit criteria live in ROADMAP.md, docs/ROADMAP-DETAIL.md, and ARCHITECTURE.md.

What is still aspirational: a one-command installer, a finished SaaS product, a public marketplace, and any claim that an outside operator can clone this repo on a fresh machine and get my full stack without installing the underlying Jeffrey substrate. That is not true today.

Take it

If you are here to study the system, start with these:

• ARCHITECTURE.md for the component map and safety doctrine.
• ROADMAP.md for the phase plan.
• docs/case-studies/ for readable examples of repeated failures becoming durable work.
• state/jsm-surface-mapping.jsonl for the JSM intake ledger.

If you run Jeffrey's stack locally, the main entrypoint is:

PATH="$PWD/bin:$PATH" skillos doctor --json
PATH="$PWD/bin:$PATH" skillos list-packs --json
PATH="$PWD/bin:$PATH" skillos health --json

Storage substrate is governed by state/storage-101-doctrine-2026-05-23.md and state/STORAGE-MANIFEST.yaml. Before operating the full local loop, run:

.flywheel/scripts/storage-preflight-doctor.sh doctor --json

That preflight checks mem health, skills DB integrity, lock-orphan state, and the storage class registry before /tmp scratch or stale lock assumptions can leak into persistent CASS/JSM state.

If you do not run Jeffrey's stack, you can still clone this repo, read it, run the portable pieces, and adapt the patterns under the license. The boundary is operational maturity, not permission: this is public code, but it is not a one-command product yet.

The deal

Most consultants hand you a slide deck and leave. I hand you a working system.

If your business is bleeding time and you cannot see where, bring me one workflow that keeps eating your week. In 20 minutes I will tell you what I would build, what proof I would need, what it would cost, and whether I think it is worth doing.

Book a 20-minute Peel Session

For peer operators running Jeffrey's stack

Below the fold. If you do not run Jeffrey's stack, the rest of this section is mostly context.

Quick CLI reference

skillos is the canonical entrypoint. Project scaffolding stays under new; the MCP aggregator runs through the same command surface.

skillos new ./my-project --from-template minimal --json
skillos serve
skillos doctor --json
skillos health --json
skillos repair --scope code-packs --dry-run --json
skillos list-packs --json
skillos get-pack admin-page-nextjs --json
skillos audit ~/Developer/skillos --json
skillos index ~/Developer/skillos --json
skillos recurring --min-strikes 3 --json
skillos extractions --threshold 3 --json
skillos register-pack <name> <source-paths...> --mission-anchor-hash <hash> --json
skillos info --json
skillos examples --json
skillos schema --json

The old skillos-mcp command shape is now scoped as skillos serve for MCP stdio mode and regular skillos <subcommand> calls for diagnostics, registry queries, indexing, and extraction workflows.

Local CI

Use act on Orbstack as the canonical iterative validator before spending hosted GitHub Actions minutes:

make ci-local

The target runs:

act -W .github/workflows/ci.yml -j public-readiness --container-daemon-socket /var/run/docker.sock

The workflow push trigger is intentionally limited to main; arc-branch iteration should use local act, while pull requests and main remain the hosted CI gate.

Honesty box

This is public MIT-licensed code. skillos can run in two honest modes: portable public surfaces without Jeffrey Emanuel's local stack, and fuller local operation when jsm, br, ntm, cm, caam, and dcg are installed and configured. You can still download, inspect, run the portable parts, and adapt the system; the full local operating loop depends on those upstream tools.

Some paths are still local to my workstation. Portability means replacing those with documented defaults and clearer dependency checks so outside operators can run more of the repo without already sharing my machine setup.

Built on Jeffrey's stack

Component	Source	Role in skillos
Anthropic Agent Skills	Anthropic open standard	The skill format itself.
NTM	Dicklesworthstone/ntm	Multi-agent pane coordination.
UBS	Dicklesworthstone/ultimate_bug_scanner	Quality scanning before skill records harden.
frankensqlite	Dicklesworthstone/frankensqlite	SQLite patterns behind the state/ ledger and JSM integrity invariants.
eidetic_engine_cli	Dicklesworthstone/eidetic_engine_cli	Memory-engine reference for the CASS boundary.
flywheel_connectors	Dicklesworthstone/flywheel_connectors	Connector patterns for the .flywheel/ substrate that skillos extends.
jsm	Premium feed	Primary skill feed. skillos consumes JSM and respects JSM ownership.
br	Jeffrey's beads issue tracker	Task graph and mutation ownership.
cm / cass	Jeffrey's memory layer	Cross-session and codebase memory.
caam	Coding Agent Account Manager	Per-tool isolated auth profiles.
dcg	Destructive Command Guard	Destructive operations guardrail.
Agent Mail	Coordination and file reservations	Durable inter-agent messaging and reservations.

Brand

• Yuzu yellow-green: #CEE741
• Ink: #1A1B1F
• Cream: #F5F0E1

The README hero image in assets/brand/yuzu-hero.jpg is the current Yuzu workshop brand asset: mascot, workshop, toolbench, and AI-control-room imagery are visible.

License

MIT. You can download, use, explore, modify, and redistribute this repo under LICENSE. Some workflows require upstream tools or configured local services, but the repo itself is public and permission is not restricted.

Joshua Nowak, ZestStream. I build things that work. Receipts over promises.