Build a Modular Skill-Based Agent System for LLMs with Dynamic Tool Routing

Build a Modular Skill-Based Agent System for LLMs with Dynamic Tool Routing in Python

Sana Hassan presents a modular agent framework that structures AI capabilities like an operating system. This system utilizes a centralized Skill Registry to manage self-describing, versioned, and composable tools.

Why This Matters

Moving from monolithic LLM prompts to modular agentic systems improves maintainability and scalability. By treating skills as individual system calls, developers can mitigate the high costs of context window bloat and improve reasoning accuracy through specialized, task-specific tools that provide structured and verifiable outputs.

Key Insights

• The Skill Registry acts as a central catalog for agent capabilities, mimicking an OS syscall table for AI agents.
• Each skill is encapsulated with metadata and JSON schemas, enabling seamless integration with OpenAI tool-calling APIs.
• Composite skills allow for fractal architecture, where complex tasks like research reporting are orchestrated by chaining simpler sub-skills.
• The SkillLoader component facilitates runtime extensibility, allowing agents to hot-swap new capabilities without system downtime.
• Internal observability via a dedicated dashboard provides real-time tracking of latency and call counts, ensuring performance transparency in multi-step reasoning loops.

Working Examples

The base abstract class for all agent capabilities, facilitating self-description and OpenAI tool compatibility.

class Skill(ABC):
    def __init__(self):
        self.metadata = self._define_metadata()
        self.schema = self._define_schema()
        self._call_count = 0

    @abstractmethod
    def execute(self, **kwargs) -> Any: ...

    def to_openai_tool(self) -> dict:
        return {
            "type": "function",
            "function": {
                "name": self.metadata.name,
                "description": self.metadata.description,
                "parameters": self.schema,
            }
        }

Practical Applications

• Use case: ResearchReportSkill orchestrates TextSummarizer and DataAnalyst for automated reporting. Pitfall: Deeply nested composite skills can exceed the agent max_iterations limit.
• Use case: SkillIntrospector allows agents to query their own registry when tasks are ambiguous. Pitfall: Vague skill descriptions lead to incorrect tool selection by the model.

References:

• https://www.marktechpost.com/2026/05/05/build-a-modular-skill-based-agent-system-for-llms-with-dynamic-tool-routing-in-python/