The control plane for agents that need to remember, execute, verify, and evolve.
Most agent frameworks help you call models, tools, or subagents. Skill System (SK) is built for the layer after that: durable work. It gives an agent a public CLI, project memory, ticket lifecycle, behavior contracts, review handoff, and the self-improvement loop needed to survive beyond one prompt.
git clone https://github.com/arthur0824hao/skills.git
cd skills
./sk init --mode minimal
./sk statusAgents fail less from lack of intelligence than from weak operating systems:
- they forget what happened last session
- they skip the boring verification step
- they lose ownership boundaries across workers
- they close work without evidence
- they repeat raw shell maneuvers that should have become tools
SK turns those weak spots into explicit surfaces.
| Problem | SK surface |
|---|---|
| "What is true right now?" | sk status, TKT, Review, Graph |
| "What did we learn last time?" | sk mem, Memory MCP |
| "Who owns this work?" | sk tkt, bundle lifecycle |
| "Is this behavior specified?" | Behavior specs and contracts |
| "Can I reuse this maneuver?" | CLI wrappers, skills, myelin inventory |
| "How does the agent improve?" | Soul, Insight, ANS, Pgysiology |
./sk status
./sk tkt list-bundles
./sk mem search "router guard"
./sk behavior generate --help
./sk dashboard --oncesk is the public API. Router, workflow, tickets, memory, review, and skill internals stay behind it.
Project-scoped PostgreSQL memory with search, MCP tools, metadata, and audit-friendly writes. SK treats memory as a project asset, not a chat transcript side effect.
TKT gives agents a work lifecycle: create, claim, block, close, verify. Closure requires evidence, not confidence.
Skills are expected to move through:
Spec -> Test -> Develop -> Contract
This keeps agent-built tooling from turning into unreviewable prompt folklore.
SK is growing an organism model for long-lived agent systems:
- Soul: behavioral profile and identity calibration
- Memory: hippocampus and durable recall
- ANS: autonomic wake/reflex/cron layer
- TKT: motor-task lifecycle
- Pgysiology: the emerging method for growing agents with Pain sensing, myelination, limbs, reflexes, and self-evolution
./sk init --mode minimal
./sk status./sk mem status
./sk mem search "deployment drift"
./sk mem store --help./sk tkt create-bundle --goal "Add a memory-backed debug workflow"
./sk tkt list-bundles
./sk tkt claim --ticket-id TKT-001
./sk tkt close --help./sk behavior generate --help
./sk gate validate| Skill | Role |
|---|---|
skill-system-cli |
Public sk command families |
skill-system-router |
Internal skill routing and guard checks |
skill-system-memory |
PostgreSQL memory + MCP surface |
skill-system-tkt |
Ticket and bundle lifecycle |
skill-system-behavior |
BDD specs, structural checks, contracts |
skill-system-review |
Review handoff and Prometheus/TKT bridge |
skill-system-soul |
Agent behavioral profiles and evolution arena |
skill-system-ans |
Autonomic sensors, wake prompts, cron/reflex metrics |
skill-system-debug |
Debug sessions, hypotheses, lessons |
skill-system-dashboard |
Operator dashboards from graph/ticket/memory data |
See skills/skills-index.json for the generated capability index.
Emerging work:
| Skill | Role |
|---|---|
skill-system-pgysiology |
Portable organism-building methodology for self-evolving agents |
flowchart LR
Operator[Operator or Agent] --> CLI[sk CLI]
CLI --> Router[Router]
Router --> TKT[TKT Control Plane]
Router --> Memory[Memory / MCP]
Router --> Behavior[Behavior Contracts]
Router --> Review[Review Bridge]
Router --> Skills[Domain Skills]
TKT --> Review
Memory --> Insight[Insight / Soul]
ANS[ANS Reflex Layer] --> CLI
Pgysiology[Pgysiology] --> ANS
Pgysiology --> Skills
Design boundaries:
- Public surface:
sk - Canonical work state: TKT and project DBs
- Recall: project memory database
- Verification: behavior specs, tests, gate rules, review bundles
- Evolution: friction -> script -> skill -> MCP/ANS reflex
- you run multi-agent coding or research loops
- you need agents to hand off work across sessions
- you need project memory with DB-level accountability
- you want scripts and skills to be discoverable rather than tribal knowledge
- you care about close evidence, not just completed-looking prose
- you are building agents that should improve their own operating system
skills/ Skill packages
config/ Runtime config
note/ Human-facing intake and persistent project rules
.tkt/ Bundle and ticket lifecycle
review/ Canonical review handoff artifacts
docs/ Architecture and contracts
dashboard/ Generated/operator dashboards
evals/ Evaluation fixtures
sk Public CLI wrapper
SK is an active research-engineering system. Some modules are stable operator surfaces, while others are deliberately experimental.
Stable enough to build on:
skCLI- memory search/store/status
- TKT bundle lifecycle
- behavior contracts
- review handoff
- dashboard generation
Actively evolving:
- ANS reflex composition
- Pgysiology portable organism bootstrapping
- myelin registry and MCP affordance routing
- cross-runtime opencode/Codex/Claude integration
- System Architecture
- DB Targeting Standard
- Memory Truth Lifecycle Contract
- Skill Maturity Matrix
- Host Plugin Packaging Contract
- Review Bundle
SK treats agent engineering as physiology, not prompt decoration.
Direct shell is muscle-cell stimulation. Scripts, CLI commands, skills, MCP tools, and ANS reflexes are whole-muscle commands. Exploration starts with raw movement; production work should become myelinated.
The goal is not to make an agent sound alive. The goal is to give it the body mechanics required to keep working when memory, context, tools, and limbs drift.
MIT. See LICENSE.