# trazum [Health: Active]

**Category:** 💻 Developer Tools  
**Repository:** https://github.com/Davmunrey/Trazum  
**GitHub Stars:** 1  
**npm Downloads (last month):** 1449  
**Views:** 0  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/trazum

## Description
Trazum as an MCP server: let an agent price and budget its own prompts before it sends them.

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `npx` (confidence: high):

```json
"mcpServers": {
  "trazum": {
    "command": "npx",
    "args": ["-y","@trazum/cli"]
  }
}
```

## Documentation

## What the trazum MCP server does

The trazum MCP server adds a preflight spending check to an agent's model-call loop. Its first and documented MCP tool, `spend_guard`, answers whether the agent may make a proposed call: `yes`, `no`, or `cannot-tell`. The check happens before the model request, so the tool does not call a model or spend money while producing its decision.

The decision combines two inputs: spending ceilings from `trazum.config.json` and spend-to-date from a usage log that the host already writes. When a request is refused, the result can identify lower-cost ways to make the same call. Each alternative is priced for that call and includes the assumptions used to calculate it.

This fits agents that operate in repeated loops, where individual decisions can otherwise disappear into a monthly aggregate. It is also useful when a prompt may be sent to different model tiers or when an agent needs an explicit answer before committing budget.

## How it works

The server is built around Trazum's deterministic analysis and pricing functions. Given the proposed call and the available local budget information, it evaluates the request against configured limits. The same inputs produce the same result; an unknown condition is reported as `cannot-tell` rather than being treated as approval or as zero cost.

The analysis is local. The documented data boundary says that prompt text, model answers, file paths, branch names, and credentials do not leave the machine. The server reads the usage information already available to its host and uses the configuration file for ceilings. It does not send the request to a model as part of the gate.

## Setup and configuration

A standard MCP client can launch the server with the following stdio configuration:

```json
{
  "mcpServers": {
    "trazum": {
      "command": "npx",
      "args": ["-y", "@trazum/mcp"]
    }
  }
}
```

The README names Cursor, Windsurf, and Claude Desktop as clients that can use this configuration, with client-specific locations such as `.cursor/mcp.json` for Cursor. The repository also provides a Claude Code plugin installation path that installs the skill and MCP server together.

Before relying on a gate, provide the ceilings expected by the server in `trazum.config.json` and ensure the host has a usage log. The supplied material does not define a required environment variable or a complete configuration schema, so those details should be checked in the repository documentation before deployment.

## Tools and capabilities

The trazum MCP server documents `spend_guard` as its first tool and the tool whose trigger is an agent decision rather than a user sentence. It can:

- Approve a proposed spend with `yes`.
- Reject it with `no` when the configured budget does not permit the call.
- Return `cannot-tell` when the available information is insufficient.
- Suggest cheaper alternatives after a refusal.
- Price alternatives for the specific call and state their assumptions.

These capabilities make the server a budget control point rather than a model provider, prompt executor, or usage-log exporter.

## Limitations and notes

The gate is only as informed as its configuration and usage log. Missing or uncertain pricing information is not silently converted into a zero-cost result; the project describes an unknown model price as a named gap. A `cannot-tell` result therefore needs handling in the calling agent's policy.

The server does not prevent a client or agent from making a separate model call unless the surrounding workflow treats the result as a required approval. It also does not itself execute the proposed request. The material describes the MCP integration around `spend_guard`; it does not establish additional MCP tool names.

Trazum is intended for local, offline analysis. That limits remote observability and data sharing, but it also means budget accuracy depends on the local pricing information, usage records, and ceilings supplied to it.

_Full upstream README: https://allmcps.com/mcp/trazum/readme_