🎯 CLM-8B: a model that scores instead of writing · CLM-8B โมเดลที่ให้คะแนน แทนการเขียน · CLM-8B：一个只打分、不写字的模型

1 Three actions, three numbers · สามการกระทำ สามตัวเลข · 三个动作，三个数字

📄 NEW FILE · clm1.py

"""clm1.py - score every action, then take the best one."""
import json
import math
import urllib.request

OLLAMA = "http://localhost:11434/api/embed"
MODEL = "nomic-embed-text"


def embed(lines):
    """Turn a list of sentences into a list of number rows."""
    payload = json.dumps({"model": MODEL, "input": lines}).encode()
    request = urllib.request.Request(
        OLLAMA, data=payload, headers={"Content-Type": "application/json"})
    with urllib.request.urlopen(request, timeout=300) as answer:
        return json.load(answer)["embeddings"]


def closeness(one, two):
    """Cosine similarity. 1.0 is the same direction, 0.0 is unrelated."""
    dot = sum(a * b for a, b in zip(one, two))
    size_one = math.sqrt(sum(a * a for a in one))
    size_two = math.sqrt(sum(b * b for b in two))
    return dot / (size_one * size_two)


STATE = "my parcel never arrived and I want my money back"

# What the agent is allowed to do. The text after the colon is the whole
# description the model gets. It is written the way a tool list is written.
ACTIONS = [
    "open_refund: start a refund for the customer",
    "track_parcel: look up where the parcel is now",
    "reset_password: send a password reset link",
]

# One call embeds the state and all three actions together.
rows = embed([STATE] + ACTIONS)
state_row = rows[0]
action_rows = rows[1:]

print("one row is", len(state_row), "numbers long")
print()
for action, row in zip(ACTIONS, action_rows):
    print(f"{closeness(state_row, row):.4f}  {action.split(':')[0]}")

scores = [closeness(state_row, row) for row in action_rows]
print()
print("picked:", ACTIONS[scores.index(max(scores))].split(":")[0])

🖥️ WHAT IT PRINTED · 27 September 2026

one row is 768 numbers long

0.5513  open_refund
0.6262  track_parcel
0.4493  reset_password

picked: track_parcel

2 Change the words, watch the gap close · เปลี่ยนคำ แล้วดูช่องว่างแคบลง · 换个说法，看差距缩小

📄 NEW FILE · clm2.py

"""clm2.py - the same actions, described in the caller s own words."""
import json
import math
import urllib.request

OLLAMA = "http://localhost:11434/api/embed"
MODEL = "nomic-embed-text"


def embed(lines):
    """Turn a list of sentences into a list of number rows."""
    payload = json.dumps({"model": MODEL, "input": lines}).encode()
    request = urllib.request.Request(
        OLLAMA, data=payload, headers={"Content-Type": "application/json"})
    with urllib.request.urlopen(request, timeout=300) as answer:
        return json.load(answer)["embeddings"]


def closeness(one, two):
    """Cosine similarity. 1.0 is the same direction, 0.0 is unrelated."""
    dot = sum(a * b for a, b in zip(one, two))
    size_one = math.sqrt(sum(a * a for a in one))
    size_two = math.sqrt(sum(b * b for b in two))
    return dot / (size_one * size_two)


STATE = "my parcel never arrived and I want my money back"

# Written as a tool list: what the function does.
TOOL_WORDS = [
    "open_refund: start a refund for the customer",
    "track_parcel: look up where the parcel is now",
    "reset_password: send a password reset link",
]

# The same three actions, written as what the customer says instead.
STATE_WORDS = [
    "open_refund: the customer wants their money back",
    "track_parcel: the customer asks where their parcel is",
    "reset_password: the customer cannot log in",
]

state_row = embed([STATE])[0]

for label, actions in (("tool words ", TOOL_WORDS),
                       ("state words", STATE_WORDS)):
    rows = embed(actions)
    scores = [closeness(state_row, row) for row in rows]
    refund, parcel = scores[0], scores[1]
    winner = actions[scores.index(max(scores))].split(":")[0]
    print(f"{label}  refund {refund:.4f}   parcel {parcel:.4f}   "
          f"gap {parcel - refund:+.4f}   picked {winner}")

🖥️ WHAT IT PRINTED

tool words   refund 0.5513   parcel 0.6262   gap +0.0749   picked track_parcel
state words  refund 0.6329   parcel 0.6372   gap +0.0043   picked track_parcel

3 A state head and an action head · หัวสถานะ และหัวการกระทำ · 一个状态头，一个动作头

4 Keep the action vectors · เก็บเวกเตอร์ของการกระทำไว้ · 把动作向量留着

📄 NEW FILE · clm3.py

"""clm3.py - embed the actions once, then keep them."""
import json
import math
import time
import urllib.request

OLLAMA = "http://localhost:11434/api/embed"
MODEL = "nomic-embed-text"


def embed(lines):
    """Turn a list of sentences into a list of number rows."""
    payload = json.dumps({"model": MODEL, "input": lines}).encode()
    request = urllib.request.Request(
        OLLAMA, data=payload, headers={"Content-Type": "application/json"})
    with urllib.request.urlopen(request, timeout=300) as answer:
        return json.load(answer)["embeddings"]


def closeness(one, two):
    """Cosine similarity. 1.0 is the same direction, 0.0 is unrelated."""
    dot = sum(a * b for a, b in zip(one, two))
    size_one = math.sqrt(sum(a * a for a in one))
    size_two = math.sqrt(sum(b * b for b in two))
    return dot / (size_one * size_two)


ACTIONS = [
    "open_refund: start a refund for the customer",
    "track_parcel: look up where the parcel is now",
    "reset_password: send a password reset link",
]

STATES = [
    "my parcel never arrived and I want my money back",
    "where is my order right now",
    "I cannot log in any more",
]

ROUNDS = 10

# The plain way. Every request embeds the state and all three actions.
start = time.time()
for turn in range(ROUNDS):
    rows = embed([STATES[turn % len(STATES)]] + ACTIONS)
    scores = [closeness(rows[0], row) for row in rows[1:]]
plain = (time.time() - start) / ROUNDS

# The CLM way. The actions never change, so embed them once and keep them.
cached = embed(ACTIONS)
start = time.time()
for turn in range(ROUNDS):
    state_row = embed([STATES[turn % len(STATES)]])[0]
    scores = [closeness(state_row, row) for row in cached]
quick = (time.time() - start) / ROUNDS

print(f"embed the lot every time : {plain * 1000:7.1f} ms a request")
print(f"actions kept, state only : {quick * 1000:7.1f} ms a request")
print(f"times faster             : {plain / quick:7.2f}")

🖥️ WHAT IT PRINTED · on a DGX Spark, three actions

embed the lot every time :    33.5 ms a request
actions kept, state only :    16.7 ms a request
times faster             :    2.01

5 Thirty actions, three hundred actions · สามสิบ และสามร้อยการกระทำ · 三十个动作，三百个动作

📄 NEW FILE · clm4.py

"""clm4.py - the more actions there are, the more the cache is worth."""
import json
import math
import time
import urllib.request

OLLAMA = "http://localhost:11434/api/embed"
MODEL = "nomic-embed-text"


def embed(lines):
    """Turn a list of sentences into a list of number rows."""
    payload = json.dumps({"model": MODEL, "input": lines}).encode()
    request = urllib.request.Request(
        OLLAMA, data=payload, headers={"Content-Type": "application/json"})
    with urllib.request.urlopen(request, timeout=300) as answer:
        return json.load(answer)["embeddings"]


def closeness(one, two):
    """Cosine similarity. 1.0 is the same direction, 0.0 is unrelated."""
    dot = sum(a * b for a, b in zip(one, two))
    size_one = math.sqrt(sum(a * a for a in one))
    size_two = math.sqrt(sum(b * b for b in two))
    return dot / (size_one * size_two)


STATE = "my parcel never arrived and I want my money back"
ROUNDS = 5

print(f"{'actions':>8}  {'no cache':>10}  {'cached':>9}  {'faster':>7}")
for count in (3, 30, 300):
    actions = [f"tool_{n}: handle support job number {n}" for n in range(count)]

    start = time.time()
    for turn in range(ROUNDS):
        rows = embed([STATE] + actions)
        scores = [closeness(rows[0], row) for row in rows[1:]]
    plain = (time.time() - start) / ROUNDS

    cached = embed(actions)
    start = time.time()
    for turn in range(ROUNDS):
        state_row = embed([STATE])[0]
        scores = [closeness(state_row, row) for row in cached]
    quick = (time.time() - start) / ROUNDS

    print(f"{count:8d}  {plain * 1000:9.1f}ms  {quick * 1000:8.1f}ms  "
          f"{plain / quick:6.2f}x")

🖥️ WHAT IT PRINTED · on a DGX Spark

 actions    no cache     cached   faster
       3       32.1ms      13.7ms    2.34x
      30      202.4ms      21.1ms    9.60x
     300     1560.8ms      29.4ms   53.02x

6 A floor under the best score · ตั้งพื้นไว้ใต้คะแนนที่ดีที่สุด · 给最高分设一条底线

📄 NEW FILE · clm5.py

"""clm5.py - a floor, because the best of three may still be wrong."""
import json
import math
import urllib.request

OLLAMA = "http://localhost:11434/api/embed"
MODEL = "nomic-embed-text"


def embed(lines):
    """Turn a list of sentences into a list of number rows."""
    payload = json.dumps({"model": MODEL, "input": lines}).encode()
    request = urllib.request.Request(
        OLLAMA, data=payload, headers={"Content-Type": "application/json"})
    with urllib.request.urlopen(request, timeout=300) as answer:
        return json.load(answer)["embeddings"]


def closeness(one, two):
    """Cosine similarity. 1.0 is the same direction, 0.0 is unrelated."""
    dot = sum(a * b for a, b in zip(one, two))
    size_one = math.sqrt(sum(a * a for a in one))
    size_two = math.sqrt(sum(b * b for b in two))
    return dot / (size_one * size_two)


ACTIONS = [
    "open_refund: start a refund for the customer",
    "track_parcel: look up where the parcel is now",
    "reset_password: send a password reset link",
]

STATES = [
    "my parcel never arrived and I want my money back",
    "what is the capital of Peru",
]

# Below this, no action is close enough to trust.
FLOOR = 0.60

cached = embed(ACTIONS)
for state in STATES:
    state_row = embed([state])[0]
    scores = [closeness(state_row, row) for row in cached]
    best = max(scores)
    name = ACTIONS[scores.index(best)].split(":")[0]
    print(f"state : {state}")
    print(f"best  : {name} at {best:.4f}")
    if best < FLOOR:
        print("        under the floor, so hand it to a person")
    print()

🖥️ WHAT IT PRINTED

state : my parcel never arrived and I want my money back
best  : track_parcel at 0.6262

state : what is the capital of Peru
best  : track_parcel at 0.4077
        under the floor, so hand it to a person

7 Where it wins, and where it loses · ชนะตรงไหน และแพ้ตรงไหน · 哪里赢，哪里输

8 Try first. The answers are folded away. · ลองเองก่อน เฉลยพับซ่อนไว้ · 先自己试。答案折起来放着。

# Add this to the end of clm1.py, in place of the single print.
# zip pairs each action with its score. sorted puts the best first,
# because reverse=True counts down instead of up.
pairs = sorted(zip(scores, ACTIONS), reverse=True)
for place, (score, action) in enumerate(pairs, start=1):
    print(f"{place}. {score:.4f}  {action.split(':')[0]}")

# The distance between first and second is how sure it is.
print(f"\nlead over second place: {pairs[0][0] - pairs[1][0]:.4f}")

1. 0.6262  track_parcel
2. 0.5513  open_refund
3. 0.4493  reset_password

lead over second place: 0.0749

# Two ways to be unsure, so two tests. Put this in place of the
# single check in clm5.py.
FLOOR = 0.60      # nothing is close enough
LEAD = 0.05       # the top two are too near each other

ranked = sorted(zip(scores, ACTIONS), reverse=True)
best, second = ranked[0][0], ranked[1][0]

if best < FLOOR:
    print("nothing fits, hand it to a person")
elif best - second < LEAD:
    print(f"too close to call: {best - second:.4f} apart, ask the customer")
else:
    print("picked:", ranked[0][1].split(":")[0])

picked: track_parcel
too close to call: 0.0043 apart, ask the customer

# A list of number rows is plain JSON, so no extra library is needed.
import os

CACHE = "actions.json"

if os.path.exists(CACHE):
    with open(CACHE) as saved:
        cached = json.load(saved)
    print("loaded", len(cached), "action rows from", CACHE)
else:
    cached = embed(ACTIONS)
    with open(CACHE, "w") as saved:
        json.dump(cached, saved)
    print("built and saved", len(cached), "action rows")

built and saved 3 action rows
loaded 3 action rows from actions.json

# Compare each action with the ones after it, so no pair is done twice.
rows = embed(ACTIONS)
pairs = []
for first in range(len(ACTIONS)):
    for second in range(first + 1, len(ACTIONS)):
        score = closeness(rows[first], rows[second])
        pairs.append((score, ACTIONS[first].split(":")[0],
                      ACTIONS[second].split(":")[0]))

for score, one, two in sorted(pairs, reverse=True):
    warning = "  <- too close" if score > 0.75 else ""
    print(f"{score:.4f}  {one} vs {two}{warning}")

0.6258  open_refund vs reset_password
0.6013  open_refund vs track_parcel
0.5414  track_parcel vs reset_password

# Time the one-off cost of building the cache.
start = time.time()
cached = embed(ACTIONS)
build = time.time() - start

# plain and quick are the two per-request times from clm3.py.
saved_each = plain - quick
requests = build / saved_each

print(f"building the cache took : {build * 1000:.1f} ms")
print(f"saved on each request   : {saved_each * 1000:.1f} ms")
print(f"pays for itself after   : {requests:.1f} requests")

building the cache took : 19.2 ms
saved on each request   : 23.0 ms
pays for itself after   : 0.8 requests