How I Kept a Retiring Technician's Fixes Alive with Hindsight

Anadi Jain — Sat, 07 Nov 2026 16:25:42 +0000

Every plant has a Ramesh. In the sample plant I built my agent around, he has spent 22 years keeping the CNC machines running, and he retires in January. He knows that alarm 2041 on CNC-3, with a whistling sound at high rpm, is a misaligned motor coupling, not the ₹38,000 spindle bearing that was replaced twice for nothing. None of that is written down anywhere.

I built Ustaad (Hindi for "master") so that knowledge stays when Ramesh goes. It is an agent that remembers what experts actually did, hands it to the next person at the moment they are stuck, and learns from every result. The memory layer is Hindsight, the open-source agent memory system by Vectorize.

The hardest part was not getting the agent to remember. It was getting it to remember honestly.

What Ustaad does

A technician asks by text, voice (Hindi, Kannada or English) or a photo of the alarm screen. Ustaad recalls what the team did before on that machine, on the same model at other sites, and across the whole plant. It answers with the proven fix, who did it, when, and how often it worked. After the repair, the technician taps Worked or Didn't work, and that result becomes a new memory.

The stack is small: a Flask API, Hindsight Cloud for memory, Groq (gpt-oss-120b) to write the answer, Sarvam for Indian-language voice and translation, and a SQLite "scorebook" for exact numbers like downtime and spare-part stock. Each industry gets its own Hindsight bank (ustaad-factory, ustaad-restaurant, ustaad-healthcare, ustaad-garage, ustaad-it). Adding an industry is one JSON file, not new code.

Memory you can't trust is worse than no memory

Retain: the outcome is the most important field

My first instinct was to store "how to fix X". That is a manual, and manuals already exist. What only a team knows is what happened: who tried what, on which machine, and whether it worked. So every repair is retained as one plain-language memory with structured tags:

text = (f"{r['datetime'][:10]}, {s.get('name', '')}: {a['id']} ({a.get('name', '')}, model {a.get('model', '')}) had "
        f"'{r['problem']}'{code}. Symptom: {r.get('symptom', '')}. Cause found: {r.get('cause', '')}. "
        f"Action by {who['name']} ({who.get('role', '')}): {r.get('action', '')}. ... "
        f"Result: {OUTCOME_TEXT.get(r['outcome'], r['outcome'])}.")
tags = [f"industry:{industry}", "kind:record", f"asset:{a['id']}", f"model:{a.get('model', '')}",
        f"type:{a.get('type_key', '')}", f"site:{a.get('site', '')}", f"person:{r['person_id']}",
        f"outcome:{r['outcome']}", f"problem:{slug(r['problem'])}"]

The outcome tag is what turns storage into experience. A fix that failed is not deleted; it comes back as a warning: don't repeat this.

Recall: tags give you cross-site learning for free

When a technician asks about CNC-3, I recall with tags_match="any" over the machine, its model and its type:

res = self._run(lambda c: c.recall(bank_id=config.bank_id(industry), query=query,
                                   tags=self._tags_for(asset),   # asset:CNC-3, model:HMC-500, type:cnc, asset:ALL
                                   tags_match="any", budget="mid", max_tokens=3000))

Because the Pune plant runs the same HMC-500 model, a fix someone made there shows up in Bengaluru, labelled "found on CNC-P2 (Pune)". I did not build a sync system. The model: tag did it.

Where it broke

Then I stress-tested it, and it failed in a way I hadn't expected.

"Low pallet clamp pressure on CNC-1" came back as a way-lube fix. Recall had pulled every memory tagged asset:CNC-1, and the model stretched one to fit.
"What is the capital of France?" got a CNC maintenance tip.
The trust banner said Verified on a paracetamol-dose question in the hospital pack, because it counted every memory recall returned, not the ones the answer used.

Semantic recall is supposed to be loose; that is how it catches "seeti" (whistle) and "whistling" as the same thing. The bug was mine. I treated "recalled" as "relevant".

The fix: two searches, a re-rank, and an agent that must show its work

Now every question runs two recalls, one near the machine and one across the whole bank, because the right fix is often on a different machine. Then I re-rank the combined results by shared words and alarm codes before the model sees them:

lex = relevance(industry, problem, [r for _, r in items], asset)
best = max(lex.values()) if lex else 0
for pos, r in items:
    s = lex.get(r["key"], 0)
    if best > 0 and s == 0:
        continue  # shares no word or code with the question, while other memories do
    if f"asset:{asset['id']}" in tags:
        s *= 1.4
    elif asset.get("model") and f"model:{asset['model']}" in tags:
        s *= 1.25
    scored.append((s + 1.5 / (1 + pos), r))  # Hindsight's own order still counts

If no memory shares a single word with the question, as with a Hindi question and English memories, I keep Hindsight's order untouched rather than throw everything away.

The second half lives in the prompt. Step one for the model is to decide which memories describe the same problem, meaning the same symptom, code or part, and list them in used_memories. A memory about a different fault on the same machine is not relevant. The trust banner is computed only from that list:

refs = {str(x).strip().upper() for x in answer.get("used_memories") or []}
for c in cards:
    c["used"] = c["ref"] in refs and not off_topic
trust = _overall_trust([c for c in cards if c["used"]])

Memories that were searched but not used fold under "Also searched". If nothing matches, the agent says so plainly: new problem, nothing in your team's memory yet. Off-topic or unsafe questions get "Outside what Ustaad answers" instead of invented steps.

One more surprise: Hindsight returned results I had never retained. These were observations: patterns Hindsight consolidates by itself across many memories. My code had rendered them as empty cards with no title. Now they get their own label, "Pattern Hindsight learned", and they are capped at two per answer so they never crowd out first-hand fixes.

What it looks like now

Same model, same question, with the memory switch off and on:

	Memory off	Memory on (Hindsight)
First check	"Check spindle bearings for wear"	"Check coupling alignment with a dial gauge — under 0.02 mm"
Evidence	None	Ramesh's fix on CNC-3, and the same fix on the Pune twin
Warning	None	Bearing swap tried twice, didn't work
Spare parts	—	"Coupling spider: 0 in store, order now"

The pallet-clamp question now finds the rotary-joint o-ring fix that worked three times on a sister machine. The capital of France gets a polite refusal.

Manuals became memories too. When a new machine arrives, a senior uploads the maker's PDF manual or pastes its product page. Ustaad keeps only the pages about specs, maintenance and alarm codes, and retains each known fault as a "Maker's manual" memory. When the team's fix differs from the book, the answer says so: "Manual says check the air supply pressure; Arjun found a leaking quick coupler on the air line." Each machine also gets a QR sticker. Scanning it opens Ustaad with that machine already selected.

What I'd tell another engineer

Store outcomes, not instructions. "Tried X, didn't work" is the most valuable memory a team has, and no document captures it.
Recalled is not relevant. Re-rank, then make the model declare which memories it actually used, and compute every trust signal from that list.
Tags are a data model. asset, model, site and outcome tags gave me cross-site learning and trust levels without a second database.
Keep a scorebook next to the brain. Hindsight is great at "what fixed this before?" Exact numbers like stock counts and downtime minutes belong in a table.
Credit drives sharing. When an expert's skill passport shows how often others reused their fix, writing it down stops feeling like giving away their job.

The model was never my bottleneck. Memory was, and specifically memory I could trust.

The code is on GitHub at Anadijain1234/Plantmind, and you can try it at ustaad-3gui.onrender.com. To build your own, start with the Hindsight documentation and Vectorize's guide to what agent memory is and why agents need it.

Thanks to my teammates, to Vectorize, and to Code.in.

DEV Community: Anadi Jain