# zopaf [Health: Active]

**Category:** 🤝 Agreements & Coordination  
**Repository:** https://github.com/rjandino/zopaf  
**GitHub Stars:** 0  
**Views:** 2  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/zopaf

## Description
Negotiation math engine. Pareto frontier, counteroffer generation, zero LLM tokens.

## Tools
Capabilities this server exposes over MCP:

- **create_session** — Create a new negotiation session. Returns a session_id used by all other tools.
- **add_issue** — Add a negotiable issue/term with options ordered worst to best for the user.
- **set_issue_range** — Set the acceptable range for a numeric issue, enabling 0-100 scoring.
- **record_preference** — Record that the user prioritizes some issues over others. Updates the weight model.
- **set_batna** — Record the user's alternatives if the deal falls through. Determines leverage.
- **generate_counteroffers** — Generate 3 iso-utility counteroffers to present simultaneously.
- **process_counterpart_response** — Process the counterpart's reaction to infer their priorities and generate a round-2 offer.
- **analyze_deal** — Score a specific deal against the Pareto frontier. Shows value captured and suggested trades.
- **get_negotiation_state** — Get current model state: issues, weights, BATNA, frontier size, and recommended next step.

## Claude Desktop Quick Installation
No confirmed install details yet, so no config is published. Follow the setup steps in the repository above.

## Documentation

## What zopaf MCP server does

The zopaf MCP server gives an AI agent a structured negotiation model instead of requiring the agent to calculate trade-offs in conversation. It represents negotiable terms, scores user preferences, accounts for a BATNA, and evaluates packages against the available trade space.

The engine is suitable for negotiations with several adjustable terms, including employment offers, vendor agreements, real estate deals, partnerships, term sheets, and settlements. The calling agent remains responsible for asking questions, presenting proposals, and explaining the result. Zopaf supplies the calculations and model state.

## How it works

A negotiation begins with `create_session`, which returns the identifier required by subsequent calls. Add each term with `add_issue`, supplying options from least favorable to most favorable for the user. Numeric terms can instead receive a range through `set_issue_range`; this maps acceptable values to a 0–100 score.

Use `record_preference` to indicate which issues matter more. Each preference updates the issue-weight model. `set_batna` records the alternatives available if no agreement is reached, and the engine uses those alternatives to determine leverage.

After the model has enough information, `generate_counteroffers` creates three packages with equal user utility but different term combinations. The documented workflow presents all three at once. When the counterpart selects or resists parts of those packages, `process_counterpart_response` uses that reaction to estimate counterpart priorities and produce a second-round offer.

## Tools and capabilities

The zopaf MCP server exposes these negotiation operations:

- `create_session` initializes a model and returns a session ID.
- `add_issue` adds a discrete term and its ordered options.
- `set_issue_range` scores a numeric term over an acceptable interval.
- `record_preference` updates relative issue weights.
- `set_batna` records alternatives and calculates leverage strength.
- `generate_counteroffers` produces three iso-utility packages.
- `process_counterpart_response` infers priorities and returns a round-two offer.
- `analyze_deal` scores a proposed package, reports captured value, and suggests trades.
- `get_negotiation_state` returns issues, weights, BATNA, frontier size, and the recommended next step.

The calculations use mixed-integer linear programming and combinatorial scoring. No LLM tokens are used for the optimization itself.

## Setup and configuration

A hosted Streamable HTTP endpoint is documented at `https://zopaf-mcp-production.up.railway.app/mcp`. Configure that URL in an MCP client that supports Streamable HTTP. Claude Desktop uses a server entry with the endpoint URL and `type` set to `streamable-http`. Claude Code can register the same endpoint with `claude mcp add zopaf --transport streamable-http`.

The tool sequence is stateful: retain the session ID returned by `create_session` and pass it to the other session operations. No environment variables or local runtime configuration are specified in the provided setup instructions.

## Limitations and notes

Zopaf is a calculation service, not a conversational negotiator. The connected agent must collect the user's priorities, decide how to communicate offers, and interpret the results for the user. Output quality depends on correctly ordered issue options, meaningful numeric ranges, recorded preferences, and an accurate BATNA.

The documentation describes three generated counteroffers as equal in utility for the user, not as identical packages. Counterpart priorities are inferred from package preference and stated pushback, so the response data supplied to the tool affects the resulting model.

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