Downtime Arbiter

Downtime Arbiter is a NitroStack MCP server for factory downtime negotiation. It models the tension between Maintenance teams that want early intervention and Production teams that want to protect throughput, then routes the final decision through deterministic arbitration instead of an opaque scheduling guess.

Built by Team Codeblood: Rithun K P, Shruthik Binduraj, Balagopal V, and Naveen Raj.

Award: 1st Place, Amrita University MCP Hackathon 2026.

Overview

Industrial maintenance planning often fails because every stakeholder sees a different part of the truth. Maintenance has sensor data and failure-risk forecasts. Production has deadlines, revenue impact, and schedule constraints. Downtime Arbiter turns that split-context problem into an auditable MCP workflow.

The server enforces the important boundaries in code:

• Maintenance can access detailed machine signals and raw risk percentages.
• Production can access only coarse urgency tiers, never raw risk data.
• Risk is represented as a P-F curve trajectory across now, +24h, +72h, and +96h.
• Failure modes use different trajectories, so slow bearing wear and fast thermal degradation do not collapse into one flat score.
• Negotiations are capped at exactly two rounds and close after resolution.
• The Arbiter compares proposal costs deterministically and escalates only when risk crosses the configured safety threshold.

Why It Matters

Downtime Arbiter is designed around a practical principle: LLMs can argue, summarize, and propose, but safety-critical decision rules should be explicit, repeatable, and inspectable.

That gives the project three useful properties:

• Context isolation: each agent gets only the data its role is allowed to see.
• Causal risk reasoning: risk changes over time and by failure mode, rather than being a single priority label.
• Auditable arbitration: final decisions are made by deterministic code with clear cost and safety thresholds.

Tech Stack

• TypeScript
• NitroStack SDK
• Model Context Protocol (MCP)
• Zod schemas for tool inputs
• Next.js-based NitroStack widgets
• Optional Groq-powered orchestration script for agent-loop experimentation

Quick Start

npm install
npm run build
npm run dev

Open the project in NitroStudio to inspect the tools, resources, prompts, and negotiation dashboard widget.

Validation

Run the deterministic evaluation suite:

npm run eval

The eval checks:

• context isolation
• P-F curve behavior
• deterministic arbiter outcomes
• negotiation round limits and closure
• maintenance schedule constraints

A healthy run reports failed_checks: 0 and pass_rate_pct: 100.

MCP Surface

Core tools:

• get_machine_signal
• get_urgency_tier
• explain_risk_trajectory
• propose_window
• check_plan_constraints
• resolve_negotiation

Dashboard tool:

• get_negotiation_dashboard

Resources:

• downtimearbiter://rolling_plan
• downtimearbiter://negotiation_log
• downtimearbiter://evaluation_rubric

Prompts:

• causal_rationale_prompt
• plan_briefing_prompt

Widget:

• negotiation-console

Optional Agent Orchestrator

npm run agent-demo runs an experimental Groq-backed orchestration script over the local MCP server. It is not required for the core NitroStack app. The production-grade behavior lives in the MCP tools and deterministic Arbiter implementation.

Create a .env file from .env.example and set GROQ_API_KEY before using the optional script.

License

MIT