Evidence row 222048

What was observed

{
  "count": 12,
  "tools": [
    {
      "description": "Use for LLM inference/reasoning cost per successful multi-step agent task, including failure overhead and context growth across turns. Use agent-workflow-cost-calculator for iPaaS/app-action/MCP orchestration fees. Use automation-cost-calculator for generic Zapier/Make/n8n workflow billing.",
      "inputSchema": {
        "examples": [
          {
            "tasks_per_month": 60000
          }
        ],
        "properties": {
          "avg_tokens_in_per_turn": {
            "description": "Avg input tokens per turn (default 3000)",
            "minimum": 0,
            "type": "number"
          },
          "avg_tokens_out_per_turn": {
            "description": "Avg output tokens per turn (default 400)",
            "minimum": 0,
            "type": "number"
          },
          "context_growth_factor": {
            "description": "Multiplier on input tokens as conversation grows (default 1.4)",
            "minimum": 1,
            "type": "number"
          },
          "model": {
            "description": "LLM model (default claude-sonnet-4-6)",
            "type": "string"
          },
          "provider": {
            "description": "LLM provider (default anthropic)",
            "type": "string"
          },
          "steps_per_task": {
            "description": "Avg reasoning steps per task (default 5)",
            "minimum": 1,
            "type": "number"
          },
          "success_rate": {
            "description": "Task success rate 0-1 (default 0.7)",
            "maximum": 1,
            "minimum": 0.01,
            "type": "number"
          },
          "tasks_per_month": {
            "description": "Tasks attempted per month",
            "minimum": 0,
            "type": "number"
          },
          "tool_calls_per_step": {
            "description": "Avg tool invocations per step (default 2)",
            "minimum": 0,
            "type": "number"
          }
        },
        "required": [
          "tasks_per_month"
        ],
        "type": "object"
      },
      "name": "agent-loop-cost-calculator"
    },
    {
      "description": "Use for automation-platform/iPaaS cost of an AI agent workflow, including app-action fan-out and MCP tool-call accounting, explicitly excluding LLM token spend. Use automation-cost-calculator for generic non-agent workflow billing. Use agent-loop-cost-calculator for LLM inference/reasoning cost per successful multi-step agent task.",
      "inputSchema": {
        "examples": [
          {
            "agent_runs_per_month": 20000
          }
        ],
        "properties": {
          "agent_runs_per_month": {
            "description": "Agent workflow runs per month",
            "minimum": 0,
            "type": "number"
          },
          "app_actions_per_run": {
            "description": "Downstream app actions per agent run (default 3)",
            "minimum": 0,
            "type": "number"
          },
          "make_modules_per_run": {
            "description": "Make modules per run; defaults to app actions + MCP calls",
            "minimum": 1,
            "type": "number"
          },
          "mcp_tool_calls_per_run": {
            "description": "MCP tool calls per agent run (default 1)",
            "minimum": 0,
            "type": "number"
          }
        },
        "required": [
          "agent_runs_per_month"
        ],
        "type": "object"
      },
      "name": "agent-workflow-cost-calculator"
    },
    {
      "description": "Use for generic or non-agent recurring workflow platform billing across Zapier task billing, Make credit billing, and n8n execution billing. Use agent-workflow-cost-calculator instead when the workflow is explicitly an AI agent with app actions or MCP tool calls. Use agent-loop-cost-calculator instead when the question is about LLM inference/reasoning cost per successful agent task.",
      "inputSchema": {
        "examples": [
          {
            "workflow_runs_per_month": 120000
          }
        ],
        "properties": {
          "billable_steps_per_run": {
            "description": "Billable actions/modules per run (default 5)",
            "minimum": 1,
            "type": "number"
          },
          "make_modules_per_run": {
            "description": "Make module actions per scenario run; defaults to billable_steps_per_run",
            "minimum": 1,
            "type": "number"
          },
          "workflow_runs_per_month": {
            "description": "Workflow/scenario runs per month",
            "minimum": 0,
            "type": "number"
          }
        },
        "required": [
          "workflow_runs_per_month"
        ],
        "type": "object"
      },
      "name": "automation-cost-calculator"
    },
    {
      "description": "Use when a user needs to know whether a document plus prompt plus output fits within a model's context window, or wants a strategy recommendation (truncate/summarize/rag/chunk).",
      "inputSchema": {
        "examples": [
          {
            "doc_tokens": 18000,
            "model_context_window": 200000
          }
        ],
        "properties": {
          "doc_tokens": {
            "description": "Primary document/content tokens",
            "minimum": 0,
            "type": "number"
          },
          "expected_out_tokens": {
            "description": "Reserved output budget (default 1000)",
            "minimum": 0,
            "type": "number"
          },
          "model_context_window": {
            "description": "Target model context size",
            "minimum": 1,
            "type": "number"
          },
          "overhead_tokens": {
            "description": "System prompt + few-shot + history (default 2000)",
            "minimum": 0,
            "type": "number"
          },
          "strategy_hint": {
            "description": "Preferred strategy (optional)",
            "enum": [
              "truncate",
              "summarize",
              "rag",
              "chunk"
            ],
            "type": "string"
          }
        },
        "required": [
          "doc_tokens",
          "model_context_window"
        ],
        "type": "object"
      },
      "name": "context-window-planner"
    },
    {
      "description": "Use when a user needs to budget an LLM evaluation run. Given samples/models/trials, returns total cost, per-run cost, and parallel time estimate.",
      "inputSchema": {
        "examples": [
          {
            "samples": 2000
          }
        ],
        "properties": {
          "avg_tokens_in": {
            "description": "Avg input tokens per sample (default 2000)",
            "minimum": 0,
            "type": "number"
          },
          "avg_tokens_out": {
            "description": "Avg output tokens per sample (default 500)",
            "minimum": 0,
            "type": "number"
          },
          "judge_enabled": {
            "description": "Enable LLM-as-judge second pass (default false)",
            "type": "boolean"
          },
          "judge_tokens_in": {
            "description": "Judge input tokens (default 1500)",
            "minimum": 0,
            "type": "number"
          },
          "judge_tokens_out": {
            "description": "Judge output tokens (default 200)",
            "minimum": 0,
            "type": "number"
          },
          "model": {
            "description": "Eval model (default claude-sonnet-4-6)",
            "type": "string"
          },
          "models": {
            "description": "Candidate models (default 1)",
            "minimum": 1,
            "type": "number"
          },
          "provider": {
            "description": "Eval provider (default anthropic)",
            "type": "string"
          },
          "samples": {
            "description": "Number of eval samples",
            "minimum": 1,
            "type": "number"
          },
          "trials_per_sample": {
            "description": "Repeats per sample (default 1)",
            "minimum": 1,
            "type": "number"
          }
        },
        "required": [
          "samples"
        ],
        "type": "object"
      },
      "name": "eval-cost-calculator"
    },
    {
      "description": "Use when a user is considering fine-tuning vs prompt engineering. Returns training cost, monthly inference savings, months-to-ROI, and breakeven volume.",
      "inputSchema": {
        "examples": [
          {
            "monthly_inference_tokens": 300000000,
            "train_tokens": 50000000
          }
        ],
        "properties": {
          "base_inference_cost_1m": {
            "description": "Baseline API output cost per 1M",
            "minimum": 0,
            "type": "number"
          },
          "finetuned_inference_cost_1m": {
            "description": "Fine-tuned inference cost per 1M",
            "minimum": 0,
            "type": "number"
          },
          "monthly_inference_tokens": {
            "description": "Expected monthly inference volume (output tokens)",
            "minimum": 0,
            "type": "number"
          },
          "prompt_reduction_pct": {
            "description": "Prompt size reduction % from eliminating few-shot (default 0)",
            "maximum": 100,
            "minimum": 0,
            "type": "number"
          },
          "train_cost_per_1m": {
            "description": "Training cost per 1M tokens",
            "minimum": 0,
            "type": "number"
          },
          "train_tokens": {
            "description": "Training tokens (dataset × epochs)",
            "minimum": 0,
            "type": "number"
          }
        },
        "required": [
          "train_tokens",
          "monthly_inference_tokens"
        ],
        "type": "object"
      },
      "name": "fine-tune-roi-calculator"
    },
    {
      "description": "Use when a user needs to budget LLM observability tooling. Returns monthly cost at given request volume with retention adjustment.",
      "inputSchema": {
        "examples": [
          {
            "provider": "langsmith",
            "requests_per_day": 50000
          }
        ],
        "properties": {
          "avg_log_bytes": {
            "description": "Avg payload bytes per traced request (default 4096)",
            "minimum": 0,
            "type": "number"
          },
          "provider": {
            "description": "Observability provider",
            "enum": [
              "langsmith",
              "langfuse",
              "helicone",
              "portkey",
              "arize",
              "braintrust"
            ],
            "type": "string"
          },
          "requests_per_day": {
            "description": "Average daily LLM requests",
            "minimum": 0,
            "type": "number"
          },
          "retention_days": {
            "description": "Retention in days (default 30)",
            "minimum": 1,
            "type": "number"
          }
        },
        "required": [
          "requests_per_day",
          "provider"
        ],
        "type": "object"
      },
      "name": "observability-cost-calculator"
    },
    {
      "description": "Use when a user asks what an LLM workload costs on a specific provider/model, or wants to compare cost across providers. Given tokens per call and call volume, returns monthly cost plus a tier comparison table.",
      "inputSchema": {
        "examples": [
          {
            "calls_per_month": 100000,
            "tokens_in": 1200,
            "tokens_out": 400
          }
        ],
        "properties": {
          "calls_per_month": {
            "description": "Monthly call volume",
            "minimum": 1,
            "type": "number"
          },
          "include_comparison": {
            "description": "Include tier comparison table (default true)",
            "type": "boolean"
          },
          "model": {
            "description": "Target model (e.g. claude-sonnet-4-6)",
            "type": "string"
          },
          "provider": {
            "description": "Target provider (e.g. anthropic, openai, together)",
            "type": "string"
          },
          "tokens_in": {
            "description": "Input tokens per call",
            "minimum": 0,
            "type": "number"
          },
          "tokens_out": {
            "description": "Output tokens per call",
            "minimum": 0,
            "type": "number"
          }
        },
        "required": [
          "tokens_in",
          "tokens_out"
        ],
        "type": "object"
      },
      "name": "provider-cost-calculator"
    },
    {
      "description": "Use when a user is planning to quantize an LLM to fit on smaller hardware. Given parameter count and precision transition, returns VRAM requirement, speedup estimate, and approximate quality delta.",
      "inputSchema": {
        "examples": [
          {
            "params_billions": 8
          }
        ],
        "properties": {
          "batch_size": {
            "description": "Serving batch size (default 1)",
            "minimum": 1,
            "type": "number"
          },
          "kv_cache_tokens": {
            "description": "Max KV cache tokens (default 8192)",
            "minimum": 0,
            "type": "number"
          },
          "params_billions": {
            "description": "Model parameter count in billions",
            "minimum": 0.1,
            "type": "number"
          },
          "precision_from": {
            "description": "Starting precision (default bf16)",
            "enum": [
              "fp32",
              "fp16",
              "bf16",
              "fp8",
              "int8",
              "int6",
              "int5",
              "int4",
              "int3",
              "int2",
              "int1"
            ],
            "type": "string"
          },
          "precision_to": {
            "description": "Target precision (default int4)",
            "enum": [
              "fp32",
              "fp16",
              "bf16",
              "fp8",
              "int8",
              "int6",
              "int5",
              "int4",
              "int3",
              "int2",
              "int1"
            ],
            "type": "string"
          }
        },
        "required": [
          "params_billions"
        ],
        "type": "object"
      },
      "name": "quantization-calculator"
    },
    {
      "description": "Use when a user needs end-to-end RAG cost estimation (embedding + vector store + generation). Returns monthly cost with breakdown and dominant-component identification.",
      "inputSchema": {
        "examples": [
          {
            "corpus_tokens": 25000000,
            "queries_per_day": 5000
          }
        ],
        "properties": {
          "answer_tokens": {
            "description": "Avg answer tokens (default 400)",
            "minimum": 0,
            "type": "number"
          },
          "chunk_size_tokens": {
            "description": "Avg chunk size (default 512)",
            "minimum": 64,
            "type": "number"
          },
          "chunks_retrieved": {
            "description": "Chunks per query (default 5)",
            "minimum": 1,
            "type": "number"
          },
          "corpus_tokens": {
            "description": "Indexed corpus size in tokens",
            "minimum": 0,
            "type": "number"
          },
          "embedding_provider": {
            "description": "Embedding model",
            "enum": [
              "openai-3-small",
              "openai-3-large",
              "voyage-3",
              "voyage-3-lite",
              "cohere-embed-v3",
              "google-text-embed-004"
            ],
            "type": "string"
          },
          "generator_model": {
            "description": "Generator model (default claude-sonnet-4-6)",
            "type": "string"
          },
          "generator_provider": {
            "description": "Generator LLM provider (default anthropic)",
            "type": "string"
          },
          "queries_per_day": {
            "description": "User query volume per day",
            "minimum": 0,
            "type": "number"
          },
          "question_tokens": {
            "description": "Avg question tokens (default 100)",
            "minimum": 0,
            "type": "number"
          },
          "reindex_fraction_per_month": {
            "description": "Fraction of corpus re-embedded per month (default 0.1)",
            "maximum": 1,
            "minimum": 0,
            "type": "number"
          },
          "vector_store": {
            "description": "Vector store",
            "enum": [
              "pinecone",
              "weaviate",
              "qdrant",
              "chroma",
              "turbopuffer"
            ],
            "type": "string"
          }
        },
        "required": [
          "queries_per_day",
          "corpus_tokens"
        ],
        "type": "object"
      },
      "name": "rag-pipeline-cost-calculator"
    },
    {
      "description": "Use when a user is deciding between API usage and self-hosted GPU inference at a given volume. Returns breakeven token volume, monthly cost comparison, and go/no-go recommendation.",
      "inputSchema": {
        "examples": [
          {
            "monthly_tokens": 750000000
          }
        ],
        "properties": {
          "api_cost_per_1m_out": {
            "description": "Current API output cost per 1M tokens",
            "minimum": 0,
            "type": "number"
          },
          "gpu_provider": {
            "description": "GPU provider (e.g. runpod, modal)",
            "type": "string"
          },
          "gpu_type": {
            "description": "GPU type (e.g. h100, a100-80gb)",
            "type": "string"
          },
          "monthly_tokens": {
            "description": "Monthly output token volume",
            "minimum": 0,
            "type": "number"
          },
          "operational_overhead_pct": {
            "description": "Ops overhead % on GPU cost (default 40)",
            "minimum": 0,
            "type": "number"
          },
          "utilization_pct": {
            "description": "Expected GPU utilization % (default 60)",
            "maximum": 100,
            "minimum": 1,
            "type": "number"
          }
        },
        "required": [
          "monthly_tokens"
        ],
        "type": "object"
      },
      "name": "self-host-breakeven-calculator"
    },
    {
      "description": "Use when a user asks how many tokens a given text will consume, or needs to estimate prompt size before pricing a workload. Given text and tokenizer family, returns low/high token range and byte-level measurements.",
      "inputSchema": {
        "examples": [
          {
            "text": "Summarize the Q3 board deck into five concise bullet points for the exec team."
          }
        ],
        "properties": {
          "expected_out_tokens": {
            "description": "Expected output token budget (optional)",
            "minimum": 0,
            "type": "number"
          },
          "text": {
            "description": "Text content to count tokens for",
            "type": "string"
          },
          "tokenizer": {
            "description": "Tokenizer family (default: default)",
            "enum": [
              "cl100k_base",
              "o200k_base",
              "claude",
              "gemini",
              "llama3",
              "mistral",
              "default"
            ],
            "type": "string"
          }
        },
        "required": [
          "text"
        ],
        "type": "object"
      },
      "name": "token-counter"
    }
  ]
}

What the leaf hashes

{"body":"b3c8dcca245674e6c80a97c3bb73b19848e3dd920b798df0c8fb1297472f2c78","id":222048,"kind":"mcp.tools","method":"probe.mcp/1","observed_us":1793027783054012,"prev":null,"subject":"10bdfa4b-ac8e-41b9-a18d-9e1d225b0fe9","subject_kind":"endpoint"}

Proof

Its day has not closed yet. A day closes ten minutes after midnight UTC; the proof appears here then.