Decision model use cases

Choosing which model, tier or reasoning effort should serve each request. A typed Choice over candidate models replaces a hand-written router or an LLM call that decides where to send work.

Deciding which tool, skill or MCP server an agent should use for the next step. Weak matches can be declined instead of guessed.

Approving, blocking or escalating a proposed agent action, such as a shell command or tool call, before it runs. Confidence thresholds decide when to auto-approve and when to ask a human.

Stopping agents and commits from writing or sending API keys, passwords and other credentials. Known formats are caught locally and ambiguous strings get a typed check.

Flagging instructions smuggled into fetched pages, tool output or user input before an agent acts on them. Usually a yes/no probability with a block threshold.

Checking whether an agent's "done" claim is backed by evidence such as passing tests or changed files. It catches premature stops in coding agents.

Keep or drop decisions over conversation history and tool output so long agent sessions stay within the context window without losing what matters.

Deciding what an agent should store, retrieve or forget, and which memories are relevant to the current step.

Stop, retry, replan or escalate decisions inside an agent loop, including stagnation detection and handing hard steps back to a larger model.

Choosing the next browser operation and target element from page state, with a small text model writing input only when needed. Covers web agents, scraping flows and browser testing.

Picking the next control and action from accessibility trees, OCR output or screenshots to drive desktop and phone apps.

Routing pull requests by risk, judging whether a diff matches its description, and blocking merges or commits that need a human look.

Finding the functions, files or lines that answer a plain-language question by asking a yes/no per chunk and ranking by probability.

Fuzzy lint rules written in English, team-convention checks and file-level quality scores that tell a coding agent what to fix first.

Semantic assertions on LLM output, end-to-end test steps that find their element by meaning, and regression gates in CI.

Deciding which log lines, alerts or incidents to suppress, watch, review or page on, so an expensive model or a human only sees what matters.

Checking a model's answer for grounding, hallucination, policy breaks or silent failures before it reaches a user or a downstream system.

General-purpose safety layers around agents that combine several typed checks into a pass, block or escalate policy.

Language clients, wrappers and typed bindings for the decision API, from the official Python and JavaScript SDKs to community ports in many languages.

Exposing typed decisions as MCP tools or packaged agent skills so any agent harness can ask a question and branch on the answer.

Adapters that bring decision calls into existing frameworks such as LangChain, LangGraph, DSPy, the AI SDK, Spring or workflow tools.

Filtering, ranking and classifying rows with plain-language conditions inside SQL, through extensions or proxies for Postgres, SQLite and DuckDB.

Running decision models on your own hardware: servers that speak the System One wire format, native ports for Apple Silicon and CPUs, and gateways.

Open-weight models and reimplementations that give typed decisions with option probabilities, usually fine-tuned small LLMs or encoders.

Ways to get decision-model behaviour from ordinary LLMs, mostly by reading option logits in one forward pass instead of generating text.

Measuring whether a model's probabilities can be trusted and picking per-question confidence thresholds, abstention rules and fallbacks.

Replacing LLM-as-judge steps with typed rubric scores or yes/no checks inside eval harnesses and regression suites.

Head-to-head studies and leaderboards that measure accuracy, calibration, latency and cost of decision models against LLMs or each other.

Labelling agent traces and telemetry with behaviours such as loops, tool errors or injection so they can be searched and alerted on.

Cutting spend by deciding when a cheap typed call is enough and when to escalate, budgeting tokens and caching repeated decisions.

Annotating rows, images or documents with typed labels at volume and sending only uncertain cases to humans.

Classifying columns, filtering bad rows and spotting duplicates in tabular or text datasets.

Pulling entities, spans or fields out of unstructured text by asking typed questions over candidate spans or fields.

Sorting documents and pages by type, splitting packets and sending each document to the right handler.

Labelling, archiving and routing incoming email by intent, sender type or urgency.

Yes/no decisions on whether a message, email or post is spam, phishing or unwanted promotion.

Classifying support tickets by topic, priority and team so they reach the right queue quickly.

Deciding when a customer conversation should move from automation to a human agent, based on frustration, risk or unresolved intent.

Picking the user's intent from a fixed set so a bot, workflow or UI can respond appropriately.

Scoring tone, emotion, satisfaction or urgency in messages, reviews and transcripts.

Assistants that read a chat thread and decide intent, risk and reply suggestions in messaging apps.

Live voice agents deciding whether to respond, wait, yield, backchannel or escalate, and audio filters that act on speech.

Policy decisions over user-generated content such as toxicity, harassment and rule breaks, with uncertain items queued for review.

Hiding or highlighting parts of a page or feed for the reader, such as ads, sponsors, spoilers, clickbait or distracting elements.

Scoring prose for quality, style, AI slop, grammar or editorial policy, and flagging what to rewrite.

Art, music, video and image tools where a typed decision picks styles, cuts or variations.

Interfaces that pick components, layouts or controls from typed decisions as the user acts.

Reranking retrieved passages, filtering evidence and deciding when retrieval should stop before an LLM writes the answer.

Choosing sources, queries and result order for web or site search, including SEO and generative-engine visibility checks.

Judging whether products match a shopper's query or filters and ordering catalogue results by relevance.

Screening papers, articles and sources against open research questions and building evidence for deep-research agents.

Choosing which edge, link or node to follow next when walking a knowledge graph, wiki or taxonomy.

Checking rental, housing, job or product listings for claims that need verification, risky pitches or policy problems before someone acts on them.

Deciding what to show a particular user next, based on their history and stated preferences.

Branching steps in business workflows, from invoice handling to form intake, on typed decisions instead of brittle rules.

Calendar, task, meeting and focus tools where a typed decision sorts, prioritises or schedules work.

Questions about home or device state that become sensors and automation triggers.

Screening CVs and applications against an editable policy, with uncertain candidates left for a recruiter.

Scoring inbound leads and accounts for fit and intent so sales time goes to the most promising ones.

Classifying brand mentions, campaigns and content for marketing and growth teams.

Flagging suspicious transactions, orders or accounts for review and deciding how risky each one is.

Per-tick buy, sell or hold decisions, position sizing and market-judgment calls in trading bots and prediction markets.

Turning typed probabilities into short-term forecasts or event predictions, often compared against real outcomes.

Checking documents, actions or content against regulatory or internal policy and recording an auditable decision.

Classifying clauses, contracts and legal texts, and judging outcomes or obligations in legal corpora.

Sorting health-related text such as notes, questions or records for routing and review, without making a diagnosis.

Finding personal data in text, logs or tables so it can be masked or kept out of prompts.

Triaging security findings, vulnerable code, supply-chain risk and alerts by severity before a human or a larger model looks.

Deciding whether a link or download is safe to open or should be blocked or warned on.

Choosing moves, turns and strategies in games, usually one typed Choice per frame, junction or turn.

Agent decisions inside simulators for driving, flight, physics or social behaviour.

Choosing which primitive, target or manoeuvre a robot or drone should execute next while low-level control stays in code.

Screening scientific records, candidates or experimental steps, for example exoplanet candidates or chemistry tasks.

Typed decisions over images, screenshots and video frames: picking labels, checking photos against records or reading game screens.

Tutorials, cookbooks, books and example repositories that teach how to design typed questions and wire decisions into code.

Other curated lists, indexes and directories that track projects built on decision models.

Funding, launch and competitor news about decision models and the companies behind them.

Threads, posts and write-ups where practitioners describe how they use decision models, what worked and what broke.

Projects that offer typed decisions as a generic building block (yes/no, choice, score) without targeting one domain.

Sorting incoming insurance claims by type, completeness and fraud risk so adjusters see urgent or suspicious claims first.

Scoring accounts or users for churn risk from support history, usage notes and conversations so retention teams can act early.

Checking whether submitted identity or business documents are complete, consistent and match the declared applicant.

Deciding whether an ad, marketplace listing or product page complies with platform policy before it goes live.

Judging whether a machine translation or subtitle is accurate and fluent enough to publish or needs human post-editing.

Checking alt text, labels and UI copy against accessibility guidelines and flagging items that need a fix.

Filtering fake, off-topic or abusive product reviews and tagging genuine ones by aspect and sentiment.

Deciding which statements in a transcript are commitments, decisions or follow-ups that should become tasks.

Projects where a decision model sorts incoming state into a label or picks where it should go next. Typical inputs are tickets, emails, alerts, documents and model requests, so this is also where model and skill routers live.

Interfaces that change what a person sees or can do based on a live typed decision. Examples include page-element filtering, spoiler and ad hiding, and editors or canvases that react as the user types.

Gates that check something before it ships or runs: generated output, code diffs, claims of completion, or an agent action. A typed yes/no or score with a confidence threshold decides whether to pass, block or escalate.

Projects that turn rubric scores or per-item probabilities into an ordering or priority. Retrieval reranking, semantic search over code or documents, and quality grading that feeds a downstream choice belong here.

The decision step inside an agent loop: which action or UI element to pick next, whether to keep or drop context, when to stop, retry or hand back to a larger model. Browser, desktop and mobile control agents are the largest group.

Using typed decisions to annotate, filter, clean or deduplicate data at volume. These projects usually replace a slower human or LLM labeling pass and keep uncertain rows for review.

Harnesses, judges and benchmarks that use or measure decision models. This covers LLM-as-judge replacements, regression gates on model output, and head-to-head accuracy, latency and cost comparisons.

Work on the models themselves and on the quality of their probabilities. Open-weight reproductions, inference tricks that read option probabilities from ordinary LLMs, calibration and threshold studies, and papers sit here.

The plumbing around decision models: SDKs and language clients, local runtimes and servers, gateways, MCP servers, agent skills and framework adapters. These projects make a decision call easy to reach rather than solve one domain problem.

Decisions made inside games, simulators and interactive environments, usually one typed choice per move or tick. They are popular demos because latency and per-step cost are easy to see.

Decisions that end in physical action: arms, drones, fleets and edge hardware, plus simulated robots that chain fixed primitives. Control and safety usually stay in code while the model makes slower tactical choices.

Trading, investment and market-judgment loops where each tick or block gets a typed buy/sell/hold style answer. Most are demos or dry-run bots, not audited strategies.

Regulatory, contractual and policy-conformance decisions that need an audit trail. Clause classification, policy checks and legal-corpus evaluations fit here.

Policy and abuse decisions over user-generated content at volume: toxicity, spam, scams and community-rule enforcement. Decisions are typically thresholded with uncertain cases left for human review.

Public evidence about how people use decision models without a standalone project: X threads, Reddit and Hacker News posts, blog write-ups, tutorials, news and sibling curated lists.

Typed decisions that gate experimental steps, triage hypotheses or screen scientific records. yibie/awesome-jev lists this category with no entries yet; projects here were placed by keyword from other lists.