Tetrees Agent EX: an MCP client kit for buying, running and selling Tetrees AI Packs

What Tetrees Agent EX actually is, and who it is for

Tetrees Agent EX is not an agent framework. It is the public integration kit for a hosted marketplace of Tetrees AI Packs, distributed as the npm package @tetrees/mcp with the MCP server name ai.tetrees/mcp. The repository holds the stdio MCP server, command line clients, configuration examples and extension samples. It explicitly excludes the Agent implementation, private Pack contents, memory representation, growth logic, AVCP scoring, service prompts, storage, moderation and exchange infrastructure.

The README splits the audience three ways. A buyer or operator searches Packs, reads a public Agent AVCP report, quotes a run, tries a Pack with Tetrees Points, acquires a free Pack, and downloads an owned .taip release. A builder connects an auditioned Pack to a user-owned HTTPS API, a nested MCP server, or a no-shell local skill while keeping credentials on their own machine. A seller creates a listing, uploads an immutable .taip version, inspects readiness, runs Agent AVCP, reads private repair feedback, and publishes a passing release.

The unifying claim is that Tetrees-hosted work needs no local GPU. Model-funded runs are quoted in Tetrees Points before execution, and an owned Pack can instead use a supported provider key supplied to the local MCP process. That is the real product boundary: you are renting or reselling packaged intelligence, not running it yourself.

How the MCP server, CLI and hosted API fit together

There are three surfaces in this repository and they do different jobs. The MCP server is a stdio process launched by your MCP client, typically through npx against a versioned tarball URL. The CLI is a separate entry point, exposed as the tetrees binary and run through npm run tetrees, which wraps the public HTTP API. The hosted API at TETREES_API_URL is where Packs, quotes, runs and reports actually live.

Data flow for a buyer looks like this. Your MCP client starts the local server with a revocable account token in its environment. The server exposes tools and resources over stdio. When you ask for a Pack, the call goes out to the Tetrees API, which returns catalogue data, a public Agent AVCP report and a runtime profile. A quote returns the exact model, token ceiling, hosted skills and growth checkpoint without starting a model request. Only a run with the confirmation flag spends Points, and unused reserved Points return.

The CLI mirrors that flow for terminal use. The README lists read-only calls such as status, catalog, models, skills, owned, runtime and report, then quote, then run. The CLI redacts secret-shaped response fields and reports Tetrees error codes, HTTP status and Retry-After. It does not retry a mutation automatically, which is the right default for anything that spends Points or changes account state.

The extension layer is the interesting part. A published Pack may declare client extensions that passed Agent AVCP, and the binding stays on the user's machine. Three patterns are supported: https_api with a fixed base URL, declared methods and environment-backed headers; mcp, a nested MCP server started without a shell and mapped to declared tool names; and local_skill, a no-shell child process that receives one JSON request and returns one JSON result. Tetrees hosting never inherits those local permissions, and a write method needs the exact per-call phrase APPROVE extensionId.methodId.

Installing the kit and running your first quote

Requirements are Node.js 20 or later and a revocable API token from the Tetrees account page. The README gives the MCP client configuration directly. Note the versioned tarball URL: the v=2.2.1 suffix is deliberate, because it stops npx from reusing an older MCP tarball cached under the same URL. The npm identity for the same package is @tetrees/mcp@2.2.1.

{
  "mcpServers": {
    "tetrees-ai": {
      "command": "npx",
      "args": ["-y", "https://ex.tetrees.ai/pkg/tetrees-mcp.tgz?v=2.2.1"],
      "env": {
        "TETREES_API_URL": "https://ex.tetrees.ai/api",
        "TETREES_TOKEN": "<revocable-account-token>"
      }
    }
  }
}

After restarting the MCP client, the README suggests asking it to search for Packs, show the public Agent AVCP report and runtime profile for the best match, quote an 8k/2k Point-funded run, and not run it until you approve the quoted maximum. That order matters: the quote is the only step that does not start a model request.

If you prefer the terminal, install dependencies and inspect the MCP contract before anything else. The inspector launches the official hosted MCP package, lists its public tools and resources, checks the expected buyer, builder and seller surface, and exits without spending Points or changing account state.

npm install
export TETREES_TOKEN="txk_..."
npm run mcp:inspect

The CLI deliberately does not auto-load secret files, so copy values from .env.example into your shell yourself. The .env.example file ships TETREES_API_URL=https://ex.tetrees.ai/api and a placeholder TETREES_TOKEN=txk_replace_me, with commented slots for OPENAI_API_KEY, ANTHROPIC_API_KEY and ZAI_API_KEY, and a commented TETREES_CLIENT_EXTENSIONS_FILE pointing at an absolute path. A read-only call and a quote look like this:

export TETREES_TOKEN="txk_..."
npm run tetrees -- status
npm run tetrees -- catalog "research"
npm run tetrees -- quote <pack-id> <model-id>

A Point-spending run needs the exact confirmation flag, and the README shows it as --confirm-spend. There is also a documented read-only buyer example you can run without any of that:

node examples/buyer/discover-and-quote.mjs "incident response"

The credential boundary is real, and so is the lock-in

The security posture here is more careful than most marketplace clients. The README is blunt that provider keys must not go into a Pack, a prompt, a source file or a shared MCP config, and that optional BYOK keys belong only in the local MCP process environment. The check:public-boundary script, run as part of npm run check, is a mechanical guard against internals leaking into the public repository.

That same boundary is the limitation. Because the repository excludes private Pack contents, memory representation and growth logic, you cannot inspect what a Pack actually does, cannot run it offline, and cannot move it to your own infrastructure. Acquiring a Pack unlocks download, BYOK, saved growth and client extensions, but the README does not describe what a downloaded .taip release contains or how it executes outside Tetrees hosting. If your requirement is a self-contained artifact you can audit line by line, this is the wrong tool.

The second constraint is the token model. Everything authenticated runs on a revocable account token, which is good for blast radius and bad for offline or air-gapped work. There is no documented local mode. The third is operational: quote, confirm, run is a multi-step flow with a human approval in the middle, and the CLI will not retry a mutation for you. That is correct for spending, but it means you own the retry logic around any transient failure, using the Retry-After value the CLI reports.

Where a plain MCP server or a local agent runtime fits better

The nearest alternative is not a competing product but a different architecture: run the MCP server yourself. The Model Context Protocol SDK is already a dependency here at version 1.30.0, and building a local stdio server that wraps your own tools gives you full visibility, no account token, no Points, and no network round trip to a quote endpoint. The trade-off is that you supply the model capacity and the packaged intelligence yourself. Tetrees Agent EX exists precisely because that is the part most teams do not want to build.

The second alternative is a local agent runtime that keeps prompts and tool definitions in your own repository. That approach wins on auditability and offline operation, and loses on the marketplace mechanics: there is no catalogue to search, no public AVCP report to compare candidates, and no way to publish a Pack and sell it. If your goal is to consume intelligence rather than to trade it, a local runtime is simpler and has fewer moving parts.

The honest framing is that Tetrees Agent EX is a distribution and settlement layer with a thin client on top. The client is small, the SDK dependency list is short, and the interesting engineering sits behind the API.

Maintenance, licence and what upgrading costs you

The last push to the default branch was on 2026-09-07, which is recent, and the repository is not archived. There are no retrieved releases, so version history has to be read from package.json, which pins the package at 2.2.1, and from the tarball URL suffix, which the README says should change only when Tetrees publishes a newer MCP contract.

That suffix is the upgrade mechanism and the upgrade hazard. Because npx caches by URL, an unchanged v= parameter means you keep running the old tarball. Bumping it is a manual edit in every MCP client config you maintain, and the README does not document a deprecation window or a changelog. The npm identity @tetrees/mcp@2.2.1 gives you a second, more conventional upgrade path if your client can install from the registry instead of a tarball URL.

The licence is MIT, stated in package.json and shipped as a LICENSE file. MIT covers the code in this repository. It does not govern the hosted service, the Packs you buy, or the terms attached to a Tetrees account, and the README does not describe how a purchased .taip release is licensed for redistribution. That is a question for Tetrees, not for the licence file, and it is worth resolving before you plan to resell anything.

Editorial conclusion

Adopt Tetrees Agent EX if you want to evaluate or resell packaged agent intelligence without standing up GPU capacity, and if you accept that the intelligence itself lives on Tetrees infrastructure with only bindings and credentials staying local. Do not adopt it if you need self-hosted inference, an offline deployment, or a local copy of the Pack logic, because the README states the repository does not contain private Pack contents, memory representation or growth logic. Before you spend anything, run npm run mcp:inspect against a revocable token to confirm the hosted tool surface matches what your client expects, and read the OpenAPI 3.1 document at https://ex.tetrees.ai/docs/tetrees-ai-pack.openapi.yaml to see which endpoints the CLI wraps.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. README
4. TetreesEX/TetreesAgent_EX on GitHub