Unified Agent Runtime Dispatch 1 Active Skill Compiled
1. Inbound Query "Review my loop..."
2. Master Agent Gemini / Muse
3. Tool Call refactor_code
4. Structured Output JSON Object
Context Overhead -74%
Bot Context Switching 0 Manual
Schema Safety Strict Type
Agent Interoperability Universal
Schema Output (Gemini 2.0 format)
// Generating compiled skill schema...
Skill compiled successfully. Ready for agent deployment.
Valid JSON Schema • 4 Properties

The Paradigm Shift: Task-Specific "Gems" vs. All-in-One Agent "Skills"

Why Google is Sunsetting Gemini Gems

Gemini Gems and OpenAI's Custom GPTs were designed as standalone custom prompt wrappers. Each time a user wanted a different task (writing code, generating charts, researching papers), they had to navigate to a distinct conversational bot. With modern reasoning models (Gemini 2.0, Meta's Muse, Anthropic Claude 3.5), all-in-one architectures automatically select tools on the fly from an active library of function schemas.

How Skills Enable Composable Automation

By transforming a Gem's prompt instructions into structured JSON schemas with typed inputs, an agent can chain multiple capabilities together in a single prompt. For example, an agent can invoke a Database Skill, feed the resulting records into a Data Cleaning Skill, and deliver the final answer without human intervention.

Agent Function Schemas & Tool Dispatch

How does converting natural language prompt instructions into structured JSON function declarations allow LLMs to invoke external tools?

Large language models do not execute code directly inside an API call; instead, function calling provides the model with structured schemas describing tool names, parameter types, descriptions, and required arguments. When a user prompt requires external data or action, the model outputs a structured tool call (such as a function name and JSON arguments) rather than freeform text. The host application executes that function and returns the structured result back to the model in a subsequent turn. This page provides a template compiler and deterministic dispatch mock illustrating how prompt bots translate into target schemas for Gemini, OpenAI, Claude, and OpenAPI.

This client-side demonstration parses preset templates or basic three-property fallbacks; it does not run an actual LLM, validate semantic parsing against custom prose prompts, or verify API endpoints in real time. The dispatch simulator displays hardcoded confidence scores (e.g., 98.4%) and mock string outputs without live inference. Furthermore, the telemetry metrics (such as -74% context overhead) are static visual UI badges rather than measured benchmarks.

Try a worked example

Select the 'SQL DB Query' preset chip. Notice that the Gem / Agent Name changes to 'SQL Query Generator & Explainer' and the Skill Identity updates to 'generate_sql_query'. Next, switch the 'Target Architecture Target' dropdown to 'Claude Tool Definition Schema'. The compiled JSON updates under the 'Generated Skill Schema' tab to output Claude's standard contract with top-level fields 'name', 'description', and 'input_schema' containing properties for 'natural_query', 'target_dialect', and 'include_explain_plan'.

Gemini Function Calling Architecture

In the Google Gemini API, tool declarations describe functions using a typed parameters object with properties and required fields. The model determines when to predict a function_call step rather than plain text, passing structured arguments for execution by the client application. Function calling with the Gemini API

The host application executes the function locally, wraps the return value in a function_result step, and supplies it back to the model across turns to complete the response. Function calling with the Gemini API

OpenAI and Anthropic Tool Contracts

OpenAI tool calling structures functions under a 'type': 'function' object containing 'name', 'description', and 'parameters' adhering to JSON Schema, with optional strict validation requiring explicit required properties. Function calling | OpenAI API

Anthropic Claude tool specifications define tools with 'name', 'description', and 'input_schema'. Claude returns a 'tool_use' block with an ID and parsed inputs, expecting the client to execute the operation and respond with a 'tool_result' block. Tool use with Claude - Claude Platform Docs

Sources and further reading

A changed instruction selects a generic schema

Read the explanation

This compiler constructs JSON locally. The code-reviewer preset has four properties: code, language, strict types and target complexity. If the trimmed instructions differ at all from the exact preset text, it switches to three generic fields: input payload, execution mode and include metadata. It does not infer a domain-specific schema from the edited instructions, and it never calls a model. The preset requires code and language. The generic branch requires only input payload. Optional fields still appear in the properties object. Switching output format wraps the same locally selected parameters using the chosen schema shape. The displayed provider names are labels in this source, not proof that these outputs satisfy a current remote API. OpenAI output slices the instruction prefix at one hundred eighty characters; Anthropic slices at one hundred fifty. Gemini uses one hundred sixty and appends three dots. OpenAPI keeps the full instructions. Identifiers are lowercased and each character outside letters, digits and underscore becomes an underscore. Export downloads the generated JSON. The dispatch demo only changes text and highlights four nodes; it does not invoke a skill.

Enjoy this tool? Build your own with Super