Showcase / Built with Affordance
The same app, run by a decision model: 266 of 270 support messages routed correctly, 74 ms each
A chat model answers by writing text, and an agent built on one parses that text for a tool call. A decision model works differently. It reads a list of options and gives a probability for each, in one forward pass, without writing anything.
We ran the same support-desk app on a chat model and on LiquidAI's decision model d1-3B, without changing the app. On 270 customer messages, d1 sent 266 to the right team, 98.5%, and took a median of 74 ms per message.
Decision models
A growing number of models are trained only to choose: LiquidAI's d1-3B, the Jev models on Hugging Face, Cloudflare's Clef. You give one a state and a question with a fixed list of options. It returns how likely each option is, and the most likely one is the answer.
d1 lists each option with a one-letter code and reads the model's next-token probabilities at the point where the answer would start. The answer is the most likely code. Only that one position matters, so the answer cannot be malformed, and there is nothing to parse.
The app: one tool per team
The app shows one customer message at a time. There is one tool per team that can take it, written as a function with a comment, and calling one sends the message there.
/** Orders: placing, changing, cancelling or tracking an order */
function orders({}: {}) { return send("orders"); }
/** Shipping: setting up or changing a shipping address */
function shipping({}: {}) { return send("shipping"); }
...return <ModelContext strategy="last-turn" system={QUESTION} log={log.records}>
{`Customer message ${i + 1} of ${tickets.length}:\n${tickets[Math.min(i, tickets.length - 1)]}`}
{[orders, shipping, delivery, invoices, payments, refunds, accounts, feedback, contact].map(fn => <Tool fn={fn}/>)}
</ModelContext>;The app names no model. ModelContext renders it in the format of whichever model the deployment names.
Tools become options
For a chat model, Affordance writes the nine tools as function definitions, and the model replies with a JSON tool call. For d1, the d1 template writes the screen as d1's state and the tools as d1's options, each with a code. This is the whole prompt d1 reads for one message, 160 tokens:
<|startoftext|><|im_start|>user
Customer message 1 of 1:
i want help cancelling purchase {{Order Number}}
QUESTION:
Which team should handle this customer message? Send it there by calling that team's tool.
Options:
A Orders: placing, changing, cancelling or tracking an order
B Shipping: setting up or changing a shipping address
C Delivery: delivery options, times and costs
D Invoices: finding or checking an invoice
E Payments: payment methods and problems paying
F Refunds: asking for a refund or checking on one
G Accounts: signing up, editing, switching or deleting an account
H Feedback: complaints and reviews
I Contact: the customer wants to reach customer service or a person
Reply with the option code only.<|im_end|>
<|im_start|>assistant
It is d1's own prompt format, token for token. A test checks it against the format LiquidAI publishes. When d1 answers A, Affordance calls the tool listed under A, which is orders(), and the app shows the next message.
The server works out d1's answer. We serve d1 with vLLM and allow only the option codes as the next token, so the most likely code is the one that comes back.
The result
We took 270 messages from the Bitext customer-support dataset, 30 for each of the nine teams, and split them across nine agents. Then we ran the same app with d1-3B and with Qwen3-4B-Instruct, a chat model of about the same size, both at temperature 0 and with the same question.
| d1-3B, a decision model | Qwen3-4B, a chat model | |
|---|---|---|
| Messages sent to the right team | 266 of 270 (98.5%) | 250 of 270 (92.6%) |
| Median time per message | 74 ms | 237 ms |
| Tokens the model wrote per message | 2 (the code and the end) | 16.7 |
| Tokens in each prompt | 161 | 1,042 |
The chat model's prompt is longer because each tool is written out as a JSON schema, and it writes a tool call of about 17 tokens where d1 writes one code. Qwen3-4B's most common mistake was sending a complaint to refunds, 7 times. d1 made four mistakes, two of them delivery questions sent to shipping.
Right answers by team
| Team | d1-3B | Qwen3-4B |
|---|---|---|
| accounts | 30 of 30 | 28 of 30 |
| contact | 30 of 30 | 30 of 30 |
| delivery | 28 of 30 | 28 of 30 |
| feedback | 29 of 30 | 23 of 30 |
| invoices | 30 of 30 | 30 of 30 |
| orders | 29 of 30 | 23 of 30 |
| payments | 30 of 30 | 30 of 30 |
| refunds | 30 of 30 | 30 of 30 |
| shipping | 30 of 30 | 28 of 30 |
One run of each. d1 ran on one GPU with vLLM and Qwen3-4B on two GPUs with SGLang, all RTX PRO 6000s, so compare the times as an indication. The first version of the question did not tell a chat model to call a tool, and Qwen3-4B then often answered in prose; the numbers above are both models on the question shown in the prompt.
Try it
The app is views/demo/support_desk, and its README has the d1 deployment. To run it on a chat model instead, change the model in affordance.yaml and leave the app as it is.