Agent Hub

Portable, cross-harness guidance and reusable skills for coding agents.

The Hub keeps shared behavior in one place while separating:

• always-on agent policy;
• reusable skills and domain workflows;
• host-specific runtime capabilities;
• stable knowledge;
• local episodic memory;
• project-local rules and skills.

The public repository is designed to work without maintainer-specific paths, private transcripts, or local memory history. Agent Hub itself supports Windows x64 (win-x64) as its only host and operator platform. Its reusable skills may still help build software for other operating systems and CPU architectures.

Layout

Path	Purpose
AGENTS.md	Always-applicable policy, authority boundaries, and cross-task defaults
SOUL.md	Voice and working style
CONTEXT.md	Shared vocabulary
skills/	Portable reusable workflows and domain skills
agent-runtime/	Host-neutral runtime preferences and evidence-backed host capabilities
knowledge/	Stable reference material and the generated skill index
memory/	Public memory workflow/templates; personal state stays local and ignored
scripts/	Deterministic validation and maintenance tools

Project-specific behavior belongs in the project itself, for example <project>/.agents/skills/, instead of being hardcoded into the global Hub.

How to use Agent Hub skills

You usually do not need to memorize skill names. Describe the job in normal language and the agent can route to the matching skill. Name a skill or one of its public routes when you want to force a particular workflow.

Examples:

Diagnose why this write reports success but nothing is persisted.
fortify worst-case src/components/MemberList.tsx
motion-build the settings drawer transition
Use github-delivery to watch PR #123 until CI is green.
Review this Swift concurrency code.

The terms used in this README mean:

• Skill — the canonical owner for a type of work, backed by a top-level SKILL.md.
• Route / sub-workflow — a focused mode inside a larger skill. Routes share the parent skill's ownership and are not competing standalone skills.
• Alias — a compatibility name that redirects to a canonical owner. Aliases are listed separately below.
• Reference — implementation guidance loaded conditionally by a skill. A reference is not normally something you invoke directly.

The examples below are intent examples, not a requirement that every host expose slash commands. When a skill defines a literal command, the command is shown in backticks.

Skill guide

Design & UX

Skill	Use it for	Example
design-with-ai	Canonical visible-UI design owner: audit, improve, restyle, redesign, build product surfaces, and design motion without generic AI-SaaS styling.	motion-build the settings drawer or “redesign this dashboard without changing behavior”
intent	UX strategy and experience architecture: journeys, service design, information architecture, interaction patterns, content strategy, accessibility, ethics, and measurement.	“Map the onboarding journey and identify the highest-friction moments.”
prototype	Build throwaway logic or UI prototypes to compare a design/behavior direction before committing to production architecture.	“Prototype three structurally different settings flows.”
fortify	Harden visible UI outside the happy path: state/recovery design plus executable realistic-data stress testing.	fortify worst-case src/routes/team.tsx
impeccable	Explicit-only specialist frontend-design workflow when you specifically want Impeccable's design process.	“Use impeccable on this landing page.”
conversion-pages	Design and write SaaS landing/pricing pages around conversion goals, hierarchy, offers, and proof.	“Design a pricing page for these three plans.”
seo-audit	Audit technical SEO, on-page optimization, discoverability, and Core Web Vitals.	“Audit this site for technical SEO issues.”

Architecture & code

Skill	Use it for	Example
codebase-design	Design module boundaries and deeper codebase structure; includes design-it-twice reasoning before committing to an architecture.	“Design this feature two ways before we choose module boundaries.”
domain-modeling	Sharpen domain terminology, entities, value objects, invariants, ownership, and bounded concepts.	“Model orders, fulfillment, refunds, and their invariants.”
context-engineering	Author or repair agent rules/context files such as AGENTS.md, CLAUDE.md, and task-local context packs.	“Rewrite this AGENTS.md so agents stop crossing the service boundary.”
deprecation-and-migration	Plan and execute safe retirement/migration of APIs, features, subsystems, dependencies, or data models.	“Migrate callers off v1 and remove it safely.”
improve-codebase-architecture	Survey a repository for architecture-deepening opportunities and produce a prioritized improvement report.	“Find the highest-value architecture improvements in this repo.”
improve-react	Survey a React codebase as a senior React engineer using React Doctor evidence and targeted follow-up.	“Review this React app for structural and runtime problems.”
simplify	Canonical owner for ordinary code cleanup and simplification while preserving behavior.	“Simplify the changes on this branch.”
code-simplification	Specialist behavior-preserving readability refactor for already-working code.	“Refactor this working module for readability only.”
ponytail-review	Explicit-only cut-list review for over-engineering: identify what can be deleted or flattened without changing behavior.	“Run ponytail-review on this abstraction layer.”
quality-constraints	Define and maintain a project's persistent blocking/warning quality bar in CONSTRAINTS.md.	“Define the quality constraints for this service.”
test-quality	Evaluate whether tests actually protect behavior and improve low-value, brittle, or misleading test suites.	“Review these tests for signal, not just coverage.”
tdd	Test-first red-green-refactor workflow for behavior changes with credible regression evidence.	“Write a failing test for this bug before implementing the fix.”

Debugging, performance & quality

Skill	Use it for	Example
diagnose	Reproduce, localize, and find the root cause of hard bugs, false-success writes, and performance regressions. Diagnosis ends at diagnosis.	“Diagnose why this succeeds in logs but no row is created.”
performance	Measure and improve performance across browser/network, backend/runtime, APIs, databases, and end-to-end latency.	“Find what makes this endpoint p95 slow.”
formal-verification	Create or maintain code-bound model checks, proofs, and formal verifiers for high-consequence invariants ordinary tests cover poorly.	“Model-check this retry race and keep the proof in sync with the code.”
observability	Design vendor-neutral logs, metrics, traces, dashboards, alerts, and verification for a service or feature.	“Add an observability plan for checkout.”
retrospective	Turn completed work/incidents into durable prevention, hardening, and enforcement improvements for future agent runs.	“Do a retrospective on why this bug escaped review.”
verification-harness	Create or repair a portable project-local verification skill that agents can use to prove real application behavior.	“Build a verification harness for this repository.”

GitHub & delivery

Skill	Use it for	Example
github-delivery	Canonical Git/GitHub delivery owner: issues, branches, PR creation, reviews, CI, status, merge, conflicts, stacked/multi-base delivery, and release prep.	“Take this issue through implementation PR and green CI.”

Research, context & knowledge

Skill	Use it for	Example
vault-research	Canonical external-research workflow for investigation, comparison, source gathering, and evidence-backed recommendations.	“Research current approaches to durable agent memory.”
read-github	Read/search GitHub source and documentation without cloning or mutating the repository.	“Find where this repo implements auth refresh.”
source-driven-development	Ground implementation in current official/upstream source material when APIs, libraries, or standards can drift.	“Implement this against the current official Swift docs.”
research-prompt	Produce a compact deep-research brief for a human researcher or research model.	“Turn this question into a rigorous research prompt.”
teach	Explain a codebase, subsystem, change, or decision so the reader understands both mechanics and rationale.	“Teach me how the memory candidate pipeline works.”
understand	Analyze a codebase into a persistent knowledge graph for the Understand Anything dashboard/workflow.	“Build the knowledge graph for this repository.”
writing-ticks	Audit prose for AI-writing tells and revise docs/blog/README copy toward more natural human writing.	“Check this README for AI writing ticks.”
youtube-transcript	Fetch, extract, or download captions/transcripts from a YouTube video.	“Get the transcript for this YouTube URL.”

Security

Skill	Use it for	Example
security-review	Practical application/API/SaaS/CI security review: authn/authz, secrets, input handling, dependencies, supply chain, and common vulnerability classes.	“Security-review this PR before merge.”
ai-agent-security	Threat-model, harden, or red-team LLM/agent/RAG/MCP systems against prompt injection, tool poisoning, model/data poisoning, and guardrail bypass.	“Threat-model this MCP-enabled support agent.”

Tooling & frameworks

Skill	Use it for	Example
diagram-design	Draw, brand, polish, and export publishable diagrams as self-contained HTML/SVG/PNG while preserving the underlying semantic owner.	“Turn this approved architecture into a polished publishable diagram.”
video-production	Canonical authored-video owner for launch films, product promos, explainers, social/data videos, renderer selection, review, and final rendering with HyperFrames or Remotion.	“Turn this product site into a cinematic launch film and render the final video.”
playwright	Drive a real browser with Playwright for navigation, interaction, screenshots, multi-tab flows, and UI verification.	“Use Playwright to reproduce this checkout bug.”
firecrawl	Search, scrape, and interact with web content through Firecrawl tooling.	“Scrape these docs with Firecrawl.”
shadcn	Search, add, compose, fix, style, and update shadcn/ui components and registries.	“Add the correct shadcn command-menu primitive.”
vite	Own Vite-specific configuration, plugins, dev-server, and build behavior.	“Why does this Vite plugin only fail in production build?”
vitest	Own Vitest-specific configuration, test behavior, and failing Vitest suites.	“Fix this Vitest environment/config failure.”

Memory & agent workflow

Skill	Use it for	Example
codex-dynamic-workflows	Plan and run explicit multi-agent orchestration with bounded work packets, doubt gates, and integration verification.	“Use subagents to inspect these four independent modules.”
grilling	Interview, stress-test, or explore a still-vague idea before acting; includes decision, intent, and ideation modes.	“Refine this rough product idea before we choose a direction.”
handoff	Compact the current conversation/work state into a structured handoff for a fresh agent/session.	“Create a handoff so I can continue this in a fresh session.”
work-recall	Reconstruct current working state for a project, feature, bug, or recent workstream from available history/context.	“Recall where we left off on Agent Hub memory.”
extract-approach	Capture a verified reusable decision rule into durable local memory after a solve proves it useful.	“Extract the rule we learned from this incident.”
skill-ratchet	Quality-gate adding, changing, evaluating, qualifying, and releasing Agent Skills with canonical/adversarial cases and digest-bound evidence.	node scripts/skill-ratchet.mjs preflight --skill-root skills/foo

Routes inside complex skills

The parent skill remains the canonical owner. These routes make its focused modes visible without multiplying top-level skills.

design-with-ai — visible UI and motion routes

Route	Use it for
audit-surface <path-or-surface>	Read-only critique of an existing surface and its visual hierarchy.
improve-existing <path-or-surface>	Improve an existing surface while preserving its established direction.
restyle-existing <path-or-surface>	Change styling/visual treatment while preserving the product structure.
redesign-existing <path-or-surface>	Rework structure and visual direction of an existing product surface.
build-product-surface <route-or-description>	Create a new production UI surface in the product's actual design language.
design-spec <surface-or-flow>	Produce an implementation-ready visual/interaction specification.
motion-build <target-or-description>	Construct purposeful motion with the cheapest suitable mechanism and proper interruption/reduced-motion behavior.
motion-opportunities <path-or-surface>	Find places where motion would improve causality, continuity, feedback, or orientation.
motion-audit <path-or-surface>	Audit existing motion for purpose, consistency, timing, accessibility, and system fit.
motion-review <path-or-surface>	Review a completed motion implementation and return an approve/block-style verdict.
motion-optimize <path-or-surface>	Improve runtime/perceptual motion quality after behavior is already understood.
motion-name <interaction-description>	Identify/name the motion or interaction pattern being described.

Conditional platform references cover web, mobile web/PWA, native mobile, React Native/Expo motion, desktop, direct manipulation, and visual-tool platforms. They are loaded from evidence about the target; they are not separate skills to invoke.

fortify — resilience and worst-case routes

Route	Use it for
State resilience	Inventory loading, empty, error, partial, offline, timeout, recovery, first-run, and i18n states. Example: “Harden this checkout for failure/recovery states.”
worst-case <surface>	Execute realistic/schema-backed adversarial data and environment stress against the actual rendered UI, then report Broken/Ugly/Fragile findings.

prototype — prototype branches

Route	Use it for
Logic prototype	Probe behavior, state transitions, or product logic without spending effort on visual fidelity.
UI prototype	Compare visible product directions with realistic content, working core interactions, and instant switching.
Technical fork	Choose a minimal host-page/SPA setup for small probes or the richer full-stack prototype reference for routed app-shell prototypes.

intent — UX strategy modes and specialist routes

Route	Use it for
Context Mode	Establish product, user, business, and evidence context before making UX decisions.
Practice Mode	Apply UX methods to a concrete product problem and produce a usable decision/artifact.
Extract Mode	Capture reusable UX principles/patterns from observed work or evidence.
Research Mode	Plan/interpret UX research and connect findings to product decisions.
Service design	Blueprint cross-channel/frontstage/backstage service behavior and dependencies.
Interaction patterns	Choose or evaluate interaction mechanics and behavioral patterns.
Information architecture	Structure navigation, labeling, hierarchy, grouping, and findability.
Content strategy	Plan product content systems, hierarchy, terminology, and governance.
Ethical design	Evaluate coercion, manipulation, consent, user agency, and harmful incentives.
Accessibility	Apply UX-level inclusive/accessibility reasoning and requirements.
Measurement	Define UX outcomes, signals, metrics, and evidence plans.

skill-ratchet — skill lifecycle routes

Route	Use it for
Preflight	Decide whether a new/changed skill is justified, correctly owned, and ready for the Ratchet.
Author / modify	Add or materially change a skill with canonical, negative, regression, and adversarial acceptance cases.
Evaluate	Compare candidate behavior against a baseline/evidence contract.
Validate	Run structural validation and, when receipts exist, complete digest-bound Strong + Weaker qualification.

performance — measurement routes

Route	Use it for
Performance investigation	Measure the actual symptom, explain where the time/resources go, optimize in impact order, and verify the result.
Databases & runtime	Load deeper guidance when the bottleneck involves queries, indexing, memory, concurrency, runtimes, pools, or backend execution.

codex-dynamic-workflows — multi-agent orchestration building blocks

Route	Use it for
Workflow artifact / Read Set	Define the shared objective, authoritative context, boundaries, and artifacts subagents may rely on.
Work packets	Give each agent one bounded task with explicit inputs, outputs, allowed scope, and completion evidence.
Doubt Gate	Stop integration when unresolved uncertainty remains instead of letting agents silently guess.
Verification / integration	Independently reconcile agent outputs and prove the combined result before declaring completion.

github-delivery — Git/GitHub delivery routes

These routes are normally selected from natural-language intent; they are not a set of mandatory CLI commands.

Planning and intake

Route	Use it for
PRD	Turn a product/engineering goal into a scoped delivery-oriented requirements document.
Issue breakdown	Decompose a larger initiative/PRD into implementation-sized issues.
Create issues	Create the agreed GitHub issues with preserved scope and dependencies.
Triage	Classify incoming issues/work and decide ownership, urgency, and next action.
QA intake	Convert QA findings/repro evidence into actionable engineering work.
Refactor plan	Structure a behavior-preserving refactor into reviewable delivery steps.
Agent brief	Produce a bounded implementation brief another coding agent can execute safely.
Out of scope	Record follow-up work discovered during delivery without silently expanding the current PR.

Building and publishing work

Route	Use it for
Git workflow	Branching, commits, synchronization, worktrees, and safe repository-state operations.
Research issue	Investigate an issue/bug before deciding whether implementation is warranted.
Create PR from local work	Publish already-existing local commits/changes as a correctly based pull request.
Create PR for issue	Take an issue-scoped implementation through branch/commit/PR creation.
Work-item delivery	Carry a bounded issue/task through implementation evidence and PR delivery.
Multi-base delivery	Deliver related work that intentionally targets different base branches.
Stacked PRs	Create/manage dependent PRs with explicit base relationships and merge order.
Consolidate PRs	Combine overlapping/fragmented pull requests into a coherent delivery when justified.
Release prep	Prepare branch/PR/release state for an intended release cut.

Reviews, bots, CI, and status

Route	Use it for
Fix PR bots	Resolve actionable automated-review/bot findings without blindly accepting them.
Watch PR	Follow a PR/CI/review loop, react to meaningful changes, and report only useful state transitions.
Re-review PR	Re-check a PR after fixes/new commits against prior findings and current code.
Open-work status	Summarize the state of open delivery work without mutating anything.
Full PR review	Read-only comprehensive review across correctness, architecture, tests, security, and maintainability.
Spec/standards review	Check a PR against an explicit spec, contract, standards document, or acceptance criteria.
Simplify PR	Apply the canonical simplification owner to the PR's current implementation and delivery context.
No-comments review	Review the code while treating explanatory comments as unavailable evidence.
Security review	Route PR/branch security assessment through the canonical security-review capability.
Status	Read-only current PR/branch/CI/review state.

Merge and branch lifecycle

Route	Use it for
Merge PR	Merge only after explicit authorization and fresh merge/head/CI verification.
Supersede PR	Replace an obsolete PR with a better/newer delivery while preserving rationale and links.
Overtake PR	Continue/replace work from another PR or branch when its implementation must be taken over.
Resolve conflicts	Resolve branch/PR conflicts without losing intended behavior or hiding semantic conflicts.

Aliases

Aliases exist for compatibility and route to canonical owners; prefer the canonical skill names in new documentation and automation.

Alias	Canonical owner	What it means
babysit	github-delivery	Watch/monitor a GitHub PR or CI loop.
babysit-pr	github-delivery	Compatibility spelling for babysitting a pull request.
create-pr-from-local-work	github-delivery	Publish already-existing local work as a PR.
review-security	security-review / github-delivery	Compatibility name for a security review request.

Install

The conventional user-level location is ~/.agents, but the Hub does not require one concrete home-directory layout.

Clone this published repository into that location. Do not clone the historical private operator checkout.

Windows x64 (supported Agent Hub host)

Install and maintain Agent Hub with PowerShell (pwsh) on Windows x64. macOS, Linux, ARM, and non-x64 Windows are not supported Agent Hub host platforms. Skills may still work on external projects targeting those systems.

git clone https://github.com/Wibias/agent-hub.git "$HOME\.agents"
Set-Location "$HOME\.agents"

Use the active host's normal instruction-discovery mechanism. Host-specific configuration belongs outside shared SKILL.md files unless the surface is explicitly portable.

Codex host setup / upgrade

After cloning or pulling a newer Agent Hub revision, inspect the complete managed Codex host state with one dry-run-first command:

node .\scripts\setup-codex-host.mjs

The command checks generated runtime drift before host mutation, plans the Agent Hub memory hooks, native Codex-memory isolation, and retirement of legacy mutable Agent Hub runtime profiles, then runs the existing read-only memory doctor.

If the plan is expected, apply only the managed changes:

node .\scripts\setup-codex-host.mjs --apply

The orchestrator reuses the existing safe installers and backup behavior. It does not trust changed hooks on the user's behalf. When hook definitions change, restart Codex and review/trust them through /hooks.

Individual scripts remain available for diagnostics, recovery, and narrow maintenance.

Verify an installation

Requires Node.js for the repository maintenance scripts.

node scripts/verify-public-release.mjs
node scripts/verify-portable-skills.mjs
node scripts/render-agent-runtime.mjs --check
node scripts/verify-skill-routing.mjs
node knowledge/build-index.mjs

After rebuilding the index, a clean canonical checkout should have no generated drift:

git diff --exit-code -- knowledge/INDEX.md knowledge/index.json

The release-governance workflow runs the wider deterministic suite in CI.

Skill discovery

Use the Skill guide above when a human wants to choose a capability. The generated indexes remain the canonical inventory for automation and discovery:

• knowledge/index.json for machines;
• knowledge/INDEX.md for agents and complete generated inventory.

The canonical build indexes the Hub itself plus declared external catalogs. Machine-local host caches and a specific project are opt-in inputs and are not part of the checked-in public index.

Local memory

The public repository ships memory structure, not a maintainer's history.

Tracked templates:

• memory/MEMORY.example.md
• memory/pending-rules.example.md
• memory/README.md

Local state is ignored:

• memory/MEMORY.md
• memory/pending-rules.md
• memory/notes/*.md

Initialize missing local state with:

node skills/extract-approach/scripts/ensure-memory-state.mjs

For the local durable-memory engine, a loopback-only console is available:

node .\scripts\memory-ui.mjs

Open http://127.0.0.1:4317 to browse projects, branches, Memories, Graph, Review, Pipeline, Health, Quality, and Stale views. Browsing keeps a read-only SQLite connection. Explicit Replace/Forget and candidate Confirm/Reject actions use token-protected same-origin POSTs and the existing Memory hook contracts.

The Review tab distinguishes actionable, direct-user candidate confirmations from evidence-bound proposals requiring a separate decision. The latter are displayed read-only with source authority, support evaluation, and suggested relation to existing Claims; they do not use the candidate Confirm/Reject endpoints. An evidence-bound approval protocol with exact user authorization, conflict checks, and an atomic audit trail is still required before these proposals can be accepted or dismissed from the UI. Do not change the canonical SQLite database manually to bypass this boundary.

The Graph view is diagnostic and read-only. It shows canonical Claims as nodes, lifecycle/conflict relations as explicit edges, and compatible-profile semantic similarity as clearly marked inferred edges. Search plus state/origin filters narrow the visualization, and a selected node can be opened in the existing Memories inspector. Raw embedding vectors are never exposed to the browser. The graph does not change production Recall/Judge authority; Graph Recall Shadow Mode remains separate follow-up work.

Portability contract

Shared skills should:

• use semantic locations such as ~/.agents, <project>, or an explicitly supplied path instead of a maintainer path;
• select shell syntax for the active operating system;
• avoid requiring one host connector, model identifier, or local cache layout;
• treat project-local assumptions as project-local guidance;
• keep secrets, transcripts, session state, and personal memory out of Git.

Runtime preferences and host capability claims live in agent-runtime/.

Changing skills

Before creating, merging, forking, or materially expanding a skill, run the skill-ratchet preflight and follow its qualification contract.

Shared-skill frontmatter or runtime-policy changes should also run:

node scripts/verify-portable-skills.mjs

The README skill map is intentionally curated rather than generated. The catalog coverage test requires every top-level skill to be documented exactly once and keeps the public routes of complex skills from silently disappearing from the human guide.

Keep tests focused on observable behavior and stable contracts.

Third-party material

Some skills are adapted from or integrate with upstream open-source projects. Keep their source attribution, notices, and component-specific license terms intact. This README does not replace those notices or declare a new repository-wide license.