DEV Community

llimage
llimage

Posted on

Weapon: Give Your Agent a Real Skill Arsenal

#agents #ai #opensource #python

Weapon: Give Your Agent a Real Skill Arsenal

FROST Five-Dimensional Meta-Model Series · Part 1

An Embarrassing Scenario

Imagine you have an Agent. It's smart—it can write code, analyze data, search for information.

But when you ask it: "Help me build a crawler to scrape e-commerce prices and analyze trends," it freezes.

Not because it can't, but because it can't find what it knows.

It has a bunch of skills scattered across the codebase, but no unified place telling it: "You know these things, use them as needed."

This is the common problem with current Agent frameworks: skills exist, but they're unorganized.

Weapon Registry: Agent's Skill Armory

In FROST V4.1, we introduced the Weapon Registry.

A Weapon is not a traditional "tool" or "function"—it's:

A discoverable, composable, versionable skill unit.

Think of it this way:

  • Traditional Agent skills are like LEGO bricks scattered on the floor
  • FROST Weapons are like equipment neatly arranged in an armory, each with an ID, description, and use case

Three Core Capabilities

1. Registration: Give Skills an Identity 

from core.armory import Armory

# Create a weapon registry
armory = Armory()

# Register a weapon
armory.register(
    name="web_scraper",
    version="1.0.0",
    skill=WebScraperSkill(),
    metadata={
        "category": "data_collection",
        "description": "Scrape web data",
        "input_schema": {"url": "str", "selector": "str"},
        "output_schema": {"data": "list[dict]"},
    }
)

# Register another one
armory.register(
    name="trend_analyzer",
    version="1.0.0",
    skill=TrendAnalyzerSkill(),
    metadata={
        "category": "analysis",
        "description": "Analyze data trends",
        "input_schema": {"data": "list[dict]"},
        "output_schema": {"trend": "str", "confidence": "float"},
    }
)
Enter fullscreen mode Exit fullscreen mode

Every weapon has:

  • Unique name: web_scraper, no conflicts with other skills
  • Version number: 1.0.0, supports upgrades and rollbacks
  • Metadata: Input/output schemas, categories, descriptions

2. Discovery: Find Skills on Demand 

# Find by category
data_skills = armory.find_by_category("data_collection")
# => [web_scraper, api_fetcher, file_parser, ...]

# Find by capability (fuzzy match)
relevant = armory.find_by_capability("scrape web")
# => [web_scraper]

# List all available weapons
all_weapons = armory.list_all()
# => [web_scraper, trend_analyzer, code_writer, ...]
Enter fullscreen mode Exit fullscreen mode

Agents no longer need to hardcode "what I can do"—they dynamically discover which weapons they can use.

3. Composition: Stack Skills to Create New Capabilities 

# Define a composite weapon
armory.register_composite(
    name="ecommerce_price_tracker",
    components=["web_scraper", "trend_analyzer"],
    description="E-commerce price tracking and trend analysis",
    workflow="""
    1. Use web_scraper to scrape price data
    2. Pass data to trend_analyzer for analysis
    3. Return analysis report
    """
)

# Use the composite weapon
result = agent.execute("ecommerce_price_tracker", {
    "url": "https://example.com/product",
    "selector": ".price"
})
Enter fullscreen mode Exit fullscreen mode

Composite weapons let Agent capabilities grow exponentially:

  • 2 base weapons → 1 composite weapon
  • 10 base weapons → 100+ possible combinations

How Is This Different from Traditional "Tool Calling"?

Dimension Traditional Tool Calling FROST Weapon Registry
Discovery Hardcoded in source Dynamic query, matched by need
Versioning None Semantic versioning (1.0.0 → 1.1.0)
Metadata Simple function signatures Full input/output schemas + categories + descriptions
Composition Manual glue code Declarative composition, auto-generated workflows
Testability Need to mock entire tool chains Each weapon tested independently, compositions also testable

Key difference: The Weapon Registry makes skills first-class citizens, not just appendages to code.

A Real-World Scenario

Suppose you want to build an automated competitor analysis Agent:

The Traditional Way 

# Hardcode all steps
class CompetitorAnalyzer:
    def __init__(self):
        self.scraper = WebScraper()  # Hard dependency
        self.analyzer = TrendAnalyzer()  # Hard dependency
        self.reporter = ReportGenerator()  # Hard dependency

    def analyze(self, competitor_url):
        data = self.scraper.scrape(competitor_url)
        trend = self.analyzer.analyze(data)
        report = self.reporter.generate(trend)
        return report
Enter fullscreen mode Exit fullscreen mode

Problems:

  • ❌ Can't swap the scraper (unless you change the code)
  • ❌ Can't reuse the analyzer (tied to this class)
  • ❌ Can't dynamically choose tools (e.g., auto-select scraper type based on URL)

The FROST Way 

# Declarative composition
agent = Agent(armory=armory)

# Agent decides which weapons to use
result = agent.execute("competitive_analysis", {
    "competitor": "https://competitor.com",
    "metrics": ["price", "features", "reviews"]
})

# Agent's internal logic (automatic):
# 1. Query armory.find_by_capability("scrape web") → select web_scraper
# 2. Query armory.find_by_capability("analyze trends") → select trend_analyzer
# 3. Query armory.find_by_capability("generate report") → select report_generator
# 4. Compose and execute, return result
Enter fullscreen mode Exit fullscreen mode

Advantages:

  • ✅ Swap any weapon anytime (found a better scraper? Just register it)
  • ✅ Weapons are reusable (trend_analyzer works in other scenarios too)
  • ✅ Agent autonomously chooses the best weapon (based on metadata matching)

Why "Weapon" Instead of "Tool"?

This is FROST's design philosophy:

Tools are passive; weapons are active.

  • Tools wait for humans to use them
  • Weapons are Agent's equipment—Agent actively chooses and actively uses them

In FROST's family governance model:

  • Ancestor defines the constitution, specifying which weapons are available
  • Parent coordinates tasks, deciding which weapon combinations to use
  • Child executes specific operations, using weapons to complete tasks

The Weapon Registry makes this process auditable, controllable, and evolvable.

Next Up: Event

Weapons solve "what Agent can do."

But how do Agents collaborate? How do they know "task completed," "error occurred," "need help"?

The answer is Event—Agent's nervous system.

Next article preview: Event: Teaching Agents to "Shout Out"

Related Links

FROST: Giving agents lineage, memory, and honor.

Top comments (0)