SkillForge — Platform for Agent Skills, Workflows & Verification Hooks

SkillForge is a centralized platform for managing production-grade agent capabilities: composable skills, multi-step workflows, verification hooks, and autonomous routines. Unlike static prompt repositories, SkillForge is built on ablation-first principles — every instruction must justify itself through evals, every skill has a shelf life, and the system continuously pushes you to delete rather than add.

Inspired by how frontier agent harnesses are rebuilt every model generation, SkillForge treats agent capabilities as disposable building blocks. Your team gets a unified registry where skills are continuously tested, measured for product overhang, and retired when models outgrow them. The goal is not to accumulate instructions, but to unhobble the model and let it do what it already can.

What SkillForge Is — and What It Is Not

The previous generation of tooling stored prompts: free-text guesses about what a model might need. Prompts have no evidence, no ownership, no lifecycle. They accumulate, rot, and silently tax every run with tokens the model no longer reads. SkillForge stores skills: named, versioned, gate-proven procedures with triggers, verification hooks, eval results, and provenance. A skill is not a hope — it is a capability with a track record.

	Prompt registry	SkillForge
Unit of storage	Free-text prompt	SKILL.md procedure with frontmatter contract
Evidence	None	Gate-proven runs, eval pass rates, provenance stamps
Lifecycle	Forever (until someone notices)	Born → Active → Aging → Zombie → Retired
Quality signal	Human opinion	Ablation Score, pass rates, transfer efficiency
Safety	Hope	Verification hooks: pre / mid / post execution
Composition	Copy-paste	Workflows: sequential, parallel, fan-out/fan-in
Runtime	One tool, one format	Cross-agent: SKILL.md open standard, MCP, REST
Default action	Add	Delete (ablation-first)

The Philosophy: Ablation-First

SkillForge operationalizes the discipline that frontier harness teams practice by hand:

Delete first. Every model generation, large parts of the system prompt, the tool set, and the skill library stop earning their place. The correct default is deletion; additions must prove themselves.
Skills expire. A skill written for yesterday’s model may hobble today’s model. Plan to retire, not just maintain.
Evals are the source of truth — until they saturate. Prompts and skills are guesses; evals are measurements. But evals also outlive their usefulness: when a model saturates an eval, the eval is thrown away and a harder one is built.
Unhobble, don’t constrain. Product overhang is real — models can do more than we think, and over-specified instructions get in the way. The registry measures the gap between what your agents can do and what they’re allowed to do.

The platform’s home screen asks one question: “What can you delete today?”

How It Works — Core Capabilities

1. Ablation-First Registry

The registry is an instrument, not a folder. It continuously measures whether each skill still matters.

Versioned skills tied to model generations — every skill records which model generation it was born on and which generations it has been validated against (“written for Opus 4.8, untested on Opus 5 — ablation recommended”)
Automated ablation tests — the eval suite runs with and without the skill; the delta is the skill’s measured contribution
Ablation Score — the percentage of your library that can be deleted without quality loss; the overengineering meter
Aging alerts — skills not validated in the last 90 days are flagged for review
New-model release triggers — when a new model generation lands, SkillForge queues an ablation sweep across the library and reports which skills became dead weight overnight

2. Skill Lifecycle Management

Every skill moves through an evidence-driven lifecycle:

Born — created from a proven source: a gate-proven Reckon run, an AgentSpace demonstration, a Dream Team certification, or a human-authored procedure that passed its validation gate. No proof → no skill.
Active — injected on trigger match; every injection tracks uses and helped (the run it was shown to then passed its gate). Proof-of-benefit outranks proof-of-selection everywhere.
Aging — unused candidates are pruned; unused active skills are demoted back to candidate — never deleted if promoted. Using or helping a skill reinforces it and resets its clock.
Zombie — the model outgrew it: ablation shows zero delta, yet the skill still loads and still costs tokens on every run. Flagged for retirement.
Retired — archived with full audit trail and eval history; restorable if a future model generation regresses the capability.

Side-by-side comparison shows a skill’s effectiveness across model versions, and rollback is one click.

3. Verification Hooks (First-Class Citizens)

Hooks are the safety and verification layer of the stack — and they are treated as product, not config.

Pre-execution hooks — input validation, context checks, safety gates. Modeled on the balanced-safety philosophy: default to ask, not deny — agents trivially bypass deny by rephrasing, so hooks interrupt only when an action is genuinely destructive (catastrophic paths: recursive deletes, force-pushes, infra mutations, DB clients, cloud control-plane changes), with safe-path carve-outs to keep false positives near zero.
Mid-execution checkpoints — the agent self-verifies along the way: the single most important thing you can give an agent is a way to check its own work.
Post-execution validation — outputs checked against eval suites and structural scanners; regressions raise alerts.
Human-in-the-loop approval gates — sensitive operations pause for a named human with full context.
Cross-agent hook protocol — the same hooks run in Claude Code, Codex CLI, OpenCode, and any runtime supporting the hook standard; compiled-binary hooks for the cases that can’t live in skill format.

4. Workflow Composer

A visual algebra for orchestrating agents at scale:

Chain skills into multi-step workflows with conditional branching and error-recovery paths
Visual workflow editor for non-technical stakeholders
Debug mode with step-by-step execution traces
Replay failures for root-cause analysis — any historical run can be re-executed step by step

5. Routines Engine

Cron-like autonomous tasks that keep systems healthy without shared context:

“Abstraction police” — find near-duplicate abstractions across codebases and unify them
Dead-code cleanup, stale-test removal, test-coverage automation
Experiment shipping — promote fully-ramped experiments and delete their flags
Runs without shared context, with persistent memory; each run is isolated and auditable
Built-in monitoring, failure recovery, and budget caps

6. Product Overhang Detector

The unhobbling instrument:

Compares agent behavior with and without each skill and instruction set
Identifies capabilities blocked by over-specification (“your skill restricts the agent to snippets; the model can now write entire modules”)
Quantifies the gap between what models can do and what they’re allowed to do
Issues unhobbling recommendations: remove this skill, re-run the eval suite, keep the deletion if the delta is zero

7. Eval-Driven Quality Gates

Every skill is tied to evidence:

Automated eval suites per skill, run on real production-shaped tasks
Pass rates, token efficiency, and cost-per-success tracked per skill per model generation
Eval versioning — evals are first-class artifacts that outlive skills by 2–3 generations
Saturation detection — when a model starts maxing an eval, the platform flags it: the eval has stopped measuring; build a harder one and retire the old

8. Workflow Orchestration

Skills compose into pipelines:

Chain skills into multi-step workflows with conditional branching and error-recovery paths
Visual workflow editor for non-technical stakeholders
Debug mode with step-by-step execution traces
Replay failures for root-cause analysis — any historical run can be re-executed step by step

9. Team Collaboration & Governance

Share skills across teams with granular permissions (private / team / org / public registries)
Review workflows and approval gates for skill changes; nothing reaches Active without a named reviewer
Comment threads on skill effectiveness; ratings grounded in eval data, not vibes
Templates for common patterns: safety, verification, error handling, incident response
Full audit log of every modification, promotion, demotion, and retirement
SkillOpt-style optimization loop for improving skills safely: bounded edits, a held-out validation gate, a rejected-edit buffer, and epoch-wise slow/meta updates — skills improve by measured increments, never by vibes

10. Universal Agent Runtime Integration

Skills follow the Agent Skills open standard (SKILL.md), so one registry serves the whole fleet:

Native support for Claude Code, Cursor, Codex, Windsurf, Copilot, Gemini CLI, OpenCode, Antigravity — anywhere the standard reaches
MCP server for remote skill discovery and injection
REST API and WebSocket support for custom integrations and CI
Hot-swap skills without restarting agent sessions
One-command install and sync across runtimes (skills add style), with per-runtime config differences handled automatically

Skill Anatomy

A SkillForge skill is a contract, not a note:

Frontmatter — name, version (semver), triggers, model compatibility, provenance stamp (source run / episode / demonstrator / author), linked evals, linked hooks, trust level
Procedure — the steps that worked, including the step most likely to be missed
References / scripts / assets — supporting material, kept out of the always-on context
Trigger model — library-relative IDF: a trigger recurring across the whole library is discounted, so injection fires on discriminating domain signal, not boilerplate; the ≥2-word bar means “two words’ worth of meaningful signal.” Self-tunes per project, no domain nouns hard-coded
Evidence links — the run’s diff, its compaction segments, its eval results: any skill can be traced back to the verbatim ground truth that produced it

Token-cheap by design: skill descriptions are kept tight so they never dominate context; heavy detail lives in references the agent pulls only when needed.

Where Skills Come From — the Provenance Pipeline

SkillForge is the convergence point of the whole stack’s learning:

From Reckon — every run that passes its objective gate may distil a candidate procedure (no proof → no skill). Candidates stay dormant until a human promotes them; only promoted skills are ever injected, and only when their trigger matches.
From AgentSpace — “Watch Me” demonstrations become replayable, named skills with decision points, not fragile macros.
From Dream Team — certified patterns and consilium-validated procedures graduate into the registry with confidence scores.
From humans — expert procedures enter through a validation gate: they must pass evals before they can steer agents.

One rule governs all four sources: a skill without evidence is a candidate, and a candidate is inert.

Metrics That Matter

Metric	What it measures	Why it exists
Ablation Score	% of library deletable without quality loss	Overengineering meter
Skill Age	Time since last validation	Rot control
Verification Pass Rate	% of hook checks passed	Safety health
Transfer Rate	Injections that led to a passing run (`helped` / `uses`)	Proof-of-benefit ranking
Product Overhang Index	Gap between “can do” and “allowed to do”	Unhobbling backlog
Eval Saturation	Models maxing an eval	Signal to rebuild evals
Token Efficiency	Tokens per successful task, per skill	Cost of carrying a skill

Real-World Use Cases

Case 1: The Post-Upgrade Purge. After a new model generation, an enterprise ran SkillForge’s ablation sweep: 61% of a 400-skill library showed zero delta. Retiring them cut prompt tokens by 44% per run and raised pass rates — the deleted instructions had been hobbling the new model.

Case 2: Safety Without Friction. A fleet running destructive-capable agents adopted balanced verification hooks: catastrophic paths ask, safe paths never interrupt. False-positive interruptions stayed under 2%, while three would-be catastrophic operations (force-push to main, recursive delete, prod infra mutation) were caught in one quarter.

Case 3: Incident Response Workflow. A workflow chains detection → triage → remediation skills with a human approval gate before any rollback. Mean time to remediate fell 58%; every step is replayable for postmortems.

Case 4: Routines as Maintenance Crew. Abstraction-police and dead-code routines run nightly across 14 repositories, opening 20–30 small, reviewable pull requests a day. Engineers review; agents maintain.

Integration with the Artena Stack

Reckon → gate-proven learned skills flow into SkillForge; promoted skills are injected back into Reckon runs on trigger match. The honest-gate rule applies to learning itself.

AgentSpace → demonstration learning publishes skills; fleet agents consume them on every task; usage and transfer metrics flow back for curation.

Dream Team → certification scenarios validate skills against new model generations; retired skills become training material on “what we used to need.”

Core Principles

Delete more, build less. Every line of instruction costs tokens on every run. The best libraries are the ones that get out of the way.
Skills are disposable. Evals are the truth — until they saturate. Plan to retire skills; plan to rebuild evals. Both are acts of maintenance, not failure.
No proof → no skill. Candidates are inert. Promotion is human. Injection is trigger-matched.
Verification beats instruction. Give agents ways to check their work; that outlasts any prompt.
Unhobble, don’t constrain. Measure the overhang. Remove the barriers. Keep the guardrails that catch catastrophes and delete the ones that catch nothing.
Cross-agent first. One skill, every runtime. Formats that lock you to one vendor are liabilities.
Low false-positive friction. A hook that cries wolf is a hook agents and humans learn to ignore. Ask only when it matters.

Technical Architecture

Skill Store — versioned, content-addressed, semver-managed SKILL.md artifacts with references/scripts/assets
Provenance Ledger — every skill traceable to its source run, diff, compaction segment, and eval results
Ablation Runner — with/without eval orchestration per skill per model generation
Eval Orchestrator — suite versioning, saturation detection, harder-eval generation queue
Hook Runtime — pre/mid/post hooks, cross-agent protocol, ask-not-deny safety tiering, compiled-binary hooks
Workflow Engine — branching pipelines, error recovery, step-level traces, replay
Routine Scheduler — isolated cron-like runs with persistent memory and budget caps
Overhang Analyzer — with/without behavior comparison and unhobbling recommendations
Governance & Audit — permissions, review gates, promotion/demotion history, immutable audit log
Distribution Layer — MCP server, REST/WebSocket API, plugin-marketplace packaging, per-runtime config translation

Getting Started

Import — bring existing prompts, CLAUDE.md/AGENTS.md content, and .reckon/skills candidates in as candidates
Baseline — run your eval suites with the imported library as-is
First ablation sweep — delete what shows zero delta; record the token savings
Set lifecycle policy — validation cadence, TTL decay, promotion rules
Connect runtimes — Claude Code, Cursor, Codex, and the rest via the standard and the MCP server
Curate weekly — review the “What can you delete today?” board; promote what proves itself; retire what doesn’t

ArteNa Technologies

ArteNa Technologies