Skill

A skill orchestrates steps. It can call function, tool, other skill, typed strategy calls, user interactions and supported human validations.

A skill is not an autonomous agent. It describes a bounded and reusable composition.

Executable skill and contextual procedure

Touba distinguishes two notions with similar names but different roles.

Notion	Role
skill	typed executable capability inside a Touba program
contextual procedure	context declared in a package with touba.package.json

A package can contain SKILL.md, references, examples, templates, or scripts. Its context guides the model; an executable skill follows the program. Both are shared through the same package format.

A Touba skill has a signature, uses declarations and a do block. It can be called only from a capability authorized by the program, and its effects go through tool declarations and the manifest.

Form

source.tb

skill Name
    takes input as InputType
    gives OutputType
    uses SomeStep
    do
        SomeStep
            with input as input
            into result
        give result

Enriched calls use with to pass arguments and into to name the result.

Simple Case

skill_simple.tb

module examples.skill_simple

type ReviewSignal
    risk is Float

function ClassifyRisk
    takes signal as ReviewSignal
    gives Text
    do
        if signal.risk >= 0.7
            give "review"
        else
            give "accept"

skill PrepareReview
    takes signal as ReviewSignal
    gives Text
    uses ClassifyRisk
    do
        ClassifyRisk
            with signal as signal
            into label

        give label

The skill does not redo the computation. It orchestrates the call and provides a reusable composition point.

Advanced Case

skill_advanced.tb

module examples.skill_advanced

type ChangeRequest
    summary is Text

type AppliedChange
    summary is Text

tool ApplyChange
    takes request as ChangeRequest
    gives AppliedChange
    requires filesystem_write

skill ReviewAndApply
    takes request as ChangeRequest
    gives AppliedChange
    uses ApplyChange
    do
        human.approve
            with context as request
            into approved

        ApplyChange
            with request as request
            into applied

        show
            with message as "Change applied"

        give applied

This case shows a richer orchestration:

• mandatory human validation;
• a call to an effectful tool;
• user output through show;
• an explicit final result.

Structured composition

A skill can compose if / else if / else, for, while and calls to typed local or imported strategies. Declare targets in uses, pass parameters with with and receive results through into. It can distribute a list with parallel, declare max_concurrency and max_items, then join ordered results.

Scopes stay isolated per call and branch; budgets and cancellation remain shared across the run. Human approvals preserve nested continuations on resume. This does not make a skill an authorized callable_by caller of an agent: use a declared strategy or agent for that boundary. See Strategy and Human validation.

What the Skill Absorbs

In a classic application, the sequence can be scattered across a service, controller, workflow script and callbacks.

With skill, the sequence becomes visible in Touba source. The skill does not decide who can use it as an agent; it describes how steps are composed.

Responsibilities

The separation is intentional:

• the skill carries a typed executable capability;
• the agent carries responsibility and invocation authority;
• the manifest grants handlers, grants, secrets and limits;
• the runtime checks the contract before external effects;
• the skill pack carries documentation context, resources and preparatory scripts.

This separation keeps skills reusable without confusing capability, authority and context.