/agents

Operations L2+ Production medium usage

/agents

Overview

The /agents command provides comprehensive discovery, listing, and management capabilities for the 400+ AIAD agents that constitute the Prismatic Platform's autonomous intelligence ecosystem. As the primary interface for agent ecosystem visibility, this command enables operators to search agents by domain, inspect individual agent capabilities, monitor agent health and status, and retrieve statistical summaries of the entire agent fleet. In a platform where agents are the fundamental units of autonomous execution, understanding the available agent landscape is essential for effective orchestration and task delegation.

The scale of the Prismatic Platform's agent ecosystem demands dedicated tooling for discovery and management. With agents spanning over a dozen specialized domains -- from OSINT intelligence operations and storage architecture to security operations and developer experience -- finding the right agent for a specific task requires structured search and filtering capabilities. The /agents command addresses this need by providing multiple query modes: domain-based filtering, keyword search, individual agent inspection, capability matching, and aggregate statistics. Each query mode returns structured output designed for both human consumption and programmatic integration.

The command is coordinated by the supreme-coordinator agent, reflecting its cross-domain nature. Unlike commands that operate within a single domain, the /agents command must have visibility across all agent domains, hierarchies, and classifications. The supreme-coordinator brings the authority and cross-domain awareness necessary to present a unified view of the entire agent ecosystem, including agents at every authority level from L4 Tactical Specialists through SUPREME and COSMIC clearance levels.

Usage

/agents [ACTION] [FILTER or AGENT-ID]

List All Agents in the Ecosystem

/agents list

Search Agents by Domain or Keyword

/agents search osint

Display Detailed Information for a Specific Agent

/agents show intel-osint-specialist

List Agent Capabilities Within a Domain

/agents capabilities storage

Check Health and Status of All Agents

/agents status

Retrieve Aggregate Agent Statistics

/agents stats

Options and Parameters

ParameterPositionRequiredTypeDefaultDescription
action1NostringlistAction to perform: list, search, show, capabilities, status, stats
filter_or_id2Nostring--Filter pattern for search, agent ID for show, domain for capabilities

Action Descriptions

ActionPurposeOutput
listDisplay all agents grouped by domainHierarchical domain-grouped agent listing
searchFind agents matching a keyword or patternFiltered agent list with relevance indicators
showDetailed view of a single agentFull agent specification, capabilities, and history
capabilitiesList capabilities within a domainCapability matrix for the specified domain
statusHealth monitoring dashboardAgent health, uptime, and error rates
statsAggregate statisticsTotal counts, domain distribution, authority breakdown

Authority and Access

PropertyValue
Authority LevelL2+ (Operational and above)
Executing Agentsupreme-coordinator
StatusProduction
Usage FrequencyMedium
CategoryOperations
Modelclaude-sonnet-4-20250514
ToolsRead, Grep, Glob, Bash
AIAD Version1.0.0
Agent Registry.claude/AGENT_REGISTRY.md

Technical Implementation

The /agents command operates by scanning the AIAD agent specification directory (.aiad/agents/) and the agent registry (.claude/AGENT_REGISTRY.md) to build a comprehensive view of the agent ecosystem. Agent specifications are parsed from their .agent.md files, extracting metadata including domain classification, authority level, capabilities, version, and status. The implementation leverages the platform's Git Trees infrastructure for high-performance file discovery.

defmodule PrismaticAgents.Discovery.Command do
  @moduledoc """
  Agent discovery and management command handler.
  Provides comprehensive agent ecosystem visibility with
  multi-domain search, filtering, and health monitoring.
  """

  @agent_spec_dir ".aiad/agents/"
  @agent_registry ".claude/AGENT_REGISTRY.md"

  @spec list(keyword()) :: {:ok, map()}
  def list(opts \\ []) do
    agents =
      discover_all_agents()
      |> group_by_domain()
      |> apply_filters(opts)
      |> sort_by_authority()

    {:ok, %{
      total: count_total(agents),
      domains: map_size(agents),
      agents_by_domain: agents
    }}
  end

  @spec search(String.t()) :: {:ok, [map()]}
  def search(pattern) do
    results =
      discover_all_agents()
      |> Enum.filter(&matches_pattern?(&1, pattern))
      |> Enum.sort_by(& &1.relevance_score, :desc)

    {:ok, results}
  end

  @spec show(String.t()) :: {:ok, map()} | {:error, :not_found}
  def show(agent_id) do
    case find_agent_by_id(agent_id) do
      nil -> {:error, :not_found}
      agent -> {:ok, parse_full_specification(agent)}
    end
  end

  defp discover_all_agents do
    Path.wildcard(Path.join(@agent_spec_dir, "*.agent.md"))
    |> Enum.map(&parse_agent_spec/1)
    |> Enum.reject(&is_nil/1)
  end

  defp group_by_domain(agents) do
    Enum.group_by(agents, & &1.domain)
  end
end

The output format varies by action. The list action produces a hierarchical view grouped by domain, with each domain showing its agent count and the individual agents within it. The search action returns a flat list sorted by relevance. The show action returns the complete parsed specification for a single agent. The stats action computes aggregate metrics including total agent count, domain distribution, authority level breakdown, and status distribution.

Domain Categories

The agent ecosystem is organized into the following primary domains, each containing specialized agents with domain-specific capabilities:

DomainDescriptionAgent Count Range
Supreme CommandPlatform-wide coordination and strategic operations5-10
Strategic PlanningLong-term architecture and roadmap planning10-20
Tactical OperationsExecution-level task coordination20-30
OSINT IntelligenceOpen-source intelligence gathering and analysis40-50
Storage & DatabaseData persistence, caching, and query optimization25-35
Web & FrontendLiveView, TailwindCSS, and UI components15-25
Analytics & IntelligenceData analysis, reporting, and ML integration15-25
Testing & QATest generation, quality assurance, and validation20-30
DocumentationTechnical writing, ADRs, and knowledge management10-15
DevOps & CI/CDDeployment, monitoring, and infrastructure15-25
SecurityVulnerability analysis, compliance, and defense20-30
PerformanceOptimization, profiling, and benchmarking10-15
EvolutionSelf-improvement, meta-evolution, and adaptation10-15
Color TeamsRed, Blue, Purple, Gray, White, Black team operations20

Workflow Integration

The /agents command is a starting point for many platform workflows. Before initiating a complex operation, operators use /agents search to identify which agents are available for the task at hand. For example, before launching an OSINT investigation, an operator might run /agents capabilities osint to understand which intelligence-gathering capabilities are available.

The command is also essential for platform administration. Running /agents status regularly provides early warning of agent health issues, enabling proactive intervention before degraded agents impact operations. The stats action supports capacity planning by revealing the distribution of agents across domains and identifying areas where additional agent coverage may be needed.

During development sessions, /agents show <agent-id> provides the detailed specification needed to understand how to invoke a specific agent, what parameters it accepts, and what outputs it produces. This eliminates the need to manually navigate the AIAD specification directory and parse raw markdown files.

Integration Points

ComponentRelationship
Prismatic AgentsPrimary target of discovery and management operations
AIAD RegistrySource of agent specifications and metadata
Quality GatesPre/post execution quality validation
TelemetryCommand execution metrics and agent health tracking
Session ContextAgent discovery results logged in session context
/orchestrateMulti-agent orchestration uses agent discovery for task assignment
/aiad-dashboardDashboard displays agent metrics discovered by this command
Mycelial NetworkAgent coordination patterns visible through network topology

Doctrine Compliance

All agent management operations are governed by the NO MERCY, NO DOUBTS doctrine:

  • NO MERCY: Agent discovery must be complete and accurate. No agents are omitted from results due to performance shortcuts or lazy enumeration. The list action returns every agent in the ecosystem without exception. The status action reports honest health metrics including degraded and failed agents -- no status whitewashing.
  • NO DOUBTS: Agent specifications are parsed and validated before presentation. When the show action displays an agent's capabilities, those capabilities are verified against the actual agent specification file. Discrepancies between the registry and individual specification files are flagged rather than silently resolved. Evidence-based health metrics are derived from actual telemetry data, not assumptions.

Best Practices

  1. Start with search before orchestration: Before invoking complex multi-agent operations, use /agents search to verify that the required agents exist and are in production status. This prevents orchestration failures due to referencing agents that are experimental or deprecated.

  2. Monitor agent health regularly: Run /agents status at the beginning of each development session to identify any agents that may have degraded since the last session. Proactive health monitoring prevents cascading failures in multi-agent workflows.

  3. Use domain filtering for focused discovery: When working within a specific domain, use /agents capabilities <domain> rather than the full list action. This provides a more focused view and reduces cognitive load.

  4. Inspect before invoking unfamiliar agents: For agents you have not worked with previously, use /agents show <agent-id> to understand the agent's full specification, including authority requirements, tool access, and expected inputs/outputs.

  5. Track agent statistics over time: Periodic /agents stats snapshots reveal the growth and evolution of the agent ecosystem, helping identify trends in domain coverage and overall platform capability.

  • /aiad-dashboard - AIAD dashboard for intelligence and domain monitoring
  • /orchestrate - Multi-agent orchestration for complex operations
  • /commit - Smart commit with quality gates and conventional format
  • /connect - MCP server connection management across 14+ servers
  • /code - Core coding implementation and feature development
  • /fix - Bug fix implementation with mandatory regression tests
  • /evolve - Living AIAD ecosystem evolution with 5-phase cycle

Connect & Contribute

Created by Tomáš Korcak (korczis) | Open Source under GHL