Key facts
| Router model | plugsky-fusion escalates per pass across tiers (live) |
| Models | 30+ models; chunk passes on cheap tiers, reduce steps escalated |
| Long context | plugsky-longctx for wide synthesis when summaries must be merged |
| JSON mode | Live for structured summaries with sections and citations |
| Caching | Hash inputs to skip unchanged documents |
| Pricing | Flat monthly self-serve plans with no per-token charges on self-serve |
| Free tier | plugsky-micro and plugsky-lite on the free plan, no card required |
| Roadmap | The batch endpoint is coming soon for bulk summarization runs |
TL;DR
- Chunk passes are cheap-tier work; the reduce step is not.
- Cap summary length per format — output is the bill.
- Skip unchanged documents with input hashing.
- Escalate dense, high-stakes or low-confidence inputs.
- Measure cost per summarized document, not per call.
How it works, step by step
- Categorise summarization jobs by input type, length and stakes.
- Split long documents into chunk groups and summarize each on a cheap tier.
- Set a fixed output schema and cap length per format.
- Reduce chunk summaries with a stronger model only when synthesis matters.
- Escalate dense, multilingual or high-stakes documents to strong tiers.
- Hash inputs and skip documents whose content is unchanged.
- Track cost per document, summary length and downstream edit rate.
Try it yourself
Open the LLM API cost calculator →
Output tokens are the summarization bill
Summaries are all output: the model writes more than it reads for short inputs, and map-reduce multiplies the number of generated passages. Controlling how much each pass writes matters more than which model writes it first. Cap output length per format, request bullets rather than prose when structure is acceptable, and avoid regenerate-until-perfect loops that repeat the full cost.
The reduce step is where quality concentrates. Chunk summaries can be produced cheaply and consistently with a tight schema; merging them into a coherent document rewards a stronger model, especially when sources conflict.
Map-reduce economics
Map-reduce exists to keep long inputs inside context limits, but it also changes the cost shape. Many small cheap passes can cost less than one enormous strong-model call, or more, depending on chunk size and summary length. Measure both patterns on your real corpus before choosing.
- Keep chunk summaries short; they are intermediate artifacts, not deliverables.
- Carry source identifiers through the reduce step so claims stay traceable.
- Skip documents whose hash has not changed.
- Use a long-context model when a single pass is genuinely cheaper or more faithful than reduce.
Escalation and measurement
Not every document deserves the same treatment. Dense regulatory text, multilingual material and anything a person will act on should escalate. The routing signal can be structural — length, language, domain — or quality-based, such as a cheap self-check that flags uncertainty.
Measure cost per summarized document, summary length, citation or coverage quality and downstream edit rate. A cheap summary that humans rewrite is not a saving. Start on the free plan with plugsky-micro and plugsky-lite for chunk passes, then evaluate strong and long-context models for reduce steps during the 14-day full-access trial; plans are on the live pricing page.
Honest comparison
| Summarization choice | Routed summarization | Strong model, single pass | Cheap model, every pass |
|---|---|---|---|
| Chunk passes | Cheap tier, capped output | Strong tier, unbounded output | Cheap and adequate |
| Reduce step | Strong tier when synthesis matters | Native strength | Weak coherence |
| Long documents | Map-reduce with traceable ids | Context limits bite | Same limits |
| Unchanged inputs | Skipped by hash | Reprocessed | Reprocessed |
| Evidence | Cost per document plus edit rate | Cost per call | Cost per call |
Frequently asked questions
What dominates summarization cost?
Output tokens, because summaries generate rather than read, and map-reduce multiplies the number of generated passages. Capping summary length and skipping unchanged documents are the largest savings.
Should the reduce step use a stronger model?
Usually yes. Chunk summaries can be cheap and schematic, but merging conflicting or dense material benefits from a stronger or long-context model where judgement changes the result.
How do I handle very long documents?
Map-reduce with short intermediate summaries and source identifiers, or a long-context model when a single pass is genuinely cheaper or more faithful. Measure both on your corpus.
Can I skip documents?
Yes. Hash inputs and skip unchanged content. Re-summarizing a document that has not changed is pure waste.
How do I stop regeneration loops?
Define acceptance criteria upfront and cap attempts. Regenerating a long summary several times costs as much as a stronger model that gets it right once.
Is batch summarization available?
Not yet — the batch endpoint is coming soon. Today, run bulk jobs with bounded concurrency and a queue, and cache results by input hash.
How do I measure quality?
Track coverage, faithfulness and downstream edit rate on a fixed document set, alongside cost per summarized document. Edit rate reveals false savings.
Can I start for free?
Yes. plugsky-micro and plugsky-lite are on the free plan with no card, and the 14-day full-access trial covers stronger and long-context models.