Skills

Between one judgment and an open-ended goal sits a large amount of work whose shape is already known. Weekly dinner planning needs candidate generation, composition, critique, and exact allergy checks. The capability "compose a provisional week from household constraints" does not need to be rediscovered on every agent run. That middle layer is a skill.

Most product architecture lives here. Agents pursue goals. cognitive units decide point questions. Skills package the procedures teams already trust: named inputs, known ordering, explicit seams, recoverable failure modes, and evaluation that covers the whole capability rather than a single leaf judgment.

Helpful context: Decide, perform, pursue places skills in the perform role. What is a cognitive unit owns single judgments inside a skill. What is an agent owns goals that call skills. This page is the canonical skill definition.

The perform responsibility

A skill is not the medium rung in a hierarchy of model calls. It may contain many cognitive units invocations and still have no agency. Agency begins when evidence can change what work to undertake next, when someone must declare that a goal is sufficiently met, and when review vocabulary includes accept, patch, replan, ask, escalate, and stop. See acting is not agency.

A small loop remains an agent if it must decide what to attempt next and when the goal is sufficiently achieved. See responsibilities, not sizes. The comparison that matters is ownership, not weight. A cognitive unit owns one open judgment and answers whether it decided well. A skill owns a known procedure and answers whether it performed the capability correctly, including seams between steps. An agent owns progress toward a goal and answers whether it achieved an acceptable trajectory through designed stopping. That ownership question settles boundary disputes faster than any metric about prompt length or model cost, because responsibility is stable across implementation changes while size fluctuates with every template revision.

A cognitive unit decides. A skill performs. An agent pursues.

The cognitive unit · Ch. 16

Meal planning skill

In the Weekly Meal Companion, a Compose Weekly Plan skill calls GenerateCandidates for declared evenings, invokes ComposeWeek with endorsed household knowledge, runs deterministic schema and allergy validation, and returns a provisional plan artifact to the agent's working state.

Answers vary. Different households, different weeks, different constraints. The shape of the work largely does not. Candidate generation precedes composition. Validation follows composition. Critique may run before handoff. That ordering is procedure, not pursuit.

The agent still owns whether the week is accepted and what happens after CritiquePlan finds a weakness. The skill performs assembly. The agent pursues review and revision at the goal level. Collapsing those layers creates either a composite cognitive units or a faux agent with no stop design.

Invoice extraction skill

The cognitive unit uses invoice verification the same way. Retrieve invoice and purchase order. Interpret fields through named cognitive units. Calculate variance. Judge materiality. Persist structured results with deterministic gates before and after each acting step.

Judgments sit in cognitive units. Ordering, seams, side effects, and recovery sit in the skill. A field interpreter can be substituted without rewriting the whole extraction procedure. A seam test can fail while every leaf cognitive unit passes its suite. That separation is why skills exist. See a skill may contain cognition.

What a skill owns

A skill owns a name that names the capability, not a single decision inside it. "Extract structured invoice" is a skill name. "Judge materiality" is a cognitive unit name. The name carries a callable contract with inputs and outputs so callers invoke the capability without reading every template inside it.

The skill also owns a bounded procedure known enough to inspect and evaluate. Branching is allowed. Rediscovery of the whole path on every run is not. The procedure declares dependencies: which cognitive units, tools, code paths, and other skills it uses. Substitution rules travel with those dependencies when work moves into libraries of cognition. Acting steps carry authority grants so the write remains a step inside a known procedure rather than undocumented reach.

Failure modes at the skill layer are distinct from cognitive unit wrong answers. A skill can fail at a seam while every cognitive unit inside performs at its published standard. Procedure evaluation covers order, invariants, recovery, and cost across the whole capability.

Named inputscognitive units + codeProcedure checksCapability output

Skills package known work. Agents decide when to invoke them.

Clear negations

A skill does not own the goal of clearing a queue or producing an accepted plan unless pursuit has been smuggled into the procedure. If a module must revise strategy from evidence and judge sufficiency, it belongs at the agent layer, not inside a skill boundary. Multiple separable judgments composed in sequence are a skill or agent strategy, not a composite cognitive units. A fixed DAG with no capability contract is an implementation shape, and when the work deserves reuse and procedure evaluation, it belongs in a skill. See why pipeline is not enough and pipelines are not agents. Skills do not belong to agents. Application code, other skills, and agents may all call the same skill.

Unfamiliar work often starts as agent exploration. The path is unknown and the team learns which steps recur, which seams break, and which cognitive units deserve their own suites. When the path stabilises, the mature move is to name it and invoke it rather than rediscover each run. See when a trajectory becomes a skill. That maturity preserves pursuit at the agent layer while settling perform work into a reusable capability. The agent gets shorter and more inspectable. The skill accrues procedure evidence.

Skills in the wider system

Skills are callable from application code, from other skills, and from agents. That independence matters for libraries: a sealed Compose Weekly Plan skill can ship in a domain package with version pins while multiple products invoke it under different pursuit policies.

Skills also interact with memory discipline. Endorsed household knowledge feeds skill inputs. Working state during a run does not become endorsed belief because a skill returned an intermediate artifact. See knowledge is endorsed.

When teams skip the skill layer, every product rediscovers the same procedure with slightly different ordering. Evaluation cannot compare capabilities across products. Incidents repeat with different names. The cost of this omission compounds quietly: each new product team builds its own extraction flow, its own composition logic, its own validation ordering, and each variant drifts until no shared evaluation baseline exists across the portfolio.

A Skill that owns perform work should declare which cognitive units it may call for decide work, and which outcomes remain outside its boundary. Perform ownership without that declaration becomes a hidden decide surface. Hidden decide surfaces are where eval suites stop matching production behaviour.

What to do next

The exercise that makes skills concrete is naming the capability a procedure performs, not the judgments inside it. Each open decision stays in its own cognitive unit, composed in the skill. Procedure quality evaluation separates from decision quality evaluation, with suites bound to cognitive units and seam tests bound to the skill. Agents call skills for settled work rather than rediscovering the path.

See skill versus capability and libraries of cognition.

Read next: What is an agent.