TSCG: Deterministic Tool-Schema Compilation for Agentic LLM Deployments

TSCG is a deterministic, dependency-free tool-schema compiler that significantly improves tool-usage accuracy for small and advanced LLMs in production environments by converting inefficient JSON schemas into token-efficient structured text, thereby resolving the format mismatch that currently causes the majority of tool-usage errors.

The Gist

Imagine you are trying to give a series of instructions to a very smart, but easily overwhelmed, assistant.

The Problem: The "JSON" Language Barrier
Currently, computer programs (such as AI agents), when they communicate with each other about which tools they have (like "search the internet" or "check the weather"), use a format called JSON. JSON is like a stubborn, technical filing system designed to be read quickly by computers. It is full of brackets, quotation marks, and repetitive labels.

For human-like AI models, especially the smaller and faster ones, reading this JSON is like trying to read a book where every single word is wrapped in a heavy, confusing plastic container. The AI gets so stalled by the "plastic" (the extra symbols and structure) that it forgets the actual instructions. The article calls this a "protocol mismatch." The AI is trying to read a computer file, not a sentence in natural language.

The Solution: TSCG (the "Translator" and "Editor")
The author, Furkan Sakizli, developed a tool called TSCG (Token-Context Semantic Grammar). Imagine TSCG as a super-fast, deterministic editor sitting between the computer and the AI.

Before the AI even sees the instructions, TSCG takes the chaotic JSON file and immediately rewrites it into a clean, naturally sounding text format. It is like taking a dense legal contract and rewriting it into a clear, bulleted list of instructions.

How it works (the 8 "Editors")
TSCG uses no magic or guesswork. It uses a fixed set of 8 specific rules (called "operators") to clean up the text:

1. It removes the baggage: It deletes polite words like "the following items" or redundant phrases that humans do not need to read.
2. It rearranges the furniture: It moves the most important parts of the instruction right to the beginning and right to the end, because AI models pay the most attention to the beginning and end of a sentence (like the "bookends" of a story).
3. It speaks the AI's language: It converts symbols into ones that the AI's internal dictionary recognizes as single "blocks" rather than multiple broken parts, which saves space.

The Results: A Miracle for Small Models
The article tested this on 12 different AI models, ranging from small (4 billion to 14 billion "brain cells") to massive, top-tier models.

• For the small models: The results were dramatic. Without TSCG, small models failed almost completely (0% accuracy) when given a list of 20 tools because the JSON was too confusing. With TSCG, their accuracy rose to 84%. It is as if the AI suddenly "woke up" and could finally understand the task.
• For the large models: Even the super-smart models got better. They became more accurate and consumed fewer "tokens" (the currency of AI thinking time), which saves money and time.

The "Aha!" Moment: It's About the Format, Not Just Compression
One of the most interesting results in the article is why this works. The author realized that for many small models, the problem was not just that the text was too long; it was that the format (JSON) was the enemy.

When the author compared "JSON text" with "plain text" (without any fancy compression), the plain text alone solved most of the problem. TSCG is the ultimate version of this: it corrects the format and compresses the text.

The "One-Size-Fits-All" Myth
The article also discovered that not all AI models react the same way.

• Some models are "hungry": They love every single rule TSCG applies and get smarter with every change.
• Some are "sensitive": They like some rules but get confused by others. If you give them too many changes, they actually get worse.
• Some are "robust": They hardly care; they work well no matter what happens.

This means there is no single "perfect" setting for every AI. You must tune the editor based on which AI you are using.

In Brief
TSCG is a free, open-source tool that acts as a translator. It takes the rigid, computer-only language of tool definitions and immediately converts it into a format that AI models can actually understand. This enables smaller, cheaper AI models to work effectively in real-world applications where they previously failed, and makes the largest models faster and more accurate. It is a simple solution to a confusing problem: Stop talking to the AI in computer code and start talking to it in clear text.

Technical Summary

Technical Summary: TSCG – Deterministic Tool-Schema Compilation for Agentic LLM Deployments

1. Problem Statement

Productive agent frameworks (e.g., OpenAI Function Calling, Anthropic Tool Use, MCP) transmit tool definitions to Large Language Models (LLMs) as JSON schemas. While JSON is optimized for deterministic machine parsing and human readability, it is suboptimal for interpretation by autoregressive language models.

This protocol mismatch creates a "capability cliff" for small models (4B–14B parameters). As the volume of JSON schema data increases, tool-call accuracy collapses, dropping to 0–49% for catalogs with more than 15 tools. This problem incurs three primary costs:

1. Token Costs: Schemas lead to purely structural redundancy and consume 3,000–25,000 tokens per call.
2. Capability Costs: Small models cannot reliably parse large-scale JSON-formatted schemas, leaving agentic capabilities locked behind frontier APIs.
3. Scaling Costs: Schema overhead grows linearly with catalog size.

The work frames this not merely as a compression problem, but as a protocol adaptation problem requiring a different representation at the API interface.

2. Methodology: The TSCG Framework

The authors introduce Token-Context Semantic Grammar (TSCG), a deterministic tool-schema compiler that transforms JSON schemas into token-efficient structured text. TSCG operates without model access, fine-tuning, or runtime search, functioning as a pre-tokenization compiler.

2.1 The Pipeline

TSCG applies a fixed pipeline of 10 deterministic transformations organized into five phases:

1. Parse: Segmentation of the input JSON.
2. Compression:
   • SDM (Semantic Density Maximization): Removes filler tokens (politeness markers, hedges, redundant connectors).
   • TAS (Tokenizer-Aligned Syntax): Selects delimiter variants that minimize token count based on BPE boundaries (e.g., -> instead of →).
   • DRO (Delimiter-Role Optimization): Replaces verbose structural phrases with compact delimiters.
3. Structural:
   • CFL (Constraint-First Layout): Moves output constraints to position 0 to exploit the "Attention Sink" phenomenon.
   • CFO (Causal-Forward Ordering): Reorders multi-step operations in topological order to ensure prerequisites are causally accessible.
4. Fragility:
   • CAS (Causal Access Score): Rates atoms by fragility (importance vs. accessibility) and places highly fragile atoms at the beginning (Attention Sink) and end (Recency Bias).
   • SAD-F (Selective Anchor Duplication): Duplicates critical atoms within a token budget to reinforce key information.
5. Closure:
   • CCP (Causal Closure Principle): Adds a summary block at the end (although empirical results show this adds overhead without consistent accuracy gains).

2.2 Theoretical Foundations

The operators are based on three properties of causal autoregressive transformers:

• Causal Attention: Early tokens cannot access later ones; thus, prerequisites must precede dependent steps (CFO).
• Attention Sink: Position 0 receives disproportionately high attention; critical constraints should be placed there (CFL).
• BPE Non-Monotonicity: String length does not correlate linearly with token count; surface forms can be selected to align with learned BPE merges (TAS).

The framework provides a formal compression bound and guarantees a token reduction of $\ge 51\%$ for well-formed schemas.

3. Main Contributions

1. Formal Optimization Framework: An eight-operator system with mathematical specifications linked to transformer mechanics, satisfying tokenizer awareness and causal attention anchoring.
2. Mechanistic Decomposition: A "Format-versus-Compression" analysis showing that for small models, representation change (JSON to text) is the dominant mechanism, while structural compression benefits frontier models.
3. TAB Benchmark: The first tool-schema compression benchmark (TSCG-Agentic-Bench), consisting of approximately 19,000 API calls across 12 models (4B–32B local + 3 frontier) and 5 scenarios.
4. Enabling Small Models: Demonstration that TSCG restores accuracy for small models (4B–14B) from near-zero to functional levels (65–90%), enabling local deployments.
5. Pro-Model Operator Matrix: Identification of three distinct operator response profiles in frontier models (Operator-Hungry, Operator-Sensitive, Operator-Robust), proving that no universal configuration exists.
6. Scaling Characterization: Shows that accuracy benefits persist even with heavy production MCP schemas, even if they saturate on light synthetic catalogs.
7. Implementation: A 1,200-line TypeScript package with no dependencies, executing in sub-millisecond time.

4. Experimental Results

4.1 Restoration of Small Models

On the TAB benchmark, TSCG dramatically improved tool-use accuracy for small models:

• Phi-4 (14B): Restored accuracy from 0% to 84.4% with 20 tools (90.3% with 50 tools).
• Mistral 7B & Gemma 3 4B: Showed massive gains (+17 to +63 percentage points) with 20–50 tools.
• Decomposition: For these models, gains were driven primarily by format translation (converting JSON to structured text) rather than compression. Compared to a text baseline, the "compression" benefit vanished or reversed, confirming that the bottleneck was JSON parsing, not context length.

4.2 Performance of Frontier Models

For frontier models (Claude Sonnet 4, GPT-4o, GPT-5.2), TSCG offered genuine structural compression benefits:

• Claude Sonnet 4: Achieved 85.2% accuracy (vs. 74.0% native JSON) with 50.1% token savings.
• GPT-5.2: Showed significant gains (+29.7 pp) in Scenario A, although performance varied depending on the operator profile.
• Accuracy-Retained Ratio (ARR): TSCG achieved ARR values of 108–181% on the external validation benchmark BFCL.

4.3 Operator Sensitivity Archetypes

Experiments isolating per-operator effects revealed three distinct behavioral profiles:

• Operator-Hungry (e.g., Opus 4.7): Benefits from every operator; the full pipeline is optimal.
• Operator-Sensitive (e.g., GPT-5.2): Certain operators (such as CFO) can degrade performance; requires selective configuration.
• Operator-Robust (e.g., Sonnet 4): Invariant to most operators; any safe configuration works.

4.4 Scaling and Generalization

• Heavy Schemas: With heavy production MCP schemas (~10,500 input tokens), TSCG retained an accuracy advantage of +5.0 pp, while gains on light synthetic catalogs saturated at 75–100 tools.
• Benchmark Validity: The synthetic TAB benchmark predicted real MCP performance within 0.1 accuracy points.

5. Significance and Claims

The work claims that TSCG addresses a critical, previously unaddressed gap in agentic LLM infrastructure: the inefficiency of JSON schemas for model consumption.

• Architectural Shift: TSCG positions schema compression as an architectural decision (external compilation) rather than a prompt-engineering technique. This is necessary because tokenization occurs before the model, and the model cannot retrospectively "reframe" its inputs.
• Deployment Guide: The work provides a data-driven taxonomy for deployments. Small models require format translation (often via a "conservative" profile), while frontier models benefit from structural compression.
• Ecosystem Impact: The authors propose creating a community-curated registry of pre-compiled tool schemas, analogous to package registries (npm/PyPI), to standardize efficiency across the agentic ecosystem.

The work concludes that TSCG enables functional tool-use agents on local, privacy-constrained hardware while optimizing token usage for frontier models, all through a deterministic, dependency-free compiler.