# Weapon: Give Your Agent a Real Skill Arsenal

> Source: <https://dev.to/llimage/weapon-give-your-agent-a-real-skill-arsenal-1cl3>
> Published: 2026-06-28 10:50:01+00:00

FROST Five-Dimensional Meta-Model Series · Part 1

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.**

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:

``` python
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:

`web_scraper`

, no conflicts with other skills`1.0.0`

, supports upgrades and rollbacks

``` js
# 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.

```
# 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:

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

Suppose you want to build an **automated competitor analysis Agent**:

``` python
# 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:

```
# 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:

This is FROST's design philosophy:

Tools are passive; weapons are active.

In FROST's family governance model:

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

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

*FROST: Giving agents lineage, memory, and honor.*