Ai Agent Tool Routing logo

Ai Agent Tool Routing

Community
FrancoStino
ai-agent-tool-routing

Use when designing or reviewing an AI agent tool registry or MCP router: document parameter schemas, caller authorization, execution limits, replay-safe retries and verification evidence.

Overview

PublisherFrancoStino
Repositoryopencode-skills-collection
Skill nameai-agent-tool-routing
Stars
90
Forks
12
Bundled files
Instructions only
LicenseMIT
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • Self-contained

    Everything the model needs lives in the instructions — no extra files to sync.

  • Open source

    Published by FrancoStino on GitHub. Read the source before you install it.

Installation

Install the Ai Agent Tool Routing AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
    https://github.com/FrancoStino/opencode-skills-collection/tree/main/bundled-skills/ai-agent-tool-routing
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/FrancoStino/opencode-skills-collection.git /tmp/opencode-skills-collection
mkdir -p .claude/skills
cp -r /tmp/opencode-skills-collection/bundled-skills/ai-agent-tool-routing .claude/skills/ai-agent-tool-routing
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Ai Agent Tool Routing in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Ai Agent Tool Routing on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Ai Agent Tool Routing is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

AI Agent Tool Routing Register

When to Use

  • Define which tools an agent may call, their parameter schemas and runtime limits.
  • Review a proposed tool registration before connecting it to an agent runtime.
  • Document timeout, retry and authorization contracts for an existing router.

Scope and prerequisites

This skill produces a register and a verification plan. A register does not implement a router or establish that a tool is safe. Read the actual server/tool schema and the application's identity and permission model. Record observed configuration separately from proposed policy. Do not invoke registered tools, read credentials or enable a production registration merely to fill the table.

Workflow

  1. Identify a task, the calling principal/tenant, the intended tool and its read or write effect. Tool names, model output and descriptions are not authorization.
  2. Read the advertised schema and implementation boundaries. Define required fields, additional-field rejection, length/range limits and schema version. Prefer rejection to guessed or lossy coercion. Schema validation does not enforce row-level authorization, path containment or network restrictions.
  3. Describe identity propagation and server-side resource checks. Bind a request to the verified principal; never let a tool argument select an arbitrary tenant.
  4. Set measured/project-approved timeout, rate, concurrency, response-size and cost limits. Cancellation must propagate to downstream work where supported; returning a timeout alone does not prove a write did not finish.
  5. Classify retries by effect. Retry only classified transient failures within a bounded budget. A write requires a verified server-side deduplication contract and reconciliation for ambiguous completion; a random key alone is insufficient.
  6. Define adversarial and failure cases: missing/unknown arguments, wrong tenant, denied resources, unavailable tool, oversized response and late completion.
  7. Record actual test evidence and unresolved gaps. Keep status Draft until the required checks ran against the exact runtime and schema revision. A register label never grants execution permission.

Field reference

FieldTypeExample / interpretation
tool_idstring, primary keyTOOL-001; use TEXT/VARCHAR, not a SERIAL integer
canonical_namestringread_document; match the advertised tool exactly
serverstringproject-docs local MCP; identify the actual installation
invocation_modeenumsynchronous / asynchronous / scheduled
effectenumread / write; unknown effects stay unresolved
parameter_schemaobject or immutable referencerequired document_id, unknown fields rejected
authorization_policyimmutable referenceverified caller plus document ownership check
runtime_limitsobjectillustrative timeout 5000 ms, response 65536 bytes
retry_contractobjectmaximum attempts, transient classes, deduplication evidence
statusenumdraft / tested / deprecated / blocked
evidencearray of referencesexact implementation revision, case IDs and observed results

For SQL or Notion exports, retain these distinctions: textual IDs stay strings; objects/arrays need a deliberate JSON representation or related tables; dates must use actual date values. Do not treat a checklist boolean as a proved control. Escape spreadsheet formula-like text as text when exporting user-supplied fields.

Worked example

An agent needs a document summary. The proposed tool accepts only a document ID; the server obtains the caller from verified session context, not from arguments.

json
{
  "tool_id": "TOOL-001",
  "canonical_name": "read_document",
  "server": "project-docs",
  "effect": "read",
  "parameter_schema": {
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "type": "object",
    "properties": {"document_id": {"type": "string", "minLength": 1, "maxLength": 80}},
    "required": ["document_id"],
    "additionalProperties": false
  },
  "runtime_limits": {"timeout_ms": 5000, "max_response_bytes": 65536},
  "retry_contract": {"max_attempts": 2, "retry_on": ["transient_unavailable"]},
  "status": "draft",
  "evidence": []
}

These limits are illustrative requirements, not measured service capabilities. The local schema can reject an added tenant_id, but an existing document ID still requires server-side ownership authorization. Expected negative checks: missing ID rejected, extra tenant rejected, another tenant's document denied, timeout reported without fabricated content. A positive authorized read alone does not close the negative cases. Promote to tested only with recorded actual results.

Limitations

  • No RPC, blockchain, relayer or transaction-signing prerequisite applies to this generic agent-tool register; a real tool may declare separate dependencies.
  • This document supplies no production router, authentication adapter or sandbox.
  • Declared retry/idempotency/rate limits must be enforced by the actual runtime.
  • Never log sensitive arguments or full results by default. Use case IDs and redacted error categories; preserve uncertainty after an ambiguous write.

Related skills

Read mcp-builder, mcp-server-security or error-handling-patterns when their actual scope fits the integration. They do not establish correctness by association.

Frequently asked questions

What does the Ai Agent Tool Routing AI skill do?

Use when designing or reviewing an AI agent tool registry or MCP router: document parameter schemas, caller authorization, execution limits, replay-safe retries and verification evidence.

Why use Ai Agent Tool Routing on TypingMind?

Because you install it once and use it with any model. Ai Agent Tool Routing is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Ai Agent Tool Routing in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/FrancoStino/opencode-skills-collection/tree/main/bundled-skills/ai-agent-tool-routing. TypingMind reads its SKILL.md and installs it as a skill you can enable per chat.

Which AI models can use Ai Agent Tool Routing?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Ai Agent Tool Routing?

As many as you like. As long as a model supports skills, you can use Ai Agent Tool Routing with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Ai Agent Tool Routing AI skill free?

Yes. It is published on GitHub by FrancoStino under the MIT license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇