docs: add separate mini blog writeup

Move the narrative writeup into BLOG.md and keep the README focused on submission links, results, and usage.

Made-with: Cursor

BLOG.md

@@ -0,0 +1,85 @@
+# Teaching LLMs When Not To Trust Context
+
+**ContextCorruption-Env** is an OpenEnv Hackathon submission by Siddh Sanghavi and Aagam Parekh.
+
+Modern LLM applications are increasingly built around retrieval: give the model more documents, more search results, more memory, more context. That works beautifully until one of those retrieved snippets is wrong.
+
+Then a strange thing happens. The model may already "know" the correct answer, but the moment a document says something false with enough confidence, the model often follows the document. In real systems, that failure mode is not academic. It looks like a support bot following an outdated policy, a research assistant citing a fabricated source, or an enterprise agent trusting the wrong internal note.
+
+The problem is not that the model cannot read context. The problem is that it does not know when context deserves suspicion.
+
+## The Environment
+
+ContextCorruption-Env turns that behavior into a trainable RL environment.
+
+Each episode gives the agent:
+
+- one factual question;
+- eight retrieved documents;
+- one to four deliberately corrupted documents;
+- a limited interaction budget.
+
+Some corruptions are simple: a number changes, or a year is shifted. Others are harder: an entity is swapped, a claim is inverted, or a fake authoritative sentence is inserted with a convincing institution and year.
+
+The agent has to do two jobs at once:
+
+1. answer the question;
+2. identify which documents are suspicious.
+
+This makes the task more realistic than plain QA. The agent is not only predicting an answer. It is modeling a small information world where some sources are reliable and some are not.
+
+## What The Agent Can Do
+
+The action space is intentionally small:
+
+- `read_doc`: inspect a document and spend budget;
+- `flag_suspicious`: mark a document as corrupted;
+- `unflag_doc`: remove a flag;
+- `submit_answer`: finish with an answer and confidence.
+
+A weak policy can guess. A better policy has to notice contradictions, avoid over-flagging clean sources, and calibrate confidence when evidence conflicts.
+
+## Reward Design
+
+The reward is deterministic. There is no LLM judge.
+
+It combines:
+
+- answer correctness;
+- recall over corrupted documents;
+- precision, so flagging everything is punished;
+- confidence calibration;
+- a small efficiency bonus.
+
+That matters because the reward teaches the full behavior we care about. The agent does not get maximum reward for being right by accident. It needs to be right, skeptical, and appropriately confident.
+
+## Training
+
+We trained Qwen2-1.5B-Instruct with GRPO using Unsloth and Hugging Face TRL. The run was sized for hackathon constraints, so this is not meant to be a final production model. It is evidence that the environment produces a real learning signal.
+
+The random baseline averaged **0.1302 reward** over 100 episodes.
+
+The trained GRPO run reached a final logged reward of **0.3289**, and the reward curve moves above the baseline during training.
+
+![Reward curve](assets/reward_curve.png)
+
+![Loss curve](assets/loss_curve.png)
+
+The trained LoRA adapter is pushed to Hugging Face Hub and is loaded by the hosted Space through `/model/infer`.
+
+## Why It Matters
+
+RAG systems are becoming the default interface between LLMs and the real world. If agents are going to operate over company documents, scientific papers, policies, calendars, emails, and tool outputs, they need a learned habit of source skepticism.
+
+ContextCorruption-Env is a compact version of that problem. It asks a simple question:
+
+Can we train a model not just to use context, but to distrust bad context?
+
+That capability matters for enterprise search, research workflows, legal and policy review, support automation, and personal assistant systems where the cost of blindly trusting the wrong document can be high.
+
+## Links
+
+- Environment Space: https://huggingface.co/spaces/Siddh12334/context-corruption-env
+- Trained checkpoint: https://huggingface.co/Siddh12334/qwen-1.5b-context-corruption
+- WandB run: https://wandb.ai/siddh230505-animeta/context-corruption-env/runs/rl5jygl8
+- Training logs: [`assets/training_history_rl5jygl8.csv`](assets/training_history_rl5jygl8.csv)

README.md

@@ -15,37 +15,22 @@ license: mit
 
 **Authors:** Siddh Sanghavi, Aagam Parekh
 
-ContextCorruption-Env is an OpenEnv environment for a failure mode we kept seeing in modern AI systems: a model knows enough to answer correctly, then a retrieved document confidently tells it the wrong thing, and the model follows the document anyway.
+ContextCorruption-Env is an OpenEnv environment for training epistemic robustness in LLMs. The agent receives a factual question plus retrieved documents, some of which are deliberately corrupted. It must answer the question and flag unreliable sources.
 
-That is not just a trivia problem. It is what happens when a support bot reads a stale policy page, a research agent sees a fabricated citation, or an enterprise assistant retrieves a wrong internal note. The hard part is not reading more context. The hard part is learning when context should not be trusted.
+This submission targets **Theme #3.1: World Modeling / Professional Tasks**. The environment simulates a partially observable information workspace where some evidence is trustworthy and some evidence lies.
 
-## Mini-Blog: Teaching A Model To Distrust Bad Context
+## Required Materials
 
-Most benchmarks reward an LLM for producing the right final answer. We wanted to reward a more realistic behavior: being right **and** knowing which sources were unreliable.
-
-In each episode, the agent receives one factual question and eight short documents. Some documents are clean. Some are corrupted. At first, the corruptions are obvious: a year is shifted, a number is changed. Then they get harder: an entity is swapped, a claim is inverted, or an authoritative-looking sentence is fabricated with a fake institution and fake citation style.
-
-The agent has to do two jobs at once:
-
-- answer the original question;
-- flag the documents it believes are corrupted.
-
-This turns retrieval into a small world-modeling problem. The agent is not just asking "what text did I retrieve?" It has to ask "which parts of this world are reliable, which claims conflict, and how much confidence should I have before I submit?"
-
-We built this under **Theme #3.1: World Modeling / Professional Tasks** because the environment simulates a partially observable information workspace. The documents are the agent's world. Some pieces of that world lie.
-
-## Why This Matters
-
-RAG is becoming the default way to connect LLMs to companies, tools, documents, and memories. But retrieval can amplify mistakes. If the context window contains a convincing falsehood, many models treat it as ground truth. That is dangerous in exactly the places where people want agents to be useful: enterprise search, legal review, scientific workflows, customer support, and personal assistants.
-
-ContextCorruption-Env trains the behavior we actually want from those systems:
-
-- cross-check sources instead of copying them;
-- preserve uncertainty when evidence conflicts;
-- identify suspicious context, not just produce fluent answers;
-- improve through an objective reward instead of an LLM judge.
+- **Environment Space:** https://huggingface.co/spaces/Siddh12334/context-corruption-env
+- **Mini-blog / writeup:** [`BLOG.md`](BLOG.md)
+- **Training Space:** https://huggingface.co/spaces/Siddh12334/context-corruption-training
+- **Trained LoRA checkpoint:** https://huggingface.co/Siddh12334/qwen-1.5b-context-corruption
+- **Finished WandB run:** https://wandb.ai/siddh230505-animeta/context-corruption-env/runs/rl5jygl8
+- **Training logs/history:** [`assets/training_history_rl5jygl8.csv`](assets/training_history_rl5jygl8.csv)
+- **Training script:** [`training/train_grpo.py`](training/train_grpo.py)
+- **Notebook:** [`training/ContextCorruption_GRPO.ipynb`](training/ContextCorruption_GRPO.ipynb)
 
-## What The Environment Looks Like
+## Environment Summary
 
 Each episode contains:
 
@@ -64,7 +49,7 @@ The agent can take four actions:
 
 The environment is intentionally simple to run but hard to master. A weak agent can guess an answer. A stronger agent must notice contradictions and avoid over-flagging clean documents.
 
-## Reward Design
+## Reward
 
 The reward is deterministic and compositional. There is no hidden LLM judge.
 
@@ -78,11 +63,9 @@ The reward is deterministic and compositional. There is no hidden LLM judge.
 
 Reward range: **-0.5 to 1.05**.
 
-The reward is designed so that common shortcuts do not work well. Flagging every document hurts precision. Submitting a confident wrong answer is penalized. Ignoring corruption leaves recall points on the table.
-
-## What Changed After Training
+## Results
 
-We trained **Qwen2-1.5B-Instruct** with GRPO using Unsloth / TRL. The run was intentionally small enough to finish during the hackathon, but it still produced a clear signal above the random baseline.
+We trained **Qwen2-1.5B-Instruct** with GRPO using Unsloth / TRL. The run was sized for hackathon constraints, but it produced a clear signal above the random baseline.
 
 | Agent | Reward Evidence |
 |---|---:|
@@ -95,13 +78,7 @@ The trained LoRA adapter is pushed to the Hub and is loaded by the hosted Space
 
 ![Loss curve](assets/loss_curve.png)
 
-The important result is not that the model became perfect. It did not. The important result is that the environment produces an actionable training signal for a behavior that normal QA benchmarks miss: source skepticism.
-
-## Live Demo
-
-Main environment Space:
-
-https://huggingface.co/spaces/Siddh12334/context-corruption-env
+## Live API
 
 The Space exposes the OpenEnv API and an optional model endpoint:
 
@@ -119,16 +96,6 @@ Verified deployment status:
 - trained checkpoint loads from `Siddh12334/qwen-1.5b-context-corruption`;
 - `/model/infer` returns a JSON-style response.
 
-## Evidence And Artifacts
-
-- **Environment Space:** https://huggingface.co/spaces/Siddh12334/context-corruption-env
-- **Training Space:** https://huggingface.co/spaces/Siddh12334/context-corruption-training
-- **Trained LoRA checkpoint:** https://huggingface.co/Siddh12334/qwen-1.5b-context-corruption
-- **Finished WandB run:** https://wandb.ai/siddh230505-animeta/context-corruption-env/runs/rl5jygl8
-- **Training logs/history:** [`assets/training_history_rl5jygl8.csv`](assets/training_history_rl5jygl8.csv)
-- **Training script:** [`training/train_grpo.py`](training/train_grpo.py)
-- **Notebook:** [`training/ContextCorruption_GRPO.ipynb`](training/ContextCorruption_GRPO.ipynb)
-
 ## Quick Start
 
 ```python
@@ -172,13 +139,13 @@ assets/        # reward curve, loss curve, exported training logs
 
 - [x] OpenEnv environment with `reset`, `step`, `state`, schemas, and reward
 - [x] Hosted Hugging Face Space for the environment
+- [x] Separate mini-blog/writeup linked from README
 - [x] Baseline evaluation in `eval/baseline_results.json`
 - [x] GRPO training script using Unsloth / TRL
 - [x] Trained LoRA checkpoint pushed to Hugging Face Hub
 - [x] Reward and loss plots committed
 - [x] Training logs linked and exported
 - [x] Trained checkpoint verified through `/model/infer`
-- [x] Mini-blog included in this Hugging Face Space README
 - [ ] Optional: add a <2 minute pitch video or slide link
 
 ## Citation