# Opportunity Cost Prover MCP > Opportunity Cost Prover forces your AI agent to stop making simple decisions based on convenience. This engine runs a 6-pivot trap, forcing it to map direct costs, quantify lost opportunities from discarded alternatives, identify irreversible tradeoffs (like vendor lock-in), and prove the math before giving you an answer. ## Overview - **Category:** reasoning - **Price:** Free - **Tags:** opportunity-cost, tradeoffs, decision-matrix, cognitive-forcing, multilingual, cost-analysis ## Description Listen up. When you ask your agent for a solution—any time—it's got this habit of just giving you the easiest path, the one with the least friction. That’s tunnel vision, pure and simple. But in engineering or architecture, every single choice is a tradeoff. Picking Option A means you gotta give up B. The Opportunity Cost Prover fixes that. It forces your AI agent to stop guessing and start doing the math. This engine runs what we call a six-pivot trap, which makes sure the agent maps out direct costs, quantifies every opportunity loss from discarded options, flags irreversible dependencies like vendor lock-in, and proves the whole damn thing works mathematically before it spits out an answer. The tool at play here is `validate_opportunity_cost`. It forces your AI client through this intense six-pivot process, making sure you don't get blindsided by a seemingly good idea that’s actually a financial trap. You use the Prover to prevent the agent from just picking what looks convenient. Here’s how it works: First, it forces your agent to map required trade-offs. It doesn't let you select a path without simultaneously validating the necessary comparison between that chosen architecture and an actual, discarded alternative you were considering. You gotta tell it both options up front so it can validate what you’re actually sacrificing. Next, it quantifies opportunity loss. If your agent rejects a viable architectural option—say, using a different database or microservice framework—this tool calculates the measurable value you're losing by making that rejection. It figures out the exact dollars and time associated with turning down a good bet. The Prover then forces it to identify one-way doors. This is critical: your agent has to surface any irreversible dependencies, whether it's proprietary APIs or getting locked into one specific vendor’s ecosystem. If that decision means you can't easily pivot later, the tool flags it immediately. Finally, it proves economic viability. It runs a hard check validating that the projected gains from your chosen path mathematically outweigh *everything*: all direct costs, all quantified opportunity losses, and every single bit of irreversible risk identified along the way. If the math doesn't hold up—if Gains don’t strictly exceed (Costs + Lost Opportunity + Irreversibility Risk)—the agent won't give you a final recommendation. The `validate_opportunity_cost` tool handles all six pivots in one go: it maps required tradeoffs by comparing your chosen path against the discarded alternative; it calculates the measurable value lost from rejecting that viable option; it identifies any one-way doors, like proprietary APIs or vendor lock-in; and it proves economic viability by running a logical proof that projected gains mathematically exceed all associated costs, losses, and risks. It makes sure you're making an informed decision, not just picking the path of least resistance. ## Tools ### validate_opportunity_cost Forces the agent through a 6-pivot trap, mapping direct costs, opportunity losses, and irreversible tradeoffs to prevent tunnel vision. ## Prompt Examples **Prompt:** ``` Chosen: AWS Lambda. Alternative: Doing nothing. Cost: Zero. Math: Lambda is infinitely scalable. ``` **Response:** ``` Verdict: TUNNEL_VISION_DETECTED. 'Doing nothing' is not a valid alternative architecture. You must compare Lambda against a real alternative like Fargate or EC2. ``` **Prompt:** ``` Chosen: AWS Lambda. Alternative: EC2. Cost: Vendor lock-in. Opportunity Cost: We lose the ability to run multi-cloud. Irreversible: None. ``` **Response:** ``` Verdict: IRREVERSIBILITY_IGNORED. Vendor lock-in into proprietary serverless event triggers (like SQS to Lambda) is heavily irreversible. You failed to identify the one-way door. ``` **Prompt:** ``` Chosen: AWS Lambda. Alternative: ECS Fargate. Cost: AWS lock-in and cold starts (+200ms latency). Opportunity: We lose container portability and local dev parity. Irreversible: Tying business logic to AWS API Gateway events. Math: The 0 maintenance overhead saves 40 eng-hours/month, which mathematically beats the portability risk since our burn rate demands immediate feature velocity. ``` **Response:** ``` Verdict: COST_PROVEN. You identified the active alternative, quantified the latency cost, mapped the lost container portability, admitted the one-way door of API Gateway, and proved the math with burn-rate realities. Proceed. ``` ## Capabilities ### Map required trade-offs The tool validates the necessary comparison between a chosen path and an active, discarded alternative. ### Quantify opportunity loss It calculates the measurable value lost by rejecting a viable architectural option. ### Identify one-way doors The agent is forced to surface irreversible dependencies, like vendor lock-in or proprietary APIs. ### Prove economic viability It validates that the projected gains mathematically outweigh all costs and lost opportunities. ## Use Cases ### Deciding between AWS Lambda and Fargate A team wants to go serverless (Chosen Path: AWS Lambda). Their agent initially suggests it's perfect. You run `validate_opportunity_cost` against an alternative like ECS Fargate. The tool forces the agent to quantify the latency cost of cold starts, map the loss of container portability, and ultimately proves that while Lambda is simpler, the inability to easily move away (the irreversible tradeoff) outweighs the maintenance overhead. ### Picking a data storage layer You are choosing between PostgreSQL and MongoDB. The agent suggests Postgres because it's familiar. You run `validate_opportunity_cost` using 'Graph Database' as the alternative. The tool forces the comparison, calculating the opportunity cost of not being able to model complex relationships quickly—a loss that a standard relational setup makes difficult. ### Evaluating a new third-party API integration Your team is considering integrating a specific payment gateway (Chosen Path). The agent suggests it's the easiest path. You run `validate_opportunity_cost` against using an open-source alternative. The tool forces you to measure the direct cost of dependency on that single vendor and quantify the opportunity loss if they change their pricing structure tomorrow. ### Choosing a multi-cloud strategy The goal is portability. An agent suggests committing everything to one cloud provider for simplicity (Chosen Path). You run `validate_opportunity_cost` against a federated, multi-cloud setup. The tool forces the math check: Are the short-term gains in simplicity worth the long-term, quantified loss of operational flexibility and vendor neutrality? ## Benefits - It prevents 'doing nothing' from being a valid answer. The tool requires you to name an active alternative, forcing a real comparison instead of defaulting to zero risk. - You get quantified proof of lost value. Instead of just saying 'it's better,' the Prover measures exactly what business capability or efficiency you lose by choosing one path over another. - It surfaces vendor lock-in. The agent cannot ignore irreversible tradeoffs; it must identify if your choice ties you to a single proprietary system, making future pivots expensive. - The math has to check out. You don't just get a verdict—you get the calculation: Gains must be greater than Costs + Opportunity Loss + Risk. - It validates complex technical decisions. Use it when comparing different database types (e.g., relational vs. graph) or service meshes, ensuring you account for every dependency. ## How It Works The bottom line is your AI client can't just give you an answer; it has to prove why that answer is actually better than the next best thing. 1. Input your proposed architecture (Chosen Path) and an actionable alternative option. 2. The tool executes a 6-pivot trap, forcing the agent to measure direct costs, potential losses, and irreversible dependencies. 3. You receive a verdict that proves or disproves the economic viability of the decision based on quantifiable metrics. ## Frequently Asked Questions **How does Opportunity Cost Prover work with cloud provider comparisons?** It compares two viable architectures by forcing six checkpoints. You input your chosen path (e.g., AWS) and a real alternative (e.g., GCP). The tool then calculates the direct cost, opportunity loss, and irreversible tradeoffs between them. **Can Opportunity Cost Prover just validate simple feature additions?** No. The Prover is designed for major architectural shifts where the cost of a mistake is high. It struggles with small changes because those losses are too negligible to quantify meaningfully in the 6-pivot structure. **What does 'irreversible tradeoff' mean using Opportunity Cost Prover?** It means identifying one-way doors—dependencies that make it incredibly hard or expensive to leave. The tool flags things like proprietary API gateway bindings, which count as a massive risk. **Is 'doing nothing' a valid alternative for validate_opportunity_cost?** No. For the analysis to be rigorous, you must provide an active, actionable alternative. The Prover requires you to compare against something real, not just inaction. **How do I set up the Opportunity Cost Prover using my AI client?** You connect it directly through your agent's standard MCP connection interface. Vinkius manages authentication, so you simply authorize access from within your preferred client's profile. **What specific inputs does the `validate_opportunity_cost` tool require?** You must provide six distinct data points: the chosen path, a viable alternative (not 'doing nothing'), direct costs, quantified opportunity loss, an irreversible risk factor, and the final mathematical proof structure. **If `validate_opportunity_cost` flags insufficient evidence, what should I do?** It means your proposed solution isn't mathematically sound based on the inputs. The tool tells you exactly which cost factor—like opportunity loss or risk—needs deeper quantification. **Are there rate limits when using the Opportunity Cost Prover MCP Server?** Yes, Vinkius manages server load and enforces standard API rate limits. Check your subscription details for specific call quotas, but it's built for deep reasoning, not high-volume simple checks. **Why can't 'doing nothing' be the discarded alternative?** Because comparing a solution against 'doing nothing' is a false dichotomy used to artificially inflate the value of the solution. The engine forces the AI to compare its idea against the next best active technical strategy. **Why does the prover require an irreversible tradeoff analysis?** Because decisions are classified into two categories: type-1 (irreversible, one-way doors) and type-2 (reversible, two-way doors). If an AI suggests a type-1 decision without acknowledging its permanent nature (e.g. schema changes, switching databases), it creates technical debt that cannot be undone. **What does 'quantify lost opportunities' mean in practice?** It means assigning a concrete cost (such as engineering velocity, infrastructure costs, or latency) to what you lose by choosing the path. For example, choosing custom development instead of a SaaS integration has an opportunity cost of slower time-to-market.