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"},
    }
)

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, ...]

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"
})

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"?

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

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

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 Teaching Framework: https://gitee.com/liao_liang_7514/frost
• FROST-SOP Engineering Platform: https://gitee.com/liao_liang_7514/frost-sop
• Five-Dimensional Meta-Model Whitepaper (coming soon)

FROST: Giving agents lineage, memory, and honor.