Epoch
Server Configuration
Describes the environment variables required to run the server.
| Name | Required | Description | Default |
|---|---|---|---|
No arguments | |||
Instructions
Guidance the server publishes about itself, which clients place ahead of the tool catalog so the model reads it before choosing anything.
This server publishes no instructions, or was last inspected before Glama recorded them.
Capabilities
Features and capabilities supported by this server
Protocol revision2025-11-25
| Capability | Details |
|---|---|
| tools | {
"listChanged": true
} |
Tools
Functions exposed to the LLM to take actions
| Name | Description |
|---|---|
| get_current_timeA | Returns the current date and time in the specified IANA timezone. Useful for grounding the LLM in the user's local time. Example timezones: 'UTC', 'America/New_York', 'Europe/London', 'Asia/Tokyo'. |
| convert_timezoneA | Converts an ISO-8601 timestamp to a target IANA timezone. The input timestamp must include timezone information or be in UTC. Returns the localised time, UTC offset, and human-readable format. Use when you need to display or compare a moment in another region's local time. |
| parse_durationA | Parses a human-readable duration string into structured seconds. Supports combinations of y (years), mo (months), w (weeks), d (days), h (hours), m (minutes), s (seconds). Examples: '2h30m', '1d6h', '1w3d', '45m'. Returns the total seconds for the duration. Use when normalising a free-text duration for arithmetic or comparison. |
| wait_boundA | Derives a deadline from the mechanism a wait actually rides (three-clock law v1.1 A2): fleet = k x cycle_seconds + PERT(turn) + 1 sd; world = PERT(turn) with a REQUIRED named external anchor; ceo = the named ladder rung (machine time never consumes a CEO rung). Returns the bound in seconds, the deadline in UTC and local (PT by default), and an envelope-ready TTL integer. Round human hours are unexamined slack. |
| time_mathA | Performs compound time-math operations. Dispatches to the appropriate sub-operation based on the 'operation' parameter. Operations: add_days, add_business_days, diff, convert_tz, parse_nl, format_duration. Use this for multi-step or dynamic time operations; for single-purpose calls use get_current_time, convert_timezone, parse_duration, add_business_days, or count_business_days. |
| add_business_daysA | Adds N business (working) days to a start date, skipping weekends and country-specific public holidays. Supports US, UK, FR, DE, and JP holidays. Returns the resulting date. Use when computing a deadline that excludes non-working days. |
| count_business_daysA | Counts the number of business (working) days between two dates, excluding weekends and country-specific public holidays. The count is exclusive of the start date and inclusive of the end date. Returns the integer day count. Use when measuring working-time span between two dates. |
| pert_estimateA | Calculate PERT expected duration from three-point estimates using Beta distribution. Formula: E = (O + 4M + P) / 6. Returns expected value, variance, standard deviation, and 95%/99% confidence bounds with urgency categorization. Use when estimating task duration with uncertain outcomes. |
| cocomo_estimateA | LLM-adapted COCOMO II parametric effort estimation. Replaces traditional 17 human-labor cost drivers with 5 LLM-specific factors: reasoning complexity, context completeness, transformation impact, iterative cycles, and human oversight. Returns both nominal and LLM-adjusted person-months. Use when estimating effort for a codebase you can size in KLOC. iterative_cycles: values <= 2.0 are literal multipliers (0.5 = one-shot, 1.0 = typical debug loop, 2.0 = heavy back-and-forth); values above 2.0 are literal cycle counts, each additional cycle adding 0.1 of multiplier anchored at 2.0 (2.0 -> 2.0x, 3 -> 2.1x, 10 -> 2.8x) — monotonic with no cliff at 2.0. |
| sprint_forecastA | Forecast sprint completion date from backlog size and historical velocity. Computes average velocity from sprint history, converts story points to hours, and returns required sprints with pessimistic estimate based on velocity variance. Use when planning a sprint completion date from backlog size and velocity history. |
| critical_pathA | Compute critical path with merge-bias adjustment for project schedules. Performs forward/backward pass to identify critical tasks and slack. Applies merge bias: tasks with >2 predecessors get 5% duration increase per extra predecessor. Returns the critical path, task slack, and project duration. Use when sequencing dependent tasks to find the longest path and available slack. |
| monte_carlo_scheduleA | Run Monte Carlo simulation for probabilistic schedule risk analysis. Samples task durations from triangular distributions and returns P10/P50/P80/P95 completion estimates with identified risk events. Use seed for reproducible results. Supply target_hours (working hours; durations are 8-hour days) to get criticalPathProbability = P(total <= target_hours); without it that field is null. |
| reference_class_estimateA | Data-driven estimate using reference class forecasting. Applies historical correction factors based on actual-vs-estimated ratios. When no historical data exists, uses industry averages (1.3-2.2x for software tasks). Prioritize this over algorithmic models when historical data is available. |
| calibrate_estimatesA | Recalculate team-specific correction factors from historical estimation data. Compares estimated vs actual hours to compute a correction multiplier. Requires PM system integration for best results. Returns recommendations for improving estimation accuracy. Use when you have accumulated actuals and want to refresh team calibration factors. |
| token_time_bridgeA | Map LLM token budgets to estimated wall-clock time. Uses model-specific calibration data (tokens/second, reasoning overhead, tool-call latency) to estimate how long a task will actually take. Bridges the gap between token-space (how agents reason) and time-space (what humans need). Use token_cost_estimate instead when dollar cost matters too. |
| token_cost_estimateA | Estimate wall-clock time AND dollar cost for LLM token usage. Combines token-to-time mapping with model-specific pricing data. Returns cost breakdown (input/output/overhead) alongside the time estimate. Use token_time_bridge when you only need wall-clock time and not dollar cost. |
| compare_modelsA | Compare all LLM models side-by-side for a given token budget. Ranks models by estimated cost or time. Shows quality tier for each model. Use when choosing which model to use for a task. |
| accuracy_trendA | Track estimation accuracy improvement over time. Computes sliding-window MAPE and compares against industry baseline (25%). Shows whether your estimates are improving, degrading, or stable. Industry research shows estimation accuracy does NOT improve with experience (Cao 2022) — self-correcting systems like Epoch can buck this trend. |
| schedule_riskB | Assess schedule risk for an estimate using historical accuracy data. Computes confidence intervals (p50/p80/p90/p95) based on your team's MAPE. Returns risk level and actionable recommendations. Uses industry baseline (25% MAPE) when no historical data is available. |
| cocomo_validateA | Validate COCOMO estimation model against 195 real historical projects. Runs the COCOMO Basic formula against projects from NASA93, COCOMO81, Albrecht, and Kemerer datasets. Reports overall MAPE, bias, per-type accuracy, and recommended coefficient adjustments. Use cocomo_ground_truth for the full multi-model benchmark across all COCOMO and AI-adjusted models. |
| cocomo_ground_truthA | Validate all COCOMO estimation models against 240 real historical projects with known effort. Runs 6 models in parallel: COCOMO Basic, COCOMO II Nominal, COCOMO II + AI 12x speedup, and AI + developer profile at human/hybrid/ai_native gradients. Reports MAPE, MMRE, PRED(25), PRED(50), bias per model, with breakdowns by dataset and project type. Use cocomo_validate for a quicker Basic COCOMO-only validation pass. |
| record_actualA | Submit actual hours for a previous estimate to improve future accuracy. Pairs with any estimation tool. The estimate_id comes from the estimate response. Actuals feed into the self-improvement loop — after enough samples, correction factors update automatically to reduce estimation bias. |
| get_pending_estimatesA | List recent estimates that have not yet received actual-hour feedback. Returns estimates awaiting actuals so you can submit feedback via record_actual. Use this to close the estimation feedback loop and improve accuracy over time. |
| batch_record_actualsA | Record actual hours for multiple estimates in a single call. Efficient for bulk feedback submission — accepts 1 to 500 entries at once. Each entry pairs an estimate ID with the actual hours spent. Returns total/succeeded/failed counts. Use when closing the feedback loop for many estimates at once; pass estimate_id values from get_pending_estimates. |
| feedback_healthA | Get a health report on the estimation feedback loop. Shows total estimates, actuals, match rate, MAPE by tool and task type, and self-improvement readiness (which types have enough data for auto-calibration). Use when checking whether you have enough recorded actuals for calibration to kick in. |
| estimate_from_contextA | Classify a free-text task description and delegate to reference-class estimation. Classifies task_type and complexity from free text (issue body, PR/diff description, or task summary) using a LOCAL, deterministic keyword/signal heuristic — no LLM call (see src/lib/context-estimate.ts). Caller-supplied task_type/complexity hints always override the classification. Delegates the resolved inputs to the same reference-class-forecasting path used by reference_class_estimate, and returns classification provenance (classified_task_type, classified_complexity, confidence, signals) alongside the estimate so callers can judge how much to trust it. |
Prompts
Interactive templates invoked by user choice
| Name | Description |
|---|---|
No prompts | |
Resources
Contextual data attached and managed by the client
| Name | Description |
|---|---|
No resources | |
TDQS
Scored across 26 tools
Several tools genuinely overlap: cocomo_validate vs cocomo_ground_truth, token_time_bridge vs token_cost_estimate, record_actual vs batch_record_actuals, and time_math which explicitly re-dispatches to convert_timezone/parse_duration/add_business_days/count_business_days. The descriptions do a good job of naming the sibling tool and when to prefer each, and estimate_from_context clearly states it delegates to reference_class_estimate, so an agent can usually resolve the choice — but it must read the description every time rather than relying on distinct surfaces.
All names are snake_case with no camelCase leakage. There is a mild split between subject-first estimation names (cocomo_estimate, pert_estimate, sprint_forecast, monte_carlo_schedule, token_cost_estimate) and verb-first utility names (get_current_time, add_business_days, compare_models, calibrate_estimates), plus a small inconsistency between record_actual and batch_record_actuals — readable but not a single uniform verb_noun pattern.
26 tools is heavy for what is essentially an estimation + time-math + token-economics server, and the count is inflated by redundancy rather than breadth: two COCOMO validators, two token-time tools, time_math duplicating four single-purpose time tools, and record_actual alongside batch_record_actuals. Trimming the overlap could bring this to a much tighter 15-18 tool surface without losing capability.
The domain lifecycle is well covered: multiple estimation strategies (PERT, COCOMO II, reference-class, Monte Carlo, critical path, sprint forecast), a full feedback loop (record_actual, batch_record_actuals, get_pending_estimates, calibrate_estimates, feedback_health, accuracy_trend), risk assessment, and supporting time arithmetic. Minor gaps remain — there is no way to list, inspect, or correct/delete an existing estimate or submitted actual, only add new feedback.