---
name: build-on-skulk
description: Build applications and discoverable capabilities for the Skulk fabric using the managed Python capability SDK and Skulk inference APIs. Use for capability contracts, child processes, streaming, durable jobs and application surfaces; ordinary cluster operation does not require this skill.
---

# Build on Skulk

Help the user build an application that uses Skulk's models and services and, when appropriate, runs as a discoverable managed capability. Explain platform-specific decisions to beginners while implementing the requested application.

## Establish the integration boundary

Read the project's existing instructions and identify its SDK version, Skulk version, packaging setup and test commands. This bundle documents SDK **0.4.0**, Python **3.13+**, managed protocol **4**, and the **Skulk 2.0.0 next-channel** API snapshot in `source-manifest.json`.

For an installed runtime that differs, use its versioned documentation, installed public SDK signatures and actual OpenAPI contract. Do not guess fields or assume the bundled snapshot is current. SDK package delivery is separate from documentation: do not invent a working public package-index command. If dependencies are unavailable, still develop against the bundled contracts and make the unexecuted validation boundary explicit.

Choose the smallest suitable path:

| Application need                                                                   | Integration                                                       |
| ---------------------------------------------------------------------------------- | ----------------------------------------------------------------- |
| Call a mounted model from a normal application                                     | Skulk's HTTP inference API; a managed provider is optional.       |
| Offer a separately packaged service/application on the fabric                      | Managed capability SDK child.                                     |
| Deliberately run a provider inside Skulk, or call Fabric streams from that context | Public `skulk.extensions` interface, with its separate lifecycle. |

The managed SDK implements the **provider side**. It is not an arbitrary Fabric-client HTTP library. Do not import Skulk worker, runner or private host implementation into the application.

## Load the relevant reference

- For descriptors, managed startup, streaming and surface design, read [references/sdk.md](references/sdk.md). Consult individual files under [references/sdk-api/](references/sdk-api/) only for the public signatures needed.
- For calling models or negotiating another capability, read [references/skulk-api.md](references/skulk-api.md). [references/capability-http.schema.json](references/capability-http.schema.json) contains the exact bundled unary call/result schemas.
- For work that outlives one invocation, read [references/durable-jobs.md](references/durable-jobs.md).
- For a complete small child, adapt [references/managed-echo.md](references/managed-echo.md). For a runnable local job simulation, use [references/operation-workshop.md](references/operation-workshop.md).

Read only the material needed for the current task. The bundled references work offline; linked developer/product docs provide fuller tutorials when reachable.

## Build against the contract

Define bounded input/output schemas, capability identity, semantic version and I/O mode before writing transport code. Discover and use exact descriptor revisions when calling capabilities. Choose unary for an immediate result, streaming for incremental exchange, and durable operation verbs for long jobs; streaming does not make work restartable.

Keep application behavior independently testable. Let Skulk own inference placement and model execution. Keep application files under its owned state root, return metadata/artifact references for large output, and report child health, surface reachability and model readiness separately.

Use the user-selected API origin and existing authentication configuration. Discover capacity without changing the cluster. Model mounting, package installation/publication and generation are effects with their own scope; proceed when authorized by the task, and do not treat installing this skill as permission to provision models, use paid services or expose an interface publicly.

## Verify and hand over

Exercise the boundaries the application actually uses: schema failures, negotiation, startup/health/shutdown, output validation, deadlines, cancellation and owned cleanup. For durable jobs, also test duplicate starts, uncertain submission and accepted-job recovery. Use fake services for deterministic local tests, then qualify the real installed integration when its prerequisites are available.

Report what ran, which versions it ran against, and what remains unverified. Distinguish code compilation, SDK/package installation, live capability readiness and useful model output. Provide the next executable step with the application code; avoid ending with only an architectural sketch.