Agents that write their own orchestration. Safe. Auditable. Yours.

Why this?

AI agents are mostly transient. Every routine task is re-derived from prose reasoning. The agent that summarized a thread yesterday will summarize one tomorrow by reasoning from scratch about how to summarize threads, burning frontier inference on a procedure with a known shape, a known output format, and known failure modes.

The waste compounds in three directions: cost (every routine operation runs through the most expensive reasoning layer in the system), latency (every operation pays the full inference cost), and drift (the same task produces slightly different results each time because nothing crystallizes).

The usual answers don't quite get there.

Most agent infrastructure today focuses on memory: episodic recall, retrieval-augmented context, conversation summarization. Those projects answer "what does the agent know." They don't answer "what can the agent do" in any persistent, executable, inspectable form. There's no hard form. No place for an agent to crystallize a learned procedure into something cheap to execute, cheap to inspect, and cheap to improve.

Skillscript began with a question: what would a Makefile look like if it built skills instead of binaries? Make is declarative and dependency-driven, and it is deliberately not where you write arbitrary logic. You name the steps and let tools do the work. Skillscript points to the same shape as agent automation and adds the part Make never needed: an approval boundary and connector-mediated access to the outside world.

Skills (in the markdown sense) are instructions describing behavior. Skillscript is the behavior itself: the orchestration the agent would otherwise have to re-derive every invocation, crystallized into a compiled artifact the runtime can execute on a schedule, in response to an event, or at the agent's request. The procedure runs the same way every time because the procedure is the source of record, not a prompt that has to be re-interpreted. Frontier inference is reserved for the work that actually needs it.

And because a skillscript is a written artifact, not a runtime prompt, you can read it. You can version it. You can compose it with others. You can lint it before it runs. You can update it when the world changes, once, in one place, and every skillscript that depends on it picks up the change.

That inspectability is also what lets the review keep pace. Auditing arbitrary code means reasoning about everything a script could do, which needs a skilled reader for every one. A skillscript puts its whole effect surface on the page, so approving it stays tractable even when agents are authoring faster than anyone can read code. And the person who knows what a system should allow can approve on the declared effects, without having to be the one who could have written the code.

This is what we mean by autonomy you can audit.