# Tiny Models For Bounded NLP Decisions

`whetstone_RSA`  
Fast-slide draft for a 5-10 minute programmer talk

This version is intentionally structured as many short slides with minimal text.
The goal is to support a visual talk with one idea per slide.

## Slide 1: Title

**Tiny Models For Bounded NLP Decisions**

`whetstone_RSA`

Turning messy user requests into deterministic tool calls

Visual idea:
Large title, small diagram of `user request -> contract -> tool`

Speaker notes:
This talk is about a middle layer between regex and LLMs.

## Slide 2: A Common Shape

Users type messy things.

Software needs clean actions.

Visual idea:
Messy speech bubble on left, clean typed API object on right

Speaker notes:
This shows up all over software.

## Slide 3: The Gap

We often have:

- fuzzy input
- bounded output
- deterministic execution

Visual idea:
Three stacked boxes with arrows

Speaker notes:
That middle combination is the important one.

## Slide 4: Today’s Typical Options

- regex
- rules
- LLM prompt

Visual idea:
Three boxes, with regex looking brittle and LLM looking oversized

Speaker notes:
Most teams bounce between brittle and oversized.

## Slide 5: Regex Is Cheap

Regex and rules are:

- fast
- local
- inspectable

Visual idea:
Green checkmarks next to those three traits

Speaker notes:
This is why people keep reaching for rules.

## Slide 6: Regex Is Also Annoying

Regex and rules are:

- brittle
- tedious
- bad at paraphrases

Visual idea:
Same rule box cracking under many user phrasings

Speaker notes:
The moment users say the same thing many ways, rules get ugly.

## Slide 7: LLMs Feel Great

LLMs are:

- flexible
- natural-language friendly
- good with paraphrases

Visual idea:
Many different speech bubbles converging successfully

Speaker notes:
This is why people like them.

## Slide 8: LLMs Are Often Overkill

For bounded tasks, LLMs can be:

- expensive
- heavy
- hard to control

Visual idea:
Huge engine powering a tiny gear

Speaker notes:
A lot of current usage is more model than the task actually needs.

## Slide 9: The Missing Middle

There should be a middle layer.

Visual idea:
`regex -> RSA -> LLM`

Speaker notes:
That middle layer is what RSA is for.

## Slide 10: What RSA Is

RSA is a contract layer for bounded semantic decisions.

Visual idea:
Contract sheet icon between user and tool

Speaker notes:
Not a chatbot. Not a search engine. A decision contract layer.

## Slide 11: What RSA Does

RSA takes:

- messy input
- bounded schema
- optional context

Visual idea:
Three inputs feeding one box

Speaker notes:
The schema is what keeps it narrow.

## Slide 12: What RSA Returns

RSA returns:

- action
- slots
- confidence
- abstain or escalate

Visual idea:
Typed JSON-like result

Speaker notes:
The output is structured, not freeform prose.

## Slide 13: The Core Pattern

Natural language  
-> semantic interpretation  
-> bounded contract  
-> deterministic software

Visual idea:
Simple four-step pipeline

Speaker notes:
The model interprets. The software executes.

## Slide 14: Example Query

`show me the failed builds from yesterday`

Visual idea:
One big centered query bubble

Speaker notes:
This is the kind of input users naturally want to type.

## Slide 15: Example Contract

Becomes:

- action: `search_builds`
- status: `failed`
- date: `yesterday`
- confidence: `0.93`

Visual idea:
Search query transformed into structured object

Speaker notes:
This is not generation. It is semantic interpretation into a contract.

## Slide 16: Example Execution

Then ordinary software:

- runs the query
- renders the results
- logs the action

Visual idea:
Database, search, and UI boxes after the contract

Speaker notes:
Once the contract exists, it is just normal software again.

## Slide 17: Why This Can Stay Tiny

The output is bounded.

Visual idea:
Huge input cloud mapped into a small action menu

Speaker notes:
The model does not need to generate arbitrary text.

## Slide 18: This Is Closer To Classical NLP

- intent classification
- entity extraction
- slot filling
- query interpretation

Visual idea:
Old-school NLP pipeline icons

Speaker notes:
This is often closer to smart search than to modern chatbot behavior.

## Slide 19: Search Bar Example

Make a search/help bar feel intelligent.

Stay local.

Stay bounded.

Visual idea:
Application search bar with local chip or small-device icon

Speaker notes:
This is one of the clearest examples for programmers.

## Slide 20: Search Bar Inputs

Users type:

- `where do I change export settings`
- `find the failed import from last week`
- `how do I reset my API token`

Visual idea:
Three stacked queries in a fake app UI

Speaker notes:
These are messy, but the outputs are still bounded.

## Slide 21: Search Bar Outputs

RSA decides:

- mode
- entity
- filters
- confidence

Visual idea:
Four labeled output chips

Speaker notes:
It interprets what subsystem should run and how.

## Slide 22: Search Bar Execution

Deterministic systems then:

- open settings
- run filtered search
- show help docs

Visual idea:
Three deterministic destination panels

Speaker notes:
RSA interprets the request and fills the structured call.

## Slide 23: Where Else This Fits

- command palettes
- workflow routing
- support triage
- tool selection
- template selection

Visual idea:
Grid of small app examples

Speaker notes:
Same shape, different domain.

## Slide 24: WhetstoneDSL / WHIMP

This fits:

- `whetstone_DSL`
- `WHIMP`

Visual idea:
Two case-study boxes with arrows into RSA

Speaker notes:
Those systems have many bounded decisions that are painful to express as pure rules.

## Slide 25: A Lot Of “LLM Workflows” Are Really This

- classification
- routing
- extraction
- slot filling

Visual idea:
Big prompt window collapsing into four small tasks

Speaker notes:
A lot of LLM spend is really being used as fuzzy routing over deterministic software.

## Slide 26: The Enterprise Angle

Many teams use giant prompts and context windows

for tasks that are actually bounded.

Visual idea:
Huge prompt box compared to small contract box

Speaker notes:
That is the efficiency argument.

## Slide 27: The Careful Claim

RSA does **not** replace all LLM reasoning.

RSA replaces bounded semantic decisions.

Visual idea:
Two circles: `bounded decisions` inside scope, `open-ended reasoning` outside scope

Speaker notes:
Keep the claim narrow and defensible.

## Slide 28: Large Context Caveat

RSA is best when the decision can use:

- compact context
- retrieved context
- distilled context

Visual idea:
Large document pile reduced to a few selected cards

Speaker notes:
For large-context tasks, pair RSA with retrieval or preprocessing.

## Slide 29: Another Example Near The Edge

Script generation can sometimes be:

- template selection
- slot filling
- deterministic rendering

Visual idea:
Prompt -> template -> filled script

Speaker notes:
Some “code generation” is really hidden template filling.

## Slide 30: The Main Idea

Use a tiny model only where deterministic software still needs help.

Visual idea:
Small model block at the routing boundary only

Speaker notes:
That is the whole philosophy.

## Slide 31: Closing

`whetstone_RSA` makes software semantically smarter

without turning everything into a chatbot.

Visual idea:
Final pipeline graphic, clean and minimal

Speaker notes:
That is the punchline I want people to leave with.