NyxKrage/talkie-1930-toolcalling

Talkie 1930 · tool calling by telegram

Talkie 1930 13B IT, a model whose world ends around 1930, taught to call tools the way a clerk of its day would: by wiring offices. Tools are an office directory, a call is a telegram, the result comes back as a reply telegram, and the clerk answers the customer in period prose.

<|directory|>STATION: inquire_exchange_rate
PURPOSE: Wire the bank's foreign exchange desk to convert a sum from one currency to another. STOP
amount (number, required): The sum to convert. STOP
...
<|end|><|user|>What will fifty pounds fetch in francs?<|end|><|assistant|><|telegram|>TO: inquire_exchange_rate
amount: 50 STOP
from_currency: pounds sterling STOP
to_currency: French francs STOP
<|end_telegram|><|end|><|reply|>FROM: inquire_exchange_rate
result: 6200.0 STOP
<|end|><|assistant|>Fifty pounds will fetch 6,200 French francs.<|end|>

The repo has everything needed to use it as an ordinary OpenAI-style tool-calling model:

path	what
/ (root)	the model, W8A16 (int8 weights, bf16 activations; vLLM's Marlin kernels, ~14 GB)
bf16/	the same model in bf16 (~25 GB), with its transformers modeling code (trust_remote_code)
vllm-plugin/	talkie-vllm: the Talkie model class for vLLM, the talkie_telegram tool-call parser and the chat template
pi/	a 1930s agent harness for the pi coding agent

Serving with vLLM (OpenAI tool calling)

hf download NyxKrage/talkie-1930-toolcalling --include "vllm-plugin/*" "pi/*" --local-dir talkie-extras
pip install ./talkie-extras/vllm-plugin        # into the environment vLLM runs in

vllm serve NyxKrage/talkie-1930-toolcalling --served-model-name talkie \
  --max-model-len 4096 --hf-overrides '{"max_position_embeddings": 4096}' \
  --enable-auto-tool-choice --tool-call-parser talkie_telegram \
  --chat-template "$(python -c 'import talkie_vllm; print(talkie_vllm.chat_template_path())')"

The plugin registers itself with vLLM (entry point vllm.general_plugins), so no --trust-remote-code or --tool-parser-plugin is needed. It was tested with vLLM 0.32.

• Chat template. It renders OpenAI messages and tools into the telegram format byte for byte as in training (checked on 3,854 training and evaluation conversations).
• Tool parser.
  • It types arguments by the tool's JSON schema, so "seventy-five pounds" for a number parameter arrives as 75.
  • It streams prose as content, and each telegram as one complete tool call.
  • It turns off skip_special_tokens for tool requests, because the telegram markers are special tokens.
• Context. Talkie was trained on 2,048 positions. The --hf-overrides only extends vLLM's RoPE table so longer requests don't crash it. Quality falls off past about 2k tokens, so keep system prompts and tool lists short.

from openai import OpenAI
client = OpenAI(base_url="http://127.0.0.1:8000/v1", api_key="none")
tools = [{"type": "function", "function": {
    "name": "inquire_weather_bureau", "description": "Wire the Meteorological Office for the forecast for a town.",
    "parameters": {"type": "object", "properties": {"town": {"type": "string"}, "date": {"type": "string"}},
                   "required": ["town"]}}}]
r = client.chat.completions.create(model="talkie", tools=tools, temperature=0,
                                   messages=[{"role": "user", "content": "What weather is Leeds to have tomorrow?"}])
print(r.choices[0].message.tool_calls)   # inquire_weather_bureau(town="Leeds", date="tomorrow")

A 1930s agent harness for pi

pi/talkie-1930.ts turns pi into a period office:

• The folder you run it in is the filing cabinet.
• The tools are period offices: consult_filing_cabinet, inventory_filing_cabinet, file_new_document, add_to_document, and consult_almanac for the date. None of them mentions a computer, a path or a shell.
• pi's system prompt is replaced by a two-line clerk brief.
• Documents can't leave the cabinet, and filing never replaces an existing document.

cp talkie-extras/pi/models.json ~/.pi/agent/models.json     # or merge the "talkie" provider into yours
cd some/folder && ../talkie-extras/pi/run.sh                # interactive
../talkie-extras/pi/run.sh "Add 'Post the letter to Bertie.' to the end of notes.txt."
python3 ../talkie-extras/pi/trace.py "What documents are kept in the cabinet?"   # shows the telegrams

How it was made

1. Data. Nemotron-Agentic and When2Call tool-calling conversations, rewritten into a 1928 setting by DeepSeek. Tools became period offices with code names; Talkie restyled the speech.
2. SFT. A QLoRA on Talkie 1930 13B IT, with new special tokens for the directory, telegrams and replies.
3. Short requests. Half the opening requests were shortened, and short "probe" requests were added: call, two-office, ask-for-a-missing-detail, decline and recover-from-an-error. The rewritten requests were long and spelled out, which taught the model to refuse or re-ask when a customer was brief.
4. RL. Two rounds with prime-rl (IPO loss, GRPO advantages) on conversation turns and probes. The reward checks the telegrams against the reference (stations, arguments, invented values), and the call-or-prose decision.
5. Final QLoRA polish, period data only:
   • contrastive "ask" pairs (the same request with and without a required detail);
   • numbers given in words;
   • recovery from office errors;
   • confusable records offices (read vs. list vs. enter vs. add vs. strike out);
   • 1,600 of the original conversations as anchors.

Evaluation

Greedy decoding. The probes are held out by office directory.

	this model
single-office requests telegraphed	98% (right office 98%)
false refusals	1–4%
missing detail → asks instead of guessing	67–73% (46% on the hardest contrastive pairs)
out-of-scope requests declined	100%
corrects a telegram after an office error	100% (argument score 0.92)
numbers in words → figures	40/40
confusable records offices: right office	98%
held-out rewritten conversations: call/prose decision	91%
held-out rewritten conversations: exact calls on call turns	48%

Limitations

• 1930s only. The model knows only the world of about 1930, and was deliberately trained only on it. Modern tools (files, shells, the web) bring back its old refusal reflex: "my duties are confined to…". In this release only 65% of modern-tool requests get a telegram. Dressing the tools as period offices (see pi/) works much better.
• Short context. It was trained on 2,048 tokens, so a modern agent's multi-thousand-token system prompt overwhelms it.
• Reporting. It sometimes reports only part of what an office wired back. It also rarely chains look-ups, like listing a drawer and then reading what it found.
• Asking. It sometimes asks for a detail it could reasonably assume, such as which London station.