Transcend

The context tax

Every AI coding agent runs the same broken loop:

1. Call a CLI tool (grep, find, cat)
2. Receive kilobytes of human-formatted terminal output
3. Dump it into the context window
4. Parse it with the LLM — the world’s most expensive regex engine
5. Repeat

This works on toy projects. On real codebases it physically cannot work. A single ripgrep across a large repository can return tens of thousands of matches, and the standard agent workflow turns that into millions of tokens. No model on Earth has a context window that large — and even if it did, you’d be paying frontier prices to do string parsing.

Transcend makes it trivial: terminal text in, typed JSON contracts out, with 89–93% context reduction and reasoning payloads under 12KB across 24,000+ matches.

“But tools already have --json flags”

Some do. Most don’t. And even when they do, JSON output is not the same as a typed contract. rg --json emits NDJSON with envelope messages, redundant path repetition per match, nested stat objects, and begin/end wrappers that carry zero information for the agent. Multiply by 24,000 matches and you have megabytes of verbose, tool-specific JSON.

Three gaps that --json flags don’t close:

No normalisation. Every tool has a different schema. rg --json looks nothing like fd --json. Transcend normalises all of them into one universal output contract — same shape, every tool, every time.

No chaining without a context-window relay. Even with JSON output, the agent reads results into its context, extracts file paths, then generates the next call. Transcend chains skills in-process. The agent says “search, then replace” once; the intermediate file list never enters the context window.

No cross-tool contract. Raw tool JSON means N different schemas and arbitrary fallback behaviour when a binary isn’t installed. Transcend skills declare their fallbacks, and every fallback normalises to the same schema regardless of which binary actually executed.

Skill contracts

A Transcend skill is a .skill.json file: typed inputs, typed outputs, an execution template, and a normalisation pipeline. Every field is a contract — the agent knows what goes in, what comes out, what can chain next, and what happens if the tool isn’t installed. No guessing, no parsing.

Execution compiles the template through a fast Nunjucks engine and pipes directly to native Rust/Go binaries — ripgrep, fd, ast-grep, jq, yq, sd, delta, hyperfine, scc. The wrapper tax is a myth: emitting rg --json is computationally cheaper than formatting human-readable text, and the warm MCP runtime makes Transcend faster than raw interactive rg in practice.

29 typed skills across 9 categories — search, text/data, git, dev, view/sys — 285 tests across 85 suites.

MCP integration

Transcend exposes its skills through the Model Context Protocol over stdio, so it’s instantly compatible with any MCP host — Claude Code, Cursor, Zed, Windsurf, and anything else that speaks the protocol. Discovery is tools/list, execution is tools/call with JSON arguments, and the return is always {"status":"ok","data":…} with exact byte offsets, line numbers, and checksums.

Zero install:

npx -y github:PXINXYZ/Transcend --mcp

Why agents reason better here

Agents reason over structured data, not terminal text. Tool pipelining passes data between tools internally and returns only a summary manifest — no context-window relay, no OS command-line length limits, no heuristic path-parsing failures. The LLM stops being a regex engine and goes back to being a reasoning engine, which is what you’re paying for.

Source: github.com/PXINXYZ/Transcend.