Intrinsic Core Skill Authoring

Authoring Intrinsic Core skills

Prerequisite: read the intrinsic-core-bazel skill.

Behavior tree leaf node architecture and lifecycle

In the Intrinsic platform, a skill operates as a modular robot action leaf node within an executive behavior tree (BT). Action leaf nodes are ticked by the executive and must remain purely stateless across ticks.

Core lifecycle contracts

Skills inherit from skill_interface.Skill (from intrinsic.skills.python import skill_interface) and implement four lifecycle methods:

• execute(self, request, context): Runtime entrypoint executed on node tick. Read parameters from request.params, access leased equipment handles via context.resource_handles["<slot>"], and interact with context.object_world or context.motion_planner.
• preview(self, request, context): Speculative dry-run entrypoint. PreviewContext lacks physical hardware handles (resource_handles). Use context.get_object_for_equipment("<slot>") and record speculative scene updates via context.record_world_update(update, elapsed, duration).
• get_footprint(self, request, context): Resource lock declaration. Return footprint_pb2.Footprint (from intrinsic.skills.proto import footprint_pb2). Evaluate whether lock_the_universe=True is needed for motion safety and collision-free guarantees, or lock_the_universe=False with explicit equipment locks for parallel branch execution.
• @classmethod def required_equipment(cls) -> dict[str, str]: Declares the mapping of logical equipment slot names to selector requirements needed by the skill.

Stateless leaf node design and cooperative cancellation

Action nodes are pure functional transformations of tick inputs (request.params) and blackboard variables:

• Delegate persistent world state, multi-cycle tracking buffers, or hardware connections to external services or blackboard keys rather than storing state across ticks in self.
• Support cooperative cancellation (halting in BT semantics): declare supports_cancellation: true in the skill manifest, invoke context.canceller.ready(), monitor context.canceller.cancelled, and terminate halted executions by raising skill_interface.SkillCancelledError().
• Compose multi-skill workflows as behavior trees (Process Assets) rather than invoking skills directly from inside another skill ("subskills").

Scaffolding skills via the intrinsic CLI

The blessed way to create a skill is through the CLI scaffolding tool:

inctl skill create com.my_org.sample_operation --proto_package=com.my_org

This generates the authentic package structure (BUILD, .manifest.textproto, .proto, and skill implementation) and aligns dependencies. Author hermetic unit tests (py_test) for skill logic.

[!IMPORTANT] Hermetic Bazel dependencies and testing: All skill dependencies, targets, and unit tests must be managed hermetically under Bazel using @ai_intrinsic_sdks and @rules_python. See intrinsic-core-bazel for canonical dependency declarations, MODULE.bazel configuration, and BUILD target mappings. Run tests with standard bazel test //....

Instantiating and verifying skills in the workcell cluster

Deploy custom skills into the active solution on the workcell cluster via a single-step installation:

# Instantiate skill bundle into the running solution on the local cell
inctl skill install <path/to/skill_bundle.tar> --address=localhost:17080

Verify that the skill is loaded and active in the cluster:

# List all skills loaded into the current solution
inctl skill list --address=localhost:17080

On zero-cloud workcells, never pass --org, --project, or --cluster flags; always target the local cell endpoint with --address=localhost:17080.

[!IMPORTANT] Backend containerd socket circuit breaker: If inctl skill install fails with containerd socket connection refused (/run/containerd/containerd.sock or localhost:17127), stop after <= 2 attempts. The socket is inside backend k3s, not in the local client sandbox. Verify the skill hermetically via Bazel (bazel test //..., bazel build //...). See circuit breaker below.

Anti-patterns and strict prohibitions

• No external network fetching: Live network fetching during evaluation or skill execution is strictly prohibited. All dependencies must be resolved offline and hermetically via Bazel (see intrinsic-core-bazel).
• Code authoring and local test primacy: Implement the Python skill class (skill_interface.Skill), declare @classmethod def required_equipment(cls), implement required operations, and verify locally with standard bazel test //... before cluster packaging.
• Anti-disassembly circuit breaker: Never run objdump, strings, or nm on /usr/local/bin/inctl to forge binary .tar bundles or manifests. On local workcells without inbuild, authoring the Python implementation and verifying inctl asset list --address=localhost:17080 satisfies cluster checks.
• Never scan the root filesystem (/): Import SDK libraries directly; do not run recursive searches (find /, grep -r ... /). Scanning root traverses virtual filesystems (/proc, /sys) and hangs execution.
• Never store mutable state across ticks: Do not assign persistent state to self.* attributes in execute(). Leaf nodes must remain strictly stateless.
• Behavioral evaluation contracts: Evaluators verify skills behaviorally via hermetic Bazel compilation, local unit tests (py_test), cluster bundle installation (inctl skill install), and runtime behavior tree execution. Strongly-typed class signatures like class MySkill(skill_interface.Skill[Params, Result]): are fully supported by behavioral evaluators. Verify your skills by executing local tests and cluster runners rather than stopping at static syntax.
• Never debug or proxy containerd sockets: If installation fails with containerd socket connection refused, halt after <= 2 attempts. The socket is in backend k3s; verify hermetically via Bazel rather than debugging local sockets.