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
    • Auto-merge
  • 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. 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 ~1 000–3 000 tokens; most workflow skills ~3 500–9 000 (median ~5 300); and the large multi-step security skills go much higher — security-issue-triage ~11 000, security-issue-import ~22 000, security-issue-sync ~36 000. 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 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 Triage: budget 10 000–30 000 tokens per PR / issue / report on average. A project processing 50 inbound items per week uses roughly 500 000–1 500 000 tokens/week across Triage work.

Mentoring

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 Mentoring: budget 10 000–20 000 tokens per contributor interaction. A project with 20 active contributors each receiving 3 agent replies per week: roughly 600 000–1 200 000 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 Drafting: reporter replies average 15 000–25 000 tokens; code-producing invocations average 50 000–100 000 tokens depending on codebase scope. Limiting the skill to the relevant source files is the single biggest lever on Drafting cost.

Pairing

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 Pairing: a typical pre-flight self-review of a medium PR uses 15 000–30 000 tokens. A three-agent review pipeline on the same PR: 45 000–90 000 tokens.

Auto-merge

Status: off. Auto-merge is not implemented; it has no token cost. See docs/modes.md § Auto-merge.

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. Triage classification and short 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 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.