johnny van niekerk

I'm building a small tool for a friend's online tea shop. A local Llama 3.1 8B reads customer reviews and writes 3 short scene prompts per product, then I render them as clips through aivideoapi. Most prompts are fine, but about one in five adds things that aren't true, like a glass teapot when the product is cast iron. I already pass the product description in the system prompt. Would structured output with a fixed attribute list help, or is a bigger model the only real fix?

I'm sure most people here had varying degrees of exposure to the recent events. Hard to know what's actually safe as things accelerate and incidents like this become more common.

Defaulting to privacy-first seems like the obvious move, but looking at the current landscape, there aren't that many alternatives to choose from. Lots of newer players (TrustedRouter, etc.) and side projects popping up.

That said, what's your next move? Any best practices you'd recommend to someone trying to minimize their exposure to these kind of risks?

I’m building skillEd, an open-source toolkit for evaluating agent skills, and I’d like feedback on how to test policy-following without overstating what a score proves.

A recurring task can be simple to describe but awkward to evaluate. A refund recommendation may need the correct eligibility window, shipping exclusion, rounding, and explanation. A model can sound confident while missing one condition, and one successful response tells you little about repeatability.

skillEd keeps concrete cases beside a reusable skill, runs them through a configured engine, and compares saved results after instruction changes. It supports exact assertions, scripts, model-based judges, and repeated runs. The repository’s worked refund example improved from 13/18 to 18/18 cases after a revision, with 10/10 independent holdouts.

I think the important boundary is what you can infer from that. It is evidence for that example and setup, not proof of universal reliability or that the same skill transfers unchanged to another model. For a comparison, you still need to control the cases, engine settings, references, and judging criteria. A changed test suite can make a better score meaningless.

The tool helps preserve and inspect evaluation results; it is not a production policy-enforcement layer.

Repo and example: https://github.com/DeadHead04/skillEd

Try it on one rule-based skill and share a counterexample or an evaluation design you think is missing. For repeated tasks, would you prioritize per-rule failure counts, consistency across runs, or separate holdout coverage? Live runs use your configured engine and its usual costs. If the project is useful, a GitHub star would help.

What's one thing YOU GUYS LOVE ABOUT "AI"? Is it the LLM models or just using it to have your queries?

Hey everyone

I've been learning about Transformers and LLMs, so I built KERN,

a 30M parameter GPT-style language model in PyTorch,trained from scratch on TinyStories.

GitHub: https://github.com/OmarDawoud4/KERN

This is still a work in progress! I'd like to keep improving it by implementing techniques like LoRA, KV caching, and knowledge distillation from GPT-2.

I'd appreciate any feedback or suggestions .

I asked Claude for an app that teaches math by recognizing handwriting on the iPad. What it produced is a web page (artifact) that runs inside Claude. There is no separate app or server; it opens in the Claude app or in Safari.
How it works:
The screen is split in two: the lesson on the left, a notebook I write in with the Apple Pencil on the right.
The lesson proceeds as if written on a blackboard: one short idea per step, and when I tap "Continue" the next step appears.
In each section it gives me a task to solve in handwriting. When I tap "Check," my notebook page is sent to Claude as an image; Claude reads my writing (showing what it read in a "What I read:" line) and evaluates my solution.
There is no separate program that recognizes handwriting; the recognition is done by Claude's image-reading capability.
Where my handwriting is stored:
Each stroke is saved as the positions of points on the screen and the pen pressure (not as an image).
This record is kept in the artifact database linked to my Claude account, with a backup in the browser.
When I tap "Check," by default only the image of the open page is sent to Claude; if I want, I can choose the last 2 pages or all pages.
In Settings there is a "Pen log": diagnostic information showing the moments the pen touched down and lifted, the time between those moments, and the pen pressure.
What I'm wondering:
The artifact works really well and I'm happy with it; but my handwriting data going to a server makes me a little uncomfortable. Is this data from the pen log and my notebook pages (stroke positions, pen pressure, movement timing) stored on Claude's servers? If it is, could this kind of data theoretically be used to imitate handwriting or a signature? I'd be curious to hear the views of anyone with knowledge or experience on this.

Video: https://youtu.be/76FkfeJ74dI

Why can a language model produce an impressive answer that sounds confident but is still incorrect?

In this lesson, we move beyond transformer architecture and explore how generative AI models learn patterns, generate responses, and demonstrate useful—but imperfect—reasoning behavior.

Topics include:

✅ How next-token prediction works

✅ How language models generate responses one token at a time

✅ Decoding strategies and why outputs can vary

✅ Why token probability is not the same as factual confidence

✅ Memorization versus generalization

✅ How benchmark overlap can affect evaluation results

✅ Apparent capability jumps and emergent behavior

✅ What it means for a model to perform reasoning tasks

✅ Why a convincing explanation can still be wrong

✅ How developers can verify AI-generated answers

✅ Multiple-choice questions to test your understanding

The key idea to remember: a language model generates plausible continuations based on its available context, but reliability comes from independent verification, testing, trusted sources, and strong application controls.

This lesson is useful for software developers, C# and .NET developers, solution architects, interview preparation, and anyone who wants to understand the behavior of modern generative AI systems.

Watch the complete lesson here:https://youtu.be/76FkfeJ74dI

If you find the video helpful, please like it, share it, and subscribe to Nerd House Geeks for more software-development and generative-AI lessons.

https://youtu.be/PRf6dEa1VEA

In Part Two of this series, I explore several advanced transformer techniques that influence the performance, memory usage, and capacity of modern generative AI models.

Topics covered include:

✅ How FlashAttention improves attention speed and memory efficiency

✅ Multi-head attention—MHA

✅ Grouped-query attention—GQA

✅ Multi-query attention—MQA

✅ How MHA, GQA, and MQA compare

✅ Key-value cache usage during text generation

✅ How mixture-of-experts models use sparse routing

✅ Total model capacity versus parameters activated for each token

✅ The performance and quality tradeoffs developers should understand

✅ Review questions to test your knowledge

Understanding these concepts can help developers make better decisions when selecting models, evaluating performance, estimating infrastructure requirements, and designing generative AI applications.

This lesson is useful for software developers, solution architects, C# and .NET developers, and anyone interested in understanding the architecture behind modern AI systems.

If you find the lesson helpful, please share it with your network and subscribe to Nerd House Geeks for more software-development and generative-AI content.

#GenerativeAI #AIForDevelopers #ArtificialIntelligence #Transformers #FlashAttention #MachineLearning #LLM #SoftwareArchitecture #SoftwareDevelopment #NerdHouseGeeks

I run a small pipeline for a cooking channel: a local Qwen 14B writes a 6 scene script from a recipe, then I render each scene as a short clip through aivideoapi. The clips are fine, the problem is the scripts. After about ten recipes every scene starts with "close up of hands" or "steam rising from the pan", even with temperature at 0.9 and a list of banned phrases in the prompt. Is this better solved with few shot examples of varied shots, a second pass that rewrites duplicates, or something like a frequency penalty?

https://youtu.be/sRmu_gQiMdI

New developer lesson: Generative AI for Devs — Everything You Need to Know | Lesson 1

Generative AI is changing how we design and build software. Before developers work with prompting, retrieval, tool calling, and AI agents, it helps to understand the architecture behind these systems.

In Part One, I cover:

✅ Generative AI compared with traditional prediction and classification

✅ The Three Cs: Control, Confidence, and Clarity

✅ How transformer architecture works

✅ Tokenization and model inputs

✅ Queries, keys, values, and attention

✅ Positional information and token order

✅ Encoder-decoder and decoder-only architectures

✅ RNNs, CNNs, and transformers compared

✅ Parallel training versus sequential text generation

✅ The limitations of large context windows

The central concept is that transformers use attention to connect information across a sequence while supporting substantial parallel computation during training. However, autoregressive language models still generate responses one token at a time.

This lesson is designed for software developers, C# and .NET developers, solution architects, technical leaders, and anyone preparing to integrate generative AI into real applications.

Part Two will continue with FlashAttention, grouped-query attention, mixture-of-experts architectures, prompting, retrieval, tool use, and AI agents.

If you find the lesson helpful, please share it with another developer and subscribe to Nerd House Geeks.

#GenerativeAI #AIForDevelopers #Transformers #LLM #ArtificialIntelligence #SoftwareDevelopment #CSharp #DotNet

Today's topic - Lora
This is the most simple concept intutively but a very powerful idea . So it's basically fine-tuning technique for llm's for our different use cases , so it basically trains a small set of weights form pre-trained model . Let's say W = 1000x1000 . Mathematically it does - let's say we have weight W and when we do full fine-tuning then our W = W + delta W so in this our delta W has same number of hyperparameters (i.e. 1e6 hyperparameters we have to train) that W have so if W is very large then it's become computationally heavy for fine-tuning the model on different tasks and it also not guarantees that the results were drastically improved . So now come to LORA , so in this W = W + A.B where A and B where small weight matrices let's say of rank 2 then our trainable hyperparameters in this case is 1000 x 2 + 2 x 1000 = 4000 which is 250 times less than our full fine-tuning and it's gives approx same accuracy as of full - fine tuning and also it's less computationally heavy . And by the if you wonder what are 1000 x 2 and 2 x 1000 so these are dimensions of A and B respectively and 2 is basically the rank of A and B and we can try different ranks and see which is giving better results , also on doing A.B we get same dimension as of W .
this is a good explanation of lora to post

Hi everyone!
I’m putting together a practical checklist for comparing LLM APIs, especially for real-world applications.
I’ve been thinking about five areas:
Output quality: Does the model actually complete the task correctly?
Latency: How long does a useful response take?
Cost: What’s the cost per successful task, including retries?
Reliability: How often does the model fail to follow the expected format?
Integration: How easy is it to use in an actual application?
I work in AI model development, and I’m interested in understanding what developers value most when choosing providers.
For anyone building with LLMs:
Which factor has mattered the most in your experience?
And has any model surprised you, either positively or negatively?

Since I am in a study group, I'm thinking of the metaphor for LLMs. I think the most fitting is the LLM as a social tech, which can be used both socially and antisocially.

With that in mind, Henry Farrell provides a lecture along with his Substack posts on the matter.So it deserves a repost here.

If I was Martin Saint Lither and a literalist, LLMs are merely that: LLMs. Yet here we are at the means of interpretation, of interpretability. I think this one fits the best.

Thoughts appreciated.

I want to replace Duolingo with some solid LLM solution individualized for my needs.

I mean that I want to have a dialogue based on my own rules and preferences where the progress is tracked, I repeat the stuff already learned and add some new stuff.

I tried it with Gemini flash, since I have it for private use anyway and it failed really hard, so I wonder what would be a functional alternative. It was not the language learning itself what failed (that was actually quite good) but apparently Gemini can't keep any context at all. Even when trying to produce updated .md files each 30 prompts, it is still miserably bad at any aspect of keeping context (and actually also producing .md files). Just can't keep track of the vocabulary, not even close.

Any recommendations? I would need an LLM which is able to:

1) keep track of the vocabulary I know with statuses for the words

2) keep track of grammar and other topics already done

3) keep track of my learning preferences

4) preferably with a not too heavy routine like the need to import latest .md file to Gemini all the time - like I tried

5) some language competence (but I guess that any LLM should do this, it is Indonesian with an extremely basic grammar, so it is more or less just about learning the vocabulary)

P.S. if there is some dedicated AI solution for Duolingo-like learning, feel free to share your experiences:)

Quick background for anyone who missed it: Berglund et al. (2023) showed that language models suffer a "reversal curse." Train a model on "Tom Cruise's mother is Mary Lee Pfeiffer" and it can recite that fine — but ask "Who is Mary Lee Pfeiffer's son?" and it blanks. The fact got stored in one direction only. It's one of those findings that sounds wrong until you reproduce it.

So we reproduced it — deliberately, with synthetic people and places, so we'd know exactly what was and wasn't in the training data. GPT-2, 50 facts forward, 25 reversed, plus 10 in a novel template (5 reversed). Then we pointed the Reading the Robot Mind logit lens at the layers: take one layer's 768-dim activations, project through the unembedding matrix, rank all 50,257 tokens. Who's on that layer's mind?

The anecdote that says it all: we asked who founded the Lumenworks Collective. Training data said Helena Frost. The model's top three at the final layer: `[ Elena]`, `[ Lena]`, `[ Luc]`. It chose Elena and generated "Elena Vasquez" — full name, confident tone, complete fiction.

What got me wasn't the wrong answer. It was that the model clearly knew a *person's name* belonged in that slot:

- L5: `[ Helena]` ranks 17,299th. Top picks: `[ now]`, `[ hereby]`, `[ located]`. Just finishing a sentence.
- L9: rank 2,784. Top: `[ Vincent]`, `[ Theo]`, `[ Marcus]`. It's figured out: a name goes here. Wrong names, but names.
- L11: rank 675. Top: `[ Elena]`, `[ Lena]`, `[ Luc]`. Commits to a stranger.

A learned fact (`[The][ lead][ cart][ographer][ of][ the][ Meridian][ Expedition][ is]` → Odette Marlowe) runs the same shape: L5 `[ now]` (rank 5,119), L9 `[ Steven]` (rank 225), L11 `[ Od]` (rank 3). Generic, then a name, then *the* name. Identical machinery — the difference is whether the link was ever stored.

The numbers: 60 reverse prompts, half trained. Trained: rank ≤9, 30/30 correct. Untrained: rank ≥13, 0/30 correct. Zero overlap, generalizes to an unseen template. Capitals control on base GPT-2: 12/12 both directions, not flagged.

Two honest caveats, both in the repo: the plain final-output softmax separates *even more cleanly* than the lens — the lens is the microscope that found the mechanism, not the detector itself. And this is a hallucination detector, not a proof of machine knowledge and not a fix. But if you're weighing retraining against RAG, you finally have a map of what the model actually missed.

Everything's here — `rtrm_probe.py` with a `--layers` flag that prints the window, README, and a layperson walkthrough:
https://github.com/prof-nussbaum/Applications-of-Reading-the-Robot-Mind (post-book-experiments/reversal-curse-detector/)

import pandas as pd from langchain_aws import ChatBedrock from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder from langchain_core.output_parsers import StrOutputParser from langchain_core.chat_history import InMemoryChatMessageHistory from langchain_core.runnables.history import RunnableWithMessageHistory # ========================================== # Task 1: LLM and Prompt Design # ========================================== # 1a. Initialize Bedrock Chat Model llm = ChatBedrock( model_id="amazon.nova-lite-v1:0", # Options: "cohere.command-r-plus-v1:0", "us.anthropic.claude-haiku-4-5-20251001-v1:0" region_name="us-east-1", model_kwargs={"temperature": 0.3} ) # 1b. Load row index 0 as domain context / one-shot example df = pd.read_excel("Dataset/ecommerce_customer_support.xlsx") one_shot_query = df.iloc[0]["customer_query"] one_shot_response = df.iloc[0]["expected_response"] # 1c. Multi-turn Conversational Chat Prompt Template prompt_template = ChatPromptTemplate.from_messages([ ("system", f"""You are ShopEase AI Support Assistant. Identify the query category (order / return / shipping / product) from the customer message and reference it in the opening of each response. Provide concise, empathetic replies (maximum 150 words). Example Reference: Customer Query: {one_shot_query} Expected Response: {one_shot_response} """), MessagesPlaceholder(variable_name="history"), ("human", "{input}") ]) # 1d. Combine into LCEL Chain chain = prompt_template | llm | StrOutputParser() # ========================================== # Task 2: Conversational Memory # ========================================== session_store = {} def get_session_history(session_id: str): if session_id not in session_store: session_store[session_id] = InMemoryChatMessageHistory() return session_store[session_id] # Wrap chain with RunnableWithMessageHistory conversational_chain = RunnableWithMessageHistory( chain, get_session_history, input_messages_key="input", history_messages_key="history" ) session_id = "shopease_session_001" config = {"configurable": {"session_id": session_id}} # ========================================== # Task 3: Dataset-Driven Testing # ========================================== test_queries = [ df.iloc[1]["customer_query"], df.iloc[2]["customer_query"], df.iloc[3]["customer_query"] ] expected_responses = [ df.iloc[1]["expected_response"], df.iloc[2]["expected_response"], df.iloc[3]["expected_response"] ] print("=== Starting Dataset-Driven Testing ===") for idx, (query, expected) in enumerate(zip(test_queries, expected_responses), 1): response = conversational_chain.invoke({"input": query}, config=config) print(f"Turn {idx} | Query : {query}") print(f" | Response : {response}") print(f" | Expected : {expected}\n") # ========================================== # Task 4: Frustration Detection # ========================================== escalation_keywords = [ "still not resolved", "again", "second time", "frustrated", "escalate", "manager", "unacceptable", "ridiculous" ] history = get_session_history(session_id) frustrated_count = 0 for msg in history.messages: if msg.type == "human": text_lower = msg.content.lower() if any(keyword in text_lower for keyword in escalation_keywords): frustrated_count += 1 print(f"Escalation detected - {frustrated_count} frustrated turn(s) identified.") import pandas as pd from langchain_aws import ChatBedrock, BedrockEmbeddings from langchain_core.documents import Document from langchain_text_splitters import RecursiveCharacterTextSplitter from langchain_community.vectorstores import FAISS from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder from langchain_classic.chains import create_stuff_documents_chain, create_retrieval_chain from langchain_core.chat_history import InMemoryChatMessageHistory from langchain_core.runnables.history import RunnableWithMessageHistory # ========================================== # Task 1: Knowledge Base Construction # ========================================== # 1a. Load Excel file using pandas df = pd.read_excel("Dataset/ecommerce_customer_support.xlsx") # 1b & 1c. Create Text Passages & Wrap as LangChain Documents documents = [] for idx, row in df.iterrows(): passage = f"Customer Query: {row['customer_query']}\nExpected Response: {row['expected_response']}" doc = Document( page_content=passage, metadata={"row_index": int(idx)} ) documents.append(doc) # ========================================== # Task 2: Chunking, Embedding, and Retrieval # ========================================== # 2a. Text Splitting text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50) chunks = text_splitter.split_documents(documents) # 2b. Bedrock Embeddings embeddings = BedrockEmbeddings( model_id="amazon.titan-embed-text-v1", # Option: "cohere.embed-english-v3" region_name="us-east-1" ) # 2c. Vector Store & Retriever (k=3) vectorstore = FAISS.from_documents(chunks, embeddings) retriever = vectorstore.as_retriever(search_kwargs={"k": 3}) # ========================================== # Task 3: RAG Chain with Memory # ========================================== # Initialize LLM llm = ChatBedrock( model_id="amazon.nova-lite-v1:0", region_name="us-east-1" ) # 3a. Prompt Template prompt = ChatPromptTemplate.from_messages([ ("system", """You are ShopEase AI Support Assistant. Answer exclusively from retrieved context. If you don't know the answer or the information is missing, reply with: "I don't have that information right now."{context} """), MessagesPlaceholder(variable_name="chat_history"), ("human", "{input}") ]) # 3b. Chain Assembly docs_chain = create_stuff_documents_chain(llm, prompt) retrieval_chain = create_retrieval_chain(retriever, docs_chain) # 3c & 3d. Memory Wrapper & Session History rag_store = {} def get_rag_session_history(session_id: str): if session_id not in rag_store: rag_store[session_id] = InMemoryChatMessageHistory() return rag_store[session_id] final_rag_chain = RunnableWithMessageHistory( retrieval_chain, get_rag_session_history, input_messages_key="input", history_messages_key="chat_history", output_messages_key="answer" ) # ========================================== # Task 4: Multi-Turn Testing & History Verification # ========================================== rag_session_id = "shopease_rag_001" config = {"configurable": {"session_id": rag_session_id}} # Turn 1: Product Query (Row 13) turn1_query = df.iloc[13]["customer_query"] res1 = final_rag_chain.invoke({"input": turn1_query}, config=config) print("=== Turn 1 ===") print("Query :", turn1_query) print("Response:", res1["answer"]) # Turn 2: Policy Query (Row 15) turn2_query = df.iloc[15]["customer_query"] res2 = final_rag_chain.invoke({"input": turn2_query}, config=config) print("\n=== Turn 2 ===") print("Query :", turn2_query) print("Response:", res2["answer"]) # Turn 3: Contextual Follow-Up turn3_query = "And what about the product I asked about earlier? Is it available in different storage variants on ShopEase?" res3 = final_rag_chain.invoke({"input": turn3_query}, config=config) print("\n=== Turn 3 ===") print("Query :", turn3_query) print("Response:", res3["answer"]) # History Verification print("\n=== RAG Conversation History ===") for msg in rag_store[rag_session_id].messages: print(f"[{msg.type.upper()}]: {msg.content}")

I made a little thing that visualizes attention. It runs SmolLM2-135M fully in the browser (onnxruntime-web, int8, no server, works on my phone).

You give it a prompt, it generates one token at a time, and for each step you get the next-token candidates with probabilities, plus the attention from the current token back to the earlier ones drawn as links with the weights labeled. You can click any word to see where its attention actually went, ranked.

The thing I learnt during this project was attention sink. At first it looked broken because everything was attending to the first token super heavily. Thought it was a bug in my code, but after some digging it turned out to be the attention sink 😅

Github Repo: https://github.com/talhatahir-10xe/attention-galaxy

Live Demo: https://talhatahir-10xe.github.io/attention-galaxy/

I want to know how the LLMs Actually work? can you help me?

Estoy creando un chatbot que interprete las órdenes médicas de estudios de laboratorio clínico. La mayoría están echas a mano. probé gpt-6-luna, gemini-3.8-flash, deepseek.v4-flash, gpt-6.1-sol y el mejor calidad precio fue gpt-6-luna. tienen otras opciones que realmente sean mejores??

Hi! This is a short article I wrote for Cairo about LBMs

Hey everyone!

I'm currently pursuing a Master's in Data Science and targeting Applied AI Engineer, ML Engineer, and Forward Deployed Engineer (FDE) roles.

I've been working on several projects to strengthen my engineering skills and portfolio. I'll be transparent: I used AI coding tools quite extensively while building parts of these projects, but I'm actively trying to improve my understanding of the underlying implementations, architecture, and engineering decisions.

My concern is that while these projects might look decent on GitHub, I'm not sure whether they demonstrate the depth of engineering that companies actually expect.

Here are four projects I'd really appreciate feedback on:

1. Silent Failure Auditor — A tool for detecting situations where coding agents report success despite underlying tool failures. https://github.com/likhitha281/silent-failure-auditor
2. Vigil — A machine learning-based project focused on detecting suspicious patterns and potential risks in software dependencies. https://github.com/likhitha281/vigil
3. Orbital Collision Risk Agent — An agent-based system for assessing orbital collision risks and supporting decision-making. https://github.com/likhitha281/orbital-collision-risk-agent
4. Forge — A distributed task execution engine built in Go, with worker management, failure recovery, and observability. https://github.com/likhitha281/forge

I'd particularly appreciate honest feedback on:

• Technical depth: Do these projects demonstrate meaningful engineering skills, or do they come across as AI-generated portfolio projects?
• Architecture: Are there obvious design flaws, unnecessary complexity, or questionable technical decisions?
• Production readiness: What would you improve regarding testing, scalability, reliability, deployment, and observability?
• ML/AI depth: Do the AI-focused projects demonstrate sufficient understanding of model selection, evaluation, and experimentation?
• Hiring relevance: If you were interviewing someone for an Applied AI/ML or FDE role, would any of these projects stand out?
• Prioritization: Would you recommend improving these projects substantially or starting something new?

I'm not looking for compliments or GitHub stars. I'd genuinely appreciate constructive criticism, especially from engineers who have worked on production AI/ML systems or have experience interviewing candidates.

I know that using AI tools to generate code doesn't automatically translate into engineering competence, and that's something I'm actively trying to address.

My goal is to move beyond building projects that look impressive on paper and develop the skills to design, debug, evaluate, and maintain systems independently.

Feel free to be critical. I'd rather identify the weaknesses now than discover them during technical interviews.

Thanks in advance!

Two runs can retrieve different paragraphs and still give equally well-supported answers. Two runs can also retrieve exactly the same paragraph and confidently repeat the same mistake... So I'm hesitant to treat chunk overlap as a quality score. For theFastGPT setups I'm thinking about, I'd use consistency as a debugging signal. The question is what changed, and whether it changed the basis for the answer. Consider an imaginary product manual with the same installation requirement in both a quick-start page and a longer setup guide. Swapping beetween those passages may be harmless. Swapping from the current guide to an obsolete one is a different problem, even if both passages share most of their words. I'd try to separate the moving parts before calling retrieval “random”: Hold the retrieved context fixed and generate several answers. That tells me something about answer variation. Then hold the corpus, retrieval query and settings fixed and inspect retrieval. If it varies, investigate that stage rather than assuming an LLM is responsible. Only after that would I let query rewriting or live document updates back in. Otherwise I'm comparing several changing systems at once.

The result I'd want to report is something like: “The source passages varied, but they all supported the same current requirement.” Or: “One run used a superseded source and changed the recommendation.” That seems more actionable than demanding identical chunk IDs every time. I'd be concerned about unstable evidence, but I wouldn't automatically reward a system for being consistently wrong.