Skip to content
/
Tier A A8 Cross-runtime harness

AgentSys (avifenesh/awesome-slash)

awesome-slash-commands · avifenesh/awesome-slash · ★ 823 · last commit 2026-05-21

Orchestrate everything around code-writing — task selection, branch management, review, PR, merge, memory — via structured pipelines with gated phases and persistent state.

Best whenCode does code work (deterministic static analysis); AI does AI work (synthesis, planning, review) — mixing the two wastes tokens and degrades quality.
Skip ifUsing LLMs for detection tasks (regex/AST is faster and deterministic), Skipping structured pipelines and going ad-hoc
vs seeds
superpowers(skills-only), AgentSys is command-primary with hierarchical multi-agent orchestration.
Primitive shape 122 total
Commands 24 Skills 47 Subagents 50 Hooks 1
00

Summary

AgentSys (avifenesh/awesome-slash) — Summary

AgentSys is a modular multi-platform agent orchestration system distributed as an npm package and Claude Code marketplace entry, comprising 26 plugins, 50 agents (40 file-based + 10 role-based specialists), and 47 skills across all installed plugins — 5 platforms supported (Claude Code, OpenCode, Codex CLI, Cursor, Kiro). The system's core thesis is "code does code work, AI does AI work" — using regex/AST/static analysis for detection tasks (no tokens wasted) and reserving LLM calls for synthesis, planning, and review. Each plugin is an independently versioned GitHub repository under the agent-sh organization; agentsys (the main repo, originally avifenesh/awesome-slash) is the marketplace and installer. AgentSys ships a dedicated CLI binary (agentsys), a PostToolUse hook enforcing script-failure reporting, and benchmarked evidence showing Sonnet + AgentSys outperforms raw Opus at 40% lower cost on the same tasks. State persists across sessions via two files (task state + axiom memory). The audit-project command runs a multi-agent iterative code review — the most sophisticated orchestration in the pack.

differs_from_seeds: Closest to claude-flow (both are large multi-plugin npm packages with persistent state and multi-agent orchestration) but AgentSys uses a marketplace-of-plugins model with independently versioned repos rather than a monolithic MCP server. Unlike superpowers (skills-only, no commands), AgentSys is command-primary (24 commands). Unlike BMAD-METHOD (persona-based subagents), AgentSys agents are file-based skill activators with explicit model assignments. The agnix linter (423 validation rules for agent configs across 12+ platforms) is unique in the seed+batch corpus.

01

Overview

AgentSys (avifenesh/awesome-slash) — Overview

Origin

Created by Avi Fenesh (avifenesh). The repository (avifenesh/awesome-slash) hosts the main AgentSys marketplace package. Companion organization agent-sh on GitHub hosts all 26 plugin repositories. Version 5.14.0, MIT license. 823 stars, 91 forks. Actively maintained as of May 2026.

Philosophy

Verbatim from README:

"AI models can write code. That's not the hard part anymore. The hard part is everything around it - task selection, branch management, code review, artifact cleanup, CI, PR comments, deployment. AgentSys is the runtime that orchestrates agents to handle all of it - structured pipelines, gated phases, specialized agents, and persistent state that survives session boundaries."

"Detection: regex, AST analysis, static analysis - fast, deterministic, no tokens wasted" "Judgment: LLM calls for synthesis, planning, review - where reasoning matters"

"Benchmarked March 2026: Sonnet + agentsys produced more output with higher specificity than raw Opus - at 40% lower cost."

Certainty Levels

A distinctive design choice — all findings are graded:

  • HIGH: Definitely a problem. Safe to auto-fix.
  • MEDIUM: Probably a problem. Needs context.
  • LOW: Might be a problem. Needs human judgment.

"This came from testing on 1,000+ repositories."

Architecture Principle

Plugins are independent; agentsys is the marketplace and installer. Each plugin lives in its own repo under agent-sh org, has its own version, and can be installed individually or together.

02

Architecture

AgentSys (avifenesh/awesome-slash) — Architecture

Distribution

  • Type: npm-package + claude-plugin (marketplace)
  • Binary: agentsys (npm bin)
  • Version: 5.14.0
  • License: MIT
  • Language: JavaScript (Node.js CommonJS)

Install

Via npm:

npm install -g agentsys

Via Claude Code marketplace:

/plugin marketplace add avifenesh/awesome-slash
# or individual plugins:
/plugin install next-task@agentsys

Via Codex:

codex plugin install agentsys

Directory Structure

.claude-plugin/
  plugin.json          # Plugin manifest (name: agentsys, v5.14.0)
  marketplace.json     # Plugin registry (26 plugins with source URLs + commit SHAs)
.claude/
  settings.json        # PostToolUse hook for Bash tool
  hooks/
    enforce-script-failure-report.sh
.codex-plugin/         # Codex adapter
.kiro/                 # Kiro adapter
adapters/
  opencode/            # OpenCode adapter
  opencode-plugin/
bin/
  cli.js               # agentsys binary
  dev-cli.js           # agentsys-dev binary
scripts/
  [30+ dev/validation scripts]
lib/                   # Platform detection and core library (~30k lines)
__tests__/             # 3,518 tests

Required Runtime

  • node >= 18
  • Platform-specific: gh CLI (for PR plugins), git

Target AI Tools

  • Claude Code (primary)
  • OpenCode
  • Codex CLI
  • Cursor
  • Kiro
03

Components

AgentSys (avifenesh/awesome-slash) — Components

Commands (24)

Command Purpose
/next-task Master workflow: task discovery, implementation, PR, merge
/prepare-delivery Pre-ship quality gates: deslop, review, validation, docs sync
/gate-and-ship /prepare-delivery + /ship combined
/axiom Durable memory: load, query, list, bootstrap, record knowledge
/banthis Durable negative memory: persist banned agent behaviors
/agnix Lint agent configs (423 rules across 12+ platforms)
/ship PR creation, CI monitoring, merge
/deslop Clean AI slop patterns from code
/perf Performance investigation with baselines and profiling
/drift-detect Compare plan vs implementation
/audit-project Multi-agent iterative code review
/enhance Plugin, agent, and prompt analyzers
/repo-intel Unified static analysis: git history, AST symbols, project metadata
/sync-docs Sync documentation with code changes
/learn Research topics, create learning guides
/consult Cross-tool AI consultation
/debate Structured debate between AI tools
/web-ctl Browser automation for AI agents
/release Versioned release with ecosystem detection
/skillers Workflow pattern learning and automation
/skill-curator Create and improve reliable SKILL.md files
/system-prompt-curator Create and improve autonomous agent system prompts
/onboard Codebase orientation for newcomers
/can-i-help Match contributor skills to project needs

Skills (47 across plugins)

Workflow

discover-tasks, prepare-delivery, check-test-coverage, orchestrate-review, validate-delivery

Enhancement

enhance-agent-prompts, enhance-claude-memory, enhance-cross-file, enhance-docs, enhance-hooks, enhance-orchestrator, enhance-plugins, enhance-prompts, enhance-skills, skill-curator, system-prompt-curator

Performance

baseline, benchmark, code-paths, investigation-logger, perf-analyzer, profile, theory-gatherer, theory-tester

Cleanup

deslop, sync-docs

Code Review

audit-project

AI Collaboration

consult, debate, learn, recommend, skillers-compact

Onboarding

can-i-help, onboard

Web

web-auth, web-browse

Release

release

Analysis

drift-analysis, repo-intel

Memory

axiom, banthis

Linting

agnix

Message Queues (external plugin)

glide-mq, glide-mq-migrate-bullmq, glide-mq-migrate-bee

Agents (50)

40 file-based agents + 10 role-based specialists in audit-project. Each has:

  • Single responsibility
  • Specific model assignment
  • Defined inputs/outputs

Hooks (1)

Event Matcher Action
PostToolUse Bash enforce-script-failure-report.sh (reminds agent to report failures before falling back to manual work)

Scripts (30+)

Development/validation scripts: bump-version.js, generate-docs.js, validate-plugins.js, validate-counts.js, validate-cross-platform.js, expand-templates.js, gen-adapters.js, scaffold.js, preflight.js, stamp-version.js, and more.

CLI Binary: agentsys

Subcommands: validate, validate plugins, validate agent-skill-compliance, validate cross-platform, validate consistency, validate paths, validate counts, preflight, preflight --all, preflight --release, gen-docs, expand-templates, gen-adapters, new plugin, new agent, new skill, new command, bump, detect, verify

Plugins (26, in marketplace.json)

Each plugin is a separate GitHub repo under agent-sh org, independently versioned and installed by the agentsys marketplace. Examples: next-task (v1.1.2), prepare-delivery (v0.1.2), and 24 more.

05

Prompts

AgentSys (avifenesh/awesome-slash) — Prompt Excerpts

Excerpt 1: PostToolUse Hook Script (enforce-script-failure-report.sh)

Technique: Minimal PostToolUse hook with input parsing and conditional reminder injection

#!/usr/bin/env bash
# enforce-script-failure-report.sh
#
# Claude Code PostToolUse hook for Bash tool invocations.
# Detects project script execution and reminds the agent to report
# failures before falling back to manual work.
#
# Input: JSON on stdin with tool_input.command
# Output: Reminder text on stdout if project script detected, nothing otherwise.
# Exit: Always 0 (hooks must not block execution)

set -euo pipefail

INPUT=$(cat 2>/dev/null || true)
if [ -z "$INPUT" ]; then exit 0; fi

COMMAND=""
if command -v jq >/dev/null 2>&1; then
  COMMAND=$(echo "$INPUT" | jq -r '.tool_input.command // empty' 2>/dev/null || true)
else
  # Fallback: grep+sed for environments without jq
  COMMAND=$(echo "$INPUT" | grep -o '"command"[[:space:]]*:[[:space:]]*"[^"]*"' | ...)
fi

Analysis: Defensive hook design — always exits 0 (never blocks), gracefully handles missing jq via grep fallback, parses tool_input.command to detect project script invocations. Minimal footprint; only emits output when it has something to say.

Excerpt 2: plugin.json Manifest

Technique: Declarative plugin manifest with semantic versioning and multi-platform keywords

{
  "name": "agentsys",
  "version": "5.14.0",
  "description": "Professional-grade slash commands for Claude Code with cross-platform support",
  "keywords": ["workflow", "automation", "code-review", "ci-cd", "slop-detection", "task-management"],
  "author": {"name": "Avi Fenesh", "url": "https://github.com/avifenesh"},
  "repository": "https://github.com/agent-sh/agentsys",
  "license": "MIT"
}

Excerpt 3: Benchmark framing (README)

Technique: Evidence-based positioning with concrete cost/quality metrics

| Configuration       | Cost  | Output tokens | Result quality                         |
|---------------------|-------|---------------|----------------------------------------|
| Opus, no agentsys   | $1.10 | 2,841         | Generic recommendations, no context   |
| Opus + agentsys     | $1.95 | 5,879         | Specific, project-aware               |
| Sonnet + agentsys   | $0.66 | 6,084         | Comparable to Opus + agentsys          |

Sonnet + agentsys produced more output with higher specificity than raw Opus - at 40% lower cost.

Analysis: README-as-argument pattern; positions the system not by listing features but by providing before/after cost and quality benchmarks from real repo tests.

09

Uniqueness

AgentSys (avifenesh/awesome-slash) — Uniqueness & Positioning

differs_from_seeds

Closest to claude-flow (both are large multi-plugin npm packages with persistent state, multi-agent orchestration, and extensive command surfaces), but AgentSys uses a marketplace-of-independent-plugins model (26 separate repos under agent-sh) while claude-flow is a monolithic MCP server with 305 tools. Unlike superpowers (skills-only, no commands), AgentSys is command-primary. Unlike BMAD-METHOD (persona-based subagents), AgentSys agents are file-based with explicit per-agent model assignments. The agnix companion linter (423 rules, LSP, 12+ platforms) is unique in the entire seed+batch corpus — no other framework ships a validation tool for its own config format. The certainty-graded findings system (HIGH/MEDIUM/LOW from testing on 1,000+ repos) and benchmarked cost comparisons are also distinctive.

Positioning

  • Marketplace-of-plugins vs. monolithic framework
  • Certainty-graded outputs as a design principle (not just best effort)
  • Detection=static, judgment=LLM as an explicit separation
  • Durable memory (axiom) + negative memory (banthis) as first-class features
  • Most cross-platform of any framework in this batch (5 platforms)

Observable Failure Modes

  1. Plugin sprawl: 26 independent repos — version conflicts between plugins, inconsistent maintenance
  2. Shallow state: Two-file state is minimal compared to claude-flow's SQLite; complex long-running tasks may exceed what two files can track
  3. agnix dependency: Many plugins benefit from/require agnix validation; adds setup complexity
  4. No isolation: In-place edits mean a failed agent run can leave the repo in a dirty state

Most Distinctive Features

  1. The agnix linter — 423 rules, LSP, 12+ platforms — is the only per-config validator in the corpus
  2. Certainty grading (HIGH/MEDIUM/LOW) on all analysis outputs
  3. Negative memory (/banthis) — persisting "never do X" instructions across sessions
04

Workflow

AgentSys (avifenesh/awesome-slash) — Workflow

Primary Workflow: /next-task

1. /next-task → task discovery (repo-intel, static analysis)
2. → implementation (specialized agents with model assignment)
3. → PR creation (/ship)
4. → CI monitoring
5. → merge

Pre-Ship Workflow: /prepare-delivery

1. /deslop → remove AI slop patterns
2. /enhance → analyze and improve prompts/agents/plugins
3. /agnix → lint agent configs (423 rules)
4. orchestrate-review → code review pass
5. validate-delivery → final validation
6. /sync-docs → sync documentation

Phases + Artifacts

Phase Artifact
Task discovery Task list with priority ordering
Static analysis repo-intel output (git history, AST symbols, metadata)
Implementation Code changes
Review Severity-graded findings (HIGH/MEDIUM/LOW)
PR GitHub PR via /ship
CI monitoring Pass/fail status
Merge Merged branch

Approval Gates

The next-task plugin uses "workflow enforcement gates" — phases cannot be skipped. The axiom memory system records approved knowledge. No explicit count found in analyzed data; gates are embedded in pipeline logic.

Multi-Agent Flow: /audit-project

The audit-project command spawns 10 role-based specialist agents in an iterative code review:

  1. Each specialist reviews from its domain (security, performance, maintainability, etc.)
  2. Findings are aggregated
  3. Iteration continues until no new findings

Persistence

State persists across sessions via two-file approach (task-state + axiom knowledge store).

06

Memory Context

AgentSys (avifenesh/awesome-slash) — Memory & Context

State Storage

Two-file persistence for cross-session continuity (from next-task plugin README description: "two-file state management"):

  1. Task state file (tracks current task, status, progress)
  2. Axiom knowledge store (approved durable knowledge via /axiom)

Durable Memory: /axiom

The axiom command provides durable positive memory:

  • Load previously stored knowledge into context
  • Query knowledge by topic
  • Bootstrap new projects with stored patterns
  • Record approved knowledge for future sessions

Negative Memory: /banthis

The banthis command persists banned agent behaviors:

  • Records patterns the agent should never repeat
  • Survives session boundaries
  • Enables "never do X again" instructions that stick

Memory Persistence

Project-scoped (task state files live in the project). The axiom/banthis knowledge stores may be global (not confirmed from available data).

Compaction

The skillers-compact skill handles compaction for the skillers workflow pattern learning skill.

Context Strategy

The system uses enriched repo-intel context (static analysis + AST) to provide structured context rather than raw file reading, reducing token waste while improving specificity (as benchmarked).

07

Orchestration

AgentSys (avifenesh/awesome-slash) — Orchestration

Multi-Agent

Yes — /audit-project runs 10 role-based specialist agents in parallel iterative review. next-task uses 8 specialist agents.

Orchestration Pattern

Hierarchical (orchestrator command → specialized agents) + parallel-fan-out within audit-project (multiple specialists run simultaneously).

Isolation Mechanism

Unknown — not confirmed from available data whether worktrees or branches are used for agent isolation.

Multi-Model

Yes — agents have "specific model assignments" (from README: "Each agent has a single responsibility, a specific model assignment"). The next-task plugin explicitly mentions "model optimization (opus/sonnet/haiku)" in its description. The exact role → model mapping lives within individual plugin repos and was not fully enumerated.

Subagent Definition Format

File-based (40 file-based agents) + role-based (10 specialists in audit-project). Skills activate agents; commands orchestrate multi-agent pipelines.

Execution Mode

Interactive-loop / sequential-with-parallel-fan-out: next-task drives an autonomous workflow loop; audit-project fans out to specialists.

Consensus Mechanism

None described — audit-project aggregates findings but no formal consensus protocol.

Cross-Tool Portability

Medium — supports 5 platforms (Claude Code, OpenCode, Codex, Cursor, Kiro) via adapter directories, but primary design is Claude Code.

08

Ui Cli Surface

AgentSys (avifenesh/awesome-slash) — UI & CLI Surface

CLI Binary

  • Exists: yes
  • Name: agentsys (+ agentsys-dev)
  • Entry: ./bin/cli.js / ./bin/dev-cli.js
  • Is thin wrapper: no (substantial validation + scaffolding runtime)
  • Subcommands: validate, preflight, gen-docs, expand-templates, gen-adapters, new, bump, detect, verify (20+ subcommands)

The agentsys binary is primarily a developer tool for working on agentsys plugins themselves — not a user-facing execution binary. End users install via npm/marketplace and use slash commands inside Claude Code.

Local UI / Dashboard

None — terminal only.

IDE Integration

Supports Claude Code, OpenCode, Codex, Cursor, and Kiro via adapter directories. No VSCode extension.

Companion Tool: agnix

The /agnix command (and companion agnix CLI repo at agent-sh/agnix) provides:

  • 423 validation rules for agent configurations
  • Real-time IDE validation via LSP
  • Auto-suggestions and auto-fix
  • Supports Claude Code, Codex, OpenCode, Cursor, Kiro, Copilot, Gemini CLI, Cline, Windsurf, Roo Code, Amp, and more

This is the most sophisticated validation surface in the batch.

Observability

  • Certainty-graded findings (HIGH/MEDIUM/LOW) on all analysis commands
  • investigation-logger skill for performance investigations
  • Session cost/quality benchmarks published in README

Related frameworks

same archetype · same primary tool · same memory type

claude-mem (thedotmack) ★ 78k
A8 Cross-runtime harness

Background worker service captures every tool call as an observation, AI-compresses sessions, and auto-injects relevant past…

pi (badlogic/earendil) ★ 55k
A8 Cross-runtime harness

A minimal, hackable, multi-provider terminal coding agent that adapts to your workflows via npm-installable TypeScript Extensions…

Agent Skills (Addy Osmani) ★ 46k
A8 Cross-runtime harness

Encodes senior-engineer software development lifecycle as 23 auto-routed skills and 7 slash commands for any AI coding agent.

wshobson/agents Plugin Marketplace ★ 36k
A8 Cross-runtime harness

Single Markdown source for 83 domain-specialized plugins that auto-generates idiomatic artifacts for five AI coding harnesses.

TabbyML/Tabby ★ 34k
A8 Cross-runtime harness

Self-hosted AI coding assistant server (alternative to GitHub Copilot) with admin dashboard, RAG-based completions, and multi-IDE…

Compound Engineering ★ 17k
A8 Cross-runtime harness

Make each unit of engineering work compound into easier future work via brainstorm→plan→execute→review→learn cycles.