Table of Contents generated with DocToc

• Mode economics — what does each mode cost to run?
  • How to read this page
    • What “tokens” means here
    • Model classes
  • Per-mode token shape
    • Triage
    • Mentoring
    • Drafting
    • Pairing
    • Agentic Autonomous
  • Model class and mode cost shape
  • Local and self-hosted inference
  • Reducing costs
  • Long-term: the ASF inference endpoint
  • Cross-references

Mode economics — what does each mode cost to run?

Indicative, not a quote. The numbers on this page describe the token-count shape of a typical invocation, not a billing prediction. Token prices vary by provider, model, date, and discount tier. Always multiply by your own provider’s current rate — or by zero if you are running local inference.

This page exists because MISSION.md § Affordability commits to documenting mode economics honestly: a maintainer evaluating adoption should be able to make an informed decision, not discover the cost after the fact. The same data informs the long-term capacity planning for an ASF-hosted inference endpoint (see Long-term: the ASF inference endpoint).

How to read this page

What “tokens” means here

One token ≈ 0.75 words in English prose, or roughly one character in structured code or JSON. Token counts on this page use K for a thousand tokens and M for a million (so 30K = 30,000 and 1.5M = 1,500,000). Practical anchors:

Every invocation loads the relevant skill file as part of its context, and that overhead varies widely by skill (measured with cl100k_base across the current catalogue). Small setup/utility skills run ~1K–3K tokens; most workflow skills ~3.5K–9K (median ~5.3K); and the large multi-step security skills go much higher — security-issue-triage ~11K, security-issue-import ~22K, security-issue-sync ~36K. This overhead applies before any project-specific content is read.

Model classes

Skills are written against a capability contract, not a vendor. Three capability classes cover the realistic range for these workflows:

Local models (Ollama, vLLM, llama.cpp) map onto Small or Mid-tier by capability; they incur hardware cost rather than per-token billing. See Local and self-hosted inference.

Per-mode token shape

Triage

The lowest-cost mode. Most Agentic Triage skills are read-bounded: the expensive part is loading context (PR diff, report body, existing issue sample), not generating output. Every output is a short proposal — a label suggestion, a routing recommendation, a classification with rationale — so output tokens are low relative to input.

Rule of thumb for Agentic Triage: budget 10K–30K tokens per PR / issue / report on average. A project processing 50 inbound items per week uses roughly 500K–1.5M tokens/week across Agentic Triage work.

Mentoring

Agentic Mentoring is conversational and per-reply: the agent reads thread context, project conventions, and contributor history, then produces a single targeted response. Cost per reply is moderate; total weekly cost depends on contributor volume.

Rule of thumb for Agentic Mentoring: budget 10K–20K tokens per contributor interaction. A project with 20 active contributors each receiving 3 agent replies per week: roughly 600K–1.2M tokens/week.

Drafting

The most variable mode. Short reporter replies are inexpensive; agent-drafted code fixes are expensive because the agent reads relevant source files in addition to the issue or report.

Rule of thumb for Agentic Drafting: reporter replies average 15K–25K tokens; code-producing invocations average 50K–100K tokens depending on codebase scope. Limiting the skill to the relevant source files is the single biggest lever on Agentic Drafting cost.

Pairing

Agentic Pairing runs in the developer’s own development cycle, not on project infrastructure — cost is per-developer-session. Multi-agent pipelines multiply the per-pass cost by the number of review agents.

Rule of thumb for Agentic Pairing: a typical pre-flight self-review of a medium PR uses 15K–30K tokens. A three-agent review pipeline on the same PR: 45K–90K tokens.

Agentic Autonomous

Status: off. Agentic Autonomous is not implemented; it has no token cost. See docs/modes.md § Agentic Autonomous.

Model class and mode cost shape

The table below describes the quality/cost trade-off per mode, not a hard recommendation. “Viable” means acceptable recall on typical cases; “Recommended” means the sweet spot between quality and cost; “Large class” means quality requirements that mid-tier models often miss.

Cost differential across classes (indicative ratio, not a price): Small-class models are typically 10–50× cheaper per token than Large-class models at hosted-API rates. Mid-tier sits at roughly 3–10× cheaper than Large. The total invocation cost is token_count × per_token_rate; the rate varies by vendor and changes over time — check your provider’s current pricing page.

Local and self-hosted inference

Running a model locally (Ollama, vLLM, llama.cpp) shifts cost from per-token billing to hardware:

Local inference is also the simplest privacy answer for most skills: data never leaves the machine, and no third-party data-processing agreement is needed. The framework’s vendor neutrality means local paths use identical skill code to hosted paths.

Reducing costs

1. Match model class to task. Agentic Triage classification and short Agentic Mentoring replies do not need a frontier model. Reserve Large-class for novel-pattern security analysis and complex multi-file code fixes.

2. Scope code reads. The biggest driver of Agentic Drafting cost is how many source files the agent loads. Small, well-named files help the skill read only what is relevant.

3. Cache skill context. Most agent CLIs support prompt-level caching. The skill file (size varies by skill class; see What “tokens” means here) and stable project configuration files are ideal cache candidates — the first invocation pays; subsequent invocations are cheap on the cached portion. Note: most provider caches have a short TTL (Anthropic prompt cache: 5 min default, 1 h extended at higher write cost), so bursty same-session workloads benefit most; periodic triage runs spaced hours apart will typically miss the cache.

4. Batch triage. issue-reassess and pr-management-stats amortise context load across a pool. Running them weekly rather than per-event reduces overall token volume compared with individual calls.

5. Run locally for development. When authoring or testing a new skill override, use a local model. Save the hosted model for production invocations.

Long-term: the ASF inference endpoint

MISSION.md § Affordability names an ASF-hosted inference endpoint (inference.apache.org, name TBD) as a long-term roadmap item: a community-affordable, foundation-governed, audit-logged inference layer any open-source maintainer — ASF or otherwise — can use without paying a vendor or accepting a vendor’s gift.

This page’s data — token counts per mode, per typical workload — is the quantitative input for the capacity planning and cost models that endpoint will need. As pilot adopters accumulate real usage data, this page will be updated with observed ranges rather than theoretical estimates, so the endpoint sizing argument rests on evidence.

Cross-references

• MISSION.md § Affordability — the policy commitment behind this page.
• docs/modes.md — per-mode skill catalogue and maturity status.
• docs/prerequisites.md — what you need to run the framework, including model-backend setup.