Dynamic Skill Resolution

The context window problem

When your agent connects to a large tool or MicroSkill server, it can receive a list of every available tool — names, descriptions, and input/output schemas all included.

At small scale, that’s fine. At large scale, it falls apart.

And it isn’t just about token cost.

Long tool lists also make it harder for your model to pick the right tool. When it has to choose from too many similar options — with overlapping descriptions, similar schemas, and subtle differences — you’re more likely to run into:

• Wrong tool selection
• Hallucinated tool calls
• Invalid arguments
• Higher latency
• Higher token usage
• Weaker reasoning due to polluted context

We solve this for you by separating catalog size from the tool surface your agent actually sees. The catalog can be large; your agent’s context stays small.

From discovery to resolution

Basic discovery only answers one question:

"Which MicroSkills match this query?"

Together, OSRE and Squillify give your agent a short, permission-aware list of relevant MicroSkills. Your agent can then review the best match, retrieve its contract, and invoke it safely.

OSRE handles the search and ranking, combining:

• Keyword matching (with field-specific boosts)
• Alias matching
• Category filtering
• Tag indexing
• Positive and negative example signals
• Weighted hybrid scoring

Before OSRE even runs, the Squillify adapter layer takes care of authorization scoping for you:

• Tenant entitlement filtering
• API key grant filtering (via SearchScope)
• Access mode enforcement
• Result limiting

Once a search comes back, your agent can pull a full MicroSkill contract through platform.skill_contract_get and then run the MicroSkill through platform.skill_execute.

Search gives you a ranked list of matching MicroSkills with basic metadata. Contract retrieval gives you a complete, ready-to-use MicroSkill contract.

Capability Resolution and Execution Flow

Here’s the full picture of how we let your agents reach a large universe of MicroSkills without flooding their context window.

{
  "valid": true,
  "normalized": "[email protected]",
  "reason": null
}

Key principles

Minimal default context

Your agent doesn’t need the full catalog up front. It only needs a small tool surface:

• A search capability (platform.skill_catalog_search)
• A contract retrieval capability (platform.skill_contract_get)
• An execution capability (platform.skill_execute)

These three foundation tools are always visible in the MCP tool list, so your model starts lean and expands only when it actually needs to.

Intent-driven resolution

Your agent doesn’t have to know the whole catalog — it just has to express what it’s trying to do.

{
  "query": "validate an email address"
}

OSRE turns that intent into one or more matching MicroSkill summaries, ranked by relevance.

Authorization-aware resolution

You can trust that search never returns MicroSkills the caller isn’t allowed to use — the Squillify adapter layer makes sure of it. Results are scoped by:

• Tenant entitlements
• API key access mode (ALL_ENABLED_SKILLS, SELECTED_SKILLS, or NONE)
• API key MicroSkill grants
• Enabled MicroSkills
• Runtime policy

Contract-first invocation

For simple invocations, the ranked summaries from search already give you enough metadata to work with. When a MicroSkill is more involved, your agent can grab the full contract via platform.skill_contract_get.

A MicroSkill contract includes:

• Stable skill key and version
• Input and output schemas
• Required fields
• Usage limits
• Examples
• Execution and determinism information

Once your agent has the contract, it can build a valid invocation without any guesswork.

Transport independence

OSRE isn’t tied to MCP. It works just as well with:

• MCP
• REST
• Internal Java calls
• SDK-based agents
• Local agent runtimes
• Future protocol adapters

MCP is just one way in. OSRE is the resolution engine underneath.

Resolution flow

Here’s what a typical agent flow looks like:

1. Your agent receives a user request.
2. The model realizes it needs a capability.
3. That capability isn’t currently visible or known.
4. Your agent calls platform.skill_catalog_search with a natural language query.
5. We scope the search to the caller’s authorized catalog through the Squillify adapter.
6. OSRE searches and ranks the candidate MicroSkills.
7. Ranked MicroSkill summaries come back.
8. Your agent picks the best match.
9. If it needs more detail, your agent calls platform.skill_contract_get to grab the full contract.
10. Your agent calls platform.skill_execute with the MicroSkill name and arguments.
11. We validate, authorize, execute, meter, and hand back the result.

Example

User request: Validate this email address: [email protected]

{
  "query": "validate email address",
  "limit": 5
}

{
  "results": [
    {
      "name": "identity.validate_email_syntax",
      "score": 0.94,
      "match_type": "FUZZY",
      "rank": 1,
      "version": "1.0.0",
      "title": "Validate email syntax",
      "description": "Validate whether a string follows a valid email address syntax without sending network requests.",
      "category": "identity",
      "input_schema": [
        {
          "name": "email",
          "type": "string",
          "description": "Email address to validate.",
          "required": true
        }
      ],
      "tags": ["email", "validation", "identity"],
      "mode": "STRICT",
      "latency": "INSTANT"
    }
  ],
  "total_available": 44,
  "total_matches": 2,
  "total_matches_bounded": false,
  "query_used": "validate email address"
}

{
  "skill_name": "identity.validate_email_syntax",
  "arguments": {
    "email": "[email protected]"
  }
}

Search API

The search your agent talks to is exposed through platform.skill_catalog_search.

Search request

{
  "query": "email validation",
  "category": "identity",
  "limit": 10,
  "include_contract": "if_unique",
  "category_mode": "resolve"
}

Search response

{
  "results": [
    {
      "name": "identity.validate_email_syntax",
      "score": 0.94,
      "match_type": "FUZZY",
      "rank": 1,
      "version": "1.0.0",
      "title": "Validate email syntax",
      "description": "Validate whether a string follows a valid email address syntax.",
      "category": "identity",
      "input_schema": [
        {
          "name": "email",
          "type": "string",
          "description": "Email address to validate.",
          "required": true
        }
      ],
      "tags": ["email", "validation", "identity"],
      "mode": "STRICT",
      "latency": "INSTANT"
    }
  ],
  "total_available": 44,
  "total_matches": 3,
  "total_matches_bounded": false,
  "query_used": "email validation",
  "category_resolution": {
    "requested": "identity",
    "resolved": ["identity"],
    "mode": "exact",
    "confidence": 1.0,
    "taxonomy_version": "tool-category/v1"
  }
}

MCP integration

In MCP environments, we expose exactly three foundation tools instead of the full catalog.

Your MCP tool list contains:

• platform.skill_catalog_search
• platform.skill_contract_get
• platform.skill_execute

Standard MicroSkills never show up directly in the MCP tool list. You discover them through platform.skill_catalog_search and invoke them through platform.skill_execute.

That keeps your MCP tool list small while still giving you the full authorized catalog to draw from.

platform.skill_catalog_search
platform.skill_contract_get
platform.skill_execute

Your agent can search for capabilities through platform.skill_catalog_search, pull the full contract through platform.skill_contract_get, then run the MicroSkill it chose through platform.skill_execute.

That way you avoid injecting hundreds of schemas into the model context.

Security model

Rest easy: dynamic resolution doesn’t skip any of our security. Every layer still applies.

Scope handling

The scope your search runs over depends on your API key’s access mode.

For unauthenticated access (the public catalog REST API), a separate unscoped search serves public MicroSkill metadata without authorization filtering.

An API key should only ever search the MicroSkills it’s allowed to use. That protects you from both unauthorized execution and catalog leakage.

Static catalog vs dynamic resolution

The model we recommend is OSRE skill resolution with authorization scoping at the adapter layer.

Why OSRE matters

OSRE is more than just a convenience layer.

It’s what lets us scale from a small catalog to hundreds or thousands of deterministic MicroSkills without ever forcing your agent to carry the entire catalog in context.

It gives your agents access to large capability surfaces while preserving:

• Low context usage
• Deterministic contracts
• Authorization boundaries
• Predictable execution
• Low runtime overhead
• Protocol independence
• Future extensibility

Recommended agent behavior

When you integrate your agents with Squillify, we’d suggest this pattern:

1. Start with the three foundation tools.
2. Reach for platform.skill_catalog_search whenever a needed capability is missing.
3. Review the top matches and choose a MicroSkill only when its description and contract fit the task. If none clearly fit, refine your search instead of guessing.
4. Use platform.skill_contract_get to pull the full contract when input schemas are complex.
5. Validate the required fields from the input schema.
6. Invoke the MicroSkill through platform.skill_execute.
7. Cache resolved contracts locally when it makes sense.
8. Re-resolve whenever the task, tenant scope, or API key changes.

Available today

Everything you need for on-demand MicroSkill discovery is available today:

• Three lightweight MCP foundation tools
• Permission-aware ranked search
• Contract retrieval and governed execution
• Equivalent discovery endpoints for REST integrations
• Optional inline contracts for clear matches

Summary

We use OSRE to make large, deterministic MicroSkill catalogs genuinely usable by your AI agents.

Your agent doesn’t need to know every MicroSkill — it just needs to know how to find the right one when the moment comes.

That’s the shift:

From: load every tool into context.
To: resolve the right contract on demand.

It keeps your agents lean, cuts down on hallucinated tool usage, holds your authorization boundaries firm, and lets us grow the catalog without growing the model context.