Which Tool For Which Job

You have a folder. It might be ten thousand stills that need a caption and a tag. It might be years of notes, tickets, or chapters that need classifying. It might be a pile of text that has to become a map of vectors so later search has somewhere to stand. A blank chat is already open, because that is the surface sitting in front of you.

A folder of stills does not want a conversation. It wants a loop that will still be running when you make coffee.

Using a frontier model for work a deterministic tool could do is a default, not a law. The skill is scoping the job, not collecting tools.

What follows is a kit you can use before you pick a surface: three questions, four ways to run what you just scoped, a trap that looks like patience and is actually a queue, a way to point the same spend at different architecture, three job shapes at altitude, and a diagnostic you can fill in on paper.

Three questions, before a tool

Ask these in order. The tool comes after the answers.

What does the task need? Some work is judgment: a plan that has to hold, a diagnosis, a piece of writing that would be nonsense if it were a template. Some work is a grind that happens to look like language or vision — label this, extract that, embed the lot, write a one-line description of a frame. Task-need is the question that separates genuine high-value reasoning from a loop. If the hard part would stay hard on the thousandth item, you are doing reasoning work. If the thousandth item is the same motion as the first, you are doing bulk work. Tool catalogues do not make that distinction for you. (TDA interpretation.)

What may the data do? Where may this payload go? May it leave your boundary to a third party? Hosted inference is not a vanishing act. Public platform documentation, accessed August 2026, describes default retention windows on abuse-monitoring logs — on the order of weeks, longer if law or safety requires it — and stricter no-retention options that typically need prior approval, with some endpoints remaining ineligible. Sending personal data to a hosted model is a processing relationship: who decides the purpose, who processes on whose behalf, what contract and what retention actually apply, and often whether an impact assessment is due. Under data-protection regimes that relationship is controller and processor, not a paste into a chat box. UK and EU guidance on the accountability side is older than a year in its base texts; treat it as foundational, not as a live pricing card. If the raw payload must not travel in the clear, that answer can force an on-boundary lane regardless of fashion or sticker price.

What does it cost at volume? One item in a chat is a rounding error. Ten thousand items at premium per-token or per-call rates is a different object. Cost-at-volume is not a lecture about thrift. It is the question that shows when an interactive frontier surface is the wrong default for a warehouse job. As of August 2026, multiple hosted inference platforms publish an asynchronous bulk lane priced below their real-time lane — commonly at half the synchronous token rate — with a completion window on the order of a day, aimed at evaluations, large-dataset classification, embedding repositories, and other work that does not need an answer this second. Exact percentages on living pricing pages move; the checkable property is the existence of a patient lane priced below the interactive one. Independent 2026 writing on total cost of ownership frames owned versus hosted as a utilisation and latency-tolerance problem: electricity, operator time, and hardware depreciation on one side; linear tokens, rate-limit engineering, and published batch discounts on the other. No universal winner. Match the lane to the job.

Tool pick follows those three answers. Own-hosting is one tool inside the kit, for when permissions or volume land there. It is not the thesis, and it is not a dogma.

Four ways to run a job

The kit is four lanes. One honest paragraph each. None of them is a personality, and none of them is the point of the piece.

Frontier. You rent a reasoning surface. You pay premium hosted rates — subscription, per-token, or both. The work remembers itself inside a provider's session and product. The data has to be allowed to leave the building. This lane fits when the task actually needs high-value inference and you accept the permission trade: a design conversation, a hard debugging pass, a piece of original analysis that would collapse if you forced it through a template. It is the wrong default for a deterministic high-volume grind that happens to be made of words or pixels. You are paying for judgment. Spend it on judgment. (TDA interpretation of the pattern.)

Owned. You buy modest consumer-class hardware once and then you pay electricity. The job remembers itself as a process on metal you control. The requirement is that the workload can run without a third-party inference surface, and that you can wait until morning when the job is not urgent. Bounded experience, one operator, one purchase anecdote, not a recommendation and not a payback story: a second-hand consumer GPU in the low four figures (GBP) can carry high-volume background image analysis overnight. Bounded again, order-of-magnitude only, not a benchmark you should expect: volumes in the tens of thousands of images have run as background owned work in that lane. Image analysis, corpus tagging, embedding a repository — the shapes that are loops, not conversations — are the reason this lane exists in the kit.

Local. Local is not a brand identity and it is not a vow to live offline. It is what happens when the first two questions land on residency: this data must not leave the boundary. Cost is owned-compute economics — hardware, power, operator time. State stays on-boundary. The data requirement is strict non-egress, or fully local inference. The origin material does not give a separate price table for "local" versus "owned". Read it as scoped control when permissions demand it, not as purism. Same skill as the rest of the kit. Different correct landing. (TDA interpretation.)

Obfuscated. Use this lane when the raw payload must not travel in the clear — sensitive, regulated, or otherwise blocked — but some shared or external compute is still on the table after a transform. Redact, de-identify, hash, strip the field that would make a person or a secret visible; then ask the permission question again on what remains. Cost and memory follow whichever compute surface is left after that constraint. If nothing acceptable remains, the raw path stays home. The decisive axis is what the data may do, not which model is fashionable. This is a working definition for the kit, not a frozen procedure. (Proposal.)

The serial-default trap

There is a way to be both slow and expensive at once, and it does not look like a mistake while you are in it.

Morning. The folder is still there. The chat has done forty items. The box in the other room would have done the night.

Hosted coding and reasoning products are built as conversations. A conversation does one thing, then the next. Faced with a folder, the path of least resistance is to send item one, wait, send item two. Most people accept that default and wait. Treat "agents default to serial" as TDA interpretation and bounded experience, not as a public empirical law: no credible study in the research window measured that interface behaviour as universal. What is checkable is the other side of the wall.

Hosted APIs, in current public documentation (accessed August 2026), expose finite parallel capacity: requests and tokens per minute, tiered by spend, exhausted on whichever metric hits first. Async bulk often sits in a separate queue. Exceed the temporary ceiling and you get a backoff signal. Burst too hard against a token-bucket and you trip the limit even when the average looked fine. A monthly spend cap can pause the lot. Parallelism here is a designed property with a ceiling, not an infinite hose, and not something that happens because a chat window is open.

Two right answers sit on either side of the trap. Neither is the serial default.

If the job is not urgent: a patient overnight process on owned compute, running while you sleep. If you need it now: a high-concurrency burst against an API, or the published async batch lane, inside the documented limits — not a crawl.

The operating axis is owned-and-patient versus API-and-massively-parallel. Never accidentally-serial.

Same spend, architected

The persuasion is not to cancel tools, and it is not to spend less. Same monthly spend, pointed at different work.

Bounded experience, one operator, capture-time, not a universal average: a serious monthly AI and subscription baseline on the order of low hundreds of USD can be the same either way. Yield differs by architecture. Reserve premium reasoning for reasoning. Send deterministic bulk to owned overnight, or to the hosted bulk lane that was priced for waiting, or to a local process if the payload cannot leave.

Paying interactive frontier rates for a warehouse job is a checkable mismatch of surface to task, not a moral failing. The same budget that buys a month of reasoning credits can also keep a modest box warm through a corpus, or buy a day of discounted async throughput on a host, or do some of each. Architecture is the decision. Thrift lectures are not.

Three job shapes, at altitude

These are generalised patterns from practice.

Bulk image analysis. A directory of stills. Each file needs a description, a set of tags, maybe a yes/no on a visual property. The thousandth frame does not need a new philosophy. It needs the same questions as the first. If the images may leave the boundary and you need the answers this afternoon, that is a parallel or async hosted job — designed against published rate limits, not typed into a chat one thumbnail at a time. If they may not leave, or you can wait until morning, that is owned or local: a loop on a box you control. Bounded experience, order-of-magnitude only: tens of thousands of images have run as background owned-GPU work in this shape. Quality, latency, and whether your hardware matches that anecdote are open questions for your lot, not facts about the world.

Corpus NLP. A pile of documents — notes, tickets, chapters, logs — and a need to classify, extract, or normalise them. Ask task-need first. Some documents require a careful read and a judgment you would defend. Most of a large corpus does not. The bulk of the pile is a loop: label, span, route. Volume-cost then decides whether that loop belongs on a patient owned process or on a hosted batch path. Data-permission decides whether the raw text may travel. If names, health, or other blocked fields are in the pages, obfuscated comes first: transform, then re-ask. If the corpus cannot leave even in reduced form, local is the landing, not a preference.

Embedding pipelines. Turn a repository into vectors so later retrieval has something to stand on. This is almost never a reasoning job. It is a warehouse job with a published home: hosted platforms name embedding repositories among the workloads their async bulk lanes are for. If the text may leave, use that lane or a parallel embed API inside its ceilings. If it may not, embed on-boundary. The failure mode is the same as the others — feeding the corpus through an interactive frontier chat because that is the tool already open, one chunk per turn, accidentally serial, billed at the reasoning rate.

The generalised move is identical in all three. Scope the item. Scope the payload. Scope the volume and the clock. Then pick a lane. Then pick an execution shape that is either patient on metal you own, or parallel or async on a host, and not a single-file conversation you never designed.

Scoping diagnostic

Fill this in on paper. Then pick. Do not start in the chat box and reason backwards.

1. Task need

• What is one item, in one sentence?
• If you ran this a thousand times, would the hard part stay hard, or become a loop?
• Is the output a judgment you would defend, or a label, extract, vector, or caption?

2. Data permission

• May the raw payload leave your boundary to a third party? Yes / no / only after transform.
• If yes: which retention and contract terms are you actually under — not the ones you hope for?
• If no, or only after transform: what has to be stripped, and is the remainder still useful?

3. Cost at volume

• How many items? Rough tokens, pages, or pixels.
• When do you need the result: seconds, hours, or by morning?
• Are you currently paying interactive frontier rates for the loop?

4. Lane Pick the mode per part, not per job. Most jobs are a thin reasoning layer wrapped around a thick deterministic core. Scope them separately.

• Reasoning + payload may leave + you accept the trade → frontier.
• Loop + you can wait + residency allows local compute → owned.
• Payload must not leave → local.
• Raw must not travel; a reduced form might → obfuscated, then re-ask 2 and 3.
• Own-hosting appears here only when the answers put it here.

5. Execution shape (if the work is a loop)

• Not urgent → overnight on owned compute.
• Needed now, and sending is allowed → parallel or async bulk inside published limits.
• One-after-another in a chat window → the trap. Do not take it by accident.

If a question is blank, you do not have a tool choice yet. You have a guess.

The collection of tools will keep growing. The questions do not. Scope the job. Then run it on purpose.

What this piece does not claim

The caveats sit here, in one block, so the body can do the work.

This is not a ranking of products, not a tour of anyone's racks, and not a service-level promise. No private system diagrams. The permission paragraphs are not legal advice: they are a scoping question about where a payload may go, and what a hosted processing relationship actually is. There is no separate published price table for "local" versus "owned" in the origin material; none is invented here.

Figures — the GPU price band, the overnight image volumes, the monthly subscription baseline — stay one operator's bounded experience: order-of-magnitude, capture-time, not benchmarks, not purchasing advice. Exact percentages on living pricing pages move; the checkable property is the existence of a patient lane priced below the interactive one. No lane is claimed to be better. Matching lane to job is the skill.

The method survives the caveats, because the method is the ordering: task, data, volume — then, and only then, the tool.