# Estimation Prover MCP for AI Agents AI Agent Connect > Estimation Prover stops your team from missing deadlines by forcing a rigorous breakdown of project scope. It identifies hidden technical risks, maps past project data, and calculates realistic contingency buffers. Instead of guessing a timeline, it requires you to define every micro-task and assumption before you commit to a date. ## Overview - **Category:** productivity - **Price:** Free - **Endpoint:** https://edge.vinkius.com/vk_preview_2EBBLjpOgvh99Mzj4qWjg1AX3u4JVxsWEXt8l5U8/ai-agent-connect - **Tags:** estimation-prover, planning-fallacy, scope-decomposition, risk-mitigation, agile-planning, contingency-buffer, historical-forecasting, agentic-timeline ## Description Software estimates usually fail because people are naturally bad at predicting how long a project will actually take. We call this the Planning Fallacy. Estimation Prover acts as a filter for your project plans, forcing a structured approach based on real data instead of gut feelings. It stops you from giving a vague three weeks estimate by requiring you to break the work down into small, manageable pieces. It also forces you to identify technical risks and historical precedents before you commit to a date. You'll find it helps ground your team in reality by making sure you account for things like API reliability and team availability upfront. By using this within the Vinkius catalog, you can ensure that your project timelines are built on a foundation of evidence rather than optimism. It's about making sure the things you don't know yet don't blow up your timeline later. It forces a conversation about what's actually happening under the hood, like infrastructure readiness or reviewer responsiveness, before the first line of code is even written. This ensures that when you finally commit to a deadline, you have the data to back it up. It turns a guess into a defensible plan that stakeholders can actually trust. ## Tools ### validate_estimation Submit a project estimate to have it audited for scope gaps and hidden risks. This helps you catch missing buffers and vague requirements before you commit to a deadline. ## Prompt Examples **Prompt:** ``` I want to build a new user dashboard. It should take about a week. Can you check that? ``` **Response:** ``` I've analyzed your request to build a user dashboard in one week. Based on the complexity of dashboard components, that estimate is likely too optimistic. **Verdict: SCOPE_VAGUE** To build a reliable timeline, you should break the dashboard into these units: - **Data Fetching Layer** (2 days) - **UI Component Library** (3 days) - **Auth Integration** (2 days) - **Testing & QA** (2 days) Total estimated time: 11 days. This includes a 20% buffer for UI bugs. ``` **Prompt:** ``` We're migrating our database to a new provider. How should we estimate this? ``` **Response:** ``` Database migrations are high-risk tasks that often involve hidden unknowns. Here is a structured breakdown for your migration: **Project: Database Migration** - **Scope:** Migrate 5 production tables to [Provider]. - **Unknowns:** Data consistency during cutover (High Impact), Migration script errors (Med Impact). - **Precedent:** Last year's migration took 14 days (estimated 10). - **Buffer:** 40% applied due to high risk. **Estimated Timeline:** 21 days. ``` **Prompt:** ``` I have a task to integrate a new payment gateway. Give me a realistic timeline. ``` **Response:** ``` Integrating a new payment gateway involves several dependencies. Here is a validated estimate: **Task: Payment Gateway Integration** - **Decomposition:** API Auth (1 day), Webhook setup (2 days), UI Flow (2 days), Sandbox testing (2 days). - **Risks:** Webhook delivery delays, API rate limits. - **Buffer:** 30% for novel integration work. - **Assumptions:** Full-time access to payment provider docs, 1 dedicated dev. **Verified Timeline:** 10.2 days. ``` ## Capabilities ### Break milestones into 2-day tasks It forces you to decompose complex work into small units that are actually manageable. ### Map technical risks and dependencies The tool identifies hidden unknowns like API limits or knowledge gaps before they cause delays. ### Link tasks to historical data It grounds your current estimates in the reality of how long similar tasks took in the past. ### Calculate specific contingency buffers It helps you set a numerical buffer for risks instead of just adding vague extra time. ### List all project assumptions It makes every assumption about team availability or scope stability explicit and visible. ### Audit project timeline feasibility It provides a final check to ensure your plan is actually achievable based on the data provided. ## Use Cases ### Fixing unrealistic mobile app dates A PM wants to build a mobile app in two weeks. The agent uses the tool to find the missing three weeks of auth and sync work. ### Planning complex database migrations A dev is tasked with a migration. The tool forces them to list specific API risks and historical migration times from last year. ### Validating startup pitches A startup uses the tool to ensure their aggressive dates are backed by actual task decomposition for potential investors. ### Breaking down vague feature requests An engineering lead uses the tool to turn a vague request like fix the dashboard into specific tasks with clear requirements. ## Benefits - Stop scope creep by using validate_estimation to force a breakdown of every major milestone into manageable units. - Eliminate the Planning Fallacy by grounding your estimates in historical project data rather than optimistic best-case guesses. - Identify hidden technical debt and risks early, ensuring that your project timeline accounts for the things you don't know yet. - Protect your team's velocity by requiring a specific, numerical contingency buffer for every task rather than just adding extra time. - Clarify team expectations by making every assumption about availability and infrastructure explicit before the project begins. ## How It Works The bottom line is you get a defensible, data-driven project timeline instead of a guess. 1. Input a high-level project goal or a rough estimate into your AI client. 2. The Connector prompts you for specific details like task decomposition, risks, and historical data. 3. You get a verified project plan with specific buffers and identified blind spots. ## Frequently Asked Questions **How does Estimation Prover help with project deadlines?** It forces a rigorous breakdown of your project into small tasks. By identifying risks and historical data early, it helps you set realistic dates that you can actually hit. **Can Estimation Prover help me stop overpromising to stakeholders?** Yes. It provides a data-backed reason for your timelines. Instead of a guess, you can show a breakdown of scope, risks, and buffers to justify your dates. **What is the Planning Fallacy and how does this Connector fix it?** The Planning Fallacy is the human tendency to underestimate project time. This Connector fixes it by requiring evidence, like historical precedents and risk mapping, before a date is set. **Does Estimation Prover work for non-software projects?** While it is optimized for software development, it can be used for any project with complex dependencies, risks, and a need for granular scope decomposition. **How does this tool handle hidden technical risks?** It prompts you to explicitly name and rank risks like API reliability or knowledge gaps. This ensures they are accounted for in your final buffer rather than being surprises later. **Can I use Estimation Prover to break down large milestones?** That is exactly what it is designed for. It forces you to decompose large, vague milestones into discrete units of work that are usually two days or less. **How does Estimation Prover validate an estimate?** It analyzes the inputs based on a 5-pivot validation. You provide the task decomposition, risk mapping, historical context, buffer metrics, and assumptions. It rejects single-line guesses or projects without buffers. **What is the recommended buffer size?** The tool enforces a minimum 20% buffer on projects with clear precedents, and increases to 40% or more for complex integrations, new frameworks, or systems with high architectural risk. **How does Reference Class Forecasting work here?** It forces you to compare the new project with similar work completed in the past. If your past authentication integration took 3 weeks instead of the planned 1 week, you must adjust the new estimate's baseline accordingly.