# Epoch (npm · @kyanitelabs/epoch)

Epoch time estimation MCP server for PERT, COCOMO, Monte Carlo, calibration, cost, and risk.

- Trust score: 79/100 (medium)
- Change this week: +34
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-03

## Components

- npm · `@kyanitelabs/epoch`: 79/100 (this document), [markdown](https://verifymcp.io/servers/kyanitelabs-epoch/kyanitelabs-epoch.md), [page](https://verifymcp.io/servers/kyanitelabs-epoch/kyanitelabs-epoch)

## Channel facts

- Registry: `npm`
- Package: `@kyanitelabs/epoch`
- Version: `0.2.9`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-08-03.

- **Supply Chain Security**: 87/100
  - No malware found by supply-chain analysis.
  - Only part of the dependency tree could be resolved (98 of 102), so this covers what we could see, not the whole tree.
  - No install/post-install scripts declared.
  - Only part of the dependency tree could be resolved (98 of 102), so this covers what we could see, not the whole tree.
- **Provenance & Transparency**: 97/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to KyaniteLabs/Epoch).
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 23 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 71/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 3122 tokens (~130/item across 24 items; 24 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 27/100
  - Stability observed for 8 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### Claude

```bash
claude mcp add kyanitelabs-epoch -- npx -y @kyanitelabs/epoch
```

### Codex

```bash
codex mcp add kyanitelabs-epoch -- npx -y @kyanitelabs/epoch
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "kyanitelabs-epoch": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "@kyanitelabs/epoch"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add kyanitelabs-epoch --command npx --arg -y --arg @kyanitelabs/epoch
```

### Hermes

```yaml
mcp_servers:
  kyanitelabs-epoch:
    command: "npx"
    args: ["-y", "@kyanitelabs/epoch"]
```

### Other

```json
{
  "mcpServers": {
    "kyanitelabs-epoch": {
      "command": "npx",
      "args": [
        "-y",
        "@kyanitelabs/epoch"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-08-03 (score 79, +4)

- [functional improvement] Stability: unverified → 0.27

### 2026-08-02 (score 75, +70)

- [security improvement] Install scripts: unverified → pass
- [security improvement] Provenance: unverified → pass
- [security improvement] Known CVEs: unverified → partial
- [security improvement] Malware scan: unverified → pass
- [security] Stability: Stability not yet verified: not enough scan history yet (needs a 30-day window).
- [security] The attested source repository moved: KyaniteLabs/Epoch
- [functional improvement] Schema quality: unverified → excellent
- [functional improvement] License: unverified → pass
- [functional improvement] Dependency health: unverified → partial
- [functional improvement] Maintenance: unverified → pass
- [functional improvement] MCP protocol: unverified → pass
- [functional improvement] Tool coverage: unverified → 100
- [functional] Licence: MIT

### 2026-08-01 (score 5, −22)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-31 (score 27, −18)

- [security regression] Malware scan: pass → unverified

### 2026-07-27 (score 45)

First indexed and scored.

## MCP tools (24)

### `get_current_time` (~74 tokens)

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'.

Input parameters:

- `timezone` (string): IANA timezone identifier. Defaults to "UTC".

### `convert_timezone` (~76 tokens)

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.

Input parameters:

- `target_tz` (string, required): Target IANA timezone identifier.
- `timestamp` (string, required): ISO-8601 timestamp to convert.

### `parse_duration` (~99 tokens)

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'.

Input parameters:

- `duration_string` (string, required): Duration string like "2h30m", "1d6h", "45m".

### `time_math` (~95 tokens)

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.

Input parameters:

- `operands` (object, required): Key-value pairs matching the chosen operation's expected fields. See operation documentation for required keys.
- `operation` (string, required): The time arithmetic operation to perform. Each operation expects specific operands.

### `add_business_days` (~95 tokens)

Adds N business (working) days to a start date, skipping weekends and country-specific public holidays. Supports US, UK, FR, DE, and JP holidays.

Input parameters:

- `country` (string): ISO-3166-1-alpha-2 country code for holiday calendar.
- `days` (number, required): Number of business days to add (negative to subtract).
- `start_date` (string, required): ISO date string for the start date.

### `count_business_days` (~96 tokens)

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.

Input parameters:

- `country` (string): ISO-3166-1-alpha-2 country code for holiday calendar.
- `end_date` (string, required): ISO date string for the end date.
- `start_date` (string, required): ISO date string for the start date.

### `pert_estimate` (~228 tokens)

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.

Input parameters:

- `ai_native`: Degree of AI assistance: 0.0 = fully human, 1.0 = fully AI-native, 0.5 = hybrid. Accepts boolean for backward compatibility (true=1.0, false=0.0).
- `most_likely` (number, required): Mode of the distribution — the single most probable outcome.
- `optimistic` (number, required): Best-case duration. Do NOT use your initial optimistic guess — this should be the absolute minimum if everything goes perfectly.
- `pessimistic` (number, required): Worst-case duration accounting for known risks and unknown unknowns.
- `task_type` (string): Optional task type for feedback matching. Enables per-task-type accuracy tracking.
- `unit` (string): Time unit for all three PERT estimates.

### `cocomo_estimate` (~393 tokens)

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.

Input parameters:

- `ai_native`: Degree of AI assistance: 0.0 = fully human, 1.0 = fully AI-native, 0.5 = hybrid. Accepts boolean for backward compatibility (true=1.0, false=0.0).
- `context_completeness` (number): How complete is the context provided to the LLM? 0.5 = exhaustive specs, 1.0 = typical, 2.0 = vague requirements.
- `human_oversight` (number): Human review overhead multiplier. 0.5 = auto-merged, 1.0 = standard PR review, 2.0 = compliance/security review.
- `iterative_cycles` (number): Iteration overhead multiplier or literal cycle count. Multiplier scale: 0.5 = one-shot, 1.0 = typical debug loop, 2.0 = heavy back-and-forth. Values above 2.0 are accepted as literal cycle counts and…
- `kloc` (number, required): Estimated thousands of lines of code. Count actual code, not comments/blank lines.
- `reasoning_complexity` (number): Multiplier for reasoning complexity of the codebase. 0.5 = trivial CRUD, 1.0 = average, 2.0 = novel algorithm/R&D.
- `task_type` (string): Optional task type for feedback matching.
- `transformation_impact` (number): Scale of transformation relative to existing code. 0.5 = small patch, 1.0 = new module, 2.0 = architectural rewrite.

### `sprint_forecast` (~200 tokens)

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.

Input parameters:

- `ai_native`: Degree of AI assistance: 0.0 = fully human, 1.0 = fully AI-native, 0.5 = hybrid. Accepts boolean for backward compatibility (true=1.0, false=0.0).
- `backlog_points` (number, required): Total story points or effort units remaining in the backlog.
- `hours_per_sprint` (number): Total productive engineering hours available per sprint (accounts for meetings, overhead).
- `sprint_length_days` (number): Calendar days in a single sprint cycle.
- `task_type` (string): Optional task type for feedback matching.
- `velocity_history` (array, required): Historical velocities from completed sprints. Minimum 1 data point; 3+ recommended for meaningful forecasts.

### `critical_path` (~88 tokens)

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.

Input parameters:

- `task_type` (string): Optional task type for feedback matching.
- `tasks` (array, required): All tasks in the project graph. Each task must have a unique name.

### `monte_carlo_schedule` (~131 tokens)

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.

Input parameters:

- `iterations` (number): Number of Monte Carlo simulation iterations (1–100,000). Higher = more stable percentiles.
- `seed` (integer): Optional seed for reproducible results.
- `task_type` (string): Optional task type for feedback matching. Enables per-task-type accuracy tracking.
- `tasks` (array, required): Task list with PERT-style three-point estimates and dependency edges.

### `reference_class_estimate` (~264 tokens)

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.

Input parameters:

- `ai_native`: Degree of AI assistance: 0.0 = fully human, 1.0 = fully AI-native, 0.5 = hybrid. Accepts boolean for backward compatibility (true=1.0, false=0.0).
- `complexity` (number): Fine-tuning complexity from 1 (trivial) to 5 (extreme). Adjusts within the scope band: low complexity shortens, high complexity lengthens the estimate.
- `scope` (string): Rough size of the task: small=tiny fix/tweak, medium=typical task, large=significant effort, xl=epic-scale. When omitted, inferred from complexity (1-2=small, 3=medium, 4=large, 5=xl).
- `task_type` (string, required): Category of work being estimated for reference-class lookup.
- `team_id` (string): Optional team identifier to scope historical data to a specific team.

### `calibrate_estimates` (~102 tokens)

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.

Input parameters:

- `minimum_samples` (number): Minimum number of completed tasks required before producing a calibration factor.
- `period_days` (number): Lookback window in calendar days for calibration data.
- `team_id` (string, required): Team identifier whose historical accuracy data should be analysed.

### `token_time_bridge` (~167 tokens)

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).

Input parameters:

- `model` (string, required): LLM model identifier. Unknown models fall back to generic estimates.
- `reasoning_depth` (string): Expected depth of chain-of-thought reasoning. Deep reasoning adds significant per-token latency.
- `task_type` (string): Optional task type for feedback matching.
- `tokens` (number, required): Total number of tokens in the LLM request (prompt + completion).
- `tool_calls` (number): Number of tool calls expected in the agentic loop. Each adds overhead latency.

### `token_cost_estimate` (~137 tokens)

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.

Input parameters:

- `model` (string, required): LLM model identifier. Unknown models fall back to generic estimates.
- `reasoning_depth` (string): Expected depth of chain-of-thought reasoning.
- `task_type` (string): Optional task type for feedback matching.
- `tokens` (number, required): Total number of tokens in the LLM request (prompt + completion).
- `tool_calls` (number): Number of tool calls expected in the agentic loop.

### `compare_models` (~111 tokens)

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.

Input parameters:

- `reasoning_depth` (string): Expected depth of chain-of-thought reasoning.
- `sort_by` (string): Sort models by cost (default) or estimated time.
- `tokens` (number, required): Total number of tokens to estimate across all models.
- `tool_calls` (number): Number of tool calls expected.

### `accuracy_trend` (~102 tokens)

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.

Input parameters:

- `team_id` (string): Optional team identifier to scope historical data.
- `window_size` (number): Number of records per sliding window.

### `schedule_risk` (~192 tokens)

Assess schedule risk for an estimate using historical accuracy data.

Computes confidence intervals (p50/p80/p95) based on your team's MAPE.
Returns risk level and actionable recommendations.
Uses industry baseline (25% MAPE) when no historical data is available.

Input parameters:

- `ai_native`: Degree of AI assistance: 0.0 = fully human, 1.0 = fully AI-native, 0.5 = hybrid. Accepts boolean for backward compatibility (true=1.0, false=0.0).
- `complexity` (number): Task complexity from 1 (trivial) to 5 (extreme). Higher complexity widens confidence intervals.
- `estimated_hours` (number, required): The estimated effort in hours to assess risk for.
- `task_type` (string): Optional task type to refine historical accuracy lookup.
- `team_id` (string): Optional team identifier to scope historical data.

### `cocomo_validate` (~81 tokens)

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.

Input parameters:

- `dataset_filter` (array): Optional filter to validate against specific datasets only.

### `cocomo_ground_truth` (~118 tokens)

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.

Input parameters:

- `dataset_filter` (array): Optional filter to validate against specific datasets only.

### `record_actual` (~93 tokens)

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.

Input parameters:

- `actual_hours` (number, required): Actual hours spent.
- `estimate_id` (string, required): ID of the estimate to update.
- `notes` (string): Optional context.

### `get_pending_estimates` (~61 tokens)

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.

Input parameters:

- `limit` (integer): Max estimates to return.

### `batch_record_actuals` (~67 tokens)

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.

Input parameters:

- `entries` (array, required): Array of actual-hour records (1–500 entries).

### `feedback_health` (~52 tokens)

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).

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/kyanitelabs-epoch/kyanitelabs-epoch#diagnostics

## Score history

- 2026-08-03: 79
- 2026-08-02: 75
- 2026-08-01: 5
- 2026-07-31: 27
- 2026-07-29: 45
- 2026-07-28: 45
- 2026-07-27: 45

## Links

- npm package: https://www.npmjs.com/package/@kyanitelabs/epoch
- Socket report: https://socket.dev/npm/package/@kyanitelabs/epoch
- Repository: https://github.com/KyaniteLabs/Epoch
- Website: https://kyanitelabs.github.io/Epoch/
- Changelog RSS feed: https://verifymcp.io/servers/kyanitelabs-epoch/kyanitelabs-epoch/changelog.xml
- Changelog JSON feed: https://verifymcp.io/servers/kyanitelabs-epoch/kyanitelabs-epoch/changelog.json
- HTML version of this page: https://verifymcp.io/servers/kyanitelabs-epoch/kyanitelabs-epoch