Skills Registry

Relevant source files

The following files were used as context for generating this wiki page:

• SKILLS.md
• AGENT.md
• README.md
• config/default.json
• tests/test_autowire.py
• rust-terminal/src/ui/tui.rs

The Skills Registry is a modular, composable framework designed to manage and discover the capabilities of AI agents within the WIREDUP ecosystem. It serves as a central repository where discrete functions, known as "Skills," can be dynamically loaded, shared, and composed into complex behaviors. This system allows agents to extend their functionality at runtime by requesting specific capabilities from the registry based on task requirements.

The registry is tightly integrated with the Auto-Wiring Engine for dependency injection and the Agent System for capability execution. It supports a wide array of categories, including research, execution, reasoning, and communication, ensuring that agents have access to standardized tools for internet searching, code execution, and data transformation.

Sources: SKILLS.md:14-25, README.md:12-23

Architecture and Core Components

The Skills System operates as an ecosystem where multiple agents interface with a central registry to discover and utilize specialized skill sets.

Skill Ecosystem Overview

The diagram above illustrates how the Skills Registry acts as the intermediary between agents and specialized capability sets.
Sources: SKILLS.md:32-55

Key Data Structures

The system is built upon several core classes and structures that define how skills are represented and managed:

Component	Description
Skill	The base class for all capabilities, containing metadata (name, version, author) and the execution logic.
SkillParameter	Defines the input requirements for a skill, including type, default values, and validation constraints.
SkillContext	The execution environment providing state, session ID, and access to other skills during execution.
SkillRegistry	The central management unit responsible for registration, discovery, and lifecycle management.

Sources: SKILLS.md:20-25, SKILLS.md:405-430, AGENT.md:250-265

Skill Registration and Discovery

Skills are registered with the registry using unique identifiers and categories. This allows agents to search for capabilities using fuzzy matching or category-based filtering.

This sequence shows the typical flow of an agent discovering and then executing a skill through the registry.
Sources: SKILLS.md:370-390, tests/test_autowire.py:165-185

Registry Operations

The SkillRegistry class supports several critical operations for maintaining the capability matrix:

• Discovery: get(name), get_by_category(category), and search(query, fuzzy=True).
• Management: register(skill), unregister(name), enable(name), and disable(name).
• Metadata: get_metadata(name) and get_stats().

Sources: SKILLS.md:370-400

Capability Matrix

The system provides several built-in skills categorized by their primary function. These are configured via the config/default.json and documented in the skills matrix.

Built-in Skill Categories

Category	Example Skill	Description	Async
Research	web_search	Internet search via engines like Google.	✅
Execution	code_execution	Sandboxed code execution in various languages.	✅
Reasoning	text_generation	LLM-based text generation and summarization.	✅
Communication	notification	Sending alerts via Slack, Discord, or Email.	✅

Sources: SKILLS.md:85-350, SKILLS.md:660-680, config/default.json:45-55

Execution Logic Snippet

Skills utilize an asynchronous execute method that validates parameters against the SkillParameter definitions before processing.

async def execute(self, context: SkillContext, **kwargs) -> dict:
    # Validate inputs against SkillParameter definitions
    self.validate_parameters(kwargs)
    
    # Perform the discrete capability logic
    result = await self.process(**kwargs)
    
    return {
        'success': True,
        'result': result,
        'metadata': {'time': context.elapsed_time()}
    }

Sources: SKILLS.md:445-475, AGENT.md:255-270

Integration with NexTerm

The Rust-based terminal interface, NexTerm, provides a visual bridge to the Skills Registry. Through the TerminalUI, users can monitor active skills and registry status in real-time.

Terminal UI Data Flow

The diagram shows the bridge between the Rust UI and the Python Skills Registry.
Sources: rust-terminal/src/ui/tui.rs:135-170, README.md:25-35

NexTerm provides specific keybindings to interact with the registry:

• Ctrl+A: Displays the current Auto-wire and Skills Registry status.
• Ctrl+S: Lists all currently registered and available services/skills.
• ai <command>: Routes commands to agents who utilize the Skills Registry for fulfillment.

Sources: rust-terminal/src/ui/tui.rs:65-85

Dynamic Loading and Composition

The registry supports CompositeSkill and SkillPipeline structures, allowing developers to chain multiple discrete skills into a single workflow.

• Composite Skills: A single skill that internally calls other registered skills (e.g., a "Research and Summarize" skill that combines web_search and text_generation).
• Skill Pipelines: Sequential execution of skills where the output of one stage serves as the input for the next (Extract -> Transform -> Validate -> Store).
• Dynamic Loading: The SkillLoader class can scan directories or modules at runtime to populate the registry without requiring a system restart.

Sources: SKILLS.md:520-565, config/default.json:57-62

Conclusion

The Skills Registry is the foundational pillar for agent autonomy within WIREDUP. By decoupling specific capabilities from the agent's core logic, the system achieves a high degree of modularity and extensibility. Whether through simple CLI commands in NexTerm or complex automated pipelines, the registry ensures that capabilities are discoverable, validated, and executed in a consistent, sandboxed environment.