kamino451

Selects the best-matching Kamino agent template for a given task, fills its template variables from the provided task and context, verifies no placeholders remain, and writes the completed agent file into the per-task folder .kamino/tasks/<task_id>/. Use when the user provides a task and wants a Kamino agent chosen and instantiated, mentions selecting or creating an agent from .kamino/agents, references the kamino agent index, or asks to run template-replace on an agent template.

Executes an assembled pipeline of instantiated Kamino agents in sequence using subagents, verifying each agent's output before proceeding to the next. Reads the run order from a dispatch-queue's execution-graph.md, prints the sequence to the terminal, and runs each step. Use when the user has a dispatch-queue (from taskgraph) or instantiated agent files and wants them executed, or asks to run/execute the assembled agents and confirm each step worked.

Copies this Kamino factory into a new folder in virgin state by running copy-factory.sh — installing both the .claude/ control plane (afac plugin manifest, skills, judge and classifier agents) and the .kamino/ data plane (blueprints, deterministic scripts, eval schemas), with an empty ledger and no inherited run data. Use when the user wants to install, clone, bootstrap, or set up a fresh agent factory in another repository or directory, asks to copy the factory somewhere, or invokes /copy-factory.

Deterministic read-only search over completed task outcome ledger records to produce score-free Agent Factory candidates.

Validates the Kamino agent library by running template-variable-checks.sh over the .kamino/agents directory — confirming every agent's required_inputs match the {{variables}} used in its body (both directions) and that its hardcoded_properties declaration is present and accurate. Use when the user wants to check or validate the agents, verify template-variable consistency, lint the agent blueprints, or invokes /check.

Ingests a source of problems + solutions from disk (a crawl, a dataset, a folder of problem files) into a standard-shape evaluation corpus the factory can sweep. Because the factory engine stays 100% corpus-agnostic, this skill does NOT hardcode any source format — it interviews the user, AUTHORS a corpus-specific builder script on demand, snapshots the ground-truth answers, runs the builder, validates the result against the corpus integrity gates, and records provenance. The authored builder and its input data live with the ingestion record (git-tracked), never in the generic engine. Use when the user wants to turn a problem set / dataset / answer list into a corpus, add a new corpus, ingest LeetCode/Project-Euler-style problems, or "make a corpus out of this folder".

Creates a new reusable Kamino agent blueprint (an agent template) from the blueprint scaffold. It discovers the authoring fields marked with <<...>> in the scaffold, interviews the user for each (persona, model, effort, rules, definition of done, steps, output format, input schema), fills them in, leaves the {{...}} invocation variables intact, writes the blueprint into the ad-hoc tier, and registers it in the index. Use when the user wants to add a new agent type, create an agent blueprint or template, design a new agent from scratch, or extend the .kamino/agents library so clone can later select it.

Benchmarks one prescribed agent blueprint against a task corpus — the caller pins the agent, and every corpus task is solved by that same agent, never the factory's own picking. This measures one agent's quality, not the factory's routing. Requires a corpus directory and an agent blueprint path as input. Per attempt it compiles an isolated run (the solver sees only the problem statement; all test tiers stay outside its reach), dispatches the solving subagent, judges success deterministically, appends the ledger, and finally regenerates the HTML report pages. Use when the user wants to evaluate, benchmark, or test a specific agent blueprint against a corpus, or run an agent-vs-corpus sweep.

Evaluates the agent factory itself against a task corpus — for every corpus task the factory picks the agent and model (candidate search + weighted-majority routing, cheap-first escalation), solves it in an isolated run dir, verifies against every test tier, and records the outcome. This measures the factory's routing quality, not one agent. Requires a corpus directory as input. Per attempt it compiles an isolated run (the solver sees only the problem statement; all test tiers stay outside its reach), dispatches the solving subagent, judges success deterministically, appends the ledger, and finally regenerates the HTML report pages. Use when the user wants to evaluate the factory / auto agent picking against a corpus, run a factory eval sweep, seed the factory with data, or continue the data flywheel.

Default entry point and orchestrator for the afac (agentfactory) plugin. Routes a user's goal to the right agent-factory capability — cloning and instantiating an existing agent, decomposing a complex task into a multi-agent pipeline, creating a new agent blueprint, or running an assembled pipeline. Use when the user states a goal and wants afac to figure out which agents are needed and assemble them, mentions the agent factory or orchestrating agents, or is unsure whether to clone, chain, build, or run agents.

Classify a failed Kamino run attempt into catalog failure modes using the run-failure-classifier agent and persist the analysis for error-analysis tooling. Use when the user wants to analyze why a run or attempt failed, classify failure modes, do error analysis on ledger failures, or find agent failure patterns.

Improves a target agent blueprint's prompt with the AutoResearch keep-or-revert loop — the "Improve" stage of the factory's learning loop (Run → Trace → Evaluate → Attribute → Improve). It sets up a fresh optimization workspace from scratch (seeds agent.md from the target blueprint, has autoresearch-program-author and autoresearch-eval-author author the per-problem harness files, initializes the nested git), then iterates: one surgical prompt edit per round, kept only when the score strictly improves. It never writes the ledger; improvements are proven afterwards via replay and baked in via createblueprint. Use when the user wants to improve or optimize an agent's prompt, run AutoResearch, act on failure analyses, or make a blueprint stop failing a class of tasks.

Lists all curated (library-tier) agents with their purpose. Use when the user asks what agents are available, wants to see the agent library, or needs to pick an agent and wants a quick overview. Runs a shell script to extract names and descriptions from the library and presents the result as a formatted inventory — does not read individual agent files.

Place a new task against historical task anchors or rank a task set using Bradley-Terry pairwise comparisons before factory routing.

Re-run a previously captured task (task detail + dispatch queue) against a specified agent version, model, or effort, judge it the same way, record it as a new attempt, and compare old versus new outcomes. Use when the user wants to retry a captured or failed task with an improved agent, replay a ledger record, A/B a blueprint change, or verify that an agent improvement actually fixes a recorded failure.

Evaluate whether a completed Kamino run fully satisfied the original task — deterministically from ground-truth test results when the run evidence carries them, otherwise using the task-run-success-judge agent.

Deterministic pre-run task detail writer. Persists task context as .kamino/evals/tasks/details/<task_id>.json without writing the outcome ledger.

Public wrapper for profiling an incoming task before Agent Factory routing. Uses task-evaluator, task-llm-judge, and the deterministic evaluate_task.py script to produce reusable task evaluation JSON.

Deterministic read-only lookup of historical task outcomes for Agent Factory routing. Uses task_outcome_ledger_read.py only and never invokes an LLM.

Deterministic post-run task outcome ledger writer. Uses task_outcome_ledger_write.py only and refuses to write without a binary success judgment.

Builds a task graph — decomposes a complex or multi-step task into an ordered chain of independent steps, maps each step onto an existing agent in the .kamino/agents index, instantiates those agents wired together by filename, and writes them into a timestamped dispatch-queue with an execution graph. Use when the user has a task that is too big for a single agent, wants a multi-agent pipeline or task graph planned, mentions task decomposition or breaking a task into steps, or wants several Kamino agents chained together.