# whetstone_RSA

`whetstone_RSA` is a library-first project for bounded natural-language-to-decision
systems.

The core premise is simple:

- use learned routing only at the ambiguity boundary
- keep the output space explicitly enumerable
- hand execution to deterministic software as early as possible

This project grows out of two existing lines of work:

- `WhetstoneAI_Fabricate`: routed-specialist architecture and tiny transformer experiments
- `CLionProjects/whetstone_DSL`: AST-first IDE and MCP pipeline with bounded decisions

## Problem Statement

LLMs are often being used for tasks that are not truly open-ended:

- choose one workflow from a small set
- fill a known form schema
- classify a request into a bounded enum
- pick an AST action from a valid operation set
- route a request to a deterministic tool

Those tasks do not need internet-scale latent knowledge. They need:

- a bounded decision vocabulary
- lightweight contextual inference
- validation and abstention
- deterministic downstream execution

`whetstone_RSA` exists to turn that into a reusable runtime rather than a one-off
experiment.

## Current Hypothesis

There is a measurable relationship between task entropy and the smallest model that
can fill a decision gate reliably.

The practical goal is not "make the model bigger until it works." The goal is:

- estimate gate entropy
- choose the smallest model family that clears the quality target
- escalate to a larger model only when the entropy budget requires it

This should let downstream applications keep model scope aligned with the actual
decision surface they are filling.

## Initial Scope

The first target is a reusable library that supports three modes:

- `classify`: pick one label from a fixed enum
- `fill`: populate a bounded structured schema
- `route`: choose a deterministic tool/template/action and return typed arguments

Each run should produce:

- selected action or label
- filled slots
- confidence
- abstain or escalate decision
- trace metadata suitable for evaluation

## First Case Study

The first case study is the WhetstoneDSL specialist fleet in:

- `/home/bill/Documents/CLionProjects/whetstone_DSL/specialists`

That work already established:

- ~800KB transformer specialists are viable for bounded editor decisions
- some tasks fit comfortably in that footprint
- other gates appear too entropic for the smallest tier and need larger variants

This project turns that observation into a formal sizing framework instead of
handling it ad hoc.

## Project Layout

- `docs/architecture.md`: library boundaries and runtime model
- `docs/case_studies/whetstone_dsl.md`: current grounding case study
- `docs/entropy_model_sizing.md`: baseline research plan for entropy-to-model sizing

## Near-Term Deliverables

1. Define the core decision schema and runtime API.
2. Inventory WhetstoneDSL gates by output vocabulary, ambiguity, and failure mode.
3. Build a baseline entropy score for each gate.
4. Train and compare specialist sizes against those gates.
5. Turn the result into a library other local projects can call.

## Design Rule

Learned behavior should live only where deterministic tooling is not yet enough.

Everything after a bounded decision should be deterministic unless there is a clear
reason not to do that.