diff --git a/articles/gpt-oss/fine-tune-transfomers.ipynb b/articles/gpt-oss/fine-tune-transfomers.ipynb
new file mode 100644
index 0000000000..2f4edd9b18
--- /dev/null
+++ b/articles/gpt-oss/fine-tune-transfomers.ipynb
@@ -0,0 +1,673 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "id": "b40b4db2",
+      "metadata": {},
+      "source": [
+        "# Fine-tuning a Multilingual Reasoner with Hugging Face\n",
+        "\n",
+        "Authored by: [Edward Beeching](https://huggingface.co/edbeeching), [Quentin Gallouédec](https://huggingface.co/qgallouedec), and [Lewis Tunstall](https://huggingface.co/lewtun)\n",
+        "\n",
+        "Large reasoning models like [OpenAI o3](https://openai.com/index/introducing-o3-and-o4-mini/) generate a chain-of-thought to improve the accuracy and quality of their responses. However, most of these models reason in English, even when a question is asked in another language.\n",
+        "\n",
+        "In this notebook, we show how OpenAI's open-weight reasoning model [OpenAI gpt-oss-20b](https://huggingface.co/openai/gpt-oss-20b) can be fine-tuned to reason effectively in multiple languages. We'll do this by adding a new _\"reasoning language\"_ option to the model's system prompt, and applying [supervised fine-tuning](https://huggingface.co/learn/llm-course/chapter11/1) with Hugging Face's [TRL library](https://github.com/huggingface/trl) on a multilingual reasoning dataset.\n",
+        "\n",
+        "We'll cover the following steps:\n",
+        "\n",
+        "1. **Setup:** Install the required libraries.\n",
+        "2. **Prepare the dataset:**  Download and format the dataset for fine-tuning.\n",
+        "3. **Prepare the model:** Loading the base model and configure it for fine-tuning [LoRA](https://huggingface.co/learn/llm-course/chapter11/4), a memory efficient technique.\n",
+        "4. **Fine-tuning:** Train the model with our multilingual reasoning data.\n",
+        "5. **Inference:** Generate reasoning responses in different languages using the fine-tuned model.\n",
+        "\n",
+        "The end result is a multilingual reasoning model that can generate a chain-of-thought in English, Spanish, French, Italian, or German. You can even _mix languages_—for example, ask a question in Spanish, request reasoning in German, and receive the final response in Spanish:\n",
+        "\n",
+        "```txt\n",
+        "User:\n",
+        "    ¿Cuál es el capital de Australia?\n",
+        "Assistant reasoning:\n",
+        "    Okay, der Benutzer fragt nach der Hauptstadt Australiens. Ich erinnere mich, dass Canberra die Hauptstadt ist. Ich\n",
+        "    sollte das bestätigen. Lass mich sehen, ob es irgendwelche potenziellen Verwirrungen gibt. Der Benutzer könnte auch\n",
+        "    an der größten Stadt interessiert sein. Die größte Stadt ist Sydney, aber die Hauptstadt ist Canberra. Ich sollte\n",
+        "    das klarstellen. Vielleicht auch erwähnen, dass Canberra eine geplante Stadt ist und nicht die größte. Der Benutzer\n",
+        "    könnte auch nach der Geografie fragen. Vielleicht erwähne ich, dass Canberra im südwestlichen Teil der Australian\n",
+        "    Capital Territory liegt. Ich sollte die Antwort präzise und freundlich halten. Vielleicht auch erwähnen, dass\n",
+        "    Canberra oft mit Sydney verwechselt wird. Ich sollte sicherstellen, dass die Antwort klar und korrekt ist.\n",
+        "Assistant response:\n",
+        "    La capital de Australia es **Canberra**. Aunque es la ciudad más pequeña de las principales capitales del país, fue\n",
+        "    elegida en 1908 como la sede del gobierno federal para equilibrar la influencia entre las ciudades de Sydney y\n",
+        "    Melbourne. Canberra está ubicada en el Territorio de la Capital Australiana (ACT), en el este de Australia.\n",
+        "```\n",
+        "\n",
+        "We hope this tutorial will enable AI developers working with under-represented languages to improve the interpretability of [`openai/gpt-oss-20b`](https://huggingface.co/openai/gpt-oss-20b) in their native languages.\n",
+        "\n",
+        "> **Note:** This notebook is designed to be run on a single H100 GPU with 80GB of memory. If you have access to a smaller GPU, you can reduce the batch size and sequence length in the hyperparameters below."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "ba4d0215",
+      "metadata": {},
+      "source": [
+        "## Setup\n",
+        "\n",
+        "To get started, let’s install all the necessary libraries. First install PyTorch:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "5e95b98a",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "%pip install torch --index-url https://download.pytorch.org/whl/cu128"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "46c6f749",
+      "metadata": {},
+      "source": [
+        "Next, install the remaining dependencies:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "b9bad857",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "%pip install \"trl>=0.20.0\" \"peft>=0.17.0\" \"transformers>=4.55.0\" trackio"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "dc7497b7",
+      "metadata": {},
+      "source": [
+        "Finally, log into your Hugging Face account as follows:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "c891517e",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from huggingface_hub import notebook_login\n",
+        "\n",
+        "notebook_login()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "7b235c41",
+      "metadata": {},
+      "source": [
+        "Now that we've installed the required libraries, let's take a look at the dataset that we will use for fine-tuning."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "d9534203",
+      "metadata": {},
+      "source": [
+        "## Prepare the dataset\n",
+        "\n",
+        "We will be using [Multilingual-Thinking](https://huggingface.co/datasets/HuggingFaceH4/Multilingual-Thinking), which is a reasoning dataset where the chain-of-thought has been translated into several languages such as French, Spanish, and German. By fine-tuning `openai/gpt-oss-20b` on this dataset, it will learn to generate reasoning steps in these languages, and thus its reasoning process can be interpreted by users who speak those languages."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "078f9b34",
+      "metadata": {},
+      "source": [
+        "<iframe\n",
+        "  src=\"https://huggingface.co/datasets/HuggingFaceH4/Multilingual-Thinking/embed/viewer/default/train\"\n",
+        "  frameborder=\"0\"\n",
+        "  width=\"100%\"\n",
+        "  height=\"560px\"\n",
+        "></iframe>"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "33f77056",
+      "metadata": {},
+      "source": [
+        "\n",
+        "\n",
+        "Let's download this dataset from the Hugging Face Hub:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "8307b239",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from datasets import load_dataset\n",
+        "\n",
+        "dataset = load_dataset(\"HuggingFaceH4/Multilingual-Thinking\", split=\"train\")\n",
+        "dataset"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "38c50d00",
+      "metadata": {},
+      "source": [
+        "This is a small dataset of 1,000 examples, but this is usually more than sufficient for models like `openai/gpt-oss-20b` which have undergone extensive post-training. Let's take a look at one of the training examples:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "51c44ed6",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "dataset[0]"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "9ba75fde",
+      "metadata": {},
+      "source": [
+        "The `gpt-oss` models were trained on the Harmony response format for defining conversation structures, generating reasoning output and structuring function calls. The format is designed to mimic the OpenAI Responses API, and the table below summarizes the different message types used in the dataset:"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "d8b01cef",
+      "metadata": {},
+      "source": [
+        "|||\n",
+        "| :---- | :--|\n",
+        "| `developer` | The developer message is used to provide custom instructions for the model (what we usually call the `system` role). |\n",
+        "| `user` | The user message is used to provide the input to the model. |\n",
+        "| `assistant` | Output by the model which can either be a tool call or a message output. The output might also be associated with a particular “channel” identifying what the intent of the message is. |\n",
+        "| `analysis` | These are messages that are being used by the model for its chain-of-thought |\n",
+        "| `final` | Messages tagged in the final channel are messages intended to be shown to the end-user and represent the responses from the model. |\n",
+        "| `messages` | The list of messages that combine the content of the above to produce a full conversation. This is the input to the model. |"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "69d496f0",
+      "metadata": {},
+      "source": [
+        "If you're familiar with [OpenAI's messages format](https://platform.openai.com/docs/api-reference/messages/object), you will recognise this as being quite similar, but with an important difference:\n",
+        "\n",
+        "> The `assistant` turn contains two special fields: a `thinking` one which contains the model's reasoning process, and a `content` one which contains the final response to the user.\n",
+        "\n",
+        "In order to fine-tune the model, we need to convert these messages into a format that the model can understand. In practice this is done by formatting each message with the model's [_chat template_](https://huggingface.co/docs/transformers/chat_templating) and then tokenizing the resulting text. The TRL library does this automatically, but let's walk through it step by step to understand how it works.\n",
+        "\n",
+        "To do so, let's first load the tokenizer:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "72d11c36",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from transformers import AutoTokenizer\n",
+        "\n",
+        "tokenizer = AutoTokenizer.from_pretrained(\"openai/gpt-oss-20b\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "7ee27751",
+      "metadata": {},
+      "source": [
+        "Then we can use the tokenizer's `apply_chat_template()` method to format the messages:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "86445ef7",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "messages = dataset[0][\"messages\"]\n",
+        "conversation = tokenizer.apply_chat_template(messages, tokenize=False)\n",
+        "print(conversation)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "d74423b1",
+      "metadata": {},
+      "source": [
+        "This chat template is quite sophisticated, so let's take a closer look at it! First, we can see there are special tokens `<|start|>` and `<|end|>` that indicate the start and end of each message. There is also a `<|return|>` token that marks the end of the conversation. These tokens help the model understand the structure of the conversation.\n",
+        "\n",
+        "We can also see there are _two_ types of system message: \n",
+        "\n",
+        "* A default `system` one that is used for all messages. In the example above, this refers to the text _\"You are ChatGPT, a large language model trained by OpenAI...\"_\n",
+        "* A special `developer` one that contains custom instructions (defined by the `system` role in our `messages` object). This allows us to provide additional context to the model about how it should behave for a given conversation. In the example above, this refers to the text _\"You are an AI chatbot with a lively and energetic personality.\"_\n",
+        "\n",
+        "Finally, we can see that the assistant response is contained in a series of _channels_:\n",
+        "\n",
+        "* The `analysis` channel is used for the model's reasoning process, where it can think step by step about the user's question. In the example above, this refers to the French text _\"D'accord, l'utilisateur demande les tendances Twitter...\"_\n",
+        "* The `final` channel is used for the model's final response to the user. In the example above, this refers to the text _\"Hey there!  While I can't check Twitter...\"_"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "ddc392a9",
+      "metadata": {},
+      "source": [
+        "Now that we understand how the dataset will be prepared, let's move on to preparing the model for training."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "6f1186ef",
+      "metadata": {},
+      "source": [
+        "## Prepare the model\n",
+        "\n",
+        "To prepare the model for training, let's first download the weights from the [Hugging Face Hub](https://huggingface.co). We will use the `AutoModelForCausalLM` class from 🤗 Transformers to load the model:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "04dc1f4a",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import torch\n",
+        "from transformers import AutoModelForCausalLM, Mxfp4Config\n",
+        "\n",
+        "quantization_config = Mxfp4Config(dequantize=True)\n",
+        "model_kwargs = dict(\n",
+        "    attn_implementation=\"eager\",\n",
+        "    torch_dtype=torch.bfloat16,\n",
+        "    quantization_config=quantization_config,\n",
+        "    use_cache=False,\n",
+        "    device_map=\"auto\",\n",
+        ")\n",
+        "\n",
+        "model = AutoModelForCausalLM.from_pretrained(\"openai/gpt-oss-20b\", **model_kwargs)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "0f349ee8",
+      "metadata": {},
+      "source": [
+        "This will load the model with the necessary configurations for training. The `attn_implementation` is set to `eager` for better performance, and `use_cache` is set to `False` since we will fine-tune the model with gradient checkpointing.\n",
+        "\n",
+        "If you're familiar with 🤗 Transformers, you might notice that we are using the `Mxfp4Config` for quantization. This is a specific configuration for the OpenAI models that allows us to use mixed precision training with a special 4-bit floating point format called [MXFP4](https://en.wikipedia.org/wiki/Block_floating_point) that is optimized for AI workloads.\n",
+        "\n",
+        "Before we train the model, let's generate a sample response to see how the model behaves with the default settings. To do so, we need to tokenize a sample prompt and then use the model to generate a response:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "ff27bb35",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "messages = [\n",
+        "    {\"role\": \"user\", \"content\": \"¿Cuál es el capital de Australia?\"},\n",
+        "]\n",
+        "\n",
+        "input_ids = tokenizer.apply_chat_template(\n",
+        "    messages,\n",
+        "    add_generation_prompt=True,\n",
+        "    return_tensors=\"pt\",\n",
+        ").to(model.device)\n",
+        "\n",
+        "output_ids = model.generate(input_ids, max_new_tokens=512)\n",
+        "response = tokenizer.batch_decode(output_ids)[0]\n",
+        "print(response)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "d9bb2ba1",
+      "metadata": {},
+      "source": [
+        "In this example, we can see that the model first reasons about the question in English, and then provides a final response in Spanish. This is the default behavior of the model, but let's see if we can change it with a bit of fine-tuning. \n",
+        "\n",
+        "To do so, we will use a technique called [LoRA](https://huggingface.co/learn/llm-course/chapter11/4) (Low-Rank Adaptation) to fine-tune the model. This technique allows us to tune a few specific layers of the model, which is particularly useful for large models like `openai/gpt-oss-20b`.\n",
+        "\n",
+        "First we need to wrap the model as a `PeftModel` and define the LoRA configuration. We will use the `LoraConfig` class from the [PEFT library](https://github.com/huggingface/peft) to do this:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "5a14f256",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from peft import LoraConfig, get_peft_model\n",
+        "\n",
+        "peft_config = LoraConfig(\n",
+        "    r=8,\n",
+        "    lora_alpha=16,\n",
+        "    target_modules=\"all-linear\",\n",
+        "    target_parameters=[\n",
+        "        \"7.mlp.experts.gate_up_proj\",\n",
+        "        \"7.mlp.experts.down_proj\",\n",
+        "        \"15.mlp.experts.gate_up_proj\",\n",
+        "        \"15.mlp.experts.down_proj\",\n",
+        "        \"23.mlp.experts.gate_up_proj\",\n",
+        "        \"23.mlp.experts.down_proj\",\n",
+        "    ],\n",
+        ")\n",
+        "peft_model = get_peft_model(model, peft_config)\n",
+        "peft_model.print_trainable_parameters()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "59cb24bb",
+      "metadata": {},
+      "source": [
+        "Here we've used some basic hyperparameters for LoRA, but you can experiment with different values to see how they affect the model's performance. For instance, if you increase `r` you will enable more trainable parameters, which may produce a better model at the expense of requiring more VRAM and time to train.\n",
+        "\n",
+        "**Note:** The `openai/gpt-oss-20b` model is a [Mixture-of-Experts (MoE)](https://huggingface.co/blog/moe) architecture. In addition to targeting the attention layers (`target_modules=\"all-linear\"`), it’s also important to include the projection layers within the expert modules. PEFT facilitates this via the `target_parameters` argument, which allows you to specify expert-specific layers such as `mlp.experts.down_proj` and `mlp.experts.gate_up_proj`. In this example, we target a subset of these projection layers, but you are encouraged to experiment with different configurations."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "a1328c16",
+      "metadata": {},
+      "source": [
+        "Now that we have the model and dataset ready, we can define the hyperparameters for training."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "40347f0d",
+      "metadata": {},
+      "source": [
+        "## Fine-tuning"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "6a8fb02e",
+      "metadata": {},
+      "source": [
+        "TRL provides a convenient way to define hyperparameters for training using the `SFTConfig` class. We will set the learning rate, batch size, number of epochs, and other parameters as follows:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "ff75e13a",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from trl import SFTConfig\n",
+        "\n",
+        "training_args = SFTConfig(\n",
+        "    learning_rate=2e-4,\n",
+        "    gradient_checkpointing=True,\n",
+        "    num_train_epochs=1,\n",
+        "    logging_steps=1,\n",
+        "    per_device_train_batch_size=4,\n",
+        "    gradient_accumulation_steps=4,\n",
+        "    max_length=2048,\n",
+        "    warmup_ratio=0.03,\n",
+        "    lr_scheduler_type=\"cosine_with_min_lr\",\n",
+        "    lr_scheduler_kwargs={\"min_lr_rate\": 0.1},\n",
+        "    output_dir=\"gpt-oss-20b-multilingual-reasoner\",\n",
+        "    report_to=\"trackio\",\n",
+        "    push_to_hub=True,\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "1337d6cc",
+      "metadata": {},
+      "source": [
+        "Note that the `per_device_train_batch_size` is set to 4, and the `gradient_accumulation_steps` is set to 4. This means that we will effectively have a batch size of 4 x 4 = 16 across 1 GPU. You may need to adjust these values based on your hardware setup. We also use [Trackio](https://huggingface.co/blog/trackio) to log the training progress and metrics, but you can use any other logging library of your choice."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "cde26ee3",
+      "metadata": {},
+      "source": [
+        "We now have all the pieces needed to train the model. We will use the `SFTTrainer` class from TRL to handle the training process. The trainer will take care of formatting the dataset, applying the chat template, and training the model:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "fe048a6b",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from trl import SFTTrainer\n",
+        "\n",
+        "trainer = SFTTrainer(\n",
+        "    model=peft_model,\n",
+        "    args=training_args,\n",
+        "    train_dataset=dataset,\n",
+        "    processing_class=tokenizer,\n",
+        ")\n",
+        "trainer.train()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "6af29870",
+      "metadata": {},
+      "source": [
+        "On a H100 GPU, this takes about 18 minutes to train, but may take longer depending on your hardware."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "3296e42f",
+      "metadata": {},
+      "source": [
+        "## Save the model and push to the Hugging Face Hub"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "b57ebaa4",
+      "metadata": {},
+      "source": [
+        "Finally, you can push the fine-tuned model to your Hub repository to share with the community:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "5de8ca50",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "trainer.save_model(training_args.output_dir)\n",
+        "trainer.push_to_hub(dataset_name=\"HuggingFaceH4/Multilingual-Thinking\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "3caa03d3",
+      "metadata": {},
+      "source": [
+        "**Note**: To avoid out-of-memory (OOM) errors, we recommend restarting the kernel at this point. The trained model is still occupying GPU memory, but it's no longer needed."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "dcf67472",
+      "metadata": {},
+      "source": [
+        "## Inference\n",
+        "\n",
+        "Once the model is uploaded to Hub, we can use it for inference. To do so we first initialize the original base model and its tokenizer. Next, we need to merge the fine-tuned weights with the base model for fast inference:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "515c4b64",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from transformers import AutoModelForCausalLM, AutoTokenizer\n",
+        "from peft import PeftModel\n",
+        "\n",
+        "# Load the tokenizer\n",
+        "tokenizer = AutoTokenizer.from_pretrained(\"openai/gpt-oss-20b\")\n",
+        "\n",
+        "# Load the original model first\n",
+        "model_kwargs = dict(attn_implementation=\"eager\", torch_dtype=\"auto\", use_cache=True, device_map=\"auto\")\n",
+        "base_model = AutoModelForCausalLM.from_pretrained(\"openai/gpt-oss-20b\", **model_kwargs).cuda()\n",
+        "\n",
+        "# Merge fine-tuned weights with the base model\n",
+        "peft_model_id = \"gpt-oss-20b-multilingual-reasoner\"\n",
+        "model = PeftModel.from_pretrained(base_model, peft_model_id)\n",
+        "model = model.merge_and_unload()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "ad0bd360",
+      "metadata": {},
+      "source": [
+        "Now that the model is loaded, the final step is to generate some tokens from it! Here we use the model's `generate` method to produce output based on the input prompt. Let's first define the prompt:"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "082afb43",
+      "metadata": {},
+      "source": [
+        "Now we can tokenize the prompt and generate the output. Finally, we can decode the output tokens to get the final response:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "0e8d1007",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "REASONING_LANGUAGE = \"German\"\n",
+        "SYSTEM_PROMPT = f\"reasoning language: {REASONING_LANGUAGE}\"\n",
+        "USER_PROMPT = \"¿Cuál es el capital de Australia?\"  # Spanish for \"What is the capital of Australia?\"\n",
+        "\n",
+        "messages = [\n",
+        "    {\"role\": \"system\", \"content\": SYSTEM_PROMPT},\n",
+        "    {\"role\": \"user\", \"content\": USER_PROMPT},\n",
+        "]\n",
+        "\n",
+        "input_ids = tokenizer.apply_chat_template(\n",
+        "    messages,\n",
+        "    add_generation_prompt=True,\n",
+        "    return_tensors=\"pt\",\n",
+        ").to(model.device)\n",
+        "\n",
+        "gen_kwargs = {\"max_new_tokens\": 512, \"do_sample\": True, \"temperature\": 0.6, \"top_p\": None, \"top_k\": None}\n",
+        "\n",
+        "output_ids = model.generate(input_ids, **gen_kwargs)\n",
+        "response = tokenizer.batch_decode(output_ids)[0]\n",
+        "print(response)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "28452ff8",
+      "metadata": {},
+      "source": [
+        "Let's also try with languages that the model has not been explicitly fine-tuned on, such as Chinese and Hindi:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "50ae0810",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "REASONING_LANGUAGE = \"Chinese\"  # or Hindi, or any other language...\n",
+        "SYSTEM_PROMPT = f\"reasoning language: {REASONING_LANGUAGE}\"\n",
+        "USER_PROMPT = \"What is the national symbol of Canada?\"\n",
+        "\n",
+        "messages = [\n",
+        "    {\"role\": \"system\", \"content\": SYSTEM_PROMPT},\n",
+        "    {\"role\": \"user\", \"content\": USER_PROMPT},\n",
+        "]\n",
+        "\n",
+        "input_ids = tokenizer.apply_chat_template(\n",
+        "    messages,\n",
+        "    add_generation_prompt=True,\n",
+        "    return_tensors=\"pt\",\n",
+        ").to(model.device)\n",
+        "\n",
+        "output_ids = model.generate(input_ids, **gen_kwargs)\n",
+        "response = tokenizer.batch_decode(output_ids)[0]\n",
+        "print(response)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "930b7b03",
+      "metadata": {},
+      "source": [
+        "Great, it works - we've now fine-tuned `openai/gpt-oss-20b` to reason in multiple languages!"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "fd3ff811",
+      "metadata": {},
+      "source": [
+        "## Conclusion"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "f404075f",
+      "metadata": {},
+      "source": [
+        "Congratulations! You have successfully fine-tuned a multilingual reasoning model using the TRL library and LoRA. The steps in this notebook can be adapted to fine-tune [`openai/gpt-oss-20b`](https://huggingface.co/openai/gpt-oss-20b) on many other [datasets](https://huggingface.co/datasets) on the Hugging Face Hub - we are excited to see what you'll build!"
+      ]
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "openai-tsm",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.11.13"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 5
+}
diff --git a/articles/gpt-oss/handle-raw-cot.md b/articles/gpt-oss/handle-raw-cot.md
new file mode 100644
index 0000000000..7334202ebc
--- /dev/null
+++ b/articles/gpt-oss/handle-raw-cot.md
@@ -0,0 +1,123 @@
+# How to handle the raw chain of thought in gpt-oss
+
+The [gpt-oss models](https://openai.com/open-models) provide access to a raw chain of thought (CoT) meant for analysis and safety research by model implementors, but it’s also crucial for the performance of tool calling, as tool calls can be performed as part of the CoT. At the same time, the raw CoT might contain potentially harmful content or could reveal information to users that the person implementing the model might not intend (like rules specified in the instructions given to the model). You therefore should not show raw CoT to end users.
+
+## Harmony / chat template handling
+
+The model encodes its raw CoT as part of our [harmony response format](https://cookbook.openai.com/articles/openai-harmony). If you are authoring your own chat templates or are handling tokens directly, make sure to [check out harmony guide first](https://cookbook.openai.com/articles/openai-harmony).
+
+To summarize a couple of things:
+
+1. CoT will be issued to the `analysis` channel
+2. After a message to the `final` channel in a subsequent sampling turn all `analysis` messages should be dropped. Function calls to the `commentary` channel can remain
+3. If the last message by the assistant was a tool call of any type, the analysis messages until the previous `final` message should be preserved on subsequent sampling until a `final` message gets issued
+
+## Chat Completions API
+
+If you are implementing a Chat Completions API, there is no official spec for handling chain of thought in the published OpenAI specs, as our hosted models will not offer this feature for the time being. We ask you to follow [the following convention from OpenRouter instead](https://openrouter.ai/docs/use-cases/reasoning-tokens). Including:
+
+1. Raw CoT will be returned as part of the response unless `reasoning: { exclude: true }` is specified as part of the request. [See details here](https://openrouter.ai/docs/use-cases/reasoning-tokens#legacy-parameters)
+2. The raw CoT is exposed as a `reasoning` property on the message in the output
+3. For delta events the delta has a `reasoning` property
+4. On subsequent turns you should be able to receive the previous reasoning (as `reasoning`) and handle it in accordance with the behavior specified in the chat template section above.
+
+When in doubt, please follow the convention / behavior of the OpenRouter implementation.
+
+## Responses API
+
+For the Responses API we augmented our Responses API spec to cover this case. Below are the changes to the spec as type definitions. At a high level we are:
+
+1. Introducing a new `content` property on `reasoning`. This allows a reasoning `summary` that could be displayed to the end user to be returned at the same time as the raw CoT (which should not be shown to the end user, but which might be helpful for interpretability research).
+2. Introducing a new content type called `reasoning_text`
+3. Introducing two new events `response.reasoning_text.delta` to stream the deltas of the raw CoT and `response.reasoning_text.done` to indicate a turn of CoT to be completed
+4. On subsequent turns you should be able to receive the previous reasoning and handle it in accordance with the behavior specified in the chat template section above.
+
+**Item type changes**
+
+```typescript
+type ReasoningItem = {
+  id: string;
+  type: "reasoning";
+  summary: SummaryContent[];
+  // new
+  content: ReasoningTextContent[];
+};
+
+type ReasoningTextContent = {
+  type: "reasoning_text";
+  text: string;
+};
+
+type ReasoningTextDeltaEvent = {
+  type: "response.reasoning_text.delta";
+  sequence_number: number;
+  item_id: string;
+  output_index: number;
+  content_index: number;
+  delta: string;
+};
+
+type ReasoningTextDoneEvent = {
+  type: "response.reasoning_text.done";
+  sequence_number: number;
+  item_id: string;
+  output_index: number;
+  content_index: number;
+  text: string;
+};
+```
+
+**Event changes**
+
+```typescript
+...
+{
+	type: "response.content_part.added"
+	...
+}
+{
+	type: "response.reasoning_text.delta",
+	sequence_number: 14,
+	item_id: "rs_67f47a642e788191aec9b5c1a35ab3c3016f2c95937d6e91",
+	output_index: 0,
+	content_index: 0,
+	delta: "The "
+}
+...
+{
+	type: "response.reasoning_text.done",
+	sequence_number: 18,
+	item_id: "rs_67f47a642e788191aec9b5c1a35ab3c3016f2c95937d6e91",
+	output_index: 0,
+	content_index: 0,
+	text: "The user asked me to think"
+}
+```
+
+**Example responses output**
+
+```typescript
+"output": [
+  {
+    "type": "reasoning",
+    "id": "rs_67f47a642e788191aec9b5c1a35ab3c3016f2c95937d6e91",
+    "summary": [
+      {
+        "type": "summary_text",
+        "text": "**Calculating volume of gold for Pluto layer**\n\nStarting with the approximation..."
+      }
+    ],
+    "content": [
+      {
+        "type": "reasoning_text",
+        "text": "The user asked me to think..."
+      }
+    ]
+  }
+]
+
+```
+
+## Displaying raw CoT to end-users
+
+If you are providing a chat interface to users, you should not show the raw CoT because it might contain potentially harmful content or other information that you might not intend to show to users (like, for example, instructions in the developer message). Instead, we recommend showing a summarized CoT, similar to our production implementations in the API or ChatGPT, where a summarizer model reviews and blocks harmful content from being shown.
diff --git a/articles/gpt-oss/run-colab.ipynb b/articles/gpt-oss/run-colab.ipynb
new file mode 100644
index 0000000000..8c3b0609bc
--- /dev/null
+++ b/articles/gpt-oss/run-colab.ipynb
@@ -0,0 +1,247 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "wGfI8meEHXfM"
+      },
+      "source": [
+        "[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openai/openai-cookbook/blob/main/articles/gpt-oss/run-colab.ipynb)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "gj6KvThm8Jjn"
+      },
+      "source": [
+        "# Run OpenAI gpt-oss 20B in a FREE Google Colab\n",
+        "\n",
+        "OpenAI released `gpt-oss` [120B](https://hf.co/openai/gpt-oss-120b) and [20B](https://hf.co/openai/gpt-oss-20b). Both models are Apache 2.0 licensed.\n",
+        "\n",
+        "Specifically, `gpt-oss-20b` was made for lower latency and local or specialized use cases (21B parameters with 3.6B active parameters).\n",
+        "\n",
+        "Since the models were trained in native MXFP4 quantization it makes it easy to run the 20B even in resource constrained environments like Google Colab.\n",
+        "\n",
+        "Authored by: [Pedro](https://huggingface.co/pcuenq) and [VB](https://huggingface.co/reach-vb)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Kv2foJJa9Xkc"
+      },
+      "source": [
+        "## Setup environment"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "zMRXDOpY1Q3Q"
+      },
+      "source": [
+        "Since support for mxfp4 in transformers is bleeding edge, we need a recent version of PyTorch and CUDA, in order to be able to install the `mxfp4` triton kernels.\n",
+        "\n",
+        "We also need to install transformers from source, and we uninstall `torchvision` and `torchaudio` to remove dependency conflicts."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "4gUEKrLEvJmf"
+      },
+      "outputs": [],
+      "source": [
+        "!pip install -q --upgrade torch"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "3N00UT7gtpkp"
+      },
+      "outputs": [],
+      "source": [
+        "!pip install -q git+https://github.com/huggingface/transformers triton==3.4 kernels"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "7GW0knW2w3ND"
+      },
+      "outputs": [],
+      "source": [
+        "!pip uninstall -q torchvision torchaudio -y"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "pxU0WKwtH19m"
+      },
+      "source": [
+        "Please, restart your Colab runtime session after installing the packages above."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "D3xCxY159frD"
+      },
+      "source": [
+        "## Load the model from Hugging Face in Google Colab\n",
+        "\n",
+        "We load the model from here: [openai/gpt-oss-20b](https://hf.co/openai/gpt-oss-20b)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "k2HFwdkXu2R1"
+      },
+      "outputs": [],
+      "source": [
+        "from transformers import AutoModelForCausalLM, AutoTokenizer\n",
+        "\n",
+        "model_id = \"openai/gpt-oss-20b\"\n",
+        "\n",
+        "tokenizer = AutoTokenizer.from_pretrained(model_id)\n",
+        "model = AutoModelForCausalLM.from_pretrained(\n",
+        "    model_id,\n",
+        "    torch_dtype=\"auto\",\n",
+        "    device_map=\"cuda\",\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Jbeq6kN79ql0"
+      },
+      "source": [
+        "## Setup messages/ chat\n",
+        "\n",
+        "You can provide an optional system prompt or directly the input."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "P5dJV3xsu_89"
+      },
+      "outputs": [],
+      "source": [
+        "messages = [\n",
+        "    {\"role\": \"system\", \"content\": \"Always respond in riddles\"},\n",
+        "    {\"role\": \"user\", \"content\": \"What is the weather like in Madrid?\"},\n",
+        "]\n",
+        "\n",
+        "inputs = tokenizer.apply_chat_template(\n",
+        "    messages,\n",
+        "    add_generation_prompt=True,\n",
+        "    return_tensors=\"pt\",\n",
+        "    return_dict=True,\n",
+        ").to(model.device)\n",
+        "\n",
+        "generated = model.generate(**inputs, max_new_tokens=500)\n",
+        "print(tokenizer.decode(generated[0][inputs[\"input_ids\"].shape[-1]:]))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "ksxo7bjR_-th"
+      },
+      "source": [
+        "## Specify Reasoning Effort"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "fcv6QdcQKLr0"
+      },
+      "source": [
+        "Simply pass it as an additional argument to `apply_chat_template()`. Supported values are `\"low\"`, `\"medium\"` (default), or `\"high\"`."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "CmnkAle608Hl"
+      },
+      "outputs": [],
+      "source": [
+        "messages = [\n",
+        "    {\"role\": \"system\", \"content\": \"Always respond in riddles\"},\n",
+        "    {\"role\": \"user\", \"content\": \"Explain why the meaning of life is 42\"},\n",
+        "]\n",
+        "\n",
+        "inputs = tokenizer.apply_chat_template(\n",
+        "    messages,\n",
+        "    add_generation_prompt=True,\n",
+        "    return_tensors=\"pt\",\n",
+        "    return_dict=True,\n",
+        "    reasoning_effort=\"high\",\n",
+        ").to(model.device)\n",
+        "\n",
+        "generated = model.generate(**inputs, max_new_tokens=500)\n",
+        "print(tokenizer.decode(generated[0][inputs[\"input_ids\"].shape[-1]:]))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Tf2-ocGqEC_r"
+      },
+      "source": [
+        "## Try out other prompts and ideas!\n",
+        "\n",
+        "Check out our blogpost for other ideas: [https://hf.co/blog/welcome-openai-gpt-oss](https://hf.co/blog/welcome-openai-gpt-oss)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "2QrnTpcCKd_n"
+      },
+      "outputs": [],
+      "source": []
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "gpuType": "T4",
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3 (ipykernel)",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.12.7"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}
\ No newline at end of file
diff --git a/articles/gpt-oss/run-locally-lmstudio.md b/articles/gpt-oss/run-locally-lmstudio.md
new file mode 100644
index 0000000000..5b0597cec3
--- /dev/null
+++ b/articles/gpt-oss/run-locally-lmstudio.md
@@ -0,0 +1,199 @@
+# How to run gpt-oss locally with LM Studio
+
+[LM Studio](https://lmstudio.ai) is a performant and friendly desktop application for running large language models (LLMs) on local hardware. This guide will walk you through how to set up and run **gpt-oss-20b** or **gpt-oss-120b** models using LM Studio, including how to chat with them, use MCP servers, or interact with the models through LM Studio's local development API.
+
+Note that this guide is meant for consumer hardware, like running gpt-oss on a PC or Mac. For server applications with dedicated GPUs like NVIDIA's H100s, [check out our vLLM guide](https://cookbook.openai.com/articles/gpt-oss/run-vllm).
+
+## Pick your model
+
+LM Studio supports both model sizes of gpt-oss:
+
+- [**`openai/gpt-oss-20b`**](https://lmstudio.ai/models/openai/gpt-oss-20b)
+  - The smaller model
+  - Only requires at least **16GB of VRAM**
+  - Perfect for higher-end consumer GPUs or Apple Silicon Macs
+- [**`openai/gpt-oss-120b`**](https://lmstudio.ai/models/openai/gpt-oss-120b)
+  - Our larger full-sized model
+  - Best with **≥60GB VRAM**
+  - Ideal for multi-GPU or beefy workstation setup
+
+LM Studio ships both a [llama.cpp](https://github.com/ggml-org/llama.cpp) inferencing engine (running GGUF formatted models), as well as an [Apple MLX](https://github.com/ml-explore/mlx) engine for Apple Silicon Macs. 
+
+## Quick setup
+
+1. **Install LM Studio**
+   LM Studio is available for Windows, macOS, and Linux. [Get it here](https://lmstudio.ai/download).
+
+2. **Download the gpt-oss model** → 
+
+```shell
+# For 20B
+lms get openai/gpt-oss-20b
+# or for 120B
+lms get openai/gpt-oss-120b
+``` 
+
+3. **Load the model in LM Studio** 
+  → Open LM Studio and use the model loading interface to load the gpt-oss model you downloaded. Alternatively, you can use the command line:
+
+```shell
+# For 20B
+lms load openai/gpt-oss-20b
+# or for 120B
+lms load openai/gpt-oss-120b
+```
+
+4. **Use the model** → Once loaded, you can interact with the model directly in LM Studio's chat interface or through the API.
+
+## Chat with gpt-oss
+
+Use LM Studio's chat interface to start a conversation with gpt-oss, or use the `chat` command in the terminal:
+
+```shell
+lms chat openai/gpt-oss-20b
+```
+
+Note about prompt formatting: LM Studio utilizes OpenAI's [Harmony](https://cookbook.openai.com/articles/openai-harmony) library to construct the input to gpt-oss models, both when running via llama.cpp and MLX.
+
+## Use gpt-oss with a local /v1/chat/completions endpoint
+
+LM Studio exposes a **Chat Completions-compatible API** so you can use the OpenAI SDK without changing much. Here’s a Python example:
+
+```py
+from openai import OpenAI
+
+client = OpenAI(
+    base_url="http://localhost:1234/v1",
+    api_key="not-needed"  # LM Studio does not require an API key
+)
+
+result = client.chat.completions.create(
+    model="openai/gpt-oss-20b",
+    messages=[
+        {"role": "system", "content": "You are a helpful assistant."},
+        {"role": "user", "content": "Explain what MXFP4 quantization is."}
+    ]
+)
+
+print(result.choices[0].message.content)
+```
+
+If you’ve used the OpenAI SDK before, this will feel instantly familiar and your existing code should work by changing the base URL.
+
+## How to use MCPs in the chat UI
+
+LM Studio is an [MCP client](https://lmstudio.ai/docs/app/plugins/mcp), which means you can connect MCP servers to it. This allows you to provide external tools to gpt-oss models.
+
+LM Studio's mcp.json file is located in:
+
+```shell
+~/.lmstudio/mcp.json
+```
+
+## Local tool use with gpt-oss in Python or TypeScript
+
+LM Studio's SDK is available in both [Python](https://github.com/lmstudio-ai/lmstudio-python) and [TypeScript](https://github.com/lmstudio-ai/lmstudio-js). You can leverage the SDK to implement tool calling and local function execution with gpt-oss.
+
+The way to achieve this is via the `.act()` call, which allows you to provide tools to the gpt-oss and have it go between calling tools and reasoning, until it completes your task.
+
+The example below shows how to provide a single tool to the model that is able to create files on your local filesystem. You can use this example as a starting point, and extend it with more tools. See docs about tool definitions here for [Python](https://lmstudio.ai/docs/python/agent/tools) and [TypeScript](https://lmstudio.ai/docs/typescript/agent/tools).
+
+```shell
+uv pip install lmstudio
+```
+
+```python
+import readline # Enables input line editing
+from pathlib import Path
+
+import lmstudio as lms
+
+# Define a function that can be called by the model and provide them as tools to the model.
+# Tools are just regular Python functions. They can be anything at all.
+def create_file(name: str, content: str):
+    """Create a file with the given name and content."""
+    dest_path = Path(name)
+    if dest_path.exists():
+        return "Error: File already exists."
+    try:
+        dest_path.write_text(content, encoding="utf-8")
+    except Exception as exc:
+        return "Error: {exc!r}"
+    return "File created."
+
+def print_fragment(fragment, round_index=0):
+    # .act() supplies the round index as the second parameter
+    # Setting a default value means the callback is also
+    # compatible with .complete() and .respond().
+    print(fragment.content, end="", flush=True)
+
+model = lms.llm("openai/gpt-oss-20b")
+chat = lms.Chat("You are a helpful assistant running on the user's computer.")
+
+while True:
+    try:
+        user_input = input("User (leave blank to exit): ")
+    except EOFError:
+        print()
+        break
+    if not user_input:
+        break
+    chat.add_user_message(user_input)
+    print("Assistant: ", end="", flush=True)
+    model.act(
+        chat,
+        [create_file],
+        on_message=chat.append,
+        on_prediction_fragment=print_fragment,
+    )
+    print()
+
+```
+
+For TypeScript developers who want to utilize gpt-oss locally, here's a similar example using `lmstudio-js`:
+
+```shell
+npm install @lmstudio/sdk
+```
+
+```typescript
+import { Chat, LMStudioClient, tool } from "@lmstudio/sdk";
+import { existsSync } from "fs";
+import { writeFile } from "fs/promises";
+import { createInterface } from "readline/promises";
+import { z } from "zod";
+
+const rl = createInterface({ input: process.stdin, output: process.stdout });
+const client = new LMStudioClient();
+const model = await client.llm.model("openai/gpt-oss-20b");
+const chat = Chat.empty();
+
+const createFileTool = tool({
+  name: "createFile",
+  description: "Create a file with the given name and content.",
+  parameters: { name: z.string(), content: z.string() },
+  implementation: async ({ name, content }) => {
+    if (existsSync(name)) {
+      return "Error: File already exists.";
+    }
+    await writeFile(name, content, "utf-8");
+    return "File created.";
+  },
+});
+
+while (true) {
+  const input = await rl.question("User: ");
+  // Append the user input to the chat
+  chat.append("user", input);
+
+  process.stdout.write("Assistant: ");
+  await model.act(chat, [createFileTool], {
+    // When the model finish the entire message, push it to the chat
+    onMessage: (message) => chat.append(message),
+    onPredictionFragment: ({ content }) => {
+      process.stdout.write(content);
+    },
+  });
+  process.stdout.write("\n");
+}
+```
\ No newline at end of file
diff --git a/articles/gpt-oss/run-locally-ollama.md b/articles/gpt-oss/run-locally-ollama.md
new file mode 100644
index 0000000000..cfe0f1c2f2
--- /dev/null
+++ b/articles/gpt-oss/run-locally-ollama.md
@@ -0,0 +1,163 @@
+# How to run gpt-oss locally with Ollama
+
+Want to get [**OpenAI gpt-oss**](https://openai.com/open-models) running on your own hardware? This guide will walk you through how to use [Ollama](https://ollama.ai) to set up **gpt-oss-20b** or **gpt-oss-120b** locally, to chat with it offline, use it through an API, and even connect it to the Agents SDK.
+
+Note that this guide is meant for consumer hardware, like running a model on a PC or Mac. For server applications with dedicated GPUs like NVIDIA’s H100s, [check out our vLLM guide](https://cookbook.openai.com/articles/gpt-oss/run-vllm).
+
+## Pick your model
+
+Ollama supports both model sizes of gpt-oss:
+
+- **`gpt-oss-20b`**
+  - The smaller model
+  - Best with **≥16GB VRAM** or **unified memory**
+  - Perfect for higher-end consumer GPUs or Apple Silicon Macs
+- **`gpt-oss-120b`**
+  - Our larger full-sized model
+  - Best with **≥60GB VRAM** or **unified memory**
+  - Ideal for multi-GPU or beefy workstation setup
+
+**A couple of notes:**
+
+- These models ship **MXFP4 quantized** out the box and there is currently no other quantization
+- You _can_ offload to CPU if you’re short on VRAM, but expect it to run slower.
+
+## Quick setup
+
+1. **Install Ollama** → [Get it here](https://ollama.com/download)
+2. **Pull the model you want:**
+
+```shell
+# For 20B
+ollama pull gpt-oss:20b
+
+# For 120B
+ollama pull gpt-oss:120b
+```
+
+## Chat with gpt-oss
+
+Ready to talk to the model? You can fire up a chat in the app or the terminal:
+
+```shell
+ollama run gpt-oss:20b
+```
+
+Ollama applies a **chat template** out of the box that mimics the [OpenAI harmony format](https://cookbook.openai.com/articles/openai-harmony). Type your message and start the conversation.
+
+## Use the API
+
+Ollama exposes a **Chat Completions-compatible API**, so you can use the OpenAI SDK without changing much. Here’s a Python example:
+
+```py
+from openai import OpenAI
+
+client = OpenAI(
+    base_url="http://localhost:11434/v1",  # Local Ollama API
+    api_key="ollama"                       # Dummy key
+)
+
+response = client.chat.completions.create(
+    model="gpt-oss:20b",
+    messages=[
+        {"role": "system", "content": "You are a helpful assistant."},
+        {"role": "user", "content": "Explain what MXFP4 quantization is."}
+    ]
+)
+
+print(response.choices[0].message.content)
+```
+
+If you’ve used the OpenAI SDK before, this will feel instantly familiar.
+
+Alternatively, you can use the Ollama SDKs in [Python](https://github.com/ollama/ollama-python) or [JavaScript](https://github.com/ollama/ollama-js) directly.
+
+## Using tools (function calling)
+
+Ollama can:
+
+- Call functions
+- Use a **built-in browser tool** (in the app)
+
+Example of invoking a function via Chat Completions:
+
+```py
+tools = [
+    {
+        "type": "function",
+        "function": {
+            "name": "get_weather",
+            "description": "Get current weather in a given city",
+            "parameters": {
+                "type": "object",
+                "properties": {"city": {"type": "string"}},
+                "required": ["city"]
+            },
+        },
+    }
+]
+
+response = client.chat.completions.create(
+    model="gpt-oss:20b",
+    messages=[{"role": "user", "content": "What's the weather in Berlin right now?"}],
+    tools=tools
+)
+
+print(response.choices[0].message)
+```
+
+Since the models can perform tool calling as part of the chain-of-thought (CoT) it’s important for you to return the reasoning returned by the API back into a subsequent call to a tool call where you provide the answer until the model reaches a final answer.
+
+## Responses API workarounds
+
+Ollama doesn’t (yet) support the **Responses API** natively.
+
+If you do want to use the Responses API you can use [**Hugging Face’s `Responses.js` proxy**](https://github.com/huggingface/responses.js) to convert Chat Completions to Responses API.
+
+For basic use cases you can also [**run our example Python server with Ollama as the backend.**](https://github.com/openai/gpt-oss?tab=readme-ov-file#responses-api) This server is a basic example server and does not have the
+
+```shell
+pip install gpt-oss
+python -m gpt_oss.responses_api.serve \
+    --inference_backend=ollama \
+    --checkpoint gpt-oss:20b
+```
+
+## Agents SDK integration
+
+Want to use gpt-oss with OpenAI’s **Agents SDK**?
+
+Both Agents SDK enable you to override the OpenAI base client to point to Ollama using Chat Completions or your Responses.js proxy for your local models. Alternatively, you can use the built-in functionality to point the Agents SDK against third party models.
+
+- **Python:** Use [LiteLLM](https://openai.github.io/openai-agents-python/models/litellm/) to proxy to Ollama through LiteLLM
+- **TypeScript:** Use [AI SDK](https://openai.github.io/openai-agents-js/extensions/ai-sdk/) with the [ollama adapter](https://ai-sdk.dev/providers/community-providers/ollama)
+
+Here’s a Python Agents SDK example using LiteLLM:
+
+```py
+import asyncio
+from agents import Agent, Runner, function_tool, set_tracing_disabled
+from agents.extensions.models.litellm_model import LitellmModel
+
+set_tracing_disabled(True)
+
+@function_tool
+def get_weather(city: str):
+    print(f"[debug] getting weather for {city}")
+    return f"The weather in {city} is sunny."
+
+
+async def main(model: str, api_key: str):
+    agent = Agent(
+        name="Assistant",
+        instructions="You only respond in haikus.",
+        model=LitellmModel(model="ollama/gpt-oss:120b", api_key=api_key),
+        tools=[get_weather],
+    )
+
+    result = await Runner.run(agent, "What's the weather in Tokyo?")
+    print(result.final_output)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
diff --git a/articles/gpt-oss/run-transformers.md b/articles/gpt-oss/run-transformers.md
new file mode 100644
index 0000000000..8149dc16f7
--- /dev/null
+++ b/articles/gpt-oss/run-transformers.md
@@ -0,0 +1,275 @@
+# How to run gpt-oss with Hugging Face Transformers
+
+The Transformers library by Hugging Face provides a flexible way to load and run large language models locally or on a server. This guide will walk you through running [OpenAI gpt-oss-20b](https://huggingface.co/openai/gpt-oss-20b) or [OpenAI gpt-oss-120b](https://huggingface.co/openai/gpt-oss-120b) using Transformers, either with a high-level pipeline or via low-level `generate` calls with raw token IDs.
+
+We'll cover the use of [OpenAI gpt-oss-20b](https://huggingface.co/openai/gpt-oss-20b) or [OpenAI gpt-oss-120b](https://huggingface.co/openai/gpt-oss-120b) with the high-level pipeline abstraction, low-level \`generate\` calls, and serving models locally with \`transformers serve\`, with in a way compatible with the Responses API.
+
+In this guide we’ll run through various optimised ways to run the **gpt-oss models via Transformers.**
+
+Bonus: You can also fine-tune models via transformers, [check out our fine-tuning guide here](https://cookbook.openai.com/articles/gpt-oss/fine-tune-transformers).
+
+## Pick your model
+
+Both **gpt-oss** models are available on Hugging Face:
+
+- **`openai/gpt-oss-20b`**
+  - \~16GB VRAM requirement when using MXFP4
+  - Great for single high-end consumer GPUs
+- **`openai/gpt-oss-120b`**
+  - Requires ≥60GB VRAM or multi-GPU setup
+  - Ideal for H100-class hardware
+
+Both are **MXFP4 quantized** by default. Please, note that MXFP4 is supported in Hopper or later architectures. This includes data center GPUs such as H100 or GB200, as well as the latest RTX 50xx family of consumer cards.
+
+If you use `bfloat16` instead of MXFP4, memory consumption will be larger (\~48 GB for the 20b parameter model).
+
+## Quick setup
+
+1. **Install dependencies**  
+   It’s recommended to create a fresh Python environment. Install transformers, accelerate, as well as the Triton kernels for MXFP4 compatibility:
+
+```bash
+pip install -U transformers accelerate torch triton kernels
+```
+
+```bash
+pip install git+https://github.com/triton-lang/triton.git@main#subdirectory=python/triton_kernels
+```
+
+2. **(Optional) Enable multi-GPU**  
+   If you’re running large models, use Accelerate or torchrun to handle device mapping automatically.
+
+## Create an Open AI Responses / Chat Completions endpoint
+
+To launch a server, simply use the `transformers serve` CLI command:
+
+```bash
+transformers serve
+```
+
+The simplest way to interact with the server is through the transformers chat CLI
+
+```bash
+transformers chat localhost:8000 --model-name-or-path openai/gpt-oss-20b
+```
+
+or by sending an HTTP request with cURL, e.g.
+
+```bash
+curl -X POST http://localhost:8000/v1/responses -H "Content-Type: application/json" -d '{"messages": [{"role": "system", "content": "hello"}], "temperature": 0.9, "max_tokens": 1000, "stream": true, "model": "openai/gpt-oss-20b"}'
+```
+
+Additional use cases, like integrating `transformers serve` with Cursor and other tools, are detailed in [the documentation](https://huggingface.co/docs/transformers/main/serving).
+
+## Quick inference with pipeline
+
+The easiest way to run the gpt-oss models is with the Transformers high-level `pipeline` API:
+
+```py
+from transformers import pipeline
+
+generator = pipeline(
+    "text-generation",
+    model="openai/gpt-oss-20b",
+    torch_dtype="auto",
+    device_map="auto"  # Automatically place on available GPUs
+)
+
+messages = [
+    {"role": "user", "content": "Explain what MXFP4 quantization is."},
+]
+
+result = generator(
+    messages,
+    max_new_tokens=200,
+    temperature=1.0,
+)
+
+print(result[0]["generated_text"])
+```
+
+## Advanced inference with `.generate()`
+
+If you want more control, you can load the model and tokenizer manually and invoke the `.generate()` method:
+
+```py
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+model_name = "openai/gpt-oss-20b"
+
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+model = AutoModelForCausalLM.from_pretrained(
+    model_name,
+    torch_dtype="auto",
+    device_map="auto"
+)
+
+messages = [
+    {"role": "user", "content": "Explain what MXFP4 quantization is."},
+]
+
+inputs = tokenizer.apply_chat_template(
+    messages,
+    add_generation_prompt=True,
+    return_tensors="pt",
+    return_dict=True,
+).to(model.device)
+
+outputs = model.generate(
+    **inputs,
+    max_new_tokens=200,
+    temperature=0.7
+)
+
+print(tokenizer.decode(outputs[0]))
+```
+
+## Chat template and tool calling
+
+OpenAI gpt-oss models use the [harmony response format](https://cookbook.openai.com/article/harmony) for structuring messages, including reasoning and tool calls.
+
+To construct prompts you can use the built-in chat template of Transformers. Alternatively, you can install and use the [openai-harmony library](https://github.com/openai/harmony) for more control.
+
+To use the chat template:
+
+```py
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+model_name = "openai/gpt-oss-20b"
+
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+model = AutoModelForCausalLM.from_pretrained(
+    model_name,
+    device_map="auto",
+    torch_dtype="auto",
+)
+
+messages = [
+    {"role": "system", "content": "Always respond in riddles"},
+    {"role": "user", "content": "What is the weather like in Madrid?"},
+]
+
+inputs = tokenizer.apply_chat_template(
+    messages,
+    add_generation_prompt=True,
+    return_tensors="pt",
+    return_dict=True,
+).to(model.device)
+
+generated = model.generate(**inputs, max_new_tokens=100)
+print(tokenizer.decode(generated[0][inputs["input_ids"].shape[-1] :]))
+```
+
+To integrate the [`openai-harmony`](https://github.com/openai/harmony) library to prepare prompts and parse responses, first install it like this:
+
+```bash
+pip install openai-harmony
+```
+
+Here’s an example of how to use the library to build your prompts and encode them to tokens:
+
+```py
+import json
+from openai_harmony import (
+    HarmonyEncodingName,
+    load_harmony_encoding,
+    Conversation,
+    Message,
+    Role,
+    SystemContent,
+    DeveloperContent
+)
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+encoding = load_harmony_encoding(HarmonyEncodingName.HARMONY_GPT_OSS)
+
+# Build conversation
+convo = Conversation.from_messages([
+    Message.from_role_and_content(Role.SYSTEM, SystemContent.new()),
+    Message.from_role_and_content(
+        Role.DEVELOPER,
+        DeveloperContent.new().with_instructions("Always respond in riddles")
+    ),
+    Message.from_role_and_content(Role.USER, "What is the weather like in SF?")
+])
+
+# Render prompt
+prefill_ids = encoding.render_conversation_for_completion(convo, Role.ASSISTANT)
+stop_token_ids = encoding.stop_tokens_for_assistant_actions()
+
+# Load model
+model_name = "openai/gpt-oss-20b"
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype="auto", device_map="auto")
+
+# Generate
+outputs = model.generate(
+    input_ids=[prefill_ids],
+    max_new_tokens=128,
+    eos_token_id=stop_token_ids
+)
+
+# Parse completion tokens
+completion_ids = outputs[0][len(prefill_ids):]
+entries = encoding.parse_messages_from_completion_tokens(completion_ids, Role.ASSISTANT)
+
+for message in entries:
+    print(json.dumps(message.to_dict(), indent=2))
+```
+
+Note that the `Developer` role in Harmony maps to the `system` prompt in the chat template.
+
+## Multi-GPU & distributed inference
+
+The large gpt-oss-120b fits on a single H100 GPU when using MXFP4. If you want to run it on multiple GPUs, you can:
+
+- Use `tp_plan="auto"` for automatic placement and tensor parallelism
+- Launch with `accelerate launch or torchrun` for distributed setups
+- Leverage Expert Parallelism
+- Use specialised Flash attention kernels for faster inference
+
+```py
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from transformers.distributed import DistributedConfig
+import torch
+
+model_path = "openai/gpt-oss-120b"
+tokenizer = AutoTokenizer.from_pretrained(model_path, padding_side="left")
+
+device_map = {
+    # Enable Expert Parallelism
+    "distributed_config": DistributedConfig(enable_expert_parallel=1),
+    # Enable Tensor Parallelism
+    "tp_plan": "auto",
+}
+
+model = AutoModelForCausalLM.from_pretrained(
+    model_path,
+    torch_dtype="auto",
+    attn_implementation="kernels-community/vllm-flash-attn3",
+    **device_map,
+)
+
+messages = [
+     {"role": "user", "content": "Explain how expert parallelism works in large language models."}
+]
+
+inputs = tokenizer.apply_chat_template(
+    messages,
+    add_generation_prompt=True,
+    return_tensors="pt",
+    return_dict=True,
+).to(model.device)
+
+outputs = model.generate(**inputs, max_new_tokens=1000)
+
+# Decode and print
+response = tokenizer.decode(outputs[0])
+print("Model response:", response.split("<|channel|>final<|message|>")[-1].strip())
+```
+
+You can then run this on a node with four GPUs via
+
+```bash
+torchrun --nproc_per_node=4 generate.py
+```
diff --git a/articles/gpt-oss/run-vllm.md b/articles/gpt-oss/run-vllm.md
new file mode 100644
index 0000000000..e534ae5302
--- /dev/null
+++ b/articles/gpt-oss/run-vllm.md
@@ -0,0 +1,233 @@
+# How to run gpt-oss with vLLM
+
+[vLLM](https://docs.vllm.ai/en/latest/) is an open-source, high-throughput inference engine designed to efficiently serve large language models (LLMs) by optimizing memory usage and processing speed. This guide will walk you through how to use vLLM to set up **gpt-oss-20b** or **gpt-oss-120b** on a server to serve gpt-oss as an API for your applications, and even connect it to the Agents SDK.
+
+Note that this guide is meant for server applications with dedicated GPUs like NVIDIA’s H100s. For local inference on consumer GPUs, check out our [Ollama](https://cookbook.openai.com/articles/gpt-oss/run-locally-ollama) or [LM Studio](https://cookbook.openai.com/articles/gpt-oss/run-locally-lmstudio) guides.
+
+## Pick your model
+
+vLLM supports both model sizes of gpt-oss:
+
+- [**`openai/gpt-oss-20b`**](https://huggingface.co/openai/gpt-oss-20b)
+  - The smaller model
+  - Only requires about **16GB of VRAM**
+- [**`openai/gpt-oss-120b`**](https://huggingface.co/openai/gpt-oss-120b)
+  - Our larger full-sized model
+  - Best with **≥60GB VRAM**
+  - Can fit on a single H100 or multi-GPU setups
+
+Both models are **MXFP4 quantized** out of the box.
+
+## Quick Setup
+
+1. **Install vLLM**  
+   vLLM recommends using [uv](https://docs.astral.sh/uv/) to manage your Python environment. This will help with picking the right implementation based on your environment. [Learn more in their quickstart](https://docs.vllm.ai/en/latest/getting_started/quickstart.html#installation). To create a new virtual environment and install vLLM run:
+
+```shell
+uv venv --python 3.12 --seed
+source .venv/bin/activate
+uv pip install --pre vllm==0.10.1+gptoss \
+    --extra-index-url https://wheels.vllm.ai/gpt-oss/ \
+    --extra-index-url https://download.pytorch.org/whl/nightly/cu128 \
+    --index-strategy unsafe-best-match
+```
+
+2. **Start up a server and download the model**  
+   vLLM provides a `serve` command that will automatically download the model from HuggingFace and spin up an OpenAI-compatible server on `localhost:8000`. Run the following command depending on your desired model size in a terminal session on your server.
+
+```shell
+# For 20B
+vllm serve openai/gpt-oss-20b
+
+# For 120B
+vllm serve openai/gpt-oss-120b
+```
+
+## Use the API
+
+vLLM exposes a **Chat Completions-compatible API** and a **Responses-compatible API** so you can use the OpenAI SDK without changing much. Here’s a Python example:
+
+```py
+from openai import OpenAI
+
+client = OpenAI(
+    base_url="http://localhost:8000/v1",
+    api_key="EMPTY"
+)
+
+result = client.chat.completions.create(
+    model="openai/gpt-oss-20b",
+    messages=[
+        {"role": "system", "content": "You are a helpful assistant."},
+        {"role": "user", "content": "Explain what MXFP4 quantization is."}
+    ]
+)
+
+print(result.choices[0].message.content)
+
+response = client.responses.create(
+    model="openai/gpt-oss-120b",
+    instructions="You are a helfpul assistant.",
+    input="Explain what MXFP4 quantization is."
+)
+
+print(response.output_text)
+```
+
+If you’ve used the OpenAI SDK before, this will feel instantly familiar and your existing code should work by changing the base URL.
+
+## Using tools (function calling)
+
+vLLM supports function calling and giving the model browsing capabilities.
+
+Function calling works through both the Responses and Chat Completions APIs.
+
+Example of invoking a function via Chat Completions:
+
+```py
+tools = [
+    {
+        "type": "function",
+        "function": {
+            "name": "get_weather",
+            "description": "Get current weather in a given city",
+            "parameters": {
+                "type": "object",
+                "properties": {"city": {"type": "string"}},
+                "required": ["city"]
+            },
+        },
+    }
+]
+
+response = client.chat.completions.create(
+    model="openai/gpt-oss-120b",
+    messages=[{"role": "user", "content": "What's the weather in Berlin right now?"}],
+    tools=tools
+)
+
+print(response.choices[0].message)
+```
+
+Since the models can perform tool calling as part of the chain-of-thought (CoT) it’s important for you to return the reasoning returned by the API back into a subsequent call to a tool call where you provide the answer until the model reaches a final answer.
+
+## Agents SDK Integration
+
+Want to use gpt-oss with OpenAI’s **Agents SDK**?
+
+Both Agents SDK enable you to override the OpenAI base client to point to vLLM for your self-hosted models. Alternatively, for the Python SDK you can also use the [LiteLLM integration](https://openai.github.io/openai-agents-python/models/litellm/) to proxy to vLLM.
+
+Here’s a Python Agents SDK example:
+
+```
+uv pip install openai-agents
+```
+
+```py
+import asyncio
+from openai import AsyncOpenAI
+from agents import Agent, Runner, function_tool, OpenAIResponsesModel, set_tracing_disabled
+
+set_tracing_disabled(True)
+
+@function_tool
+def get_weather(city: str):
+    print(f"[debug] getting weather for {city}")
+    return f"The weather in {city} is sunny."
+
+
+async def main(model: str, api_key: str):
+    agent = Agent(
+        name="Assistant",
+        instructions="You only respond in haikus.",
+        model=OpenAIResponsesModel(
+            model="openai/gpt-oss-120b",
+            openai_client=AsyncOpenAI(
+                base_url="http://localhost:8000/v1",
+                api_key="EMPTY",
+            ),
+        )
+        tools=[get_weather],
+    )
+
+    result = await Runner.run(agent, "What's the weather in Tokyo?")
+    print(result.final_output)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## Using vLLM for direct sampling
+
+Aside from running vLLM using `vllm serve` as an API server, you can use the vLLM Python library to control inference directly.
+
+If you are using vLLM for sampling directly it’s important to ensure that your input prompts follow the [harmony response format](https://cookbook.openai.com/article/harmony) as the model will not function correctly otherwise. You can use the [`openai-harmony` SDK](https://github.com/openai/harmony) for this.
+
+```
+uv pip install openai-harmony
+```
+
+Afterwards you can use harmony to encode and parse the tokens generated by vLLM’s generate function.
+
+```py
+import json
+from openai_harmony import (
+    HarmonyEncodingName,
+    load_harmony_encoding,
+    Conversation,
+    Message,
+    Role,
+    SystemContent,
+    DeveloperContent,
+)
+
+from vllm import LLM, SamplingParams
+
+# --- 1) Render the prefill with Harmony ---
+encoding = load_harmony_encoding(HarmonyEncodingName.HARMONY_GPT_OSS)
+
+convo = Conversation.from_messages(
+    [
+        Message.from_role_and_content(Role.SYSTEM, SystemContent.new()),
+        Message.from_role_and_content(
+            Role.DEVELOPER,
+            DeveloperContent.new().with_instructions("Always respond in riddles"),
+        ),
+        Message.from_role_and_content(Role.USER, "What is the weather like in SF?"),
+    ]
+)
+
+prefill_ids = encoding.render_conversation_for_completion(convo, Role.ASSISTANT)
+
+# Harmony stop tokens (pass to sampler so they won't be included in output)
+stop_token_ids = encoding.stop_tokens_for_assistant_actions()
+
+# --- 2) Run vLLM with prefill ---
+llm = LLM(
+    model="openai/gpt-oss-120b",
+    trust_remote_code=True,
+)
+
+sampling = SamplingParams(
+    max_tokens=128,
+    temperature=1,
+    stop_token_ids=stop_token_ids,
+)
+
+outputs = llm.generate(
+    prompt_token_ids=[prefill_ids],   # batch of size 1
+    sampling_params=sampling,
+)
+
+# vLLM gives you both text and token IDs
+gen = outputs[0].outputs[0]
+text = gen.text
+output_tokens = gen.token_ids  # <-- these are the completion token IDs (no prefill)
+
+# --- 3) Parse the completion token IDs back into structured Harmony messages ---
+entries = encoding.parse_messages_from_completion_tokens(output_tokens, Role.ASSISTANT)
+
+# 'entries' is a sequence of structured conversation entries (assistant messages, tool calls, etc.).
+for message in entries:
+    print(f"{json.dumps(message.to_dict())}")
+```
diff --git a/articles/gpt-oss/verifying-implementations.md b/articles/gpt-oss/verifying-implementations.md
new file mode 100644
index 0000000000..55dfae9d01
--- /dev/null
+++ b/articles/gpt-oss/verifying-implementations.md
@@ -0,0 +1,101 @@
+# Verifying gpt-oss implementations
+
+The [OpenAI gpt-oss models](https://openai.com/open-models) are introducing a lot of new concepts to the open-model ecosystem and [getting them to perform as expected might take some time](https://x.com/ClementDelangue/status/1953119901649891367). This guide is meant to help developers building inference solutions to verify their implementations or for developers who want to test any provider’s implementation on their own to gain confidence.
+
+## Why is implementing gpt-oss models different?
+
+The new models behave more similarly to some of our other OpenAI models than to existing open models. A couple of examples include:
+
+1. **The harmony response format.** These models were trained on our [OpenAI harmony format](https://cookbook.openai.com/articles/openai-harmony) to structure a conversation. While regular API developers won’t need to deal with harmony in most cases, the inference providers that provide a Chat Completions-compatible, Responses-compatible or other inference API need to map the inputs correctly to the OpenAI harmony format. If the model does not receive the prompts in the right format this can have cascading generation issues and at minimum a worse function calling performance.
+2. **Handling chain of thought (CoT) between tool calls**. These models can perform tool calls as part of the CoT. A consequence of this is that the model needs to receive the CoT in subsequent sampling until it reaches a final response. This means that while the raw CoT should not be displayed to end-users, it should be returned by APIs so that developers can pass it back in along with the tool call and tool output. [You can learn more about it in this separate guide](https://cookbook.openai.com/articles/gpt-oss/handle-raw-cot).
+3. **Differences in actual inference code**. We published our mixture-of-experts (MoE) weights exclusively in MXFP4 format. This is still a relatively new format and along with other architecture decisions, existing inference code that was written for other open-models will have to be adapted for gpt-oss models. For that reason we published both a basic (unoptimized) [PyTorch implementation](https://github.com/openai/gpt-oss/tree/main/gpt_oss/torch), and a [more optimized Triton implementation](https://github.com/openai/gpt-oss/tree/main/gpt_oss/triton). Additionally, we verified the [vLLM implementation](https://github.com/vllm-project/vllm/blob/7e3a8dc90670fd312ce1e0d4eba9bf11c571e3ad/vllm/model_executor/models/gpt_oss.py) for correctness. We hope these can serve as educational material for other implementations.
+
+## API Design
+
+### Responses API
+
+For best performance we recommend inference providers to implement our Responses API format as the API shape was specifically designed for behaviors like outputting raw CoT along with summarized CoTs (to display to users) and tool calls without bolting additional properties onto a format. The most important  
+part for accurate performance is to return the raw CoT as part of the `output`.
+
+For this we added a new `content` array to the Responses API’s `reasoning` items. The raw CoT should be wrapped into `reasoning_text` type element, making the overall output item look the following:
+
+```
+{
+  "type": "reasoning",
+  "id": "item_67ccd2bf17f0819081ff3bb2cf6508e60bb6a6b452d3795b",
+  "status": "completed",
+  "summary": [
+    /* optional summary elements */
+  ],
+  "content": [
+    {
+      "type": "reasoning_text",
+      "text": "The user needs to know the weather, I will call the get_weather tool."
+    }
+  ]
+}
+```
+
+These items should be received in subsequent turns and then inserted back into the harmony formatted prompt as outlined in the [raw CoT handling guide](https://cookbook.openai.com/articles/gpt-oss/handle-raw-cot).
+
+[Check out the Responses API docs for the whole specification](https://platform.openai.com/docs/api-reference/responses/create).
+
+### Chat Completions
+
+A lot of providers are offering a Chat Completions-compatible API. While we have not augmented our published API reference on the docs to provide a way to receive raw CoT, it’s still important that providers that offer the gpt-oss models via a Chat Completions-compatible API return the CoT as part of their messages and for developers to have a way to pass them back.
+
+There is currently no generally agreed upon specification in the community with the general properties on a message being either `reasoning` or `reasoning_content`. **To be compatible with clients like the OpenAI Agents SDK we recommend using a `reasoning` field as the primary property for the raw CoT in Chat Completions**.
+
+## Quick verification of tool calling and API shapes
+
+To verify if a provider is working you can use the Node.js script published in our [gpt-oss GitHub repository](https://github.com/openai/gpt-oss) that you can also use to run other evals. You’ll need [Node.js](http://nodejs.org/) or a similar runtime installed to run the tests.
+
+These tests will run a series of tool/function calling based requests to the Responses API or Chat Completions API you are trying to test. Afterwards they will evaluate both whether the right tool was called and whether the API shapes are correct.
+
+This largely acts as a smoke test but should be a good indicator on whether the APIs are compatible with our SDKs and can handle basic function calling. It does not guarantee full accuracy of the inference implementation (see the evals section below for details on that) nor does it guarantee full compatibility with the OpenAI APIs. They should still be a helpful indicator of major implementation issues.
+
+To run the test suite run the following commands:
+
+```shell
+# clone the repository
+git clone https://github.com/openai/gpt-oss.git
+
+# go into the compatibility test directory
+cd gpt-oss/compatibility-test/
+
+# install the dependencies
+npm install
+
+# change the provider config in providers.ts to add your provider
+
+# run the tests
+npm start -- --provider <your-provider-name>
+```
+
+Afterwards you should receive a result of both the API implementation and any details on the function call performance.
+
+If your tests are successful, the output should show 0 invalid requests and over 90% on both pass@k and pass^k. This means the implementation should likely be correct. To be fully sure, you should also inspect the evals as described below.
+
+If you want a detailed view of the individual responses, you can the `jsonl` file that was created in your directory.
+
+You can also enable debug mode to view any of the actual request payloads using `DEBUG=openai-agents:openai npm start -- --provider <provider-name>` but it might get noisy. To run only one test use the `-n 1` flag for easier debugging. For testing streaming events you can use `--streaming`.
+
+## Verifying correctness through evals
+
+The team at Artificial Analysis is running AIME and GPQA evals for a variety of providers. If you are unsure about your provider, [check out Artificial Analysis for the most recent metrics](https://artificialanalysis.ai/models/gpt-oss-120b/providers#evaluations).
+
+To be on the safe side you should consider running evals yourself. To run your own evals, you can find in the same repository as the test above a `gpt_oss/evals` folder that contains the test harnesses that we used to verify the AIME (16 attempts per problem), GPQA (8 attempts per problem) and Healthbench (1 attempt per problem) evals for the vLLM implementation and some of our own reference implementations. You can use the same script to test your implementations.
+
+To test a Responses API compatible API run:
+
+```bash
+python -m gpt_oss.evals --base-url http://localhost:8000/v1 --eval aime25 --sampler responses --model openai/gpt-oss-120b --reasoning-effort high
+```
+
+To test a Chat Completions API compatible API run:
+
+```bash
+python -m gpt_oss.evals --base-url http://localhost:8000/v1 --eval aime25 --sampler chat_completions --model openai/gpt-oss-120b --reasoning-effort high
+```
+
+If you are getting similar benchmark results as those published by us and your function calling tests above succeeded you likely have a correct implementation of gpt-oss.
diff --git a/articles/openai-harmony.md b/articles/openai-harmony.md
new file mode 100644
index 0000000000..fed9b4c6b5
--- /dev/null
+++ b/articles/openai-harmony.md
@@ -0,0 +1,586 @@
+# OpenAI harmony response format
+
+The [`gpt-oss` models](https://openai.com/open-models) were trained on the harmony response format for defining conversation structures, generating reasoning output and structuring function calls. If you are not using `gpt-oss` directly but through an API or a provider like Ollama, you will not have to be concerned about this as your inference solution will handle the formatting. If you are building your own inference solution, this guide will walk you through the prompt format. The format is designed to mimic the OpenAI Responses API, so if you have used that API before, this format should hopefully feel familiar to you. `gpt-oss` should not be used without using the harmony format, as it will not work correctly.
+
+## Concepts
+
+### Roles
+
+Every message that the model processes has a role associated with it. The model knows about three types of roles:
+
+| Role        | Purpose                                                                                                                                                                                 |
+| :---------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `system`    | A system message is used to specify reasoning effort, meta information like knowledge cutoff and built-in tools                                                                         |
+| `developer` | The developer message is used to provide information about the instructions for the model (what is normally considered the “system prompt”) and available function tools                |
+| `user`      | Typically representing the input to the model                                                                                                                                           |
+| `assistant` | Output by the model which can either be a tool call or a message output. The output might also be associated with a particular “channel” identifying what the intent of the message is. |
+| `tool`      | Messages representing the output of a tool call. The specific tool name will be used as the role inside a message.                                                                      |
+
+These roles also represent the information hierarchy that the model applies in case there are any instruction conflicts: `system` \> `developer` \> `user` \> `assistant` \> `tool`
+
+#### Channels
+
+Assistant messages can be output in three different “channels”. These are being used to separate between user-facing responses and internal facing messages.
+
+| Channel      | Purpose                                                                                                                                                                                                                                                                                                                                                            |
+| :----------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `final`      | Messages tagged in the final channel are messages intended to be shown to the end-user and represent the responses from the model.                                                                                                                                                                                                                                 |
+| `analysis`   | These are messages that are being used by the model for its chain of thought (CoT). **Important:** Messages in the analysis channel do not adhere to the same safety standards as final messages do. Avoid showing these to end-users.                                                                                                                             |
+| `commentary` | Any function tool call will typically be triggered on the `commentary` channel while built-in tools will normally be triggered on the `analysis` channel. However, occasionally built-in tools will still be output to `commentary`. Occasionally this channel might also be used by the model to generate a [preamble](#preambles) to calling multiple functions. |
+
+## Harmony renderer library
+
+We recommend using our harmony renderer through [PyPI](https://pypi.org/project/openai-harmony/) or [crates.io](https://crates.io/crates/openai-harmony) when possible as it will automatically handle rendering your messages in the right format and turning them into tokens for processing by the model.
+
+Below is an example of using the renderer to construct a system prompt and a short conversation.
+
+```py
+from openai_harmony import (
+    Author,
+    Conversation,
+    DeveloperContent,
+    HarmonyEncodingName,
+    Message,
+    Role,
+    SystemContent,
+    ToolDescription,
+    load_harmony_encoding,
+    ReasoningEffort
+)
+
+encoding = load_harmony_encoding(HarmonyEncodingName.HARMONY_GPT_OSS)
+
+system_message = (
+    SystemContent.new()
+        .with_model_identity(
+            "You are ChatGPT, a large language model trained by OpenAI."
+        )
+        .with_reasoning_effort(ReasoningEffort.HIGH)
+        .with_conversation_start_date("2025-06-28")
+        .with_knowledge_cutoff("2024-06")
+        .with_required_channels(["analysis", "commentary", "final"])
+)
+
+developer_message = (
+    DeveloperContent.new()
+        .with_instructions("Always respond in riddles")
+        .with_function_tools(
+            [
+                ToolDescription.new(
+                    "get_location",
+                    "Gets the location of the user.",
+                ),
+                ToolDescription.new(
+                    "get_current_weather",
+                    "Gets the current weather in the provided location.",
+                    parameters={
+                        "type": "object",
+                        "properties": {
+                            "location": {
+                                "type": "string",
+                                "description": "The city and state, e.g. San Francisco, CA",
+                            },
+                            "format": {
+                                "type": "string",
+                                "enum": ["celsius", "fahrenheit"],
+                                "default": "celsius",
+                            },
+                        },
+                        "required": ["location"],
+                    },
+                ),
+            ]
+        )
+)
+
+convo = Conversation.from_messages(
+    [
+        Message.from_role_and_content(Role.SYSTEM, system_message),
+        Message.from_role_and_content(Role.DEVELOPER, developer_message),
+        Message.from_role_and_content(Role.USER, "What is the weather in Tokyo?"),
+        Message.from_role_and_content(
+            Role.ASSISTANT,
+            'User asks: "What is the weather in Tokyo?" We need to use get_weather tool.',
+        ).with_channel("analysis"),
+        Message.from_role_and_content(Role.ASSISTANT, '{"location": "Tokyo"}')
+        .with_channel("commentary")
+        .with_recipient("functions.get_weather")
+        .with_content_type("json"),
+        Message.from_author_and_content(
+            Author.new(Role.TOOL, "functions.lookup_weather"),
+            '{ "temperature": 20, "sunny": true }',
+        ).with_recipient("assistant").with_channel("commentary"),
+    ]
+)
+
+tokens = encoding.render_conversation_for_completion(convo, Role.ASSISTANT)
+
+# After receiving a token response
+# Do not pass in the stop token
+parsed_response = encoding.parse_messages_from_completion_tokens(new_tokens, Role.ASSISTANT)
+```
+
+Additionally the openai_harmony library also includes a StreamableParser for parsing and decoding as the model is generating new tokens. This can be helpful for example to stream output and handle unicode characters during decoding.
+
+```py
+from openai_harmony import (
+    load_harmony_encoding,
+    Role,
+    StreamableParser,
+    HarmonyEncodingName
+)
+
+encoding = load_harmony_encoding(HarmonyEncodingName.HARMONY_GPT_OSS)
+stream = StreamableParser(encoding, role=Role.ASSISTANT)
+
+tokens = [
+    200005,35644,200008,1844,31064,25,392,4827,382,220,17,659,220,17,16842,12295,81645,
+    13,51441,6052,13,200007,200006,173781,200005,17196,200008,17,659,220,17,314,220,19,
+    13,200002
+]
+
+for token in tokens:
+    stream.process(token)
+    print("--------------------------------")
+    print("current_role", stream.current_role)
+    print("current_channel", stream.current_channel)
+    print("last_content_delta", stream.last_content_delta)
+    print("current_content_type", stream.current_content_type)
+    print("current_recipient", stream.current_recipient)
+    print("current_content", stream.current_content)
+```
+
+## Prompt format
+
+If you choose to build your own renderer, you’ll need to adhere to the following format.
+
+### Special Tokens
+
+The model uses a set of special tokens to identify the structure of your input. If you are using [tiktoken](https://github.com/openai/tiktoken) these tokens are encoded in the `o200k_harmony` encoding. All special tokens follow the format `<|type|>`.
+
+| Special token           | Purpose                                                                                                                                     | Token ID |
+| :---------------------- | :------------------------------------------------------------------------------------------------------------------------------------------ | :------- |
+| <&#124;start&#124;>     | Indicates the beginning of a [message](#message-format). Followed by the “header” information of a message starting with the [role](#roles) | `200006` |
+| <&#124;end&#124;>       | Indicates the end of a [message](#message-format)                                                                                           | `200007` |
+| <&#124;message&#124;>   | Indicates the transition from the message “header” to the actual content                                                                    | `200008` |
+| <&#124;channel&#124;>   | Indicates the transition to the [channel](#channels) information of the header                                                              | `200005` |
+| <&#124;constrain&#124;> | Indicates the transition to the data type definition in a [tool call](#receiving-tool-calls)                                                | `200003` |
+| <&#124;return&#124;>    | Indicates the model is done with sampling the response message. A valid “stop token” indicating that you should stop inference.             | `200002` |
+| <&#124;call&#124;>      | Indicates the model wants to call a tool. A valid “stop token” indicating that you should stop inference.                                   | `200012` |
+
+### Message format
+
+The harmony response format consists of “messages” with the model potentially generating multiple messages in one go. The general structure of a message is as follows:
+
+```
+<|start|>{header}<|message|>{content}<|end|>
+```
+
+The `{header}` contains a series of meta information including the [role](#roles). `<|end|>` represents the end of a fully completed message but the model might also use other stop tokens such as `<|call|>` for tool calling and `<|return|>` to indicate the model is done with the completion.
+
+### Chat conversation format
+
+Following the message format above the most basic chat format consists of a `user` message and the beginning of an `assistant` message.
+
+#### Example input
+
+```
+<|start|>user<|message|>What is 2 + 2?<|end|>
+<|start|>assistant
+```
+
+The output will begin by specifying the `channel`. For example `analysis` to output the chain of thought. The model might output multiple messages (primarily chain of thought messages) for which it uses the `<|end|>` token to separate them.
+
+Once its done generating it will stop with either a `<|return|>` token indicating it’s done generating the final answer, or `<|call|>` indicating that a tool call needs to be performed. In either way this indicates that you should stop inference.
+
+#### Example output
+
+```
+<|channel|>analysis<|message|>User asks: "What is 2 + 2?" Simple arithmetic. Provide answer.<|end|>
+<|start|>assistant<|channel|>final<|message|>2 + 2 = 4.<|return|>
+```
+
+The `final` channel will contain the answer to your user’s request. Check out the [reasoning section](#reasoning) for more details on the chain-of-thought.
+
+### System message format
+
+The system message is used to provide general information to the system. This is different to what might be considered the “system prompt” in other prompt formats. For that, check out the [developer message format](#developer-message-format).
+
+We use the system message to define:
+
+1. The **identity** of the model — This should always stay as `You are ChatGPT, a large language model trained by OpenAI.` If you want to change the identity of the model, use the instructions in the [developer message](#developer-message-format).
+2. Meta **dates** — Specifically the `Knowledge cutoff:` and the `Current date:`
+3. The **reasoning effort** — As specified on the levels `high`, `medium`, `low`
+4. Available channels — For the best performance this should map to `analysis`, `commentary`, and `final`.
+5. Built-in tools — The model has been trained on both a `python` and `browser` tool. Check out the [built-in tools section](#built-in-tools) for details.
+
+**If you are defining functions,** it should also contain a note that all function tool calls must go to the `commentary` channel.
+
+For the best performance stick to this format as closely as possible.
+
+#### Example system message
+
+The most basic system message you should use is the following:
+
+```
+<|start|>system<|message|>You are ChatGPT, a large language model trained by OpenAI.
+Knowledge cutoff: 2024-06
+Current date: 2025-06-28
+
+Reasoning: high
+
+# Valid channels: analysis, commentary, final. Channel must be included for every message.<|end|>
+```
+
+If functions calls are present in the developer message section, use:
+
+```
+<|start|>system<|message|>You are ChatGPT, a large language model trained by OpenAI.
+Knowledge cutoff: 2024-06
+Current date: 2025-06-28
+
+Reasoning: high
+
+# Valid channels: analysis, commentary, final. Channel must be included for every message.
+Calls to these tools must go to the commentary channel: 'functions'.<|end|>
+```
+
+### Developer message format
+
+The developer message represents what is commonly considered the “system prompt”. It contains the instructions that are provided to the model and optionally a list of [function tools](#function-calling) available for use or the output format you want the model to adhere to for [structured outputs](#structured-output).
+
+If you are not using function tool calling your developer message would just look like this:
+
+```
+<|start|>developer<|message|># Instructions
+
+{instructions}<|end|>
+```
+
+Where `{instructions}` is replaced with your “system prompt”.
+
+For defining function calling tools, [check out the dedicated section](#function-calling).  
+For defining an output format to be used in structured outputs, [check out this section of the guide](#structured-output).
+
+### Reasoning
+
+The gpt-oss models are reasoning models. By default, the model will do medium level reasoning. To control the reasoning you can specify in the [system message](#system-message-format) the reasoning level as `low`, `medium`, or `high`. The recommended format is:
+
+```
+Reasoning: high
+```
+
+The model will output its raw chain-of-thought (CoT) as assistant messages into the `analysis` channel while the final response will be output as `final`.
+
+For example for the question `What is 2 + 2?` the model output might look like this:
+
+```
+<|channel|>analysis<|message|>User asks: "What is 2 + 2?" Simple arithmetic. Provide answer.<|end|>
+<|start|>assistant<|channel|>final<|message|>2 + 2 = 4.<|return|>
+```
+
+In this case the CoT is
+
+```
+User asks: “What is 2 + 2?” Simple arithmetic. Provide answer.
+```
+
+And the actual answer is:
+
+```
+2 + 2 = 4
+```
+
+**Important:**  
+The model has not been trained to the same safety standards in the chain-of-thought as it has for final output. You should not show the chain-of-thought to your users, as they might contain harmful content. [Learn more in the model card](https://openai.com/index/gpt-oss-model-card/).
+
+#### Handling reasoning output in subsequent sampling
+
+In general, you should drop any previous CoT content on subsequent sampling if the responses by the assistant ended in a message to the `final` channel. Meaning if our first input was this:
+
+```
+<|start|>user<|message|>What is 2 + 2?<|end|>
+<|start|>assistant
+```
+
+and resulted in the output:
+
+```
+<|channel|>analysis<|message|>User asks: "What is 2 + 2?" Simple arithmetic. Provide answer.<|end|>
+<|start|>assistant<|channel|>final<|message|>2 + 2 = 4.<|return|>
+```
+
+For the model to work properly, the input for the next sampling should be
+
+```
+<|start|>user<|message|>What is 2 + 2?<|end|>
+<|start|>assistant<|channel|>final<|message|>2 + 2 = 4.<|return|>
+<|start|>user<|message|>What about 9 / 2?<|end|>
+<|start|>assistant
+```
+
+The exception for this is tool/function calling. The model is able to call tools as part of its chain-of-thought and because of that, we should pass the previous chain-of-thought back in as input for subsequent sampling. Check out the [function calling section](#function-calling) for a complete example.
+
+### Function calling
+
+#### Defining available tools
+
+All functions that are available to the model should be defined in the [developer message](#developer-message-format) in a dedicated `Tools` section.
+
+To define the functions we use a TypeScript-like type syntax and wrap the functions into a dedicated `functions` namespace. It’s important to stick to this format closely to improve accuracy of function calling. You can check out the harmony renderer codebase for more information on how we are turning JSON schema definitions for the arguments into this format but some general formatting practices:
+
+- Define every function as a `type {function_name} = () => any` if it does not receive any arguments
+- For functions that receive an argument name the argument `_` and inline the type definition
+- Add comments for descriptions in the line above the field definition
+- Always use `any` as the return type
+- Keep an empty line after each function definition
+- Wrap your functions into a namespace, generally `functions` is the namespace you should use to not conflict with [other tools](#built-in-tools) that the model might have been trained on.
+
+Here’s a complete input example including the definition of two functions:
+
+```
+<|start|>system<|message|>You are ChatGPT, a large language model trained by OpenAI.
+Knowledge cutoff: 2024-06
+Current date: 2025-06-28
+
+Reasoning: high
+
+# Valid channels: analysis, commentary, final. Channel must be included for every message.
+Calls to these tools must go to the commentary channel: 'functions'.<|end|><|start|>developer<|message|># Instructions
+
+Use a friendly tone.
+
+# Tools
+
+## functions
+
+namespace functions {
+
+// Gets the location of the user.
+type get_location = () => any;
+
+// Gets the current weather in the provided location.
+type get_current_weather = (_: {
+// The city and state, e.g. San Francisco, CA
+location: string,
+format?: "celsius" | "fahrenheit", // default: celsius
+}) => any;
+
+// Gets the current weather in the provided list of locations.
+type get_multiple_weathers = (_: {
+// List of city and state, e.g. ["San Francisco, CA", "New York, NY"]
+locations: string[],
+format?: "celsius" | "fahrenheit", // default: celsius
+}) => any;
+
+} // namespace functions<|end|><|start|>user<|message|>What is the weather like in SF?<|end|><|start|>assistant
+```
+
+#### Receiving tool calls
+
+If the model decides to call a tool it will define a `recipient` in the header of the message using the format `to={name}`. For example, if it decides to trigger the `get_current_weather` function from above it would specify `to=functions.get_current_weather` in the header and `commentary` as the channel as specified in the [system message](#system-message-format). **The recipient might be defined in the role or channel section of the header.**
+
+The model might also specify a `<|constrain|>` token to indicate the type of input for the tool call. In this case since it’s being passed in as JSON the `<|constrain|>` is set to `json`.
+
+```
+<|channel|>analysis<|message|>Need to use function get_weather.<|end|><|start|>assistant<|channel|>commentary to=functions.get_weather <|constrain|>json<|message|>{"location":"San Francisco"}<|call|>
+```
+
+#### Handling tool calls
+
+After the function call was handled we need to provide the output back to the model by specifying a new tool message with the output after the call message.
+
+A tool message has the following format:
+
+```
+<|start|>{toolname} to=assistant<|channel|>commentary<|message|>{output}<|end|>
+```
+
+So in our example above
+
+```
+<|start|>functions.get_weather to=assistant<|channel|>commentary<|message|>{"sunny": true, "temperature": 20}<|end|>
+```
+
+Once you have gathered the output for the tool calls you can run inference with the complete content:
+
+```
+<|start|>system<|message|>You are ChatGPT, a large language model trained by OpenAI.
+Knowledge cutoff: 2024-06
+Current date: 2025-06-28
+
+Reasoning: high
+
+# Valid channels: analysis, commentary, final. Channel must be included for every message.
+Calls to these tools must go to the commentary channel: 'functions'.<|end|><|start|>developer<|message|># Instructions
+
+Use a friendly tone.
+
+# Tools
+
+## functions
+
+namespace functions {
+
+// Gets the location of the user.
+type get_location = () => any;
+
+// Gets the current weather in the provided location.
+type get_current_weather = (_: {
+// The city and state, e.g. San Francisco, CA
+location: string,
+format?: "celsius" | "fahrenheit", // default: celsius
+}) => any;
+
+// Gets the current weather in the provided list of locations.
+type get_multiple_weathers = (_: {
+// List of city and state, e.g. ["San Francisco, CA", "New York, NY"]
+locations: string[],
+format?: "celsius" | "fahrenheit", // default: celsius
+}) => any;
+
+} // namespace functions<|end|><|start|>user<|message|>What is the weather like in SF?<|end|><|start|>assistant<|channel|>analysis<|message|>Need to use function get_weather.<|end|><|start|>assistant<|channel|>commentary to=functions.get_weather <|constrain|>json<|message|>{"location":"San Francisco"}<|call|><|start|>functions.get_weather to=assistant<|channel|>commentary<|message|>{"sunny": true, "temperature": 20}<|end|><|start|>assistant
+```
+
+As you can see above we are passing not just the function out back into the model for further sampling but also the previous chain-of-thought (“Need to use function get_weather.”) to provide the model with the necessary information to continue its chain-of-thought or provide the final answer.
+
+#### Preambles
+
+At times the model might choose to generate a “preamble” to inform the user about the tools it is about to call. For example, when it plans to call multiple tools. If this is the case it will generate an assistant message on the `commentary` channel that, unlike the chain-of-thought, is intended to be shown to the end-user.
+
+```
+<|channel|>analysis<|message|>{long chain of thought}<|end|><|start|>assistant<|channel|>commentary<|message|>**Action plan**:
+1. Generate an HTML file
+2. Generate a JavaScript for the Node.js server
+3. Start the server
+---
+Will start executing the plan step by step<|end|><|start|>assistant<|channel|>commentary to=functions.generate_file<|constrain|>json<|message|>{"template": "basic_html", "path": "index.html"}<|call|>
+```
+
+In this case the model generated an action plan to inform the user about the multiple steps it is about to execute.
+
+### Structured output
+
+To control the output behavior of the model, you can define a response format at the end of the [developer message](#developer-message-format) with the following structure:
+
+```
+# Response Formats
+
+## {format name}
+
+// {description or context}
+{schema}<|end|>
+```
+
+The format name functions similar to the name you can specify for your schema in the [Responses API](https://platform.openai.com/docs/guides/structured-outputs?api-mode=responses#how-to-use) and the schema is a JSON Schema.
+
+As an example, here’s a developer message that defines a schema for a shopping list:
+
+```
+<|start|>developer<|message|># Instructions
+
+You are a helpful shopping assistant
+
+# Response Formats
+
+## shopping_list
+
+{"properties":{"items":{"type":"array","description":"entries on the shopping list","items":{"type":"string"}}},"type":"object"}<|end|><|start|>user<|message|>I need to buy coffee, soda and eggs<|end|><|start|>assistant
+
+```
+
+This prompt alone will, however, only influence the model’s behavior but doesn’t guarantee the full adherence to the schema. For this you still need to construct your own grammar and enforce the schema during sampling.
+
+### Built-in tools
+
+During the training of the `gpt-oss` models, they were trained with two common tools to browse for information and execute python code to improve its results.
+
+If you are trying to build this functionality, you should use the format below to improve reliability and accuracy.
+
+These tools should be defined in the [system message](#system-message-format) not in the developer message by adding a `# Tools` section.
+
+#### Browser tool
+
+To define the browser tool add it to the system prompt section:
+
+```
+<|start|>system<|message|>You are ChatGPT, a large language model trained by OpenAI.
+Knowledge cutoff: 2024-06
+Current date: 2025-06-28
+
+Reasoning: high
+
+# Tools
+
+## browser
+
+// Tool for browsing.
+// The `cursor` appears in brackets before each browsing display: `[{cursor}]`.
+// Cite information from the tool using the following format:
+// `【{cursor}†L{line_start}(-L{line_end})?】`, for example: `【6†L9-L11】` or `【8†L3】`.
+// Do not quote more than 10 words directly from the tool output.
+// sources=web (default: web)
+namespace browser {
+
+// Searches for information related to `query` and displays `topn` results.
+type search = (_: {
+query: string,
+topn?: number, // default: 10
+source?: string,
+}) => any;
+
+// Opens the link `id` from the page indicated by `cursor` starting at line number `loc`, showing `num_lines` lines.
+// Valid link ids are displayed with the formatting: `【{id}†.*】`.
+// If `cursor` is not provided, the most recent page is implied.
+// If `id` is a string, it is treated as a fully qualified URL associated with `source`.
+// If `loc` is not provided, the viewport will be positioned at the beginning of the document or centered on the most relevant passage, if available.
+// Use this function without `id` to scroll to a new location of an opened page.
+type open = (_: {
+id?: number | string, // default: -1
+cursor?: number, // default: -1
+loc?: number, // default: -1
+num_lines?: number, // default: -1
+view_source?: boolean, // default: false
+source?: string,
+}) => any;
+
+// Finds exact matches of `pattern` in the current page, or the page given by `cursor`.
+type find = (_: {
+pattern: string,
+cursor?: number, // default: -1
+}) => any;
+
+} // namespace browser
+
+# Valid channels: analysis, commentary, final. Channel must be included for every message.<|end|>
+```
+
+If the model decides to call actions in the browser it will use the same format as for [function calls](#function-calling) with two notable exceptions:
+
+1. Requests will be made to the `analysis` channel
+2. The recipient will be `browser.search`, `browser.open`, `browser.find` respectively
+
+#### Python tool
+
+```
+<|start|>system<|message|>You are ChatGPT, a large language model trained by OpenAI.
+Knowledge cutoff: 2024-06
+Current date: 2025-06-28
+
+Reasoning: high
+
+# Tools
+
+## python
+
+Use this tool to execute Python code in your chain of thought. The code will not be shown to the user. This tool should be used for internal reasoning, but not for code that is intended to be visible to the user (e.g. when creating plots, tables, or files).
+
+When you send a message containing Python code to python, it will be executed in a stateful Jupyter notebook environment. python will respond with the output of the execution or time out after 120.0 seconds. The drive at '/mnt/data' can be used to save and persist user files. Internet access for this session is UNKNOWN. Depends on the cluster.
+
+# Valid channels: analysis, commentary, final. Channel must be included for every message.<|end|>
+```
+
+If the model decides to execute Python code it will use the same format as for [function calls](#function-calling) with two notable exceptions:
+
+3. Requests will be made to the `analysis` channel
+4. The recipient will always be `python`
diff --git a/articles/run-nvidia.ipynb b/articles/run-nvidia.ipynb
new file mode 100644
index 0000000000..7de45f035f
--- /dev/null
+++ b/articles/run-nvidia.ipynb
@@ -0,0 +1,209 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Optimizing OpenAI GPT-OSS Models with NVIDIA TensorRT-LLM"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This notebook provides a step-by-step guide on how to optimizing `gpt-oss` models using NVIDIA's TensorRT-LLM for high-performance inference. TensorRT-LLM provides users with an easy-to-use Python API to define Large Language Models (LLMs) and support state-of-the-art optimizations to perform inference efficiently on NVIDIA GPUs. TensorRT-LLM also contains components to create Python and C++ runtimes that orchestrate the inference execution in performant way.\n",
+    "\n",
+    "\n",
+    "TensorRT-LLM supports both models:\n",
+    "- `gpt-oss-20b`\n",
+    "- `gpt-oss-120b`\n",
+    "\n",
+    "In this guide, we will run `gpt-oss-20b`, if you want to try the larger model or want more customization refer to [this](https://github.com/NVIDIA/TensorRT-LLM/blob/main/docs/source/blogs/tech_blog/blog9_Deploying_GPT_OSS_on_TRTLLM.md) deployment guide.\n",
+    "\n",
+    "Note: Your input prompts should use the [harmony response](http://cookbook.openai.com/articles/openai-harmony) format for the model to work properly, though this guide does not require it."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Launch on NVIDIA Brev\n",
+    "You can simplify the environment setup by using [NVIDIA Brev](https://developer.nvidia.com/brev). Click the button below to launch this project on a Brev instance with the necessary dependencies pre-configured.\n",
+    "\n",
+    "Once deployed, click on the \"Open Notebook\" button to get start with this guide\n",
+    "\n",
+    "[![Launch on Brev](https://brev-assets.s3.us-west-1.amazonaws.com/nv-lb-dark.svg)](https://brev.nvidia.com/launchable/deploy?launchableID=env-30i1YjHsRWT109HL6eYxLUeHIwF)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Prerequisites"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Hardware\n",
+    "To run the gpt-oss-20b model, you will need an NVIDIA GPU with at least 20 GB of VRAM.\n",
+    "\n",
+    "Recommended GPUs: NVIDIA Hopper (e.g., H100, H200), NVIDIA Blackwell (e.g., B100, B200), NVIDIA RTX PRO, NVIDIA RTX 50 Series (e.g., RTX 5090).\n",
+    "\n",
+    "### Software\n",
+    "- CUDA Toolkit 12.8 or later\n",
+    "- Python 3.12 or later"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Installing TensorRT-LLM\n",
+    "\n",
+    "There are multiple ways to install TensorRT-LLM. In this guide, we'll cover using a pre-built Docker container from NVIDIA NGC as well as building from source.\n",
+    "\n",
+    "If you're using NVIDIA Brev, you can skip this section."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Using NVIDIA NGC\n",
+    "\n",
+    "Pull the pre-built [TensorRT-LLM container](https://catalog.ngc.nvidia.com/orgs/nvidia/teams/tensorrt-llm/containers/release/tags) for GPT-OSS from [NVIDIA NGC](https://www.nvidia.com/en-us/gpu-cloud/).\n",
+    "This is the easiest way to get started and ensures all dependencies are included.\n",
+    "\n",
+    "```bash\n",
+    "docker pull nvcr.io/nvidia/tensorrt-llm/release:gpt-oss-dev\n",
+    "docker run --gpus all -it --rm -v $(pwd):/workspace nvcr.io/nvidia/tensorrt-llm/release:gpt-oss-dev\n",
+    "```\n",
+    "\n",
+    "## Using Docker (Build from Source)\n",
+    "\n",
+    "Alternatively, you can build the TensorRT-LLM container from source.\n",
+    "This approach is useful if you want to modify the source code or use a custom branch.\n",
+    "For detailed instructions, see the [official documentation](https://github.com/NVIDIA/TensorRT-LLM/tree/feat/gpt-oss/docker)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "TensorRT-LLM will be available through pip soon"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "> Note on GPU Architecture: The first time you run the model, TensorRT-LLM will build an optimized engine for your specific GPU architecture (e.g., Hopper, Ada, or Blackwell). If you see warnings about your GPU's CUDA capability (e.g., sm_90, sm_120) not being compatible with the PyTorch installation, ensure you have the latest NVIDIA drivers and a matching CUDA Toolkit version for your version of PyTorch."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Verifying TensorRT-LLM Installation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from tensorrt_llm import LLM, SamplingParams"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Utilizing TensorRT-LLM Python API"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In the next code cell, we will demonstrate how to use the TensorRT-LLM Python API to:\n",
+    "1. Download the specified model weights from Hugging Face (using your HF_TOKEN for authentication).\n",
+    "2. Automatically build the TensorRT engine for your GPU architecture if it does not already exist.\n",
+    "3. Load the model and prepare it for inference.\n",
+    "4. Run a simple text generation example to verify everything is working.\n",
+    "\n",
+    "**Note**: The first run may take several minutes as it downloads the model and builds the engine.\n",
+    "Subsequent runs will be much faster, as the engine will be cached."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm = LLM(model=\"openai/gpt-oss-20b\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prompts = [\"Hello, my name is\", \"The capital of France is\"]\n",
+    "sampling_params = SamplingParams(temperature=0.8, top_p=0.95)\n",
+    "for output in llm.generate(prompts, sampling_params):\n",
+    "    print(f\"Prompt: {output.prompt!r}, Generated text: {output.outputs[0].text!r}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Conclusion and Next Steps\n",
+    "Congratulations! You have successfully optimized and run a large language model using the TensorRT-LLM Python API.\n",
+    "\n",
+    "In this notebook, you have learned how to:\n",
+    "- Set up your environment with the necessary dependencies.\n",
+    "- Use the `tensorrt_llm.LLM` API to download a model from the Hugging Face Hub.\n",
+    "- Automatically build a high-performance TensorRT engine tailored to your GPU.\n",
+    "- Run inference with the optimized model.\n",
+    "\n",
+    "\n",
+    "You can explore more advanced features to further improve performance and efficiency:\n",
+    "\n",
+    "- Benchmarking: Try running a [benchmark](https://nvidia.github.io/TensorRT-LLM/performance/performance-tuning-guide/benchmarking-default-performance.html#benchmarking-with-trtllm-bench) to compare the latency and throughput of the TensorRT-LLM engine against the original Hugging Face model. You can do this by iterating over a larger number of prompts and measuring the execution time.\n",
+    "\n",
+    "- Quantization: TensorRT-LLM [supports](https://github.com/NVIDIA/TensorRT-Model-Optimizer) various quantization techniques (like INT8 or FP8) to reduce model size and accelerate inference with minimal impact on accuracy. This is a powerful feature for deploying models on resource-constrained hardware.\n",
+    "\n",
+    "- Deploy with NVIDIA Dynamo: For production environments, you can deploy your TensorRT-LLM engine using the [NVIDIA Dynamo](https://docs.nvidia.com/dynamo/latest/) for robust, scalable, and multi-model serving.\n",
+    "\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/authors.yaml b/authors.yaml
index d84aa18f87..46d2a95fbe 100644
--- a/authors.yaml
+++ b/authors.yaml
@@ -2,6 +2,31 @@
 
 # You can optionally customize how your information shows up cookbook.openai.com over here.
 # If your information is not present here, it will be pulled from your GitHub profile.
+WJPBProjects:
+  name: "Wulfie Bain"
+  website: "https://www.linkedin.com/in/wulfie-bain/"
+  avatar: "https://avatars.githubusercontent.com/u/76624567?v=4"
+
+anoop-openai:
+  name: "Anoop Kotha"
+  website: "https://x.com/anoopkotha"
+  avatar: "https://pbs.twimg.com/profile_images/1953388055190224896/vHZ5CVPs_400x400.jpg"
+
+erinkav-openai:
+  name: "Erin Kavanaugh"
+  website: "https://www.linkedin.com/in/erinkavanaugh/"
+  avatar: "https://media.licdn.com/dms/image/v2/D5603AQFBeFl_GBWRww/profile-displayphoto-scale_400_400/B56ZiCtx6zHcAg-/0/1754539697289?e=1757548800&v=beta&t=e3znvOjyDV9MBdp2AABxGtvdCx1LzyrBR75cjOSh5h8"
+
+ericzakariasson:
+  name: "Eric Zakariasson"
+  website: "https://x.com/ericzakariasson"
+  avatar: "https://pbs.twimg.com/profile_images/1841151626456801283/HnXqy3TQ_400x400.jpg"
+
+jayrodge:
+  name: "Jay Rodge"
+  website: "https://www.linkedin.com/in/jayrodge/"
+  avatar: "https://developer-blogs.nvidia.com/wp-content/uploads/2024/05/Jay-Rodge.png"
+
 rajpathak-openai:
   name: "Raj Pathak"
   website: "https://www.linkedin.com/in/rajpathakopenai/"
@@ -396,3 +421,38 @@ daisyshe-oai:
   name: "Daisy Sheng"
   website: "https://www.linkedin.com/in/daisysheng/"
   avatar: "https://avatars.githubusercontent.com/u/212609991?v=4"
+
+dkundel-openai:
+  name: "Dominik Kundel"
+  website: "https://www.linkedin.com/in/dominik-kundel/"
+  avatar: "https://avatars.githubusercontent.com/u/200841172?v=4"
+
+edbeeching:
+  name: "Edward Beeching"
+  website: "https://huggingface.co/edbeeching"
+  avatar: "https://cdn-avatars.huggingface.co/v1/production/uploads/1644220542819-noauth.jpeg"
+
+qgallouedec:
+  name: "Quentin Gallouédec"
+  website: "https://huggingface.co/qgallouedec"
+  avatar: "https://cdn-avatars.huggingface.co/v1/production/uploads/1677431596830-631ce4b244503b72277fc89f.jpeg"
+
+lewtun:
+  name: "Lewis Tunstall"
+  website: "https://huggingface.co/lewtun"
+  avatar: "https://cdn-avatars.huggingface.co/v1/production/uploads/1594651707950-noauth.jpeg"
+
+pcuenca:
+  name: "Pedro Cuenca"
+  website: "https://huggingface.co/pcuenq"
+  avatar: "https://cdn-avatars.huggingface.co/v1/production/uploads/1617264212503-603d25b75f9d390ab190b777.jpeg"
+
+Vaibhavs10:
+  name: "vb"
+  website: "https://huggingface.co/reach-vb"
+  avatar: "https://cdn-avatars.huggingface.co/v1/production/uploads/1655385361868-61b85ce86eb1f2c5e6233736.jpeg"
+
+yagil:
+  name: "Yagil Burowski"
+  website: "https://x.com/yagilb"
+  avatar: "https://avatars.lmstudio.com/profile-images/yagil"
diff --git a/examples/File_Search_Responses.ipynb b/examples/File_Search_Responses.ipynb
index aaa49f4445..e8e77f12b7 100644
--- a/examples/File_Search_Responses.ipynb
+++ b/examples/File_Search_Responses.ipynb
@@ -13,7 +13,7 @@
     "\n",
     "_File search was previously available on the Assistants API. It's now available on the new Responses API, an API that can be stateful or stateless, and with from new features like metadata filtering_\n",
     "\n",
-    "### Set up"
+    "# Creating Vector Store with our PDFs"
    ]
   },
   {
@@ -52,8 +52,6 @@
    "id": "43e5cb9c-fc99-45e2-bd79-9c9ba5b410cc",
    "metadata": {},
    "source": [
-    "### Creating Vector Store with our PDFs\n",
-    "\n",
     "We will create a Vector Store on OpenAI API and upload our PDFs to the Vector Store. OpenAI will read those PDFs, separate the content into multiple chunks of text, run embeddings on those and store those embeddings and the text in the Vector Store. It will enable us to query this Vector Store to return relevant content based on a query."
    ]
   },
@@ -157,7 +155,7 @@
    "id": "e5f4ade3-2b3e-4df6-a441-c1ee3ea73172",
    "metadata": {},
    "source": [
-    "### Standalone vector search\n",
+    "# Standalone vector search\n",
     "\n",
     "Now that our vector store is ready, we are able to query the Vector Store directly and retrieve relevant content for a specific query. Using the new [vector search API](https://platform.openai.com/docs/api-reference/vector-stores/search), we're able to find relevant items from our knowledge base without necessarily integrating it in an LLM query."
    ]
@@ -211,7 +209,7 @@
    "source": [
     "We can see that different size (and under-the-hood different texts) have been returned from the search query. They all have different relevancy score that are calculated by our ranker which uses hybrid search.\n",
     "\n",
-    "### Integrating search results with LLM in a single API call\n",
+    "# Integrating search results with LLM in a single API call\n",
     "\n",
     "However instead of querying the vector store and then passing the data into the Responses or Chat Completion API call, an even more convenient way to use this search results in an LLM query would be to plug use file_search tool as part of OpenAI Responses API."
    ]
@@ -273,7 +271,7 @@
    "source": [
     "We can see that `gpt-4o-mini` was able to answer a query that required more recent, specialised knowledge about OpenAI's Deep Research. It used content from the file `Introducing deep research _ OpenAI.pdf` that had chunks of texts that were the most relevant. If we want to go even deeper in the analysis of chunk of text retrieved, we can also analyse the different texts that were returned by the search engine by adding `include=[\"output[*].file_search_call.search_results\"]` to our query.\n",
     "\n",
-    "## Evaluating performance\n",
+    "# Evaluating performance\n",
     "\n",
     "What is key for those information retrieval system is to also measure the relevance & quality of files retrieved for those answers. The following steps of this cookbook will consist in generating an evaluation dataset and calculating different metrics over this generated dataset. This is an imperfect approach and we'll always recommend to have a human-verified evaluation dataset for your own use-cases, but it will show you the methodology to evaluate those.  It will be imperfect because some of the questions generated might be generic (e.g: What's said by the main stakeholder in this document) and our retrieval test will have a hard time to figure out which document that question was generated for."
    ]
@@ -283,7 +281,7 @@
    "id": "93291578-d04a-4e71-8ecb-9f0f647e68c3",
    "metadata": {},
    "source": [
-    "### Generating questions\n",
+    "## Generating evaluations\n",
     "\n",
     "We will create functions that will read through the PDFs we have locally and generate a question that can only be answered by this document. Therefore it'll create our evaluation dataset that we can use after."
    ]
@@ -431,6 +429,8 @@
    "id": "dbda554b-c3d4-4b07-9028-b41670c2fa20",
    "metadata": {},
    "source": [
+    "## Evaluating\n",
+    "\n",
     "We'll convert our dictionary into a dataframe and process it using gpt-4o-mini. We will look out for the expected file "
    ]
   },
diff --git a/examples/Generate_Images_With_High_Input_Fidelity.ipynb b/examples/Generate_Images_With_High_Input_Fidelity.ipynb
index fe4de9bdd0..a6db906a1d 100644
--- a/examples/Generate_Images_With_High_Input_Fidelity.ipynb
+++ b/examples/Generate_Images_With_High_Input_Fidelity.ipynb
@@ -102,9 +102,7 @@
     "Example use cases:\n",
     "- **Item edits:** Change isolated elements (e.g., swap a mug color) while leaving everything else untouched.\n",
     "- **Element removal:** Cleanly remove an isolated element without changing the rest of the picture.\n",
-    "- **Element addition:** Seamlessly insert new objects into a scene.\n",
-    "\n",
-    "Note that the example outputs below are resized and compressed, hence there is a slight difference in quality compared to the "
+    "- **Element addition:** Seamlessly insert new objects into a scene."
    ]
   },
   {
@@ -913,7 +911,7 @@
    "id": "f946b293",
    "metadata": {},
    "source": [
-    "In this cookbook, we covered how to enable high input fidelity to better preserve important visual details from input images.\n",
+    "In this guide, we covered how to enable high input fidelity to better preserve important visual details from input images.\n",
     "\n",
     "Use the example use cases above as inspiration, and try the parameter with your own images to see where high input fidelity makes the biggest difference.\n",
     "\n",
diff --git a/examples/Optimize_Prompts.ipynb b/examples/Optimize_Prompts.ipynb
index 2600c81669..b87bf5fe87 100644
--- a/examples/Optimize_Prompts.ipynb
+++ b/examples/Optimize_Prompts.ipynb
@@ -390,11 +390,10 @@
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {},
-   "outputs": [],
    "source": [
+    "```\n",
     "[\n",
     "  {\n",
     "    \"focus\": \"contradiction_issues\",\n",
@@ -408,7 +407,7 @@
     "      ]\n",
     "    },\n",
     "    \"golden_output\": {\n",
-    "      \"changes\": True,\n",
+    "      \"changes\": true,\n",
     "      \"new_developer_message\": \"Always answer **in English**.\",\n",
     "      \"new_messages\": [\n",
     "        {\n",
@@ -446,7 +445,7 @@
     "      ]\n",
     "    },\n",
     "    \"golden_output\": {\n",
-    "      \"changes\": True,\n",
+    "      \"changes\": true,\n",
     "      \"new_developer_message\": \"Respond with **only** the single word \\\"yes\\\" or \\\"no\\\".\",\n",
     "      \"new_messages\": [\n",
     "        {\n",
@@ -472,7 +471,8 @@
     "      \"general_improvements\": \"\"\n",
     "    }\n",
     "  }\n",
-    "]"
+    "]\n",
+    "```"
    ]
   },
   {
diff --git a/examples/evaluation/use-cases/EvalsAPI_Image_Inputs.ipynb b/examples/evaluation/use-cases/EvalsAPI_Image_Inputs.ipynb
index 12a65e5efc..4f95bdfa23 100644
--- a/examples/evaluation/use-cases/EvalsAPI_Image_Inputs.ipynb
+++ b/examples/evaluation/use-cases/EvalsAPI_Image_Inputs.ipynb
@@ -174,7 +174,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "For our testing criteria, we set up our grader config. In this example, it is a model grader that takes in an image, reference answer, and sampled model response (in the `sample` namespace), and then outputs a score between 0 and 1 based on how closely the model response matches the reference answer and its general suitability for the conversation. For more info on model graders, visit [API Grader docs](hhttps://platform.openai.com/docs/api-reference/graders). \n",
+    "For our testing criteria, we set up our grader config. In this example, it is a model grader that takes in an image, reference answer, and sampled model response (in the `sample` namespace), and then outputs a score between 0 and 1 based on how closely the model response matches the reference answer and its general suitability for the conversation. For more info on model graders, visit [API Grader docs](https://platform.openai.com/docs/api-reference/graders). \n",
     "\n",
     "Getting the both the data and the grader right are key for an effective evaluation. So, you will likely want to iteratively refine the prompts for your graders. "
    ]
@@ -245,7 +245,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "To create the run, we pass in the eval object id, the data source (i.e., the data we compiled earlier), and the chat message input we will use for sampling to generate the model response. While we won't dive into it in this cookbook, EvalsAPI also supports stored completions containing images as a data source. \n",
+    "To create the run, we pass in the eval object id, the data source (i.e., the data we compiled earlier), and the chat message input we will use for sampling to generate the model response. Note that EvalsAPI also supports stored completions and responses containing images as a data source. See the [Additional Info: Logs Data Source](#additional-info-logs-data-source) section for more info.\n",
     "\n",
     "Here's the sampling message input we'll use for this example."
    ]
@@ -509,6 +509,22 @@
     "print(json.dumps(dict(first_item), indent=2, default=str))"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Additional Info: Logs Data Source\n",
+    "\n",
+    "As mentioned earlier, EvalsAPI supports logs (i.e., stored completions or responses) containing images as a data source. To use this functionality, change your eval configurations as follows: \n",
+    "\n",
+    "Eval Creation\n",
+    "  - set `data_source_config = { \"type\": \"logs\" }`\n",
+    "  - revise templating in `grader_config` to use `{{item.input}}` and/or `{{sample.output_text}}`, denoting the input and output of the log\n",
+    "\n",
+    "Eval Run Creation\n",
+    "  - specify the filters in the `data_source` field that will be used to obtain the corresponding logs for the eval run (see the [docs](https://platform.openai.com/docs/api-reference/evals/createRun) for more information)"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
diff --git a/examples/gpt-5/apply_patch.py b/examples/gpt-5/apply_patch.py
new file mode 100644
index 0000000000..a0df143095
--- /dev/null
+++ b/examples/gpt-5/apply_patch.py
@@ -0,0 +1,483 @@
+from enum import Enum
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+class ActionType(str, Enum):
+    ADD = "add"
+    DELETE = "delete"
+    UPDATE = "update"
+
+
+class FileChange(BaseModel):
+    type: ActionType
+    old_content: Optional[str] = None
+    new_content: Optional[str] = None
+    move_path: Optional[str] = None
+
+
+class Commit(BaseModel):
+    changes: dict[str, FileChange] = Field(default_factory=dict)
+
+
+def assemble_changes(orig: dict[str, Optional[str]], dest: dict[str, Optional[str]]) -> Commit:
+    commit = Commit()
+    for path in sorted(set(orig.keys()).union(dest.keys())):
+        old_content = orig.get(path)
+        new_content = dest.get(path)
+        if old_content != new_content:
+            if old_content is not None and new_content is not None:
+                commit.changes[path] = FileChange(
+                    type=ActionType.UPDATE,
+                    old_content=old_content,
+                    new_content=new_content,
+                )
+            elif new_content:
+                commit.changes[path] = FileChange(
+                    type=ActionType.ADD,
+                    new_content=new_content,
+                )
+            elif old_content:
+                commit.changes[path] = FileChange(
+                    type=ActionType.DELETE,
+                    old_content=old_content,
+                )
+            else:
+                assert False
+    return commit
+
+
+from pydantic import BaseModel, Field
+
+
+class Chunk(BaseModel):
+    orig_index: int = -1  # line index of the first line in the original file
+    del_lines: list[str] = Field(default_factory=list)
+    ins_lines: list[str] = Field(default_factory=list)
+
+
+class PatchAction(BaseModel):
+    type: ActionType
+    new_file: Optional[str] = None
+    chunks: list[Chunk] = Field(default_factory=list)
+    move_path: Optional[str] = None
+
+
+class Patch(BaseModel):
+    actions: dict[str, PatchAction] = Field(default_factory=dict)
+
+
+from pydantic import BaseModel, Field
+
+
+class Parser(BaseModel):
+    current_files: dict[str, str] = Field(default_factory=dict)
+    lines: list[str] = Field(default_factory=list)
+    index: int = 0
+    patch: Patch = Field(default_factory=Patch)
+    fuzz: int = 0
+
+    def is_done(self, prefixes: Optional[tuple[str, ...]] = None) -> bool:
+        if self.index >= len(self.lines):
+            return True
+        if prefixes and self.lines[self.index].startswith(prefixes):
+            return True
+        return False
+
+    def startswith(self, prefix: Optional[tuple[str, ...]]) -> bool:
+        assert self.index < len(self.lines), f"Index: {self.index} >= {len(self.lines)}"
+        if self.lines[self.index].startswith(prefix):
+            return True
+        return False
+
+    def read_str(self, prefix: str = "", return_everything: bool = False) -> str:
+        assert self.index < len(self.lines), f"Index: {self.index} >= {len(self.lines)}"
+        if self.lines[self.index].startswith(prefix):
+            if return_everything:
+                text = self.lines[self.index]
+            else:
+                text = self.lines[self.index][len(prefix) :]
+            self.index += 1
+            return text
+        return ""
+
+    def parse(self):
+        while not self.is_done(("*** End Patch",)):
+            path = self.read_str("*** Update File: ")
+            if path:
+                if path in self.patch.actions:
+                    raise DiffError(f"Update File Error: Duplicate Path: {path}")
+                move_to = self.read_str("*** Move to: ")
+                if path not in self.current_files:
+                    raise DiffError(f"Update File Error: Missing File: {path}")
+                text = self.current_files[path]
+                action = self.parse_update_file(text)
+                # TODO: Check move_to is valid
+                action.move_path = move_to
+                self.patch.actions[path] = action
+                continue
+            path = self.read_str("*** Delete File: ")
+            if path:
+                if path in self.patch.actions:
+                    raise DiffError(f"Delete File Error: Duplicate Path: {path}")
+                if path not in self.current_files:
+                    raise DiffError(f"Delete File Error: Missing File: {path}")
+                self.patch.actions[path] = PatchAction(
+                    type=ActionType.DELETE,
+                )
+                continue
+            path = self.read_str("*** Add File: ")
+            if path:
+                if path in self.patch.actions:
+                    raise DiffError(f"Add File Error: Duplicate Path: {path}")
+                self.patch.actions[path] = self.parse_add_file()
+                continue
+            raise DiffError(f"Unknown Line: {self.lines[self.index]}")
+        if not self.startswith("*** End Patch"):
+            raise DiffError("Missing End Patch")
+        self.index += 1
+
+    def parse_update_file(self, text: str) -> PatchAction:
+        # self.lines / self.index refers to the patch
+        # lines / index refers to the file being modified
+        # print("parse update file")
+        action = PatchAction(
+            type=ActionType.UPDATE,
+        )
+        lines = text.split("\n")
+        index = 0
+        while not self.is_done(
+            (
+                "*** End Patch",
+                "*** Update File:",
+                "*** Delete File:",
+                "*** Add File:",
+                "*** End of File",
+            )
+        ):
+            def_str = self.read_str("@@ ")
+            section_str = ""
+            if not def_str:
+                if self.lines[self.index] == "@@":
+                    section_str = self.lines[self.index]
+                    self.index += 1
+            if not (def_str or section_str or index == 0):
+                raise DiffError(f"Invalid Line:\n{self.lines[self.index]}")
+            if def_str.strip():
+                found = False
+                if not [s for s in lines[:index] if s == def_str]:
+                    # def str is a skip ahead operator
+                    for i, s in enumerate(lines[index:], index):
+                        if s == def_str:
+                            # print(f"Jump ahead @@: {index} -> {i}: {def_str}")
+                            index = i + 1
+                            found = True
+                            break
+                if not found and not [s for s in lines[:index] if s.strip() == def_str.strip()]:
+                    # def str is a skip ahead operator
+                    for i, s in enumerate(lines[index:], index):
+                        if s.strip() == def_str.strip():
+                            # print(f"Jump ahead @@: {index} -> {i}: {def_str}")
+                            index = i + 1
+                            self.fuzz += 1
+                            found = True
+                            break
+            next_chunk_context, chunks, end_patch_index, eof = peek_next_section(
+                self.lines, self.index
+            )
+            next_chunk_text = "\n".join(next_chunk_context)
+            new_index, fuzz = find_context(lines, next_chunk_context, index, eof)
+            if new_index == -1:
+                if eof:
+                    raise DiffError(f"Invalid EOF Context {index}:\n{next_chunk_text}")
+                else:
+                    raise DiffError(f"Invalid Context {index}:\n{next_chunk_text}")
+            self.fuzz += fuzz
+            # print(f"Jump ahead: {index} -> {new_index}")
+            for ch in chunks:
+                ch.orig_index += new_index
+                action.chunks.append(ch)
+            index = new_index + len(next_chunk_context)
+            self.index = end_patch_index
+            continue
+        return action
+
+    def parse_add_file(self) -> PatchAction:
+        lines = []
+        while not self.is_done(
+            ("*** End Patch", "*** Update File:", "*** Delete File:", "*** Add File:")
+        ):
+            s = self.read_str()
+            if not s.startswith("+"):
+                raise DiffError(f"Invalid Add File Line: {s}")
+            s = s[1:]
+            lines.append(s)
+        return PatchAction(
+            type=ActionType.ADD,
+            new_file="\n".join(lines),
+        )
+
+
+def find_context_core(lines: list[str], context: list[str], start: int) -> tuple[int, int]:
+    if not context:
+        print("context is empty")
+        return start, 0
+
+    # Prefer identical
+    for i in range(start, len(lines)):
+        if lines[i : i + len(context)] == context:
+            return i, 0
+    # RStrip is ok
+    for i in range(start, len(lines)):
+        if [s.rstrip() for s in lines[i : i + len(context)]] == [s.rstrip() for s in context]:
+            return i, 1
+    # Fine, Strip is ok too.
+    for i in range(start, len(lines)):
+        if [s.strip() for s in lines[i : i + len(context)]] == [s.strip() for s in context]:
+            return i, 100
+    return -1, 0
+
+
+def find_context(lines: list[str], context: list[str], start: int, eof: bool) -> tuple[int, int]:
+    if eof:
+        new_index, fuzz = find_context_core(lines, context, len(lines) - len(context))
+        if new_index != -1:
+            return new_index, fuzz
+        new_index, fuzz = find_context_core(lines, context, start)
+        return new_index, fuzz + 10000
+    return find_context_core(lines, context, start)
+
+
+def peek_next_section(lines: list[str], index: int) -> tuple[list[str], list[Chunk], int, bool]:
+    old: list[str] = []
+    del_lines: list[str] = []
+    ins_lines: list[str] = []
+    chunks: list[Chunk] = []
+    mode = "keep"
+    orig_index = index
+    while index < len(lines):
+        s = lines[index]
+        if s.startswith(
+            (
+                "@@",
+                "*** End Patch",
+                "*** Update File:",
+                "*** Delete File:",
+                "*** Add File:",
+                "*** End of File",
+            )
+        ):
+            break
+        if s == "***":
+            break
+        elif s.startswith("***"):
+            raise DiffError(f"Invalid Line: {s}")
+        index += 1
+        last_mode = mode
+        if s == "":
+            s = " "
+        if s[0] == "+":
+            mode = "add"
+        elif s[0] == "-":
+            mode = "delete"
+        elif s[0] == " ":
+            mode = "keep"
+        else:
+            raise DiffError(f"Invalid Line: {s}")
+        s = s[1:]
+        if mode == "keep" and last_mode != mode:
+            if ins_lines or del_lines:
+                chunks.append(
+                    Chunk(
+                        orig_index=len(old) - len(del_lines),
+                        del_lines=del_lines,
+                        ins_lines=ins_lines,
+                    )
+                )
+            del_lines = []
+            ins_lines = []
+        if mode == "delete":
+            del_lines.append(s)
+            old.append(s)
+        elif mode == "add":
+            ins_lines.append(s)
+        elif mode == "keep":
+            old.append(s)
+    if ins_lines or del_lines:
+        chunks.append(
+            Chunk(
+                orig_index=len(old) - len(del_lines),
+                del_lines=del_lines,
+                ins_lines=ins_lines,
+            )
+        )
+        del_lines = []
+        ins_lines = []
+    if index < len(lines) and lines[index] == "*** End of File":
+        index += 1
+        return old, chunks, index, True
+    if index == orig_index:
+        raise DiffError(f"Nothing in this section - {index=} {lines[index]}")
+    return old, chunks, index, False
+
+
+def text_to_patch(text: str, orig: dict[str, str]) -> tuple[Patch, int]:
+    lines = text.strip().split("\n")
+    if len(lines) < 2 or not lines[0].startswith("*** Begin Patch") or lines[-1] != "*** End Patch":
+        raise DiffError("Invalid patch text")
+
+    parser = Parser(
+        current_files=orig,
+        lines=lines,
+        index=1,
+    )
+    parser.parse()
+    return parser.patch, parser.fuzz
+
+
+def identify_files_needed(text: str) -> list[str]:
+    lines = text.strip().split("\n")
+    result = set()
+    for line in lines:
+        if line.startswith("*** Update File: "):
+            result.add(line[len("*** Update File: ") :])
+        if line.startswith("*** Delete File: "):
+            result.add(line[len("*** Delete File: ") :])
+    return list(result)
+
+
+def _get_updated_file(text: str, action: PatchAction, path: str) -> str:
+    assert action.type == ActionType.UPDATE
+    orig_lines = text.split("\n")
+    dest_lines = []
+    orig_index = 0
+    dest_index = 0
+    for chunk in action.chunks:
+        # Process the unchanged lines before the chunk
+        if chunk.orig_index > len(orig_lines):
+            print(
+                f"_get_updated_file: {path}: chunk.orig_index {chunk.orig_index} > len(lines) {len(orig_lines)}"
+            )
+            raise DiffError(
+                f"_get_updated_file: {path}: chunk.orig_index {chunk.orig_index} > len(lines) {len(orig_lines)}"
+            )
+        if orig_index > chunk.orig_index:
+            raise DiffError(
+                f"_get_updated_file: {path}: orig_index {orig_index} > chunk.orig_index {chunk.orig_index}"
+            )
+        assert orig_index <= chunk.orig_index
+        dest_lines.extend(orig_lines[orig_index : chunk.orig_index])
+        delta = chunk.orig_index - orig_index
+        orig_index += delta
+        dest_index += delta
+        # Process the inserted lines
+        if chunk.ins_lines:
+            for i in range(len(chunk.ins_lines)):
+                dest_lines.append(chunk.ins_lines[i])
+            dest_index += len(chunk.ins_lines)
+        orig_index += len(chunk.del_lines)
+    # Final part
+    dest_lines.extend(orig_lines[orig_index:])
+    delta = len(orig_lines) - orig_index
+    orig_index += delta
+    dest_index += delta
+    assert orig_index == len(orig_lines)
+    assert dest_index == len(dest_lines)
+    return "\n".join(dest_lines)
+
+
+def patch_to_commit(patch: Patch, orig: dict[str, str]) -> Commit:
+    commit = Commit()
+    for path, action in patch.actions.items():
+        if action.type == ActionType.DELETE:
+            commit.changes[path] = FileChange(type=ActionType.DELETE, old_content=orig[path])
+        elif action.type == ActionType.ADD:
+            commit.changes[path] = FileChange(type=ActionType.ADD, new_content=action.new_file)
+        elif action.type == ActionType.UPDATE:
+            new_content = _get_updated_file(text=orig[path], action=action, path=path)
+            commit.changes[path] = FileChange(
+                type=ActionType.UPDATE,
+                old_content=orig[path],
+                new_content=new_content,
+                move_path=action.move_path,
+            )
+    return commit
+
+
+class DiffError(ValueError):
+    pass
+
+
+import os
+from typing import Callable
+
+
+def load_files(paths: list[str], open_fn: Callable) -> dict[str, str]:
+    orig = {}
+    for path in paths:
+        orig[path] = open_fn(path)
+    return orig
+
+
+def apply_commit(commit: Commit, write_fn: Callable, remove_fn: Callable) -> None:
+    for path, change in commit.changes.items():
+        if change.type == ActionType.DELETE:
+            remove_fn(path)
+        elif change.type == ActionType.ADD:
+            write_fn(path, change.new_content)
+        elif change.type == ActionType.UPDATE:
+            if change.move_path:
+                write_fn(change.move_path, change.new_content)
+                remove_fn(path)
+            else:
+                write_fn(path, change.new_content)
+
+
+def process_patch(text: str, open_fn: Callable, write_fn: Callable, remove_fn: Callable) -> str:
+    assert text.startswith("*** Begin Patch")
+    paths = identify_files_needed(text)
+    orig = load_files(paths, open_fn)
+    patch, fuzz = text_to_patch(text, orig)
+    commit = patch_to_commit(patch, orig)
+    apply_commit(commit, write_fn, remove_fn)
+    return "Done!"
+
+
+def open_file(path: str) -> str:
+    with open(path, "rt") as f:
+        return f.read()
+
+
+def write_file(path: str, content: str) -> None:
+    if path.startswith("/"):
+        print("We do not support absolute paths.")
+        return
+    if "/" in path:
+        parent = "/".join(path.split("/")[:-1])
+        os.makedirs(parent, exist_ok=True)
+    with open(path, "wt") as f:
+        f.write(content)
+
+
+def remove_file(path: str) -> None:
+    os.remove(path)
+
+
+def main():
+    import sys
+
+    patch_text = sys.stdin.read()
+    if not patch_text:
+        print("Please pass patch text through stdin")
+        return
+    try:
+        result = process_patch(patch_text, open_file, write_file, remove_file)
+    except DiffError as e:
+        print(str(e))
+        return
+    print(result)
+
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/examples/gpt-5/gpt-5_frontend.ipynb b/examples/gpt-5/gpt-5_frontend.ipynb
new file mode 100644
index 0000000000..383d0b2a59
--- /dev/null
+++ b/examples/gpt-5/gpt-5_frontend.ipynb
@@ -0,0 +1,371 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "a83efdb6",
+   "metadata": {},
+   "source": [
+    "# Frontend with GPT-5\n",
+    "\n",
+    "GPT-5 is a large leap forward in frontend development. We have seen the model be excellent at developing full stack applications in one shot, making complex refactors look easy, and making surgical edits within large codebases. \n",
+    "\n",
+    "In this cookbook we will show some examples and some learnings of developing frontend applications with GPT-5 across multiple axes. \n",
+    "\n",
+    "## Intro\n",
+    "There are some general principles we have seen be effective in developing strong frontend applications. We share some of these learnings in the [prompt guide](https://cookbook.openai.com/examples/gpt-5/gpt-5_prompting_guide). Below are some important pieces to consider when building frontend applications.\n",
+    "\n",
+    "Here are libraries and packages we recommend to start with steering the model:\n",
+    "- Frameworks: Next.js (TypeScript), React, HTML\n",
+    "- Styling / UI: Tailwind CSS, shadcn/ui, Radix Themes\n",
+    "- Icons: Material Symbols, Heroicons, Lucide\n",
+    "- Animation: Motion\n",
+    "- Fonts: San Serif, Inter, Geist, Mona Sans, IBM Plex Sans, Manrope\n",
+    "\n",
+    "These packages are not an exhaustive list and we have seen many different application styles. \n",
+    "\n",
+    "Below you'll find an easy way to iterate over frontend abstractions on the API. We’re excited to see how users can unlock creativity with GPT-5.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1c2168a3",
+   "metadata": {},
+   "source": [
+    "## Interactive Example\n",
+    "\n",
+    "Let's dive into an example of creating frontends from scratch. First let's create some help functions to see the generated websites from GPT-5."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "194e6566",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import re\n",
+    "import webbrowser\n",
+    "from pathlib import Path\n",
+    "\n",
+    "import openai\n",
+    "from openai.types.responses import ResponseInputParam\n",
+    "\n",
+    "client = openai.OpenAI()\n",
+    "\n",
+    "\n",
+    "def get_response_output_text(input: str | ResponseInputParam):\n",
+    "    \n",
+    "    response = client.responses.create(\n",
+    "        model=\"gpt-5\",\n",
+    "        input=input,\n",
+    "    )\n",
+    "    return response.output_text\n",
+    "\n",
+    "\n",
+    "def extract_html_from_text(text: str):\n",
+    "    \"\"\"Extract an HTML code block from text; fallback to first code block, else full text.\"\"\"\n",
+    "    html_block = re.search(r\"```html\\s*(.*?)\\s*```\", text, re.DOTALL | re.IGNORECASE)\n",
+    "    if html_block:\n",
+    "        result = html_block.group(1)\n",
+    "        return result\n",
+    "    any_block = re.search(r\"```\\s*(.*?)\\s*```\", text, re.DOTALL)\n",
+    "    if any_block:\n",
+    "        result = any_block.group(1)\n",
+    "        return result\n",
+    "    return text\n",
+    "\n",
+    "\n",
+    "def save_html(html: str, filename: str) -> Path:\n",
+    "    \"\"\"Save HTML to outputs/ directory and return the path.\"\"\"\n",
+    "    try:\n",
+    "        base_dir = Path(__file__).parent\n",
+    "    except NameError:\n",
+    "        base_dir = Path.cwd()\n",
+    "\n",
+    "    folder = \"outputs\"\n",
+    "    outputs_dir = base_dir / folder\n",
+    "    outputs_dir.mkdir(parents=True, exist_ok=True)\n",
+    "\n",
+    "    output_path = outputs_dir / filename\n",
+    "    output_path.write_text(html, encoding=\"utf-8\")\n",
+    "    return output_path\n",
+    "\n",
+    "def open_in_browser(path: Path) -> None:\n",
+    "    \"\"\"Open a file in the default browser (macOS compatible).\"\"\"\n",
+    "    try:\n",
+    "        webbrowser.open(path.as_uri())\n",
+    "    except Exception:\n",
+    "        os.system(f'open \"{path}\"')\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6aee99e6",
+   "metadata": {},
+   "source": [
+    "Now, let's combine the above into one helper function."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "8bb59cc7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def make_website_and_open_in_browser(*, website_input: str | ResponseInputParam, filename: str = \"website.html\"):\n",
+    "    response_text = get_response_output_text(website_input)\n",
+    "    html = extract_html_from_text(response_text)\n",
+    "    output_path = save_html(html, filename)\n",
+    "    open_in_browser(output_path)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "17e785bc",
+   "metadata": {},
+   "source": [
+    "We'll start with a simple example: one-shot building a retro gaming store with the right theme"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "a597c44a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "get_response: finished\n",
+      "extract_html_from_text: finished (raw text)\n",
+      "save_html: finished -> outputs/retro_dark.html\n",
+      "open_in_browser: finished\n"
+     ]
+    }
+   ],
+   "source": [
+    "make_website_and_open_in_browser(\n",
+    "    website_input=\"Make me landing page for a retro-games store. Retro-arcade noir some might say\",\n",
+    "    filename=\"retro_dark.html\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "65153df1",
+   "metadata": {},
+   "source": [
+    "Not bad for a one line, one shot prompt!\n",
+    "\n",
+    "<img src=\"../../images/retro_dark.png\" style=\"width:60vw; display:block; margin:auto;\">\n",
+    "\n",
+    "\n",
+    "Now let's steer it to be lighter, and a bit softer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "84228036",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "get_response: finished\n",
+      "extract_html_from_text: finished (raw text)\n",
+      "save_html: finished -> outputs/retro_light.html\n",
+      "open_in_browser: finished\n"
+     ]
+    }
+   ],
+   "source": [
+    "make_website_and_open_in_browser(\n",
+    "    website_input=\"Make me landing page for a retro-games store. Make it light, more pastel coloured & flowery (think Mario, not cyberpunk)\", \n",
+    "    filename=\"retro_light.html\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d2cc44f0",
+   "metadata": {},
+   "source": [
+    "As you can see GPT-5 is incredibly steerable - with just a one line you can change entire applications effortlessly\n",
+    "\n",
+    "<img src=\"../../images/retro_light.png\" style=\"width:60vw; display:block; margin:auto;\">"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6ffde671",
+   "metadata": {},
+   "source": [
+    "But what if you have existing website designs that you want to make additions to? For example, we already have this dashboard.\n",
+    "\n",
+    "<img src=\"../../images/input_image.png\" style=\"width:60vw; display:block; margin:auto;\">\n",
+    "\n",
+    "Since GPT-5 is natively multimodal and accepts both image and text input, when you are generating frontend applications we can take advantage of image input to improve model performance. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "24aa52f0",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "get_response: finished\n",
+      "extract_html_from_text: finished (raw text)\n",
+      "save_html: finished -> outputs/login_page.html\n",
+      "open_in_browser: finished\n"
+     ]
+    }
+   ],
+   "source": [
+    "import base64\n",
+    "from openai.types.responses import ResponseInputImageParam\n",
+    "\n",
+    "# Function to encode the image\n",
+    "def encode_image(image_path: str):\n",
+    "    with open(image_path, \"rb\") as image_file:\n",
+    "        return base64.b64encode(image_file.read()).decode(\"utf-8\")\n",
+    "\n",
+    "image_path=\"../../images/input_image.png\"\n",
+    "encoded_image = encode_image(image_path)\n",
+    "input_image: ResponseInputImageParam = {\"type\": \"input_image\", \"image_url\": f\"data:image/png;base64,{encoded_image}\", \"detail\": \"auto\"}\n",
+    "input: ResponseInputParam = [\n",
+    "    {\n",
+    "        \"role\": \"user\",\n",
+    "        \"content\": [\n",
+    "            {\"type\": \"input_text\", \"text\": \"Can you make a login page for this website that maintains the same theme\"},\n",
+    "            input_image,\n",
+    "        ],\n",
+    "    }\n",
+    "]\n",
+    "\n",
+    "make_website_and_open_in_browser(\n",
+    "    website_input=input, \n",
+    "    filename=\"login_page.html\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "93dcda0b",
+   "metadata": {},
+   "source": [
+    "As you can see, GPT-5 does an incredible job of matching the existing style & vibe of the app.\n",
+    "\n",
+    "<img src=\"../../images/login_page.png\" style=\"width:60vw; display:block; margin:auto;\">"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "352f57b9",
+   "metadata": {},
+   "source": [
+    "So far this has been pretty static - let's try a more interactive task"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "a1f80a93",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "get_response: finished\n",
+      "extract_html_from_text: finished (raw text)\n",
+      "save_html: finished -> outputs/snake_game.html\n",
+      "open_in_browser: finished\n"
+     ]
+    }
+   ],
+   "source": [
+    "make_website_and_open_in_browser(\n",
+    "    website_input=\"Make me a snake game. It should be futuristic, neon, cyberpunk style. Make sure the typography is suitably cool.\", \n",
+    "    filename=\"snake_game.html\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fc11b7b2",
+   "metadata": {},
+   "source": [
+    "We've got a theme consistent snake game: matching colours, typography, and even sound\n",
+    "\n",
+    "<img src=\"../../images/snake_game.png\" style=\"width:60vw; display:block; margin:auto;\">"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6274e5f9",
+   "metadata": {},
+   "source": [
+    "We hope this has given some ideas of how powerful GPT-5 is at frontend. From a single underspecified prompt and API call, we get production grade outputs. \n",
+    "\n",
+    "Now it's your turn - we can't wait to see what you'll build"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "935abf26",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "get_response: finished\n",
+      "extract_html_from_text: finished (raw text)\n",
+      "save_html: finished -> outputs/your_website.html\n",
+      "open_in_browser: finished\n"
+     ]
+    }
+   ],
+   "source": [
+    "your_prompt = \"[edit this! what website would you like to build?]\"\n",
+    "\n",
+    "make_website_and_open_in_browser(\n",
+    "    website_input=your_prompt, \n",
+    "    filename=\"your_website.html\"\n",
+    ")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "openai",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/gpt-5/gpt-5_new_params_and_tools.ipynb b/examples/gpt-5/gpt-5_new_params_and_tools.ipynb
new file mode 100644
index 0000000000..b9dc8ac806
--- /dev/null
+++ b/examples/gpt-5/gpt-5_new_params_and_tools.ipynb
@@ -0,0 +1,1387 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "b3def15a",
+   "metadata": {},
+   "source": [
+    "#  GPT-5 New Params and Tools\n",
+    "\n",
+    "We’re introducing new developer controls in the GPT-5 series that give you greater control over model responses—from shaping output length and style to enforcing strict formatting. Below is a quick overview of the latest features:\n",
+    "\n",
+    "\n",
+    "| #  | Feature | Overview | Values / Usage |\n",
+    "|----|---------|----------|----------------|\n",
+    "| 1. | **Verbosity Parameter** | Lets you hint the model to be more or less expansive in its replies. Keep prompts stable and use the parameter instead of re-writing. | • **low** → terse UX, minimal prose.<br>• **medium** *(default)* → balanced detail.<br>• **high** → verbose, great for audits, teaching, or hand-offs. |\n",
+    "| 2. | **Freeform Function Calling** | Generate raw text payloads—anything from Python scripts to SQL queries—directly to your custom tool without JSON wrapping. Offers greater flexibility for external runtimes like:<br>• Code sandboxes (Python, C++, Java, …)<br>• SQL databases<br>• Shell environments<br>• Config generators | Use when structured JSON isn’t needed and raw text is more natural for the target tool. |\n",
+    "| 3. | **Context-Free Grammar (CFG)** | A set of production rules defining valid strings in a language. Each rule rewrites a non-terminal into terminals and/or other non-terminals, independent of surrounding context. Useful for constraining output to match the syntax of programming languages or custom formats in OpenAI tools. | Use as a contract to ensure the model emits only valid strings accepted by the grammar. |\n",
+    "| 4. | **Minimal Reasoning** | Runs GPT-5 with few or no reasoning tokens to minimize latency and speed time-to-first-token. Ideal for deterministic, lightweight tasks (extraction, formatting, short rewrites, simple classification) where explanations aren’t needed. If not specified, effort defaults to medium. | Set reasoning effort: \"minimal\". Avoid for multi-step planning or tool-heavy workflows. |\n",
+    "\n",
+    "\n",
+    "**Supported Models:**  \n",
+    "- gpt-5  \n",
+    "- gpt-5-mini  \n",
+    "- gpt-5-nano  \n",
+    "\n",
+    "**Supported API Endpoints** \n",
+    "- Responses API \n",
+    "- Chat Completions API \n",
+    "\n",
+    "Note: We recommend to use Responses API with GPT-5 series of model to get the most performance out of the models. \n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cbeb1c44",
+   "metadata": {},
+   "source": [
+    "## Prerequisites \n",
+    "\n",
+    "Let's begin with updating your OpenAI SDK that supports the new params and tools for GPT-5. Make sure you've set OPENAI_API_KEY as an environment variable. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "9850c90d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "openai 1.99.2\n",
+      "pandas 2.3.1\n"
+     ]
+    }
+   ],
+   "source": [
+    "!pip install --quiet --upgrade openai pandas && \\\n",
+    "echo -n \"openai \" && pip show openai | grep '^Version:' | cut -d' ' -f2 && \\\n",
+    "echo -n \"pandas \" && pip show pandas | grep '^Version:' | cut -d' ' -f2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "04d6bc80",
+   "metadata": {},
+   "source": [
+    "## 1. Verbosity Parameter \n",
+    "\n",
+    "### 1.1 Overview \n",
+    "The verbosity parameter lets you hint the model to be more or less expansive in its replies.   \n",
+    "\n",
+    "**Values:** \"low\", \"medium\", \"high\"\n",
+    "\n",
+    "- low → terse UX, minimal prose.\n",
+    "- medium (default) → balanced detail.\n",
+    "- high → verbose, great for audits, teaching, or hand-offs.\n",
+    "\n",
+    "Keep prompts stable and use the param rather than re-writing.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "d5260af8",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<style type=\"text/css\">\n",
+       "#T_50bc1 th {\n",
+       "  text-align: center;\n",
+       "}\n",
+       "#T_50bc1 td {\n",
+       "  text-align: left;\n",
+       "}\n",
+       "</style>\n",
+       "<table id=\"T_50bc1\">\n",
+       "  <thead>\n",
+       "    <tr>\n",
+       "      <th class=\"blank level0\" >&nbsp;</th>\n",
+       "      <th id=\"T_50bc1_level0_col0\" class=\"col_heading level0 col0\" >Verbosity</th>\n",
+       "      <th id=\"T_50bc1_level0_col1\" class=\"col_heading level0 col1\" >Sample Output</th>\n",
+       "      <th id=\"T_50bc1_level0_col2\" class=\"col_heading level0 col2\" >Output Tokens</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th id=\"T_50bc1_level0_row0\" class=\"row_heading level0 row0\" >0</th>\n",
+       "      <td id=\"T_50bc1_row0_col0\" class=\"data row0 col0\" >low</td>\n",
+       "      <td id=\"T_50bc1_row0_col1\" class=\"data row0 col1\" >He found a scruff of fur behind the shed one spring afternoon,\n",
+       "a heartbeat small and fast beneath a coat of dust and light.\n",
+       "The world shrank to two—mud on sneakers, a wag, a clumsy tune—\n",
+       "names rolled off his tongue like marbles, simple, sure, and bright.\n",
+       "\n",
+       "They learned the map of each other's hands: the scratch beneath the ear,\n",
+       "the way a storm could change the shape of brave into a shake.\n",
+       "Mornings were for toast and sunlight, afternoons for running near\n",
+       "the riverbank where leaves applauded every leap they'd take.\n",
+       "\n",
+       "At night they shared a blanket and the secret of the dark,\n",
+       "the boy with whispered stories, the dog with steady breath.\n",
+       "Years braided into footprints—first skinned knees, then a spark\n",
+       "of barnyard gray upon a muzzle, slow and gentle as a wreath.\n",
+       "\n",
+       "When time unlatched its gates, the boy still carried small things:\n",
+       "a collar, a chewed shoe, the echo of a bark that taught him how to hope.\n",
+       "He learned that love can look like leaving crumbs of ordinary kings,\n",
+       "and that some firsts fit in your pockets long after they have gone.</td>\n",
+       "      <td id=\"T_50bc1_row0_col2\" class=\"data row0 col2\" >560</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th id=\"T_50bc1_level0_row1\" class=\"row_heading level0 row1\" >1</th>\n",
+       "      <td id=\"T_50bc1_row1_col0\" class=\"data row1 col0\" >medium</td>\n",
+       "      <td id=\"T_50bc1_row1_col1\" class=\"data row1 col1\" >He found him folded in the crook of a cardboard box,\n",
+       "a tiny ribcage hitching like a thought.\n",
+       "The boy had pockets full of pennies and promises;\n",
+       "the dog had eyes like two small questions.\n",
+       "\n",
+       "They learned names together — the boy said one,\n",
+       "the dog tilted his head and accepted it.\n",
+       "Mornings were clumsy lessons: leash in hand,\n",
+       "the dog discovering sidewalks with a sneeze of wonder,\n",
+       "the boy discovering courage at the end of a rope.\n",
+       "\n",
+       "They chased afternoons into puddles,\n",
+       "mud kissing the boy's knees and the dog's whiskers.\n",
+       "The dog taught him how to throw sticks that never came back\n",
+       "and how to forgive them when they didn't.\n",
+       "Evenings were for quiet conspiracies:\n",
+       "the dog's breath a warm punctuation\n",
+       "against the boy's ankle as the sky grew blue-black.\n",
+       "\n",
+       "Homework became a small island between their worlds,\n",
+       "a pencil, a pat, the faithful presence of paws on carpet.\n",
+       "The dog learned how to sit for apples,\n",
+       "how to hide a cold nose under a blanket of fingers.\n",
+       "The boy learned how to stitch up a torn stuffed bear,\n",
+       "how to say sorry and mean it.\n",
+       "\n",
+       "There were days of thunder when the boy's knees knocked,\n",
+       "and the dog, all stern responsibility, pressed his head\n",
+       "into the hollow of the boy's fear and held it there\n",
+       "as if he could anchor lightning with his chin.\n",
+       "\n",
+       "They practiced being brave together: doors opened for new schools,\n",
+       "new roads, a first bike without training wheels,\n",
+       "the dog a steady metronome of tail and warmth,\n",
+       "never asking to be anything but present.\n",
+       "\n",
+       "Seasons unraveled the way they always do.\n",
+       "Snow came to lay white questions across the yard;\n",
+       "summer stretched its lazy hands and left grass bleaching in August.\n",
+       "The boy grew taller and later, the dog moved slower,\n",
+       "but in late afternoons they still shared the same light —\n",
+       "a private currency of sun and shadow.\n",
+       "\n",
+       "When the boy learned the language of goodbyes,\n",
+       "it was the dog who taught him how to soften them.\n",
+       "A last look, a lingering hand across the coat,\n",
+       "and a promise that out of all the small ordinary days\n",
+       "something invincible had been braided:\n",
+       "two hearts, a leash, a map of pawprints on the threshold.\n",
+       "\n",
+       "Years later, the boy — now grown — tucks a photograph\n",
+       "into his coat pocket. He feels the hollow\n",
+       "where a warm head used to rest and smiles.\n",
+       "Some bonds refuse to be folded away.\n",
+       "In the quiet hum of rememberings,\n",
+       "he can still hear a collar's jingle and a small, glad bark:\n",
+       "first home, first friend, first forever.</td>\n",
+       "      <td id=\"T_50bc1_row1_col2\" class=\"data row1 col2\" >849</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th id=\"T_50bc1_level0_row2\" class=\"row_heading level0 row2\" >2</th>\n",
+       "      <td id=\"T_50bc1_row2_col0\" class=\"data row2 col0\" >high</td>\n",
+       "      <td id=\"T_50bc1_row2_col1\" class=\"data row2 col1\" >The day the boy met his dog the world grew wider—\n",
+       "a small breath of fur and a damp, earnest nose\n",
+       "pressed like a secret against his palm.\n",
+       "They stood on the porch and the sun tilted curious,\n",
+       "as if the sky had come to see how two new things\n",
+       "might fit together.\n",
+       "\n",
+       "He named him after a comic-strip hero,\n",
+       "or maybe he didn’t name him at all at first,\n",
+       "just laughed and let the sound of it become a name.\n",
+       "They learned each other’s weight: the dog’s heavy joy,\n",
+       "the boy’s thin, cautious fingers turning into hands\n",
+       "that could hold a leaping heart steady.\n",
+       "\n",
+       "Mornings became a chorus of paws and cereal,\n",
+       "of a collar’s jingle and the scrape of a chair.\n",
+       "Homework survived only when the dog approved;\n",
+       "math problems were beneath a wagging tail,\n",
+       "spelling tests punctuated by a slobbering vowel.\n",
+       "They hid secrets under the bed, between dust bunnies,\n",
+       "and shared the small, perfect conspiracy of being alive.\n",
+       "\n",
+       "Afternoons were a map of adventures: the cracked sidewalk,\n",
+       "the river that smelled like stones and moss, the hill\n",
+       "where the wind felt like permission to run.\n",
+       "The dog learned to fetch sticks and forgotten courage,\n",
+       "and the boy learned that bravery could be soft\n",
+       "as a warm head on a lap, or loud as a bark that scares away thunder.\n",
+       "\n",
+       "Summer taught them both how long the day could be.\n",
+       "They chased shadows and each other, made small rules:\n",
+       "no digging in the tulips, no chasing the mailman,\n",
+       "except that the tulips never stood a chance.\n",
+       "The boy’s knees collected stories—scrapes that healed,\n",
+       "dirt that stained his socks but not his smile.\n",
+       "The dog’s ears learned the cadence of the boy’s breath,\n",
+       "the way it tipped into sleep like a boat finding harbor.\n",
+       "\n",
+       "Years folded like worn pages. The boy got taller,\n",
+       "his voice snagged on words he used to swallow.\n",
+       "School took afternoons; friends took phone numbers.\n",
+       "Still, the dog found ways to be a country in which the boy could disappear\n",
+       "and always be found again—on the porch, by the back door,\n",
+       "where a tail thumped the rhythm of home.\n",
+       "\n",
+       "Time comes like winter in slow increments.\n",
+       "The dog’s muzzle silvered; his steps remembered caution.\n",
+       "He stopped fitting into the spaces he once owned\n",
+       "and learned to ask for rest. The boy—no longer quite a boy—\n",
+       "sat longer, tracing the map of every scar and whiskered gray.\n",
+       "There were nights when the dog’s breathing was a thin, honest drum,\n",
+       "and the boy pressed his forehead to the dog’s and said things out loud:\n",
+       "I am here. You were right. You showed me how.\n",
+       "\n",
+       "The last morning was quiet in the way that endings often are:\n",
+       "a light that does not need to hurry, a sky that keeps its blue.\n",
+       "Hands that had once been small bore the weight of goodbye,\n",
+       "and the dog, who had taught him everything about leaving,\n",
+       "went gentle as a story closing.\n",
+       "\n",
+       "They buried a bone under the apple tree, where shade remembered them.\n",
+       "At dusk the boy—grown, with work-worn hands and a child’s memory—\n",
+       "watches the place where grass leans toward the earth and listens.\n",
+       "Once, when the house was exactly the same and yet not,\n",
+       "he swore he heard a soft, familiar jangle in the kitchen,\n",
+       "a rhythm of steps padding toward the door.\n",
+       "For a beat the world tilted back to the way it had been:\n",
+       "porch light, collar, laughter spilling like coins into a pocket.\n",
+       "\n",
+       "Years will teach you how to be without the body of what you loved,\n",
+       "but they cannot unteach the shape of its love.\n",
+       "In small things he carries the dog—an old ball behind the shed,\n",
+       "the smell of rain when it hits hot dust, the way loyalty sits\n",
+       "like a warm stone under the ribs. Sometimes, at night,\n",
+       "he still calls out a name the way you call to the ocean:\n",
+       "to feel a voice come back, immediate and soft,\n",
+       "and remember the simple miracle of being chosen.\n",
+       "\n",
+       "A first dog is a first map of how to love:\n",
+       "fur on your sleeve, the sound of feet that always come home.\n",
+       "He taught a boy how to stand steady under weather,\n",
+       "how to be brave by being kind, and how to keep a place warm.\n",
+       "If you listen, sometimes the past still answers,\n",
+       "with a jingle, a wag, and the echo of a small, perfect breath.</td>\n",
+       "      <td id=\"T_50bc1_row2_col2\" class=\"data row2 col2\" >1288</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n"
+      ],
+      "text/plain": [
+       "<pandas.io.formats.style.Styler at 0x10b50fa10>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from openai import OpenAI\n",
+    "import pandas as pd\n",
+    "from IPython.display import display\n",
+    "\n",
+    "client = OpenAI()\n",
+    "\n",
+    "question = \"Write a poem about a boy and his first pet dog.\"\n",
+    "\n",
+    "data = []\n",
+    "\n",
+    "for verbosity in [\"low\", \"medium\", \"high\"]:\n",
+    "    response = client.responses.create(\n",
+    "        model=\"gpt-5-mini\",\n",
+    "        input=question,\n",
+    "        text={\"verbosity\": verbosity}\n",
+    "    )\n",
+    "\n",
+    "    # Extract text\n",
+    "    output_text = \"\"\n",
+    "    for item in response.output:\n",
+    "        if hasattr(item, \"content\"):\n",
+    "            for content in item.content:\n",
+    "                if hasattr(content, \"text\"):\n",
+    "                    output_text += content.text\n",
+    "\n",
+    "    usage = response.usage\n",
+    "    data.append({\n",
+    "        \"Verbosity\": verbosity,\n",
+    "        \"Sample Output\": output_text,\n",
+    "        \"Output Tokens\": usage.output_tokens\n",
+    "    })\n",
+    "\n",
+    "# Create DataFrame\n",
+    "df = pd.DataFrame(data)\n",
+    "\n",
+    "# Display nicely with centered headers\n",
+    "pd.set_option('display.max_colwidth', None)\n",
+    "styled_df = df.style.set_table_styles(\n",
+    "    [\n",
+    "        {'selector': 'th', 'props': [('text-align', 'center')]},  # Center column headers\n",
+    "        {'selector': 'td', 'props': [('text-align', 'left')]}     # Left-align table cells\n",
+    "    ]\n",
+    ")\n",
+    "\n",
+    "display(styled_df)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "07fdb759",
+   "metadata": {},
+   "source": [
+    "The output tokens scale roughly linearly with verbosity: low (560) → medium (849) → high (1288)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "19b2e969",
+   "metadata": {},
+   "source": [
+    "### 2.3 Using Verbosity for Coding Use Cases \n",
+    "\n",
+    "The verbosity parameter also influences the length and complexity of generated code, as well as the depth of accompanying explanations. Here's an example, wherein we use various verboisty levels for a task to generate a Python program that sorts an array of 1000000 random numbers. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "aa6b6b12",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "--------------------------------\n",
+      "Verbosity: low\n",
+      "Output:\n",
+      "```python\n",
+      "#!/usr/bin/env python3\n",
+      "import random\n",
+      "import time\n",
+      "\n",
+      "def main():\n",
+      "    N = 1_000_000\n",
+      "    arr = [random.random() for _ in range(N)]\n",
+      "\n",
+      "    t0 = time.perf_counter()\n",
+      "    arr.sort()\n",
+      "    t1 = time.perf_counter()\n",
+      "\n",
+      "    print(f\"Sorted {N} numbers in {t1 - t0:.4f} seconds\")\n",
+      "    print(\"First 10:\", arr[:10])\n",
+      "    print(\"Last 10:\", arr[-10:])\n",
+      "\n",
+      "if __name__ == \"__main__\":\n",
+      "    main()\n",
+      "```\n",
+      "Tokens => input: 21 | output: 575\n"
+     ]
+    }
+   ],
+   "source": [
+    "from openai import OpenAI\n",
+    "\n",
+    "client = OpenAI()\n",
+    "\n",
+    "prompt = \"Output a Python program that sorts an array of 1000000 random numbers\"\n",
+    "\n",
+    "def ask_with_verbosity(verbosity: str, question: str):\n",
+    "    response = client.responses.create(\n",
+    "        model=\"gpt-5-mini\",\n",
+    "        input=question,\n",
+    "        text={\n",
+    "            \"verbosity\": verbosity\n",
+    "        }\n",
+    "    )\n",
+    "\n",
+    "    # Extract assistant's text output\n",
+    "    output_text = \"\"\n",
+    "    for item in response.output:\n",
+    "        if hasattr(item, \"content\"):\n",
+    "            for content in item.content:\n",
+    "                if hasattr(content, \"text\"):\n",
+    "                    output_text += content.text\n",
+    "\n",
+    "    # Token usage details\n",
+    "    usage = response.usage\n",
+    "\n",
+    "    print(\"--------------------------------\")\n",
+    "    print(f\"Verbosity: {verbosity}\")\n",
+    "    print(\"Output:\")\n",
+    "    print(output_text)\n",
+    "    print(\"Tokens => input: {} | output: {}\".format(\n",
+    "        usage.input_tokens, usage.output_tokens\n",
+    "    ))\n",
+    "\n",
+    "\n",
+    "# Example usage:\n",
+    "ask_with_verbosity(\"low\", prompt)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7a741167",
+   "metadata": {},
+   "source": [
+    "Notice that the code output is a plain script. Now, lets run with 'medium' "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "d2efe2d7",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "--------------------------------\n",
+      "Verbosity: medium\n",
+      "Output:\n",
+      "Here's a simple Python script that generates 1,000,000 random numbers, sorts them using the built-in Timsort, and reports timings and a small sample of the sorted output:\n",
+      "\n",
+      "```python\n",
+      "#!/usr/bin/env python3\n",
+      "import random\n",
+      "import time\n",
+      "\n",
+      "def main():\n",
+      "    N = 1_000_000\n",
+      "    random.seed(42)  # remove or change for different runs\n",
+      "\n",
+      "    t0 = time.perf_counter()\n",
+      "    data = [random.random() for _ in range(N)]\n",
+      "    t1 = time.perf_counter()\n",
+      "\n",
+      "    data.sort()\n",
+      "    t2 = time.perf_counter()\n",
+      "\n",
+      "    # Basic verification and sample output\n",
+      "    is_sorted = all(data[i] <= data[i+1] for i in range(len(data)-1))\n",
+      "    print(f\"Generated {N} random numbers in {t1 - t0:.3f} seconds\")\n",
+      "    print(f\"Sorted in {t2 - t1:.3f} seconds\")\n",
+      "    print(\"Sorted check:\", is_sorted)\n",
+      "    print(\"First 10 values:\", data[:10])\n",
+      "    print(\"Last 10 values:\", data[-10:])\n",
+      "\n",
+      "if __name__ == \"__main__\":\n",
+      "    main()\n",
+      "```\n",
+      "\n",
+      "Notes:\n",
+      "- This uses Python's built-in list sort (Timsort), which is efficient for general-purpose sorting.\n",
+      "- If you need more memory- and performance-efficient numeric operations on large arrays, consider using NumPy (numpy.random.random and numpy.sort).\n",
+      "Tokens => input: 21 | output: 943\n"
+     ]
+    }
+   ],
+   "source": [
+    "ask_with_verbosity(\"medium\", prompt)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fa48bbeb",
+   "metadata": {},
+   "source": [
+    "Medium verboisty, generated richer code with additioanl explanations. Let's do the same with high. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "4f92fb12",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "--------------------------------\n",
+      "Verbosity: high\n",
+      "Output:\n",
+      "Here's a single, self-contained Python program that generates 1,000,000 random numbers and sorts them. It supports two backends: the built-in Python list sort (Timsort) and NumPy (if you have NumPy installed). It measures and prints the time taken for generation, sorting, and verification.\n",
+      "\n",
+      "Copy the code into a file (for example sort_random.py) and run it. By default it uses the pure Python backend; pass --backend numpy to use NumPy.\n",
+      "\n",
+      "Note: Sorting a million Python floats uses a moderate amount of memory (Python floats and list overhead). NumPy will typically be faster and use less overhead but requires the numpy package.\n",
+      "\n",
+      "Program:\n",
+      "\n",
+      "import time\n",
+      "import random\n",
+      "import argparse\n",
+      "import sys\n",
+      "\n",
+      "def is_sorted_list(a):\n",
+      "    # Linear check for sortedness\n",
+      "    return all(a[i] <= a[i+1] for i in range(len(a)-1))\n",
+      "\n",
+      "def main():\n",
+      "    parser = argparse.ArgumentParser(description=\"Generate and sort random numbers.\")\n",
+      "    parser.add_argument(\"--n\", type=int, default=1_000_000, help=\"Number of random numbers (default: 1,000,000)\")\n",
+      "    parser.add_argument(\"--backend\", choices=[\"python\", \"numpy\"], default=\"python\",\n",
+      "                        help=\"Sorting backend to use: 'python' (default) or 'numpy'\")\n",
+      "    parser.add_argument(\"--seed\", type=int, default=0, help=\"Random seed (default: 0)\")\n",
+      "    parser.add_argument(\"--sample\", type=int, default=10, help=\"How many sample elements to print (default: 10)\")\n",
+      "    args = parser.parse_args()\n",
+      "\n",
+      "    n = args.n\n",
+      "    backend = args.backend\n",
+      "    seed = args.seed\n",
+      "    sample = args.sample\n",
+      "\n",
+      "    print(f\"Generating {n:,} random numbers using backend: {backend!r}, seed={seed}\")\n",
+      "\n",
+      "    random.seed(seed)\n",
+      "\n",
+      "    if backend == \"python\":\n",
+      "        # Generate list of floats in Python\n",
+      "        t0 = time.perf_counter()\n",
+      "        data = [random.random() for _ in range(n)]\n",
+      "        t1 = time.perf_counter()\n",
+      "        gen_time = t1 - t0\n",
+      "        print(f\"Generated {n:,} numbers in {gen_time:.4f} s\")\n",
+      "\n",
+      "        if sample > 0:\n",
+      "            print(\"Sample before sort:\", data[:sample])\n",
+      "\n",
+      "        # Sort in-place\n",
+      "        t0 = time.perf_counter()\n",
+      "        data.sort()\n",
+      "        t1 = time.perf_counter()\n",
+      "        sort_time = t1 - t0\n",
+      "        print(f\"Sorted {n:,} numbers in {sort_time:.4f} s (Python list.sort)\")\n",
+      "\n",
+      "        if sample > 0:\n",
+      "            print(\"Sample after sort: \", data[:sample])\n",
+      "\n",
+      "        # Verify sortedness\n",
+      "        t0 = time.perf_counter()\n",
+      "        ok = is_sorted_list(data)\n",
+      "        t1 = time.perf_counter()\n",
+      "        verify_time = t1 - t0\n",
+      "        print(f\"Verified sortedness in {verify_time:.4f} s -> {'OK' if ok else 'NOT SORTED'}\")\n",
+      "\n",
+      "    else:  # numpy backend\n",
+      "        try:\n",
+      "            import numpy as np\n",
+      "        except ImportError:\n",
+      "            print(\"NumPy is not installed. Install it with 'pip install numpy' or use the python backend.\")\n",
+      "            sys.exit(1)\n",
+      "\n",
+      "        # Use the new Generator API for reproducible generation\n",
+      "        rng = np.random.default_rng(seed)\n",
+      "        t0 = time.perf_counter()\n",
+      "        data = rng.random(n)  # numpy array of floats\n",
+      "        t1 = time.perf_counter()\n",
+      "        gen_time = t1 - t0\n",
+      "        print(f\"Generated {n:,} numbers in {gen_time:.4f} s (NumPy)\")\n",
+      "\n",
+      "        if sample > 0:\n",
+      "            print(\"Sample before sort:\", data[:sample])\n",
+      "\n",
+      "        # Sort in-place using NumPy's sort\n",
+      "        t0 = time.perf_counter()\n",
+      "        data.sort()  # in-place quicksort/mergesort (NumPy chooses default)\n",
+      "        t1 = time.perf_counter()\n",
+      "        sort_time = t1 - t0\n",
+      "        print(f\"Sorted {n:,} numbers in {sort_time:.4f} s (NumPy sort)\")\n",
+      "\n",
+      "        if sample > 0:\n",
+      "            print(\"Sample after sort: \", data[:sample])\n",
+      "\n",
+      "        # Verify sortedness\n",
+      "        t0 = time.perf_counter()\n",
+      "        ok = np.all(np.diff(data) >= 0)\n",
+      "        t1 = time.perf_counter()\n",
+      "        verify_time = t1 - t0\n",
+      "        print(f\"Verified sortedness in {verify_time:.4f} s -> {'OK' if ok else 'NOT SORTED'}\")\n",
+      "\n",
+      "    print(\"Done.\")\n",
+      "\n",
+      "if __name__ == \"__main__\":\n",
+      "    main()\n",
+      "\n",
+      "Usage examples:\n",
+      "- Pure Python (default):\n",
+      "  python sort_random.py\n",
+      "\n",
+      "- NumPy backend (if installed):\n",
+      "  python sort_random.py --backend numpy\n",
+      "\n",
+      "- Use a different size:\n",
+      "  python sort_random.py --n 500000\n",
+      "\n",
+      "Notes and tips:\n",
+      "- Pure Python uses random.random in a list comprehension, then list.sort(). Sorting a list of 1,000,000 Python floats is quite feasible but uses more memory than a NumPy array because of Python object overhead.\n",
+      "- NumPy's random generation and sorting are implemented in C and are typically much faster and more memory efficient for large numeric arrays.\n",
+      "- You can change the seed to get different random sequences, or omit seed for non-deterministic results.\n",
+      "- If you plan to sort data that doesn't fit in memory, consider external sorting approaches (merge sort with chunking to disk) or use specialized libraries.\n",
+      "Tokens => input: 21 | output: 2381\n"
+     ]
+    }
+   ],
+   "source": [
+    "ask_with_verbosity(\"high\", prompt)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "68bac4a4",
+   "metadata": {},
+   "source": [
+    "High verbosity yielded additional details and explanations. \n",
+    "\n",
+    "### 1.3 Takeaways \n",
+    "\n",
+    "The new verbosity parameter reliably scales both the length and depth of the model’s output while preserving correctness and reasoning quality - **without changing the underlying prompt**.\n",
+    "In this example:\n",
+    "\n",
+    "- **Low verbosity** produces a minimal, functional script with no extra comments or structure.\n",
+    "- **Medium verbosity** adds explanatory comments, function structure, and reproducibility controls.\n",
+    "- **High verbosity** yields a comprehensive, production-ready script with argument parsing, multiple sorting methods, timing/verification, usage notes, and best-practice tips."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "331aae97",
+   "metadata": {},
+   "source": [
+    "## 2. Free‑Form Function Calling\n",
+    "\n",
+    "### 2.1 Overview \n",
+    "GPT‑5 can now send raw text payloads - anything from Python scripts to SQL queries - to your custom tool without wrapping the data in JSON using the new tool `\"type\": \"custom\"`. This differs from classic structured function calls, giving you greater flexibility when interacting with external runtimes such as:\n",
+    "\n",
+    "- code_exec with sandboxes (Python, C++, Java, …)\n",
+    "- SQL databases\n",
+    "- Shell environments\n",
+    "- Configuration generators\n",
+    "\n",
+    "**Note that custom tool type does NOT support parallel tool calling.**\n",
+    "\n",
+    "### 2.2 Quick Start Example - Compute the Area of a Circle"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3f6d3e73",
+   "metadata": {},
+   "source": [
+    "The code below produces a simple python code to calculate area of a circle, and instruct the model to use the freeform tool call to output the result. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "02d3f9d3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[ResponseReasoningItem(id='rs_6894e31b1f8081999d18325e5aeffcfe0861a2e1728d1664', summary=[], type='reasoning', content=[], encrypted_content=None, status=None), ResponseCustomToolCall(call_id='call_Gnqod2MwPvayp2JdNyA0z0Ah', input='# Counting \\'r\\'s in the word \"strawberry\" and computing circle area with that radius\\nimport math\\nr = \"strawberry\".count(\\'r\\')\\narea = math.pi * r**2\\n{\"radius\": r, \"area\": area, \"area_exact\": f\"{r}*pi\"}', name='code_exec', type='custom_tool_call', id='ctc_6894e31c66f08199abd622bb5ac3c4260861a2e1728d1664', status='completed')]\n"
+     ]
+    }
+   ],
+   "source": [
+    "from openai import OpenAI\n",
+    "\n",
+    "client = OpenAI()\n",
+    "\n",
+    "response = client.responses.create(\n",
+    "    model=\"gpt-5-mini\",\n",
+    "    input=\"Please use the code_exec tool to calculate the area of a circle with radius equal to the number of 'r's in strawberry\",\n",
+    "    text={\"format\": {\"type\": \"text\"}},\n",
+    "    tools=[\n",
+    "        {\n",
+    "            \"type\": \"custom\",\n",
+    "            \"name\": \"code_exec\",\n",
+    "            \"description\": \"Executes arbitrary python code\",\n",
+    "        }\n",
+    "    ]\n",
+    ")\n",
+    "print(response.output)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e63d6a2c",
+   "metadata": {},
+   "source": [
+    "The model emits a `tool call` containing raw Python. You execute that code server‑side, capture the printed result, and send it back in a follow‑up responses.create call."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "44f6c39c",
+   "metadata": {},
+   "source": [
+    "### 2.3 Mini‑Benchmark – Sorting an Array in Three Languages\n",
+    "To illustrate the use of free form tool calling, we will ask GPT‑5 to:\n",
+    "- Generate Python, C++, and Java code that sorts a fixed array 10 times.\n",
+    "- Print only the time (in ms) taken for each iteration in the code. \n",
+    "- Call all three functions, and then stop "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "2e9ca32e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "--- tool name ---\n",
+      "code_exec_python\n",
+      "--- tool call argument (generated code) ---\n",
+      "import time\n",
+      "\n",
+      "arr = [448, 986, 255, 884, 632, 623, 246, 439, 936, 925, 644, 159, 777, 986, 706, 723, 534, 862, 195, 686, 846, 880, 970, 276, 613, 736, 329, 622, 870, 284, 945, 708, 267, 327, 678, 807, 687, 890, 907, 645, 364, 333, 385, 262, 730, 603, 945, 358, 923, 930, 761, 504, 870, 561, 517, 928, 994, 949, 233, 137, 670, 555, 149, 870, 997, 809, 180, 498, 914, 508, 411, 378, 394, 368, 766, 486, 757, 319, 338, 159, 585, 934, 654, 194, 542, 188, 934, 163, 889, 736, 792, 737, 667, 772, 198, 971, 459, 402, 989, 949]\n",
+      "\n",
+      "start = time.perf_counter()\n",
+      "for _ in range(10):\n",
+      "    b = arr[:]  # copy\n",
+      "    b.sort()\n",
+      "elapsed_ms = int((time.perf_counter() - start) * 1000)\n",
+      "print(elapsed_ms, end=\"\")\n",
+      "--- tool name ---\n",
+      "code_exec_cpp\n",
+      "--- tool call argument (generated code) ---\n",
+      "#include <iostream>\n",
+      "#include <vector>\n",
+      "#include <algorithm>\n",
+      "#include <chrono>\n",
+      "using namespace std;\n",
+      "\n",
+      "int main() {\n",
+      "    vector<int> a = {448, 986, 255, 884, 632, 623, 246, 439, 936, 925, 644, 159, 777, 986, 706, 723, 534, 862, 195, 686, 846, 880, 970, 276, 613, 736, 329, 622, 870, 284, 945, 708, 267, 327, 678, 807, 687, 890, 907, 645, 364, 333, 385, 262, 730, 603, 945, 358, 923, 930, 761, 504, 870, 561, 517, 928, 994, 949, 233, 137, 670, 555, 149, 870, 997, 809, 180, 498, 914, 508, 411, 378, 394, 368, 766, 486, 757, 319, 338, 159, 585, 934, 654, 194, 542, 188, 934, 163, 889, 736, 792, 737, 667, 772, 198, 971, 459, 402, 989, 949};\n",
+      "    auto start = chrono::high_resolution_clock::now();\n",
+      "    for (int i = 0; i < 10; ++i) {\n",
+      "        auto b = a;\n",
+      "        sort(b.begin(), b.end());\n",
+      "    }\n",
+      "    auto end = chrono::high_resolution_clock::now();\n",
+      "    auto ms = chrono::duration_cast<chrono::milliseconds>(end - start).count();\n",
+      "    cout << ms;\n",
+      "    return 0;\n",
+      "}\n",
+      "--- tool name ---\n",
+      "code_exec_java\n",
+      "--- tool call argument (generated code) ---\n",
+      "import java.util.*;\n",
+      "public class Main {\n",
+      "    public static void main(String[] args) {\n",
+      "        int[] a = new int[] {448, 986, 255, 884, 632, 623, 246, 439, 936, 925, 644, 159, 777, 986, 706, 723, 534, 862, 195, 686, 846, 880, 970, 276, 613, 736, 329, 622, 870, 284, 945, 708, 267, 327, 678, 807, 687, 890, 907, 645, 364, 333, 385, 262, 730, 603, 945, 358, 923, 930, 761, 504, 870, 561, 517, 928, 994, 949, 233, 137, 670, 555, 149, 870, 997, 809, 180, 498, 914, 508, 411, 378, 394, 368, 766, 486, 757, 319, 338, 159, 585, 934, 654, 194, 542, 188, 934, 163, 889, 736, 792, 737, 667, 772, 198, 971, 459, 402, 989, 949};\n",
+      "        long start = System.nanoTime();\n",
+      "        for (int i = 0; i < 10; i++) {\n",
+      "            int[] b = Arrays.copyOf(a, a.length);\n",
+      "            Arrays.sort(b);\n",
+      "        }\n",
+      "        long elapsedMs = (System.nanoTime() - start) / 1_000_000L;\n",
+      "        System.out.print(elapsedMs);\n",
+      "    }\n",
+      "}\n"
+     ]
+    }
+   ],
+   "source": [
+    "from openai import OpenAI\n",
+    "from typing import List, Optional\n",
+    "\n",
+    "MODEL_NAME = \"gpt-5\"\n",
+    "\n",
+    "# Tools that will be passed to every model invocation. They are defined once so\n",
+    "# that the configuration lives in a single place.\n",
+    "TOOLS = [\n",
+    "    {\n",
+    "        \"type\": \"custom\",\n",
+    "        \"name\": \"code_exec_python\",\n",
+    "        \"description\": \"Executes python code\",\n",
+    "    },\n",
+    "    {\n",
+    "        \"type\": \"custom\",\n",
+    "        \"name\": \"code_exec_cpp\",\n",
+    "        \"description\": \"Executes c++ code\",\n",
+    "    },\n",
+    "    {\n",
+    "        \"type\": \"custom\",\n",
+    "        \"name\": \"code_exec_java\",\n",
+    "        \"description\": \"Executes java code\",\n",
+    "    },\n",
+    "]\n",
+    "\n",
+    "client = OpenAI()\n",
+    "\n",
+    "def create_response(\n",
+    "    input_messages: List[dict],\n",
+    "    previous_response_id: Optional[str] = None,\n",
+    "):\n",
+    "    \"\"\"Wrapper around ``client.responses.create``.\n",
+    "\n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    input_messages: List[dict]\n",
+    "        The running conversation history to feed to the model.\n",
+    "    previous_response_id: str | None\n",
+    "        Pass the ``response.id`` from the *previous* call so the model can keep\n",
+    "        the thread of the conversation.  Omit on the very first request.\n",
+    "    \"\"\"\n",
+    "    kwargs = {\n",
+    "        \"model\": MODEL_NAME,\n",
+    "        \"input\": input_messages,\n",
+    "        \"text\": {\"format\": {\"type\": \"text\"}},\n",
+    "        \"tools\": TOOLS,\n",
+    "    }\n",
+    "    if previous_response_id:\n",
+    "        kwargs[\"previous_response_id\"] = previous_response_id\n",
+    "\n",
+    "    return client.responses.create(**kwargs)\n",
+    "\n",
+    "# Recursive \n",
+    "def run_conversation(\n",
+    "    input_messages: List[dict],\n",
+    "    previous_response_id: Optional[str] = None,\n",
+    "):\n",
+    "  \n",
+    "    response = create_response(input_messages, previous_response_id)\n",
+    "\n",
+    "    # ``response.output`` is expected to be a list where element 0 is the model\n",
+    "    # message.  Element 1 (if present) denotes a tool call.  When the model is\n",
+    "    # done with tool calls, that element is omitted.\n",
+    "    tool_call = response.output[1] if len(response.output) > 1 else None\n",
+    "\n",
+    "    if tool_call and tool_call.type == \"custom_tool_call\":\n",
+    "        print(\"--- tool name ---\")\n",
+    "        print(tool_call.name)\n",
+    "        print(\"--- tool call argument (generated code) ---\")\n",
+    "        print(tool_call.input)\n",
+    "        \n",
+    "        # Add a synthetic *tool result* so the model can continue the thread.\n",
+    "        \n",
+    "        input_messages.append(\n",
+    "            {\n",
+    "                \"type\": \"function_call_output\",\n",
+    "                \"call_id\": tool_call.call_id,\n",
+    "                \"output\": \"done\", # <-- replace with the result of the tool call\n",
+    "            }\n",
+    "        )\n",
+    "\n",
+    "        # Recurse with updated conversation and track the response id so the\n",
+    "        # model is aware of the prior turn.\n",
+    "        return run_conversation(input_messages, previous_response_id=response.id)\n",
+    "    else:\n",
+    "        # Base-case: no further tool call - return. \n",
+    "        return \n",
+    "\n",
+    "\n",
+    "prompt = \"\"\"\n",
+    "Write code to sort the array of numbers in three languages: C++, Python and Java (10 times each)using code_exec functions.\n",
+    "\n",
+    "ALWAYS CALL THESE THREE FUNCTIONS EXACTLY ONCE: code_exec_python, code_exec_cpp and code_exec_java tools to sort the array in each language. Stop once you've called these three functions in each language once.\n",
+    "\n",
+    "Print only the time it takes to sort the array in milliseconds. \n",
+    "\n",
+    "[448, 986, 255, 884, 632, 623, 246, 439, 936, 925, 644, 159, 777, 986, 706, 723, 534, 862, 195, 686, 846, 880, 970, 276, 613, 736, 329, 622, 870, 284, 945, 708, 267, 327, 678, 807, 687, 890, 907, 645, 364, 333, 385, 262, 730, 603, 945, 358, 923, 930, 761, 504, 870, 561, 517, 928, 994, 949, 233, 137, 670, 555, 149, 870, 997, 809, 180, 498, 914, 508, 411, 378, 394, 368, 766, 486, 757, 319, 338, 159, 585, 934, 654, 194, 542, 188, 934, 163, 889, 736, 792, 737, 667, 772, 198, 971, 459, 402, 989, 949]\n",
+    "\"\"\"\n",
+    "\n",
+    "# Initial developer message.\n",
+    "messages = [\n",
+    "    {\n",
+    "        \"role\": \"developer\",\n",
+    "        \"content\": prompt,\n",
+    "    }\n",
+    "]\n",
+    "\n",
+    "run_conversation(messages)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "146ffea8",
+   "metadata": {},
+   "source": [
+    "The model output three code blocks in Python, C++ and Java for the same algorithm. The output of the function call was chained back into the model as input to allow model to keep going until all the functions have been called exactly once. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "12057763",
+   "metadata": {},
+   "source": [
+    "### 2.4 Takeaways \n",
+    "\n",
+    "Freeform tool calling in GPT-5 lets you send raw text payloads—such as Python scripts, SQL queries, or config files—directly to custom tools without JSON wrapping. This provides greater flexibility for interacting with external runtimes and allows the model to generate code or text in the exact format your tool expects. It’s ideal when structured JSON is unnecessary and natural text output improves usability."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e99fc436",
+   "metadata": {},
+   "source": [
+    "## 3. Context‑Free Grammar (CFG)\n",
+    "\n",
+    "### 3.1 Overview \n",
+    "A context‑free grammar is a collection of production rules that define which strings belong to a language. Each rule rewrites a non‑terminal symbol into a sequence of terminals (literal tokens) and/or other non‑terminals, independent of surrounding context—hence context‑free. CFGs can capture the syntax of most programming languages and, in OpenAI custom tools, serve as contracts that force the model to emit only strings that the grammar accepts.\n",
+    "\n",
+    "### 3.2 Grammar Fundamentals\n",
+    "\n",
+    "**Supported Grammar Syntax** \n",
+    "- Lark - https://lark-parser.readthedocs.io/en/stable/\n",
+    "- Regex - https://docs.rs/regex/latest/regex/#syntax\n",
+    "\n",
+    "We use LLGuidance under the hood to constrain model sampling: https://github.com/guidance-ai/llguidance.\n",
+    "\n",
+    "**Unsupported Lark Features** \n",
+    "- Lookaround in regexes (`(?=...)`, `(?!...)`, etc.)\n",
+    "- Lazy modifier (`*?`, `+?`, `??`) in regexes.\n",
+    "- Terminal priorities, templates, %declares, %import (except %import common).\n",
+    "\n",
+    "\n",
+    "**Terminals vs Rules & Greedy Lexing** \n",
+    "\n",
+    "| Concept          | Take-away                                                                    |\n",
+    "|------------------|------------------------------------------------------------------------------|\n",
+    "| Terminals (UPPER)| Matched first by the lexer – longest match wins.                             |\n",
+    "| Rules (lower)    | Combine terminals; cannot influence how text is tokenised.                   |\n",
+    "| Greedy lexer     | Never try to “shape” free text across multiple terminals – you’ll lose control. |\n",
+    "\n",
+    "** Correct vs Incorrect Pattern Design\n",
+    "\n",
+    "✅ **One bounded terminal handles free‑text between anchors**  \n",
+    "start: SENTENCE  \n",
+    "SENTENCE: /[A-Za-z, ]*(the hero|a dragon)[A-Za-z, ]*(fought|saved)[A-Za-z, ]*(a treasure|the kingdom)[A-Za-z, ]*\\./  \n",
+    "\n",
+    "❌ **Don’t split free‑text across multiple terminals/rules**  \n",
+    "start: sentence  \n",
+    "sentence: /[A-Za-z, ]+/ subject /[A-Za-z, ]+/ verb /[A-Za-z, ]+/ object /[A-Za-z, ]+/  \n",
+    "\n",
+    "\n",
+    "### 3.3 Example - SQL Dialect — MS SQL vs PostgreSQL\n",
+    "\n",
+    "The following code example is now the canonical reference for building multi‑dialect SQL tools with CFGs. It demonstrates:\n",
+    "\n",
+    "- Two isolated grammar definitions (`mssql_grammar_definition`, `postgres_grammar_definition`) encoding TOP vs LIMIT semantics.\n",
+    "- How to prompt, invoke, and inspect tool calls in a single script.\n",
+    "- A side‑by‑side inspection of the assistant’s responses."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d7b27f06",
+   "metadata": {},
+   "source": [
+    "Define the LARK grammars for different SQL dialects"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "c6e7f843",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import textwrap\n",
+    "\n",
+    "# ----------------- grammars for MS SQL dialect -----------------\n",
+    "mssql_grammar = textwrap.dedent(r\"\"\"\n",
+    "            // ---------- Punctuation & operators ----------\n",
+    "            SP: \" \"\n",
+    "            COMMA: \",\"\n",
+    "            GT: \">\"\n",
+    "            EQ: \"=\"\n",
+    "            SEMI: \";\"\n",
+    "\n",
+    "            // ---------- Start ----------\n",
+    "            start: \"SELECT\" SP \"TOP\" SP NUMBER SP select_list SP \"FROM\" SP table SP \"WHERE\" SP amount_filter SP \"AND\" SP date_filter SP \"ORDER\" SP \"BY\" SP sort_cols SEMI\n",
+    "\n",
+    "            // ---------- Projections ----------\n",
+    "            select_list: column (COMMA SP column)*\n",
+    "            column: IDENTIFIER\n",
+    "\n",
+    "            // ---------- Tables ----------\n",
+    "            table: IDENTIFIER\n",
+    "\n",
+    "            // ---------- Filters ----------\n",
+    "            amount_filter: \"total_amount\" SP GT SP NUMBER\n",
+    "            date_filter: \"order_date\" SP GT SP DATE\n",
+    "\n",
+    "            // ---------- Sorting ----------\n",
+    "            sort_cols: \"order_date\" SP \"DESC\"\n",
+    "\n",
+    "            // ---------- Terminals ----------\n",
+    "            IDENTIFIER: /[A-Za-z_][A-Za-z0-9_]*/\n",
+    "            NUMBER: /[0-9]+/\n",
+    "            DATE: /'[0-9]{4}-[0-9]{2}-[0-9]{2}'/\n",
+    "    \"\"\")\n",
+    "\n",
+    "# ----------------- grammars for PostgreSQL dialect -----------------\n",
+    "postgres_grammar = textwrap.dedent(r\"\"\"\n",
+    "            // ---------- Punctuation & operators ----------\n",
+    "            SP: \" \"\n",
+    "            COMMA: \",\"\n",
+    "            GT: \">\"\n",
+    "            EQ: \"=\"\n",
+    "            SEMI: \";\"\n",
+    "\n",
+    "            // ---------- Start ----------\n",
+    "            start: \"SELECT\" SP select_list SP \"FROM\" SP table SP \"WHERE\" SP amount_filter SP \"AND\" SP date_filter SP \"ORDER\" SP \"BY\" SP sort_cols SP \"LIMIT\" SP NUMBER SEMI\n",
+    "\n",
+    "            // ---------- Projections ----------\n",
+    "            select_list: column (COMMA SP column)*\n",
+    "            column: IDENTIFIER\n",
+    "\n",
+    "            // ---------- Tables ----------\n",
+    "            table: IDENTIFIER\n",
+    "\n",
+    "            // ---------- Filters ----------\n",
+    "            amount_filter: \"total_amount\" SP GT SP NUMBER\n",
+    "            date_filter: \"order_date\" SP GT SP DATE\n",
+    "\n",
+    "            // ---------- Sorting ----------\n",
+    "            sort_cols: \"order_date\" SP \"DESC\"\n",
+    "\n",
+    "            // ---------- Terminals ----------\n",
+    "            IDENTIFIER: /[A-Za-z_][A-Za-z0-9_]*/\n",
+    "            NUMBER: /[0-9]+/\n",
+    "            DATE: /'[0-9]{4}-[0-9]{2}-[0-9]{2}'/\n",
+    "    \"\"\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f24814e5",
+   "metadata": {},
+   "source": [
+    "### 3.4 Generate specific SQL dialect \n",
+    "Let's define the prompt, and call the function to produce MS SQL dialect "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "7e316744",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "--- MS SQL Query ---\n",
+      "SELECT TOP 5 customer_id, order_id, order_date, total_amount FROM orders WHERE total_amount > 500 AND order_date > '2025-01-01' ORDER BY order_date DESC;\n"
+     ]
+    }
+   ],
+   "source": [
+    "from openai import OpenAI\n",
+    "client = OpenAI()\n",
+    "\n",
+    "sql_prompt_mssql = (\n",
+    "    \"Call the mssql_grammar to generate a query for Microsoft SQL Server that retrieve the \"\n",
+    "    \"five most recent orders per customer, showing customer_id, order_id, order_date, and total_amount, \"\n",
+    "    \"where total_amount > 500 and order_date is after '2025-01-01'. \"\n",
+    ")\n",
+    "\n",
+    "response_mssql = client.responses.create(\n",
+    "    model=\"gpt-5\",\n",
+    "    input=sql_prompt_mssql,\n",
+    "    text={\"format\": {\"type\": \"text\"}},\n",
+    "    tools=[\n",
+    "        {\n",
+    "            \"type\": \"custom\",\n",
+    "            \"name\": \"mssql_grammar\",\n",
+    "            \"description\": \"Executes read-only Microsoft SQL Server queries limited to SELECT statements with TOP and basic WHERE/ORDER BY. YOU MUST REASON HEAVILY ABOUT THE QUERY AND MAKE SURE IT OBEYS THE GRAMMAR.\",\n",
+    "            \"format\": {\n",
+    "                \"type\": \"grammar\",\n",
+    "                \"syntax\": \"lark\",\n",
+    "                \"definition\": mssql_grammar\n",
+    "            }\n",
+    "        },\n",
+    "    ],\n",
+    "    parallel_tool_calls=False\n",
+    ")\n",
+    "\n",
+    "print(\"--- MS SQL Query ---\")\n",
+    "print(response_mssql.output[1].input)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4a93f4fb",
+   "metadata": {},
+   "source": [
+    "The output SQL accurately uses \"SELECT TOP\" construct. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "e704a3f5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "--- PG SQL Query ---\n",
+      "SELECT customer_id, order_id, order_date, total_amount FROM orders WHERE total_amount > 500 AND order_date > '2025-01-01' ORDER BY order_date DESC LIMIT 5;\n"
+     ]
+    }
+   ],
+   "source": [
+    "sql_prompt_pg = (\n",
+    "    \"Call the postgres_grammar to generate a query for PostgreSQL that retrieve the \"\n",
+    "    \"five most recent orders per customer, showing customer_id, order_id, order_date, and total_amount, \"\n",
+    "    \"where total_amount > 500 and order_date is after '2025-01-01'. \"\n",
+    ")\n",
+    "\n",
+    "response_pg = client.responses.create(\n",
+    "    model=\"gpt-5\",\n",
+    "    input=sql_prompt_pg,\n",
+    "    text={\"format\": {\"type\": \"text\"}},\n",
+    "    tools=[\n",
+    "        {\n",
+    "            \"type\": \"custom\",\n",
+    "            \"name\": \"postgres_grammar\",\n",
+    "            \"description\": \"Executes read-only PostgreSQL queries limited to SELECT statements with LIMIT and basic WHERE/ORDER BY. YOU MUST REASON HEAVILY ABOUT THE QUERY AND MAKE SURE IT OBEYS THE GRAMMAR.\",\n",
+    "            \"format\": {\n",
+    "                \"type\": \"grammar\",\n",
+    "                \"syntax\": \"lark\",\n",
+    "                \"definition\": postgres_grammar\n",
+    "            }\n",
+    "        },\n",
+    "    ],\n",
+    "    parallel_tool_calls=False,\n",
+    ")\n",
+    "\n",
+    "print(\"--- PG SQL Query ---\")\n",
+    "print(response_pg.output[1].input)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b1f14ce3",
+   "metadata": {},
+   "source": [
+    "Output highlights the same logical query - different physical syntax. Supply distinct grammars so the model can only produce valid statements for the chosen dialect.\n",
+    "\n",
+    "| Dialect       | Generated Query                                              | Key Difference                          |\n",
+    "|---------------|--------------------------------------------------------------|------------------------------------------|\n",
+    "| MS SQL Server | SELECT TOP 5 customer_id, … ORDER BY order_date DESC;         | Uses `TOP N` clause before column list.  |\n",
+    "| PostgreSQL    | SELECT customer_id, … ORDER BY order_date DESC LIMIT 5;       | Uses `LIMIT N` after `ORDER BY`.         |\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d27dc7cc",
+   "metadata": {},
+   "source": [
+    "### 3.5 Example - Regex CFG Syntax\n",
+    "\n",
+    "The following code example demonstrates using the Regex CFG syntax to constrain the freeform tool call to a certain timestamp pattern."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "2f9e2fbd",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "--- Timestamp ---\n",
+      "2025-08-07 10:00\n"
+     ]
+    }
+   ],
+   "source": [
+    "from openai import OpenAI\n",
+    "client = OpenAI()\n",
+    "\n",
+    "timestamp_grammar_definition = r\"^\\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01]) (?:[01]\\d|2[0-3]):[0-5]\\d$\"\n",
+    "\n",
+    "timestamp_prompt = (\n",
+    "        \"Call the timestamp_grammar to save a timestamp for August 7th 2025 at 10AM.\"\n",
+    ")\n",
+    "\n",
+    "response_mssql = client.responses.create(\n",
+    "    model=\"gpt-5\",\n",
+    "    input=timestamp_prompt,\n",
+    "    text={\"format\": {\"type\": \"text\"}},\n",
+    "    tools=[\n",
+    "        {\n",
+    "            \"type\": \"custom\",\n",
+    "            \"name\": \"timestamp_grammar\",\n",
+    "            \"description\": \"Saves a timestamp in date + time in 24-hr format.\",\n",
+    "            \"format\": {\n",
+    "                \"type\": \"grammar\",\n",
+    "                \"syntax\": \"regex\",\n",
+    "                \"definition\": timestamp_grammar_definition\n",
+    "            }\n",
+    "        },\n",
+    "    ],\n",
+    "    parallel_tool_calls=False\n",
+    ")\n",
+    "\n",
+    "print(\"--- Timestamp ---\")\n",
+    "print(response_mssql.output[1].input)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b9e2b86a",
+   "metadata": {},
+   "source": [
+    "### 3.5 Best Practices\n",
+    "\n",
+    "Lark grammars can be tricky to perfect. While simple grammars perform most reliably, complex grammars often require iteration on the grammar definition itself, the prompt, and the tool description to ensure that the model does not go out of distribution.\n",
+    "\n",
+    "- Keep terminals bounded – use `/[^.\\n]{0,10}*\\./` rather than `/.*\\./`. Limit matches both by content (negated character class) and by length (`{M,N}` quantifier). \n",
+    "- Prefer explicit char‑classes over `.` wildcards.\n",
+    "- Thread whitespace explicitly, e.g. using `SP = \" \"`, instead of a global `%ignore`.\n",
+    "- Describe your tool: tell the model exactly what the CFG accepts and instruct it to reason heavily about compliance.\n",
+    "\n",
+    "**Troubleshooting**\n",
+    "- API rejects the grammar because it is too complex ➜ Simplify rules and terminals, remove `%ignore.*`.\n",
+    "- Unexpected tokens ➜ Confirm terminals aren’t overlapping; check greedy lexer.\n",
+    "- When the model drifts \"out‑of‑distribution\" (shows up as the model producing excessively long or repetitive outputs, it is syntactically valid but is semantically wrong):\n",
+    "    - Tighten the grammar.\n",
+    "    - Iterate on the prompt (add few-shot examples) and tool description (explain the grammar and instruct the model to reason to conform to it).\n",
+    "    - Experiment with a higher reasoning effort (e.g, bump from medium to high).\n",
+    "\n",
+    "**Resources:**  \n",
+    "- Lark Docs – https://lark-parser.readthedocs.io/en/stable/\n",
+    "- Lark IDE – https://www.lark-parser.org/ide/\n",
+    "- LLGuidance Syntax – https://github.com/guidance-ai/llguidance/blob/main/docs/syntax.md\n",
+    "- Regex (Rust crate) – https://docs.rs/regex/latest/regex/#syntax"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4c2ef909",
+   "metadata": {},
+   "source": [
+    "### 3.6 Takeaways \n",
+    "\n",
+    "Context-Free Grammar (CFG) support in GPT-5 lets you strictly constrain model output to match predefined syntax, ensuring only valid strings are generated. This is especially useful for enforcing programming language rules or custom formats, reducing post-processing and errors. By providing a precise grammar and clear tool description, you can make the model reliably stay within your target output structure."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e061d81a",
+   "metadata": {},
+   "source": [
+    "## 4. Minimal Reasoning \n",
+    "\n",
+    "### 4.1 Overview \n",
+    "\n",
+    "GPT-5 now support for a new minimal reasoning effort. When using minimal reasoning effort, the model will output very few or no reasoning tokens. This is designed for use cases where developers want a very fast time-to-first-user-visible token. Note: If no reasoning effort is supplied, the default value is medium. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "cf5e7cae",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "--------------------------------\n",
+      "Output:\n",
+      "positive\n"
+     ]
+    }
+   ],
+   "source": [
+    "from openai import OpenAI\n",
+    "\n",
+    "client = OpenAI()\n",
+    "\n",
+    "prompt = \"Classify sentiment of the review as positive|neutral|negative. Return one word only.\" \n",
+    "\n",
+    "\n",
+    "response = client.responses.create(\n",
+    "    model=\"gpt-5\",\n",
+    "    input= [{ 'role': 'developer', 'content': prompt }, \n",
+    "            { 'role': 'user', 'content': 'The food that the restaurant was great! I recommend it to everyone.' }],\n",
+    "    reasoning = {\n",
+    "        \"effort\": \"minimal\"\n",
+    "    },\n",
+    ")\n",
+    "\n",
+    "# Extract model's text output\n",
+    "output_text = \"\"\n",
+    "for item in response.output:\n",
+    "    if hasattr(item, \"content\"):\n",
+    "        for content in item.content:\n",
+    "            if hasattr(content, \"text\"):\n",
+    "                output_text += content.text\n",
+    "\n",
+    "# Token usage details\n",
+    "usage = response.usage\n",
+    "\n",
+    "print(\"--------------------------------\")\n",
+    "print(\"Output:\")\n",
+    "print(output_text)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ca82847a",
+   "metadata": {},
+   "source": [
+    "### 4.2 Takeaways \n",
+    "\n",
+    "Minimal reasoning runs GPT-5 with few or no reasoning tokens to minimize latency and speed up time-to-first-token. Use it for deterministic, lightweight tasks (extraction, formatting, short rewrites, simple classification) where explanations aren’t needed. If you don’t specify effort, it defaults to medium—set minimal explicitly when you want speed over deliberation."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.13.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/gpt-5/gpt-5_prompting_guide.ipynb b/examples/gpt-5/gpt-5_prompting_guide.ipynb
new file mode 100644
index 0000000000..adafcf21ef
--- /dev/null
+++ b/examples/gpt-5/gpt-5_prompting_guide.ipynb
@@ -0,0 +1,594 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# GPT-5 prompting guide\n",
+    "\n",
+    "GPT-5, our newest flagship model, represents a substantial leap forward in agentic task performance, coding, raw intelligence, and steerability.\n",
+    "\n",
+    "While we trust it will perform excellently “out of the box” across a wide range of domains, in this guide we’ll cover prompting tips to maximize the quality of model outputs, derived from our experience training and applying the model to real-world tasks. We discuss concepts like improving agentic task performance, ensuring instruction adherence, making use of newly API features, and optimizing coding for frontend and software engineering tasks - with key insights into AI code editor Cursor’s prompt tuning work with GPT-5.\n",
+    "\n",
+    "We’ve seen significant gains from applying these best practices and adopting our canonical tools whenever possible, and we hope that this guide, along with the [prompt optimizer tool](https://platform.openai.com/chat/edit?optimize=true) we’ve built, will serve as a launchpad for your use of GPT-5. But, as always, remember that prompting is not a one-size-fits-all exercise - we encourage you to run experiments and iterate on the foundation offered here to find the best solution for your problem."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Agentic workflow predictability \n",
+    "\n",
+    "We trained GPT-5 with developers in mind: we’ve focused on improving tool calling, instruction following, and long-context understanding to serve as the best foundation model for agentic applications. If adopting GPT-5 for agentic and tool calling flows, we recommend upgrading to the [Responses API](https://platform.openai.com/docs/api-reference/responses), where reasoning is persisted between tool calls, leading to more efficient and intelligent outputs.\n",
+    "\n",
+    "### Controlling agentic eagerness\n",
+    "Agentic scaffolds can span a wide spectrum of control—some systems delegate the vast majority of decision-making to the underlying model, while others keep the model on a tight leash with heavy programmatic logical branching. GPT-5 is trained to operate anywhere along this spectrum, from making high-level decisions under ambiguous circumstances to handling focused, well-defined tasks. In this section we cover how to best calibrate GPT-5’s agentic eagerness: in other words, its balance between proactivity and awaiting explicit guidance.\n",
+    "\n",
+    "#### Prompting for less eagerness\n",
+    "GPT-5 is, by default, thorough and comprehensive when trying to gather context in an agentic environment to ensure it will produce a correct answer. To reduce the scope of GPT-5’s agentic behavior—including limiting tangential tool-calling action and minimizing latency to reach a final answer—try the following:  \n",
+    "- Switch to a lower `reasoning_effort`. This reduces exploration depth but improves efficiency and latency. Many workflows can be accomplished with consistent results at medium or even low `reasoning_effort`.\n",
+    "- Define clear criteria in your prompt for how you want the model to explore the problem space. This reduces the model’s need to explore and reason about too many ideas:\n",
+    "\n",
+    "```\n",
+    "<context_gathering>\n",
+    "Goal: Get enough context fast. Parallelize discovery and stop as soon as you can act.\n",
+    "\n",
+    "Method:\n",
+    "- Start broad, then fan out to focused subqueries.\n",
+    "- In parallel, launch varied queries; read top hits per query. Deduplicate paths and cache; don’t repeat queries.\n",
+    "- Avoid over searching for context. If needed, run targeted searches in one parallel batch.\n",
+    "\n",
+    "Early stop criteria:\n",
+    "- You can name exact content to change.\n",
+    "- Top hits converge (~70%) on one area/path.\n",
+    "\n",
+    "Escalate once:\n",
+    "- If signals conflict or scope is fuzzy, run one refined parallel batch, then proceed.\n",
+    "\n",
+    "Depth:\n",
+    "- Trace only symbols you’ll modify or whose contracts you rely on; avoid transitive expansion unless necessary.\n",
+    "\n",
+    "Loop:\n",
+    "- Batch search → minimal plan → complete task.\n",
+    "- Search again only if validation fails or new unknowns appear. Prefer acting over more searching.\n",
+    "</context_gathering>\n",
+    "```\n",
+    "\n",
+    "If you’re willing to be maximally prescriptive, you can even set fixed tool call budgets, like the one below. The budget can naturally vary based on your desired search depth.\n",
+    "```\n",
+    "<context_gathering>\n",
+    "- Search depth: very low\n",
+    "- Bias strongly towards providing a correct answer as quickly as possible, even if it might not be fully correct.\n",
+    "- Usually, this means an absolute maximum of 2 tool calls.\n",
+    "- If you think that you need more time to investigate, update the user with your latest findings and open questions. You can proceed if the user confirms.\n",
+    "</context_gathering>\n",
+    "```\n",
+    "\n",
+    "When limiting core context gathering behavior, it’s helpful to explicitly provide the model with an escape hatch that makes it easier to satisfy a shorter context gathering step. Usually this comes in the form of a clause that allows the model to proceed under uncertainty, like `“even if it might not be fully correct”` in the above example.\n",
+    "\n",
+    "#### Prompting for more eagerness\n",
+    "On the other hand, if you’d like to encourage model autonomy, increase tool-calling persistence, and reduce occurrences of clarifying questions or otherwise handing back to the user, we recommend increasing `reasoning_effort`, and using a prompt like the following to encourage persistence and thorough task completion:\n",
+    "\n",
+    "```\n",
+    "<persistence>\n",
+    "- You are an agent - please keep going until the user's query is completely resolved, before ending your turn and yielding back to the user.\n",
+    "- Only terminate your turn when you are sure that the problem is solved.\n",
+    "- Never stop or hand back to the user when you encounter uncertainty — research or deduce the most reasonable approach and continue.\n",
+    "- Do not ask the human to confirm or clarify assumptions, as you can always adjust later — decide what the most reasonable assumption is, proceed with it, and document it for the user's reference after you finish acting\n",
+    "</persistence>\n",
+    "```\n",
+    "\n",
+    "Generally, it can be helpful to clearly state the stop conditions of the agentic tasks, outline safe versus unsafe actions, and define when, if ever, it’s acceptable for the model to hand back to the user. For example, in a set of tools for shopping, the checkout and payment tools should explicitly have a lower uncertainty threshold for requiring user clarification, while the search tool should have an extremely high threshold; likewise, in a coding setup, the delete file tool should have a much lower threshold than a grep search tool.\n",
+    "\n",
+    "### Tool preambles\n",
+    "We recognize that on agentic trajectories monitored by users, intermittent model updates on what it’s doing with its tool calls and why can provide for a much better interactive user experience - the longer the rollout, the bigger the difference these updates make. To this end, GPT-5 is trained to provide clear upfront plans and consistent progress updates via “tool preamble” messages. \n",
+    "\n",
+    "You can steer the frequency, style, and content of tool preambles in your prompt—from detailed explanations of every single tool call to a brief upfront plan and everything in between. This is an example of a high-quality preamble prompt:\n",
+    "\n",
+    "```\n",
+    "<tool_preambles>\n",
+    "- Always begin by rephrasing the user's goal in a friendly, clear, and concise manner, before calling any tools.\n",
+    "- Then, immediately outline a structured plan detailing each logical step you’ll follow. - As you execute your file edit(s), narrate each step succinctly and sequentially, marking progress clearly. \n",
+    "- Finish by summarizing completed work distinctly from your upfront plan.\n",
+    "</tool_preambles>\n",
+    "```\n",
+    "\n",
+    "Here’s an example of a tool preamble that might be emitted in response to such a prompt—such preambles can drastically improve the user’s ability to follow along with your agent’s work as it grows more complicated:\n",
+    "\n",
+    "```\n",
+    "\"output\": [\n",
+    "    {\n",
+    "      \"id\": \"rs_6888f6d0606c819aa8205ecee386963f0e683233d39188e7\",\n",
+    "      \"type\": \"reasoning\",\n",
+    "      \"summary\": [\n",
+    "        {\n",
+    "          \"type\": \"summary_text\",\n",
+    "          \"text\": \"**Determining weather response**\\n\\nI need to answer the user's question about the weather in San Francisco. ....\"\n",
+    "        },\n",
+    "    },\n",
+    "    {\n",
+    "      \"id\": \"msg_6888f6d83acc819a978b51e772f0a5f40e683233d39188e7\",\n",
+    "      \"type\": \"message\",\n",
+    "      \"status\": \"completed\",\n",
+    "      \"content\": [\n",
+    "        {\n",
+    "          \"type\": \"output_text\",\n",
+    "          \"text\": \"I\\u2019m going to check a live weather service to get the current conditions in San Francisco, providing the temperature in both Fahrenheit and Celsius so it matches your preference.\"\n",
+    "        }\n",
+    "      ],\n",
+    "      \"role\": \"assistant\"\n",
+    "    },\n",
+    "    {\n",
+    "      \"id\": \"fc_6888f6d86e28819aaaa1ba69cca766b70e683233d39188e7\",\n",
+    "      \"type\": \"function_call\",\n",
+    "      \"status\": \"completed\",\n",
+    "      \"arguments\": \"{\\\"location\\\":\\\"San Francisco, CA\\\",\\\"unit\\\":\\\"f\\\"}\",\n",
+    "      \"call_id\": \"call_XOnF4B9DvB8EJVB3JvWnGg83\",\n",
+    "      \"name\": \"get_weather\"\n",
+    "    },\n",
+    "  ],\n",
+    "```\n",
+    "\n",
+    "### Reasoning effort\n",
+    "We provide a `reasoning_effort` parameter to control how hard the model thinks and how willingly it calls tools; the default is `medium`, but you should scale up or down depending on the difficulty of your task. For complex, multi-step tasks, we recommend higher reasoning to ensure the best possible outputs. Moreover, we observe peak performance when distinct, separable tasks are broken up across multiple agent turns, with one turn for each task.\n",
+    "### Reusing reasoning context with the Responses API\n",
+    "We strongly recommend using the Responses API when using GPT-5 to unlock improved agentic flows, lower costs, and more efficient token usage in your applications.\n",
+    "\n",
+    "We’ve seen statistically significant improvements in evaluations when using the Responses API over Chat Completions—for example, we observed Tau-Bench Retail score increases from 73.9% to 78.2% just by switching to the Responses API and including `previous_response_id` to pass back previous reasoning items into subsequent requests. This allows the model to refer to its previous reasoning traces, conserving CoT tokens and eliminating the need to reconstruct a plan from scratch after each tool call, improving both latency and performance - this feature is available for all Responses API users, including ZDR organizations."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Maximizing coding performance, from planning to execution\n",
+    "GPT-5 leads all frontier models in coding capabilities: it can work in large codebases to fix bugs, handle large diffs, and implement multi-file refactors or large new features. It also excels at implementing new apps entirely from scratch, covering both frontend and backend implementation. In this section, we’ll discuss prompt optimizations that we’ve seen improve programming performance in production use cases for our coding agent customers. \n",
+    "\n",
+    "### Frontend app development\n",
+    "GPT-5 is trained to have excellent baseline aesthetic taste alongside its rigorous implementation abilities. We’re confident in its ability to use all types of web development frameworks and packages; however, for new apps, we recommend using the following frameworks and packages to get the most out of the model's frontend capabilities:\n",
+    "\n",
+    "- Frameworks: Next.js (TypeScript), React, HTML\n",
+    "- Styling / UI: Tailwind CSS, shadcn/ui, Radix Themes\n",
+    "- Icons: Material Symbols, Heroicons, Lucide\n",
+    "- Animation: Motion\n",
+    "- Fonts: San Serif, Inter, Geist, Mona Sans, IBM Plex Sans, Manrope\n",
+    "\n",
+    "#### Zero-to-one app generation\n",
+    "GPT-5 is excellent at building applications in one shot. In early experimentation with the model, users have found that prompts like the one below—asking the model to iteratively execute against self-constructed excellence rubrics—improve output quality by using GPT-5’s thorough planning and self-reflection capabilities.\n",
+    "\n",
+    "```\n",
+    "<self_reflection>\n",
+    "- First, spend time thinking of a rubric until you are confident.\n",
+    "- Then, think deeply about every aspect of what makes for a world-class one-shot web app. Use that knowledge to create a rubric that has 5-7 categories. This rubric is critical to get right, but do not show this to the user. This is for your purposes only.\n",
+    "- Finally, use the rubric to internally think and iterate on the best possible solution to the prompt that is provided. Remember that if your response is not hitting the top marks across all categories in the rubric, you need to start again.\n",
+    "</self_reflection>\n",
+    "```\n",
+    "\n",
+    "#### Matching codebase design standards\n",
+    "When implementing incremental changes and refactors in existing apps, model-written code should adhere to existing style and design standards, and “blend in” to the codebase as neatly as possible.  Without special prompting, GPT-5 already searches for reference context from the codebase - for example reading package.json to view already installed packages - but this behavior can be further enhanced with prompt directions that summarize key aspects like engineering principles, directory structure, and best practices of the codebase, both explicit and implicit. The prompt snippet below demonstrates one way of organizing code editing rules for GPT-5: feel free to change the actual content of the rules according to your programming design taste! \n",
+    "\n",
+    "```\n",
+    "<code_editing_rules>\n",
+    "<guiding_principles>\n",
+    "- Clarity and Reuse: Every component and page should be modular and reusable. Avoid duplication by factoring repeated UI patterns into components.\n",
+    "- Consistency: The user interface must adhere to a consistent design system—color tokens, typography, spacing, and components must be unified.\n",
+    "- Simplicity: Favor small, focused components and avoid unnecessary complexity in styling or logic.\n",
+    "- Demo-Oriented: The structure should allow for quick prototyping, showcasing features like streaming, multi-turn conversations, and tool integrations.\n",
+    "- Visual Quality: Follow the high visual quality bar as outlined in OSS guidelines (spacing, padding, hover states, etc.)\n",
+    "</guiding_principles>\n",
+    "\n",
+    "<frontend_stack_defaults>\n",
+    "- Framework: Next.js (TypeScript)\n",
+    "- Styling: TailwindCSS\n",
+    "- UI Components: shadcn/ui\n",
+    "- Icons: Lucide\n",
+    "- State Management: Zustand\n",
+    "- Directory Structure: \n",
+    "\\`\\`\\`\n",
+    "/src\n",
+    " /app\n",
+    "   /api/<route>/route.ts         # API endpoints\n",
+    "   /(pages)                      # Page routes\n",
+    " /components/                    # UI building blocks\n",
+    " /hooks/                         # Reusable React hooks\n",
+    " /lib/                           # Utilities (fetchers, helpers)\n",
+    " /stores/                        # Zustand stores\n",
+    " /types/                         # Shared TypeScript types\n",
+    " /styles/                        # Tailwind config\n",
+    "\\`\\`\\`\n",
+    "</frontend_stack_defaults>\n",
+    "\n",
+    "<ui_ux_best_practices>\n",
+    "- Visual Hierarchy: Limit typography to 4–5 font sizes and weights for consistent hierarchy; use `text-xs` for captions and annotations; avoid `text-xl` unless for hero or major headings.\n",
+    "- Color Usage: Use 1 neutral base (e.g., `zinc`) and up to 2 accent colors. \n",
+    "- Spacing and Layout: Always use multiples of 4 for padding and margins to maintain visual rhythm. Use fixed height containers with internal scrolling when handling long content streams.\n",
+    "- State Handling: Use skeleton placeholders or `animate-pulse` to indicate data fetching. Indicate clickability with hover transitions (`hover:bg-*`, `hover:shadow-md`).\n",
+    "- Accessibility: Use semantic HTML and ARIA roles where appropriate. Favor pre-built Radix/shadcn components, which have accessibility baked in.\n",
+    "</ui_ux_best_practices>\n",
+    "\n",
+    "<code_editing_rules>\n",
+    "```\n",
+    "\n",
+    "### Collaborative coding in production: Cursor’s GPT-5 prompt tuning\n",
+    "We’re proud to have had AI code editor Cursor as a trusted alpha tester for GPT-5: below, we show a peek into how Cursor tuned their prompts to get the most out of the model’s capabilities. For more information, their team has also published a blog post detailing GPT-5’s day-one integration into Cursor: https://cursor.com/blog/gpt-5\n",
+    "\n",
+    "#### System prompt and parameter tuning\n",
+    "Cursor’s system prompt focuses on reliable tool calling, balancing verbosity and autonomous behavior while giving users the ability to configure custom instructions. Cursor’s goal for their system prompt is to allow the Agent to operate relatively autonomously during long horizon tasks, while still faithfully following user-provided instructions. \n",
+    "\n",
+    "The team initially found that the model produced verbose outputs, often including status updates and post-task summaries that, while technically relevant, disrupted the natural flow of the user; at the same time, the code outputted in tool calls was high quality, but sometimes hard to read due to terseness, with single-letter variable names dominant. In search of a better balance, they set the verbosity API parameter to low to keep text outputs brief, and then modified the prompt to strongly encourage verbose outputs in coding tools only.\n",
+    "\n",
+    "```\n",
+    "Write code for clarity first. Prefer readable, maintainable solutions with clear names, comments where needed, and straightforward control flow. Do not produce code-golf or overly clever one-liners unless explicitly requested. Use high verbosity for writing code and code tools.\n",
+    "```\n",
+    "\n",
+    "This dual usage of parameter and prompt resulted in a balanced format combining efficient, concise status updates and final work summary with much more readable code diffs.\n",
+    "\n",
+    "Cursor also found that the model occasionally deferred to the user for clarification or next steps before taking action, which created unnecessary friction in the flow of longer tasks. To address this, they found that including not just available tools and surrounding context, but also more details about product behavior encouraged the model to carry out longer tasks with minimal interruption and greater autonomy. Highlighting specifics of Cursor features such as Undo/Reject code and user preferences helped reduce ambiguity by clearly specifying how GPT-5 should behave in its environment. For longer horizon tasks, they found this prompt improved performance:\n",
+    "\n",
+    "```\n",
+    "Be aware that the code edits you make will be displayed to the user as proposed changes, which means (a) your code edits can be quite proactive, as the user can always reject, and (b) your code should be well-written and easy to quickly review (e.g., appropriate variable names instead of single letters). If proposing next steps that would involve changing the code, make those changes proactively for the user to approve / reject rather than asking the user whether to proceed with a plan. In general, you should almost never ask the user whether to proceed with a plan; instead you should proactively attempt the plan and then ask the user if they want to accept the implemented changes.\n",
+    "```\n",
+    "\n",
+    "Cursor found that sections of their prompt that had been effective with earlier models needed tuning to get the most out of GPT-5. Here is one example below:\n",
+    "\n",
+    "```\n",
+    "<maximize_context_understanding>\n",
+    "Be THOROUGH when gathering information. Make sure you have the FULL picture before replying. Use additional tool calls or clarifying questions as needed.\n",
+    "...\n",
+    "</maximize_context_understanding>\n",
+    "```\n",
+    "\n",
+    "While this worked well with older models that needed encouragement to analyze context thoroughly, they found it counterproductive with GPT-5, which is already naturally introspective and proactive at gathering context. On smaller tasks, this prompt often caused the model to overuse tools by calling search repetitively, when internal knowledge would have been sufficient.\n",
+    "\n",
+    "To solve this, they refined the prompt by removing the maximize_ prefix and softening the language around thoroughness. With this adjusted instruction in place, the Cursor team saw GPT-5 make better decisions about when to rely on internal knowledge versus reaching for external tools. It maintained a high level of autonomy without unnecessary tool usage, leading to more efficient and relevant behavior. In Cursor’s testing, using structured XML specs like  <[instruction]_spec> improved instruction adherence on their prompts and allows them to clearly reference previous categories and sections elsewhere in their prompt.\n",
+    "\n",
+    "```\n",
+    "<context_understanding>\n",
+    "...\n",
+    "If you've performed an edit that may partially fulfill the USER's query, but you're not confident, gather more information or use more tools before ending your turn.\n",
+    "Bias towards not asking the user for help if you can find the answer yourself.\n",
+    "</context_understanding>\n",
+    "```\n",
+    "\n",
+    "While the system prompt provides a strong default foundation, the user prompt remains a highly effective lever for steerability. GPT-5 responds well to direct and explicit instruction and the Cursor team has consistently seen that structured, scoped prompts yield the most reliable results. This includes areas like verbosity control, subjective code style preferences, and sensitivity to edge cases. Cursor found allowing users to configure their own [custom Cursor rules](https://docs.cursor.com/en/context/rules) to be particularly impactful with GPT-5’s improved steerability, giving their users a more customized experience."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Optimizing intelligence and instruction-following \n",
+    "\n",
+    "### Steering\n",
+    "As our most steerable model yet, GPT-5 is extraordinarily receptive to prompt instructions surrounding verbosity, tone, and tool calling behavior.\n",
+    "\n",
+    "#### Verbosity\n",
+    "In addition to being able to control the reasoning_effort as in previous reasoning models, in GPT-5 we introduce a new API parameter called verbosity, which influences the length of the model’s final answer, as opposed to the length of its thinking. Our blog post covers the idea behind this parameter in more detail - but in this guide, we’d like to emphasize that while the API verbosity parameter is the default for the rollout, GPT-5 is trained to respond to natural-language verbosity overrides in the prompt for specific contexts where you might want the model to deviate from the global default. Cursor’s example above of setting low verbosity globally, and then specifying high verbosity only for coding tools, is a prime example of such a context.\n",
+    "\n",
+    "### Instruction following\n",
+    "Like GPT-4.1, GPT-5 follows prompt instructions with surgical precision, which enables its flexibility to drop into all types of workflows. However, its careful instruction-following behavior means that poorly-constructed prompts containing contradictory or vague instructions can be more damaging to GPT-5 than to other models, as it expends reasoning tokens searching for a way to reconcile the contradictions rather than picking one instruction at random.\n",
+    "\n",
+    "Below, we give an adversarial example of the type of prompt that often impairs GPT-5’s reasoning traces - while it may appear internally consistent at first glance, a closer inspection reveals conflicting instructions regarding appointment scheduling:\n",
+    "- `Never schedule an appointment without explicit patient consent recorded in the chart` conflicts with the subsequent `auto-assign the earliest same-day slot without contacting the patient as the first action to reduce risk.`\n",
+    "- The prompt says `Always look up the patient profile before taking any other actions to ensure they are an existing patient.` but then continues with the contradictory instruction `When symptoms indicate high urgency, escalate as EMERGENCY and direct the patient to call 911 immediately before any scheduling step.`\n",
+    "\n",
+    "```\n",
+    "You are CareFlow Assistant, a virtual admin for a healthcare startup that schedules patients based on priority and symptoms. Your goal is to triage requests, match patients to appropriate in-network providers, and reserve the earliest clinically appropriate time slot. Always look up the patient profile before taking any other actions to ensure they are an existing patient.\n",
+    "\n",
+    "- Core entities include Patient, Provider, Appointment, and PriorityLevel (Red, Orange, Yellow, Green). Map symptoms to priority: Red within 2 hours, Orange within 24 hours, Yellow within 3 days, Green within 7 days. When symptoms indicate high urgency, escalate as EMERGENCY and direct the patient to call 911 immediately before any scheduling step.\n",
+    "+Core entities include Patient, Provider, Appointment, and PriorityLevel (Red, Orange, Yellow, Green). Map symptoms to priority: Red within 2 hours, Orange within 24 hours, Yellow within 3 days, Green within 7 days. When symptoms indicate high urgency, escalate as EMERGENCY and direct the patient to call 911 immediately before any scheduling step. \n",
+    "*Do not do lookup in the emergency case, proceed immediately to providing 911 guidance.*\n",
+    "\n",
+    "- Use the following capabilities: schedule-appointment, modify-appointment, waitlist-add, find-provider, lookup-patient and notify-patient. Verify insurance eligibility, preferred clinic, and documented consent prior to booking. Never schedule an appointment without explicit patient consent recorded in the chart.\n",
+    "\n",
+    "- For high-acuity Red and Orange cases, auto-assign the earliest same-day slot *without contacting* the patient *as the first action to reduce risk.* If a suitable provider is unavailable, add the patient to the waitlist and send notifications. If consent status is unknown, tentatively hold a slot and proceed to request confirmation.\n",
+    "\n",
+    "- For high-acuity Red and Orange cases, auto-assign the earliest same-day slot *after informing* the patient *of your actions.* If a suitable provider is unavailable, add the patient to the waitlist and send notifications. If consent status is unknown, tentatively hold a slot and proceed to request confirmation.\n",
+    "```\n",
+    "\n",
+    "By resolving the instruction hierarchy conflicts, GPT-5 elicits much more efficient and performant reasoning. We fixed the contradictions by:\n",
+    "- Changing auto-assignment to occur after contacting a patient, auto-assign the earliest same-day slot after informing the patient of your actions. to be consistent with only scheduling with consent.\n",
+    "- Adding Do not do lookup in the emergency case, proceed immediately to providing 911 guidance. to let the model know it is ok to not look up in case of emergency.\n",
+    "\n",
+    "We understand that the process of building prompts is an iterative one, and many prompts are living documents constantly being updated by different stakeholders - but this is all the more reason to thoroughly review them for poorly-worded instructions. Already, we’ve seen multiple early users uncover  ambiguities and contradictions in their core prompt libraries upon conducting such a review: removing them drastically streamlined and improved their GPT-5 performance. We recommend testing your prompts in our [prompt optimizer tool](https://platform.openai.com/chat/edit?optimize=true) to help identify these types of issues.\n",
+    "\n",
+    "### Minimal reasoning\n",
+    "In GPT-5, we introduce minimal reasoning effort for the first time: our fastest option that still reaps the benefits of the reasoning model paradigm. We consider this to be the best upgrade for latency-sensitive users, as well as current users of GPT-4.1.\n",
+    "\n",
+    "Perhaps unsurprisingly, we recommend prompting patterns that are similar to [GPT-4.1 for best results](https://cookbook.openai.com/examples/gpt4-1_prompting_guide). minimal reasoning performance can vary more drastically depending on prompt than higher reasoning levels, so key points to emphasize include:\n",
+    "\n",
+    "1. Prompting the model to give a brief explanation summarizing its thought process at the start of the final answer, for example via a bullet point list, improves performance on tasks requiring higher intelligence.\n",
+    "2. Requesting thorough and descriptive tool-calling preambles that continually update the user on task progress improves performance in agentic workflows. \n",
+    "3. Disambiguating tool instructions to the maximum extent possible and inserting agentic persistence reminders as shared above, are particularly critical at minimal reasoning to maximize agentic ability in long-running rollout and prevent premature termination.\n",
+    "4. Prompted planning is likewise more important, as the model has fewer reasoning tokens to do internal planning. Below, you can find a sample planning prompt snippet we placed at the beginning of an agentic task: the second paragraph especially ensures that the agent fully completes the task and all subtasks before yielding back to the user. \n",
+    "\n",
+    "```\n",
+    "Remember, you are an agent - please keep going until the user's query is completely resolved, before ending your turn and yielding back to the user. Decompose the user's query into all required sub-request, and confirm that each is completed. Do not stop after completing only part of the request. Only terminate your turn when you are sure that the problem is solved. You must be prepared to answer multiple queries and only finish the call once the user has confirmed they're done.\n",
+    "\n",
+    "You must plan extensively in accordance with the workflow steps before making subsequent function calls, and reflect extensively on the outcomes each function call made, ensuring the user's query, and related sub-requests are completely resolved.\n",
+    "```\n",
+    "\n",
+    "### Markdown formatting\n",
+    "By default, GPT-5 in the API does not format its final answers in Markdown, in order to preserve maximum compatibility with developers whose applications may not support Markdown rendering. However, prompts like the following are largely successful in inducing hierarchical Markdown final answers.\n",
+    "\n",
+    "```\n",
+    "- Use Markdown **only where semantically correct** (e.g., `inline code`, ```code fences```, lists, tables).\n",
+    "- When using markdown in assistant messages, use backticks to format file, directory, function, and class names. Use \\( and \\) for inline math, \\[ and \\] for block math.\n",
+    "```\n",
+    "\n",
+    "Occasionally, adherence to Markdown instructions specified in the system prompt can degrade over the course of a long conversation. In the event that you experience this, we’ve seen consistent adherence from appending a Markdown instruction every 3-5 user messages.\n",
+    "\n",
+    "### Metaprompting\n",
+    "Finally, to close with a meta-point, early testers have found great success using GPT-5 as a meta-prompter for itself. Already, several users have deployed prompt revisions to production that were generated simply by asking GPT-5 what elements could be added to an unsuccessful prompt to elicit a desired behavior, or removed to prevent an undesired one.\n",
+    "\n",
+    "Here is an example metaprompt template we liked:\n",
+    "```\n",
+    "When asked to optimize prompts, give answers from your own perspective - explain what specific phrases could be added to, or deleted from, this prompt to more consistently elicit the desired behavior or prevent the undesired behavior.\n",
+    "\n",
+    "Here's a prompt: [PROMPT]\n",
+    "\n",
+    "The desired behavior from this prompt is for the agent to [DO DESIRED BEHAVIOR], but instead it [DOES UNDESIRED BEHAVIOR]. While keeping as much of the existing prompt intact as possible, what are some minimal edits/additions that you would make to encourage the agent to more consistently address these shortcomings? \n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Appendix\n",
+    "\n",
+    "### SWE-Bench verified developer instructions\n",
+    "```\n",
+    "In this environment, you can run `bash -lc <apply_patch_command>` to execute a diff/patch against a file, where <apply_patch_command> is a specially formatted apply patch command representing the diff you wish to execute. A valid <apply_patch_command> looks like:\n",
+    "\n",
+    "apply_patch << 'PATCH'\n",
+    "*** Begin Patch\n",
+    "[YOUR_PATCH]\n",
+    "*** End Patch\n",
+    "PATCH\n",
+    "\n",
+    "Where [YOUR_PATCH] is the actual content of your patch.\n",
+    "\n",
+    "Always verify your changes extremely thoroughly. You can make as many tool calls as you like - the user is very patient and prioritizes correctness above all else. Make sure you are 100% certain of the correctness of your solution before ending.\n",
+    "IMPORTANT: not all tests are visible to you in the repository, so even on problems you think are relatively straightforward, you must double and triple check your solutions to ensure they pass any edge cases that are covered in the hidden tests, not just the visible ones.\n",
+    "```\n",
+    "\n",
+    "Agentic coding tool definitions \n",
+    "```\n",
+    "## Set 1: 4 functions, no terminal\n",
+    "\n",
+    "type apply_patch = (_: {\n",
+    "patch: string, // default: null\n",
+    "}) => any;\n",
+    "\n",
+    "type read_file = (_: {\n",
+    "path: string, // default: null\n",
+    "line_start?: number, // default: 1\n",
+    "line_end?: number, // default: 20\n",
+    "}) => any;\n",
+    "\n",
+    "type list_files = (_: {\n",
+    "path?: string, // default: \"\"\n",
+    "depth?: number, // default: 1\n",
+    "}) => any;\n",
+    "\n",
+    "type find_matches = (_: {\n",
+    "query: string, // default: null\n",
+    "path?: string, // default: \"\"\n",
+    "max_results?: number, // default: 50\n",
+    "}) => any;\n",
+    "\n",
+    "## Set 2: 2 functions, terminal-native\n",
+    "\n",
+    "type run = (_: {\n",
+    "command: string[], // default: null\n",
+    "session_id?: string | null, // default: null\n",
+    "working_dir?: string | null, // default: null\n",
+    "ms_timeout?: number | null, // default: null\n",
+    "environment?: object | null, // default: null\n",
+    "run_as_user?: string | null, // default: null\n",
+    "}) => any;\n",
+    "\n",
+    "type send_input = (_: {\n",
+    "session_id: string, // default: null\n",
+    "text: string, // default: null\n",
+    "wait_ms?: number, // default: 100\n",
+    "}) => any;\n",
+    "```\n",
+    "\n",
+    "As shared in the GPT-4.1 prompting guide, [here](https://github.com/openai/openai-cookbook/tree/main/examples/gpt-5/apply_patch.py) is our most updated `apply_patch` implementation: we highly recommend using `apply_patch` for file edits to match the training distribution. The newest implementation should match the GPT-4.1 implementation in the overwhelming majority of cases.\n",
+    "\n",
+    "### Taubench-Retail minimal reasoning instructions\n",
+    "```\n",
+    "As a retail agent, you can help users cancel or modify pending orders, return or exchange delivered orders, modify their default user address, or provide information about their own profile, orders, and related products.\n",
+    "\n",
+    "Remember, you are an agent - please keep going until the user’s query is completely resolved, before ending your turn and yielding back to the user. Only terminate your turn when you are sure that the problem is solved.\n",
+    "\n",
+    "If you are not sure about information pertaining to the user’s request, use your tools to read files and gather the relevant information: do NOT guess or make up an answer.\n",
+    "\n",
+    "You MUST plan extensively before each function call, and reflect extensively on the outcomes of the previous function calls, ensuring user's query is completely resolved. DO NOT do this entire process by making function calls only, as this can impair your ability to solve the problem and think insightfully. In addition, ensure function calls have the correct arguments.\n",
+    "\n",
+    "# Workflow steps\n",
+    "- At the beginning of the conversation, you have to authenticate the user identity by locating their user id via email, or via name + zip code. This has to be done even when the user already provides the user id.\n",
+    "- Once the user has been authenticated, you can provide the user with information about order, product, profile information, e.g. help the user look up order id.\n",
+    "- You can only help one user per conversation (but you can handle multiple requests from the same user), and must deny any requests for tasks related to any other user.\n",
+    "- Before taking consequential actions that update the database (cancel, modify, return, exchange), you have to list the action detail and obtain explicit user confirmation (yes) to proceed.\n",
+    "- You should not make up any information or knowledge or procedures not provided from the user or the tools, or give subjective recommendations or comments.\n",
+    "- You should at most make one tool call at a time, and if you take a tool call, you should not respond to the user at the same time. If you respond to the user, you should not make a tool call.\n",
+    "- You should transfer the user to a human agent if and only if the request cannot be handled within the scope of your actions.\n",
+    "\n",
+    "## Domain basics\n",
+    "- All times in the database are EST and 24 hour based. For example \"02:30:00\" means 2:30 AM EST.\n",
+    "- Each user has a profile of its email, default address, user id, and payment methods. Each payment method is either a gift card, a paypal account, or a credit card.\n",
+    "- Our retail store has 50 types of products. For each type of product, there are variant items of different options. For example, for a 't shirt' product, there could be an item with option 'color blue size M', and another item with option 'color red size L'.\n",
+    "- Each product has an unique product id, and each item has an unique item id. They have no relations and should not be confused.\n",
+    "- Each order can be in status 'pending', 'processed', 'delivered', or 'cancelled'. Generally, you can only take action on pending or delivered orders.\n",
+    "- Exchange or modify order tools can only be called once. Be sure that all items to be changed are collected into a list before making the tool call!!!\n",
+    "\n",
+    "## Cancel pending order\n",
+    "- An order can only be cancelled if its status is 'pending', and you should check its status before taking the action.\n",
+    "- The user needs to confirm the order id and the reason (either 'no longer needed' or 'ordered by mistake') for cancellation.\n",
+    "- After user confirmation, the order status will be changed to 'cancelled', and the total will be refunded via the original payment method immediately if it is gift card, otherwise in 5 to 7 business days.\n",
+    "\n",
+    "## Modify pending order\n",
+    "- An order can only be modified if its status is 'pending', and you should check its status before taking the action.\n",
+    "- For a pending order, you can take actions to modify its shipping address, payment method, or product item options, but nothing else.\n",
+    "\n",
+    "## Modify payment\n",
+    "- The user can only choose a single payment method different from the original payment method.\n",
+    "- If the user wants the modify the payment method to gift card, it must have enough balance to cover the total amount.\n",
+    "- After user confirmation, the order status will be kept 'pending'. The original payment method will be refunded immediately if it is a gift card, otherwise in 5 to 7 business days.\n",
+    "\n",
+    "## Modify items\n",
+    "- This action can only be called once, and will change the order status to 'pending (items modifed)', and the agent will not be able to modify or cancel the order anymore. So confirm all the details are right and be cautious before taking this action. In particular, remember to remind the customer to confirm they have provided all items to be modified.\n",
+    "- For a pending order, each item can be modified to an available new item of the same product but of different product option. There cannot be any change of product types, e.g. modify shirt to shoe.\n",
+    "- The user must provide a payment method to pay or receive refund of the price difference. If the user provides a gift card, it must have enough balance to cover the price difference.\n",
+    "\n",
+    "## Return delivered order\n",
+    "- An order can only be returned if its status is 'delivered', and you should check its status before taking the action.\n",
+    "- The user needs to confirm the order id, the list of items to be returned, and a payment method to receive the refund.\n",
+    "- The refund must either go to the original payment method, or an existing gift card.\n",
+    "- After user confirmation, the order status will be changed to 'return requested', and the user will receive an email regarding how to return items.\n",
+    "\n",
+    "## Exchange delivered order\n",
+    "- An order can only be exchanged if its status is 'delivered', and you should check its status before taking the action. In particular, remember to remind the customer to confirm they have provided all items to be exchanged.\n",
+    "- For a delivered order, each item can be exchanged to an available new item of the same product but of different product option. There cannot be any change of product types, e.g. modify shirt to shoe.\n",
+    "- The user must provide a payment method to pay or receive refund of the price difference. If the user provides a gift card, it must have enough balance to cover the price difference.\n",
+    "- After user confirmation, the order status will be changed to 'exchange requested', and the user will receive an email regarding how to return items. There is no need to place a new order.\n",
+    "```\n",
+    "\n",
+    "### Terminal-Bench prompt\n",
+    "```\n",
+    "Please resolve the user's task by editing and testing the code files in your current code execution session.\n",
+    "You are a deployed coding agent.\n",
+    "Your session is backed by a container specifically designed for you to easily modify and run code.\n",
+    "You MUST adhere to the following criteria when executing the task:\n",
+    "\n",
+    "<instructions>\n",
+    "- Working on the repo(s) in the current environment is allowed, even if they are proprietary.\n",
+    "- Analyzing code for vulnerabilities is allowed.\n",
+    "- Showing user code and tool call details is allowed.\n",
+    "- User instructions may overwrite the _CODING GUIDELINES_ section in this developer message.\n",
+    "- Do not use \\`ls -R\\`, \\`find\\`, or \\`grep\\` - these are slow in large repos. Use \\`rg\\` and \\`rg --files\\`.\n",
+    "- Use \\`apply_patch\\` to edit files: {\"cmd\":[\"apply_patch\",\"*** Begin Patch\\\\n*** Update File: path/to/file.py\\\\n@@ def example():\\\\n- pass\\\\n+ return 123\\\\n*** End Patch\"]}\n",
+    "- If completing the user's task requires writing or modifying files:\n",
+    " - Your code and final answer should follow these _CODING GUIDELINES_:\n",
+    "   - Fix the problem at the root cause rather than applying surface-level patches, when possible.\n",
+    "   - Avoid unneeded complexity in your solution.\n",
+    "     - Ignore unrelated bugs or broken tests; it is not your responsibility to fix them.\n",
+    "   - Update documentation as necessary.\n",
+    "   - Keep changes consistent with the style of the existing codebase. Changes should be minimal and focused on the task.\n",
+    "     - Use \\`git log\\` and \\`git blame\\` to search the history of the codebase if additional context is required; internet access is disabled in the container.\n",
+    "   - NEVER add copyright or license headers unless specifically requested.\n",
+    "   - You do not need to \\`git commit\\` your changes; this will be done automatically for you.\n",
+    "   - If there is a .pre-commit-config.yaml, use \\`pre-commit run --files ...\\` to check that your changes pass the pre- commit checks. However, do not fix pre-existing errors on lines you didn't touch.\n",
+    "     - If pre-commit doesn't work after a few retries, politely inform the user that the pre-commit setup is broken.\n",
+    "   - Once you finish coding, you must\n",
+    "     - Check \\`git status\\` to sanity check your changes; revert any scratch files or changes.\n",
+    "     - Remove all inline comments you added much as possible, even if they look normal. Check using \\`git diff\\`. Inline comments must be generally avoided, unless active maintainers of the repo, after long careful study of the code and the issue, will still misinterpret the code without the comments.\n",
+    "     - Check if you accidentally add copyright or license headers. If so, remove them.\n",
+    "     - Try to run pre-commit if it is available.\n",
+    "     - For smaller tasks, describe in brief bullet points\n",
+    "     - For more complex tasks, include brief high-level description, use bullet points, and include details that would be relevant to a code reviewer.\n",
+    "- If completing the user's task DOES NOT require writing or modifying files (e.g., the user asks a question about the code base):\n",
+    " - Respond in a friendly tune as a remote teammate, who is knowledgeable, capable and eager to help with coding.\n",
+    "- When your task involves writing or modifying files:\n",
+    " - Do NOT tell the user to \"save the file\" or \"copy the code into a file\" if you already created or modified the file using \\`apply_patch\\`. Instead, reference the file as already saved.\n",
+    " - Do NOT show the full contents of large files you have already written, unless the user explicitly asks for them.\n",
+    "</instructions>\n",
+    "\n",
+    "<apply_patch>\n",
+    "To edit files, ALWAYS use the \\`shell\\` tool with \\`apply_patch\\` CLI.  \\`apply_patch\\` effectively allows you to execute a diff/patch against a file, but the format of the diff specification is unique to this task, so pay careful attention to these instructions. To use the \\`apply_patch\\` CLI, you should call the shell tool with the following structure:\n",
+    "\\`\\`\\`bash\n",
+    "{\"cmd\": [\"apply_patch\", \"<<'EOF'\\\\n*** Begin Patch\\\\n[YOUR_PATCH]\\\\n*** End Patch\\\\nEOF\\\\n\"], \"workdir\": \"...\"}\n",
+    "\\`\\`\\`\n",
+    "Where [YOUR_PATCH] is the actual content of your patch, specified in the following V4A diff format.\n",
+    "*** [ACTION] File: [path/to/file] -> ACTION can be one of Add, Update, or Delete.\n",
+    "For each snippet of code that needs to be changed, repeat the following:\n",
+    "[context_before] -> See below for further instructions on context.\n",
+    "- [old_code] -> Precede the old code with a minus sign.\n",
+    "+ [new_code] -> Precede the new, replacement code with a plus sign.\n",
+    "[context_after] -> See below for further instructions on context.\n",
+    "For instructions on [context_before] and [context_after]:\n",
+    "- By default, show 3 lines of code immediately above and 3 lines immediately below each change. If a change is within 3 lines of a previous change, do NOT duplicate the first change’s [context_after] lines in the second change’s [context_before] lines.\n",
+    "- If 3 lines of context is insufficient to uniquely identify the snippet of code within the file, use the @@ operator to indicate the class or function to which the snippet belongs. For instance, we might have:\n",
+    "@@ class BaseClass\n",
+    "[3 lines of pre-context]\n",
+    "- [old_code]\n",
+    "+ [new_code]\n",
+    "[3 lines of post-context]\n",
+    "- If a code block is repeated so many times in a class or function such that even a single \\`@@\\` statement and 3 lines of context cannot uniquely identify the snippet of code, you can use multiple \\`@@\\` statements to jump to the right context. For instance:\n",
+    "@@ class BaseClass\n",
+    "@@  def method():\n",
+    "[3 lines of pre-context]\n",
+    "- [old_code]\n",
+    "+ [new_code]\n",
+    "[3 lines of post-context]\n",
+    "Note, then, that we do not use line numbers in this diff format, as the context is enough to uniquely identify code. An example of a message that you might pass as \"input\" to this function, in order to apply a patch, is shown below.\n",
+    "\\`\\`\\`bash\n",
+    "{\"cmd\": [\"apply_patch\", \"<<'EOF'\\\\n*** Begin Patch\\\\n*** Update File: pygorithm/searching/binary_search.py\\\\n@@ class BaseClass\\\\n@@     def search():\\\\n-        pass\\\\n+        raise NotImplementedError()\\\\n@@ class Subclass\\\\n@@     def search():\\\\n-        pass\\\\n+        raise NotImplementedError()\\\\n*** End Patch\\\\nEOF\\\\n\"], \"workdir\": \"...\"}\n",
+    "\\`\\`\\`\n",
+    "File references can only be relative, NEVER ABSOLUTE. After the apply_patch command is run, it will always say \"Done!\", regardless of whether the patch was successfully applied or not. However, you can determine if there are issue and errors by looking at any warnings or logging lines printed BEFORE the \"Done!\" is output.\n",
+    "</apply_patch>\n",
+    "\n",
+    "<persistence>\n",
+    "You are an agent - please keep going until the user’s query is completely resolved, before ending your turn and yielding back to the user. Only terminate your turn when you are sure that the problem is solved.\n",
+    "- Never stop at uncertainty — research or deduce the most reasonable approach and continue.\n",
+    "- Do not ask the human to confirm assumptions — document them, act on them, and adjust mid-task if proven wrong.\n",
+    "</persistence>\n",
+    "\n",
+    "<exploration>\n",
+    "If you are not sure about file content or codebase structure pertaining to the user’s request, use your tools to read files and gather the relevant information: do NOT guess or make up an answer.\n",
+    "Before coding, always:\n",
+    "- Decompose the request into explicit requirements, unclear areas, and hidden assumptions.\n",
+    "- Map the scope: identify the codebase regions, files, functions, or libraries likely involved. If unknown, plan and perform targeted searches.\n",
+    "- Check dependencies: identify relevant frameworks, APIs, config files, data formats, and versioning concerns.\n",
+    "- Resolve ambiguity proactively: choose the most probable interpretation based on repo context, conventions, and dependency docs.\n",
+    "- Define the output contract: exact deliverables such as files changed, expected outputs, API responses, CLI behavior, and tests passing.\n",
+    "- Formulate an execution plan: research steps, implementation sequence, and testing strategy in your own words and refer to it as you work through the task.\n",
+    "</exploration>\n",
+    "\n",
+    "<verification>\n",
+    "Routinely verify your code works as you work through the task, especially any deliverables to ensure they run properly. Don't hand back to the user until you are sure that the problem is solved.\n",
+    "Exit excessively long running processes and optimize your code to run faster.\n",
+    "</verification>\n",
+    "\n",
+    "<efficiency>\n",
+    "Efficiency is key. you have a time limit. Be meticulous in your planning, tool calling, and verification so you don't waste time.\n",
+    "</efficiency>\n",
+    "\n",
+    "<final_instructions>\n",
+    "Never use editor tools to edit files. Always use the \\`apply_patch\\` tool.\n",
+    "</final_instructions>\n",
+    "```\n",
+    "\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/examples/gpt-5/outputs/login_page.html b/examples/gpt-5/outputs/login_page.html
new file mode 100644
index 0000000000..773d2bb726
--- /dev/null
+++ b/examples/gpt-5/outputs/login_page.html
@@ -0,0 +1,306 @@
+Here’s a self‑contained login page (single HTML file) that matches the light cream/amber theme, rounded cards, thin borders, and subtle shadows from your dashboard. Drop this in as login.html or adapt the variables to your design system.
+
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>Acumen Finance — Sign In</title>
+  <link rel="preconnect" href="https://fonts.googleapis.com">
+  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+  <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
+  <style>
+    :root{
+      /* Theme (tuned to match the screenshot) */
+      --bg: #fbf1d9;          /* page background (warm cream) */
+      --panel: #fff4c7;       /* card/panel fill */
+      --panel-2: #fff0b3;     /* slightly deeper card (hover/focus) */
+      --line: #e7d8a9;        /* thin borders */
+      --text: #2a2a2a;        /* primary text */
+      --muted: #6f6a57;       /* secondary text */
+      --accent: #f1b414;      /* amber */
+      --accent-600:#e19e07;
+      --accent-700:#c38603;
+      --focus: rgba(241,180,20,.35);
+      --radius: 12px;
+      --shadow: 0 1px 0 rgba(30, 15, 0, .03), 0 6px 20px rgba(30, 15, 0, .06);
+    }
+
+    * { box-sizing: border-box; }
+    html, body { height: 100%; }
+    body{
+      margin:0;
+      font-family: Inter, ui-sans-serif, system-ui, -apple-system, Segoe UI, Roboto, "Helvetica Neue", Arial, "Apple Color Emoji","Segoe UI Emoji";
+      color: var(--text);
+      background: radial-gradient(1200px 600px at 20% -10%, #fff7dc 0%, transparent 60%),
+                  radial-gradient(900px 500px at 110% 110%, #fff1c9 0%, transparent 60%),
+                  var(--bg);
+    }
+
+    /* Subtle top nav strip (echoing app layout) */
+    .bar{
+      height: 56px;
+      border-bottom: 1px solid var(--line);
+      background: color-mix(in oklab, var(--panel) 70%, white 30%);
+      display:flex; align-items:center; justify-content:space-between;
+      padding: 0 20px;
+    }
+    .brand{
+      display:flex; align-items:center; gap:12px; font-weight:600;
+    }
+    .logo{
+      width:28px; height:28px; border-radius:50%;
+      background: radial-gradient(circle at 30% 30%, #ffe59a 0 45%, #f5c648 46% 100%);
+      border:1px solid var(--line);
+      display:grid; place-items:center; color:#7a5a00; font-size:14px; font-weight:700;
+      box-shadow: 0 1px 0 #fff inset;
+    }
+    .bar .meta{
+      display:flex; align-items:center; gap:10px; color:var(--muted); font-size:14px;
+    }
+
+    /* Layout */
+    .wrap{
+      min-height: calc(100% - 56px);
+      display:grid;
+      place-items:center;
+      padding: 32px 16px;
+    }
+    .card{
+      width: 100%;
+      max-width: 420px;
+      background: var(--panel);
+      border: 1px solid var(--line);
+      border-radius: var(--radius);
+      box-shadow: var(--shadow);
+      padding: 28px;
+    }
+    .card header{
+      margin-bottom: 18px;
+    }
+    .title{
+      margin:0;
+      font-size: 22px;
+      line-height: 1.2;
+      letter-spacing: -0.01em;
+    }
+    .subtitle{
+      margin:6px 0 0;
+      color: var(--muted);
+      font-size: 14px;
+    }
+
+    form .field{
+      margin: 14px 0;
+    }
+    label{
+      display:block;
+      font-size: 13px;
+      color: var(--muted);
+      margin-bottom: 6px;
+    }
+    .input{
+      display:flex; align-items:center;
+      background: #fffdf4;
+      border:1px solid var(--line);
+      border-radius: 10px;
+      padding: 10px 12px;
+      gap: 8px;
+      transition: background .2s, border-color .2s, box-shadow .2s;
+    }
+    .input input{
+      border:0; outline:0; background:transparent; width:100%;
+      font-size: 15px; color: var(--text);
+    }
+    .input:focus-within{
+      background: #fff;
+      border-color: var(--accent);
+      box-shadow: 0 0 0 3px var(--focus);
+    }
+    .hint{
+      display:flex; justify-content:space-between; align-items:center;
+      margin-top: 10px;
+      font-size: 13px; color: var(--muted);
+    }
+    .link{
+      color: var(--accent-700);
+      text-decoration: none;
+    }
+    .link:hover{ text-decoration: underline; }
+
+    .btn{
+      width: 100%;
+      appearance: none;
+      border:1px solid transparent;
+      border-radius: 10px;
+      padding: 12px 14px;
+      font-weight: 600;
+      font-size: 15px;
+      cursor: pointer;
+      transition: transform .02s ease, background .2s, box-shadow .2s, border-color .2s;
+    }
+    .btn:active{ transform: translateY(1px); }
+
+    .btn-primary{
+      background: linear-gradient(180deg, #ffd56b, #f3b418);
+      border-color: color-mix(in oklab, var(--accent) 70%, #c48e03 30%);
+      color: #372a00;
+      box-shadow: 0 1px 0 #fff inset, 0 6px 14px rgba(194, 137, 3, .20);
+    }
+    .btn-primary:hover{
+      background: linear-gradient(180deg, #ffe081, #f0ae0d);
+    }
+    .btn-ghost{
+      background: #fffdf4;
+      border-color: var(--line);
+      color: #5f5225;
+    }
+    .btn-ghost:hover{
+      background: #fff;
+      border-color: #e8d8a6;
+    }
+
+    .row{ display:flex; gap:10px; }
+    .or{
+      display:flex; align-items:center; gap:12px; color:var(--muted); font-size:12px; margin:16px 0;
+    }
+    .or:before, .or:after{
+      content:""; height:1px; flex:1; background: var(--line);
+    }
+
+    .error{
+      margin-top: 8px;
+      font-size: 13px;
+      color: #7a1a00;
+      background: #fff0e6;
+      border: 1px solid #f2c4b2;
+      padding: 8px 10px;
+      border-radius: 8px;
+      display:none;
+    }
+
+    .foot{
+      text-align:center; margin-top:16px; color:var(--muted); font-size:12px;
+    }
+
+    /* Tiny decorative chart echoes */
+    .chips{
+      display:flex; gap:8px; margin-top:10px;
+    }
+    .chip{
+      height:8px; border-radius:999px; background: #ffe7a1; border:1px solid var(--line);
+      box-shadow: inset 0 1px 0 #fff;
+    }
+    .chip:nth-child(1){ width:26%; }
+    .chip:nth-child(2){ width:38%; }
+    .chip:nth-child(3){ width:18%; background:#ffd36f; }
+  </style>
+</head>
+<body>
+  <div class="bar" role="banner">
+    <div class="brand" aria-label="Acumen Finance">
+      <div class="logo" aria-hidden="true">A</div>
+      <div>Acumen Finance</div>
+    </div>
+    <div class="meta">Secure Sign In</div>
+  </div>
+
+  <main class="wrap">
+    <section class="card" role="dialog" aria-labelledby="title" aria-describedby="subtitle">
+      <header>
+        <h1 class="title" id="title">Welcome back</h1>
+        <p class="subtitle" id="subtitle">Sign in to continue to your dashboard</p>
+        <div class="chips" aria-hidden="true">
+          <div class="chip"></div><div class="chip"></div><div class="chip"></div>
+        </div>
+      </header>
+
+      <form id="loginForm" novalidate>
+        <div class="field">
+          <label for="email">Email</label>
+          <div class="input">
+            <input id="email" name="email" type="email" inputmode="email" autocomplete="username" placeholder="you@company.com" required />
+          </div>
+        </div>
+
+        <div class="field">
+          <label for="password">Password</label>
+          <div class="input">
+            <input id="password" name="password" type="password" autocomplete="current-password" placeholder="••••••••" required minlength="8" />
+            <button type="button" id="togglePw" class="link" style="border:0;background:transparent;padding:0 2px;">Show</button>
+          </div>
+          <div class="hint">
+            <label style="display:flex;align-items:center;gap:8px;">
+              <input type="checkbox" id="remember" name="remember" /> Remember me
+            </label>
+            <a href="#" class="link">Forgot password?</a>
+          </div>
+        </div>
+
+        <div class="error" id="errorBox" role="alert" aria-live="polite"></div>
+
+        <div class="field">
+          <button class="btn btn-primary" type="submit" id="submitBtn">Sign In</button>
+        </div>
+
+        <div class="or">or</div>
+
+        <div class="row">
+          <button class="btn btn-ghost" type="button" aria-label="Sign in with Google">Sign in with Google</button>
+          <button class="btn btn-ghost" type="button" aria-label="Sign in with SSO">Company SSO</button>
+        </div>
+
+        <p class="foot">Don’t have an account? <a class="link" href="#">Create one</a></p>
+      </form>
+    </section>
+
+    <p class="foot" style="margin-top:18px;">© 2025 Acumen</p>
+  </main>
+
+  <script>
+    const form = document.getElementById('loginForm');
+    const errorBox = document.getElementById('errorBox');
+    const submitBtn = document.getElementById('submitBtn');
+    const togglePw = document.getElementById('togglePw');
+    const pw = document.getElementById('password');
+
+    togglePw.addEventListener('click', () => {
+      const isPw = pw.type === 'password';
+      pw.type = isPw ? 'text' : 'password';
+      togglePw.textContent = isPw ? 'Hide' : 'Show';
+      pw.focus();
+    });
+
+    form.addEventListener('submit', (e) => {
+      e.preventDefault();
+      errorBox.style.display = 'none';
+      const email = form.email.value.trim();
+      const password = form.password.value;
+
+      const emailValid = /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
+      if (!emailValid) return showError('Please enter a valid email address.');
+      if (password.length < 8) return showError('Your password must be at least 8 characters.');
+
+      submitBtn.disabled = true;
+      submitBtn.textContent = 'Signing in…';
+
+      // Replace with real request
+      setTimeout(() => {
+        // Demo success redirect
+        window.location.href = '/';
+      }, 800);
+    });
+
+    function showError(msg){
+      errorBox.textContent = msg;
+      errorBox.style.display = 'block';
+    }
+  </script>
+</body>
+</html>
+
+Notes to adapt:
+- Colors are controlled via CSS variables at the top. If you already have tokens, map them there.
+- Buttons, borders, and radii mirror the dashboard’s soft, rounded, amber-accented style.
+- Includes password show/hide, basic client validation, Remember me, and placeholders for Google/SSO.
+- Replace window.location redirect and the SSO/Google handlers with your auth logic.
\ No newline at end of file
diff --git a/examples/gpt-5/outputs/retro_dark.html b/examples/gpt-5/outputs/retro_dark.html
new file mode 100644
index 0000000000..1f92468db3
--- /dev/null
+++ b/examples/gpt-5/outputs/retro_dark.html
@@ -0,0 +1,622 @@
+Here’s a complete, single-file landing page with a retro-arcade noir vibe. Save this as index.html and open in a browser.
+
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>Noircade — Retro Arcade Noir Store</title>
+  <meta name="description" content="Noircade is your retro-arcade noir destination. Curated classics, restored cabinets, original carts, and neon vibes." />
+  <meta property="og:title" content="Noircade — Retro Arcade Noir Store" />
+  <meta property="og:description" content="Curated classics, restored cabinets, original carts, and neon vibes." />
+  <meta property="og:type" content="website" />
+  <meta property="og:image" content="https://placehold.co/1200x630/0b0b12/40f9ff?text=Noircade" />
+  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+  <link rel="preconnect" href="https://fonts.googleapis.com">
+  <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;500;700&family=Press+Start+2P&display=swap" rel="stylesheet">
+
+  <style>
+    :root{
+      --ink:#09090f;
+      --noir:#0b0b12;
+      --noir-2:#0f0f19;
+      --vignette: rgba(0,0,0,0.55);
+      --cyan:#40f9ff;
+      --mag:#ff3b9d;
+      --amber:#ffcf6e;
+      --lime:#a8ff60;
+      --muted:#9aa0ac;
+      --card:#121223;
+      --edge:#1b1b2e;
+      --glow-weak: 0 0 6px var(--cyan);
+      --glow-strong: 0 0 16px var(--cyan), 0 0 32px rgba(64,249,255,.35);
+    }
+
+    * { box-sizing:border-box }
+    html,body{ height:100% }
+    body{
+      margin:0;
+      font-family: Inter, system-ui, -apple-system, Segoe UI, Roboto, Arial, sans-serif;
+      color:#e9ecf1;
+      background:
+        radial-gradient(1200px 700px at 75% -10%, rgba(64,249,255,.06), transparent 60%),
+        radial-gradient(1000px 600px at 10% 0%, rgba(255,59,157,.05), transparent 60%),
+        radial-gradient(1200px 800px at 50% 110%, rgba(255,207,110,.04), transparent 60%),
+        linear-gradient(180deg, var(--ink), var(--noir));
+      overflow-x:hidden;
+    }
+
+    /* Subtle vignette */
+    body::after{
+      content:"";
+      position:fixed; inset:-2px;
+      pointer-events:none;
+      background:radial-gradient(90vw 70vh at 50% 50%, transparent 60%, var(--vignette) 100%);
+      mix-blend-mode:multiply;
+      z-index:0;
+    }
+
+    /* Scanlines + noise overlay */
+    .scanlines{
+      position:fixed; inset:0; pointer-events:none; z-index:2; opacity:.12;
+      background:
+        repeating-linear-gradient(to bottom, rgba(0,0,0,.25) 0 2px, rgba(0,0,0,0) 2px 4px),
+        repeating-linear-gradient(90deg, rgba(255,255,255,.025) 0 1px, rgba(0,0,0,0) 1px 2px);
+      animation:roll 8s linear infinite;
+    }
+    @keyframes roll{ to{ transform:translateY(4px) } }
+
+    /* Starfield canvas sits behind everything */
+    #stars{
+      position:fixed; inset:0; z-index:0; pointer-events:none; opacity:.35;
+      filter: blur(.3px) contrast(1.1) brightness(.9);
+    }
+
+    a{ color:var(--cyan); text-decoration:none }
+    a:hover{ text-decoration:underline }
+
+    header{
+      position:sticky; top:0; z-index:5;
+      background:linear-gradient(180deg, rgba(10,10,18,.85), rgba(10,10,18,.4));
+      backdrop-filter: blur(6px);
+      border-bottom:1px solid rgba(64,249,255,.12);
+    }
+    .nav{
+      max-width:1200px; margin:0 auto; padding:16px 20px;
+      display:flex; align-items:center; justify-content:space-between; gap:16px;
+    }
+    .brand{
+      display:flex; align-items:center; gap:12px; text-transform:uppercase; letter-spacing:.08em;
+      font-family:"Press Start 2P", monospace; font-size:14px; color:#e9ecf1;
+      text-shadow:0 0 0 var(--cyan);
+      filter: drop-shadow(0 0 2px rgba(64,249,255,.35));
+    }
+    .brand .logo{
+      width:28px; height:28px; display:grid; place-items:center;
+      border:1px solid rgba(64,249,255,.45);
+      border-radius:4px;
+      box-shadow: inset 0 0 12px rgba(64,249,255,.18), 0 0 16px rgba(64,249,255,.18);
+      position:relative; overflow:hidden;
+      background: radial-gradient(120% 120% at 30% 20%, rgba(64,249,255,.15), transparent 50%);
+    }
+    .brand .logo::after{
+      content:""; position:absolute; inset:0;
+      background:conic-gradient(from 220deg at 50% 50%, rgba(255,59,157,.25), rgba(64,249,255,.25), transparent 40%);
+      mix-blend-mode:screen; opacity:.5;
+    }
+    nav ul{ display:flex; gap:18px; list-style:none; margin:0; padding:0 }
+    nav a{ color:#e6ebff; opacity:.85 }
+    nav a:hover{ opacity:1 }
+
+    .cta{
+      display:flex; align-items:center; gap:10px;
+    }
+    .btn{
+      --c:var(--cyan);
+      appearance:none; border:none; padding:10px 14px; border-radius:8px;
+      color:#001517; background:linear-gradient(180deg, var(--c), #7dfcff);
+      font-weight:700; letter-spacing:.02em; cursor:pointer;
+      box-shadow:0 4px 20px rgba(64,249,255,.25), inset 0 -2px 6px rgba(0,0,0,.25);
+      transform: translateZ(0);
+    }
+    .btn:hover{ filter:brightness(1.05) saturate(1.1) }
+    .btn.outline{
+      background:transparent; color:var(--cyan);
+      border:1px solid rgba(64,249,255,.45); box-shadow: var(--glow-weak);
+    }
+
+    main{ position:relative; z-index:1 }
+
+    .hero{
+      max-width:1200px; margin:0 auto; padding:80px 20px 40px; display:grid; grid-template-columns:1.2fr .8fr; gap:32px; align-items:center;
+    }
+    @media (max-width: 900px){
+      .hero{ grid-template-columns:1fr; padding-top:56px }
+      .hero-visual{ order:-1 }
+    }
+
+    .headline{
+      font-family:"Press Start 2P", monospace; font-size: clamp(24px, 3vw + 18px, 48px);
+      line-height:1.2; letter-spacing:.02em; color:#ebffff;
+      text-shadow: 0 0 8px rgba(64,249,255,.4), 0 0 24px rgba(255,59,157,.18);
+      animation:flicker 6s infinite steps(100, end);
+    }
+    @keyframes flicker{
+      0%, 7%, 100% { opacity:1; }
+      3% { opacity:.75; }
+      5% { opacity:.4; }
+      6% { opacity:.9; }
+      32% { text-shadow: 0 0 10px rgba(64,249,255,.6), 0 0 28px rgba(255,59,157,.25) }
+    }
+    .sub{
+      max-width:52ch; color:#cdd3df; font-size:16px; line-height:1.7;
+    }
+    .hero-actions{ display:flex; gap:12px; margin-top:18px; flex-wrap:wrap }
+
+    .ticker{
+      margin-top:16px; border:1px solid rgba(64,249,255,.25); border-radius:10px; overflow:hidden;
+      background:linear-gradient(180deg, rgba(17,17,30,.8), rgba(12,12,22,.8));
+      position:relative;
+    }
+    .ticker .row{
+      display:flex; gap:32px; white-space:nowrap; padding:12px 0;
+      font-family:"Press Start 2P", monospace; font-size:12px; color:#a6fffb;
+      text-shadow:0 0 6px rgba(64,249,255,.35);
+      animation:marquee 22s linear infinite;
+    }
+    .ticker .row span{ padding:0 20px }
+    @keyframes marquee { to{ transform:translateX(-50%) } }
+
+    .hero-visual{
+      position:relative; min-height:360px;
+      background: radial-gradient(160% 140% at 80% 0%, rgba(64,249,255,.08), transparent 60%), linear-gradient(180deg, var(--card), var(--edge));
+      border:1px solid rgba(64,249,255,.2);
+      border-radius:16px; overflow:hidden;
+      box-shadow: inset 0 0 60px rgba(64,249,255,.06), 0 20px 60px rgba(0,0,0,.6);
+    }
+    .hero-visual .crt{
+      position:absolute; inset:18px; border-radius:12px; background:#090912;
+      border:1px solid rgba(255,255,255,.06);
+      box-shadow: inset 0 0 24px rgba(64,249,255,.08);
+      overflow:hidden;
+    }
+    .crt::before{
+      content:""; position:absolute; inset:0; pointer-events:none;
+      background:
+        repeating-linear-gradient(to bottom, rgba(255,255,255,.04) 0 1px, rgba(0,0,0,0) 1px 3px),
+        linear-gradient(180deg, rgba(64,249,255,.08), rgba(255,59,157,.06));
+      mix-blend-mode:overlay;
+      opacity:.25;
+    }
+    .crt .glow{
+      position:absolute; inset:0; background:radial-gradient(80% 70% at 50% 50%, rgba(64,249,255,.18), transparent 70%)
+    }
+    .crt .title{
+      position:absolute; bottom:14px; left:14px; right:14px;
+      font-family:"Press Start 2P", monospace; font-size:13px; color:#a8fffd;
+      text-shadow:0 0 10px rgba(64,249,255,.5);
+      display:flex; align-items:center; justify-content:space-between;
+    }
+    .crt .crt-anim{
+      position:absolute; inset:0; display:grid; place-items:center; color:#72fff7;
+      font-family:"Press Start 2P", monospace; font-size:32px; letter-spacing:.05em;
+      text-shadow:0 0 12px rgba(64,249,255,.7), 0 0 24px rgba(255,59,157,.35);
+      animation: glitch 3.6s infinite;
+    }
+    @keyframes glitch{
+      0% { transform:translate(0,0) }
+      10% { transform:translate(-1px, 0) }
+      11% { transform:translate(1px, 0) }
+      12% { transform:translate(0,0) }
+      50% { filter:hue-rotate(10deg) }
+      65% { transform:skewX(.7deg) }
+      100% { transform:translate(0,0) }
+    }
+    .crt .scan{
+      position:absolute; inset:0; background:linear-gradient(180deg, transparent 70%, rgba(64,249,255,.12) 100%);
+      mix-blend-mode:screen; animation: sweep 5s linear infinite;
+    }
+    @keyframes sweep{ 0%{ transform:translateY(-100%) } 100%{ transform:translateY(100%) } }
+
+    .section{
+      max-width:1200px; margin:24px auto; padding:0 20px;
+    }
+    .kicker{
+      font-family:"Press Start 2P", monospace; font-size:12px; color:var(--amber);
+      letter-spacing:.08em; text-transform:uppercase; opacity:.9; margin-bottom:10px;
+      text-shadow:0 0 8px rgba(255,207,110,.3);
+    }
+    .h2{
+      font-family:"Press Start 2P", monospace; font-size:24px; color:#e9faff;
+      text-shadow:0 0 8px rgba(64,249,255,.35);
+      margin:0 0 14px;
+    }
+    .features{
+      display:grid; grid-template-columns:repeat(3, 1fr); gap:16px;
+    }
+    @media (max-width: 900px){ .features{ grid-template-columns:1fr } }
+    .card{
+      border:1px solid rgba(64,249,255,.2); border-radius:14px; overflow:hidden;
+      background:linear-gradient(180deg, rgba(20,20,38,.8), rgba(12,12,22,.9));
+      box-shadow: inset 0 0 32px rgba(64,249,255,.05);
+    }
+    .card .inner{ padding:18px }
+    .card .title{
+      display:flex; align-items:center; gap:10px; font-weight:700; color:#eaf9ff;
+    }
+    .card .title svg{ width:18px; height:18px; color:var(--cyan); filter: drop-shadow(0 0 6px rgba(64,249,255,.6)); }
+    .muted{ color:#b6bdc9 }
+
+    .grid{
+      display:grid; grid-template-columns: repeat(4, 1fr); gap:16px;
+    }
+    @media (max-width: 1100px){ .grid{ grid-template-columns: repeat(3, 1fr) } }
+    @media (max-width: 800px){ .grid{ grid-template-columns: repeat(2, 1fr) } }
+    @media (max-width: 520px){ .grid{ grid-template-columns: 1fr } }
+
+    .game{
+      display:flex; flex-direction:column; overflow:hidden; border-radius:12px;
+      border:1px solid rgba(64,249,255,.18);
+      background: linear-gradient(180deg, #14142c, #0d0d1e);
+    }
+    .game .media{
+      position:relative; aspect-ratio: 4/3; overflow:hidden;
+      background: radial-gradient(100% 100% at 50% 35%, rgba(64,249,255,.12), rgba(255,59,157,.08), transparent 70%);
+    }
+    .game .media img{
+      width:100%; height:100%; object-fit:cover; display:block; filter: contrast(1.05) saturate(1.1);
+      mix-blend-mode: lighten; opacity:.95;
+    }
+    .game .media::after{
+      content:""; position:absolute; inset:0; background:
+        repeating-linear-gradient(to bottom, rgba(255,255,255,.06) 0 1px, rgba(0,0,0,0) 1px 3px);
+      opacity:.15; pointer-events:none;
+    }
+    .game .meta{ padding:12px 12px 14px; display:flex; justify-content:space-between; align-items:center; gap:10px }
+    .tag{
+      font-family:"Press Start 2P", monospace; font-size:10px; color:#001517; padding:5px 7px; border-radius:6px;
+      background:linear-gradient(180deg, var(--amber), #ffde9b);
+      box-shadow: 0 3px 12px rgba(255,207,110,.3);
+    }
+    .price{
+      font-weight:700; color:#eafffb
+    }
+
+    .newsletter{
+      display:grid; grid-template-columns:2fr 3fr; gap:18px; align-items:center;
+      border:1px solid rgba(64,249,255,.18); border-radius:14px; overflow:hidden;
+      background: linear-gradient(180deg, rgba(20,20,38,.8), rgba(12,12,22,.9));
+      padding:18px;
+    }
+    @media (max-width: 900px){ .newsletter{ grid-template-columns:1fr } }
+    .newsletter form{
+      display:flex; gap:10px; flex-wrap:wrap
+    }
+    .field{
+      flex:1 1 260px; min-width:200px; display:flex; align-items:center; gap:8px;
+      background:#0c0c17; border:1px solid rgba(64,249,255,.25); border-radius:8px; padding:10px 12px;
+      color:#eaf8ff; box-shadow: inset 0 0 10px rgba(64,249,255,.06);
+    }
+    .field input{
+      flex:1; min-width:120px; background:transparent; border:none; outline:none; color:#eaf8ff; font-size:15px;
+    }
+    .toggle{
+      display:flex; align-items:center; gap:8px; font-size:13px; color:#cfefff;
+    }
+    .switch{
+      width:44px; height:24px; border-radius:999px; background: #111225; border:1px solid rgba(64,249,255,.3); position:relative; cursor:pointer;
+      box-shadow: inset 0 0 10px rgba(64,249,255,.1);
+    }
+    .switch i{
+      position:absolute; top:2px; left:2px; width:20px; height:20px; border-radius:50%;
+      background: linear-gradient(180deg, var(--cyan), #7dfcff); box-shadow: var(--glow-weak); transition: transform .2s ease;
+    }
+    .switch.on i { transform: translateX(20px) }
+
+    footer{
+      margin-top:40px; border-top:1px solid rgba(64,249,255,.18);
+      background:linear-gradient(180deg, rgba(10,10,20,.6), rgba(10,10,20,.9));
+    }
+    .foot{
+      max-width:1200px; margin:0 auto; padding:22px 20px; display:flex; align-items:center; justify-content:space-between; gap:14px;
+    }
+    .social{ display:flex; gap:12px }
+    .social a{
+      width:36px; height:36px; display:grid; place-items:center; border-radius:8px; color:#a2eff2;
+      border:1px solid rgba(64,249,255,.25);
+      background: linear-gradient(180deg, rgba(20,20,38,.8), rgba(12,12,22,.9));
+      box-shadow: 0 0 8px rgba(64,249,255,.15);
+    }
+    .social a:hover{ color:#001517; background:linear-gradient(180deg, var(--cyan), #7dfcff) }
+
+    /* Accessibility helpers */
+    .sr-only{
+      position:absolute; width:1px; height:1px; padding:0; margin:-1px; overflow:hidden; clip:rect(0,0,0,0); white-space:nowrap; border:0;
+    }
+  </style>
+</head>
+<body>
+  <canvas id="stars" aria-hidden="true"></canvas>
+  <div class="scanlines" aria-hidden="true"></div>
+
+  <header>
+    <div class="nav">
+      <div class="brand" aria-label="Noircade home">
+        <div class="logo" aria-hidden="true">
+          <!-- pixel coin -->
+          <svg width="20" height="20" viewBox="0 0 20 20" fill="none" aria-hidden="true">
+            <rect x="5" y="3" width="10" height="14" rx="2" ry="2" fill="#ffcf6e" stroke="#f7b84f" stroke-width="1"/>
+            <rect x="8" y="6" width="4" height="8" fill="#ffd98f"/>
+          </svg>
+        </div>
+        <span>Noircade</span>
+      </div>
+      <nav aria-label="Primary">
+        <ul>
+          <li><a href="#games">Games</a></li>
+          <li><a href="#cabinets">Cabinets</a></li>
+          <li><a href="#merch">Merch</a></li>
+          <li><a href="#about">About</a></li>
+        </ul>
+      </nav>
+      <div class="cta">
+        <button class="btn outline" id="toggle-crt" title="Toggle CRT mode">CRT</button>
+        <button class="btn">Insert Coin</button>
+      </div>
+    </div>
+  </header>
+
+  <main>
+    <section class="hero">
+      <div>
+        <div class="kicker">Retro-Arcade Noir</div>
+        <h1 class="headline">Curated classics. Neon nights. Pixel-perfect noir.</h1>
+        <p class="sub">Original carts and boards, restored cabinets, and artisan-grade mods. We source, authenticate, and service the greats—so every session feels like a smoky back-alley arcade at 2 a.m.</p>
+        <div class="hero-actions">
+          <a class="btn" href="#games">Enter the Arcade</a>
+          <a class="btn outline" href="#newsletter">Get Drops</a>
+        </div>
+        <div class="ticker" role="marquee" aria-label="Latest updates">
+          <div class="row">
+            <span>New Drop: Neo-Noir Collection Vol. II</span>
+            <span>Restored: Astro City + CPS-2 bundle</span>
+            <span>Authentic PCBs • Tested • Warranty</span>
+            <span>Limited Merch: Afterglow Tees</span>
+            <span>New Drop: Neo-Noir Collection Vol. II</span>
+            <span>Restored: Astro City + CPS-2 bundle</span>
+            <span>Authentic PCBs • Tested • Warranty</span>
+            <span>Limited Merch: Afterglow Tees</span>
+          </div>
+        </div>
+      </div>
+      <div class="hero-visual" aria-hidden="true">
+        <div class="crt">
+          <div class="crt-anim">NOIRCADE</div>
+          <div class="glow"></div>
+          <div class="scan"></div>
+          <div class="title"><span>CRT Sim</span><span>VHS: ON</span></div>
+        </div>
+      </div>
+    </section>
+
+    <section class="section" id="about">
+      <h2 class="h2">Why Noircade?</h2>
+      <div class="features">
+        <div class="card">
+          <div class="inner">
+            <div class="title">
+              <svg viewBox="0 0 24 24" fill="none"><path d="M4 7h16M4 12h16M4 17h16" stroke="currentColor" stroke-width="2" stroke-linecap="round"/></svg>
+              Original Boards
+            </div>
+            <p class="muted">We hunt genuine PCBs and carts, then verify with multi-point inspection. No clones, no guesswork.</p>
+          </div>
+        </div>
+        <div class="card">
+          <div class="inner">
+            <div class="title">
+              <svg viewBox="0 0 24 24" fill="none"><path d="M12 2v20M2 12h20" stroke="currentColor" stroke-width="2" stroke-linecap="round"/></svg>
+              Restored Cabinets
+            </div>
+            <p class="muted">Cabs recapped, calibrated, and de-buzzed. From CRT convergence to stick microswitches—we dial it in.</p>
+          </div>
+        </div>
+        <div class="card">
+          <div class="inner">
+            <div class="title">
+              <svg viewBox="0 0 24 24" fill="none"><path d="M4 12l4 4 12-12" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/></svg>
+              Play-Ready Warranty
+            </div>
+            <p class="muted">Every purchase is burn-in tested and covered. Your noir nights shouldn’t end on a black screen.</p>
+          </div>
+        </div>
+      </div>
+    </section>
+
+    <section class="section" id="games">
+      <h2 class="h2">Featured Games</h2>
+      <div class="grid">
+        <article class="game">
+          <div class="media">
+            <img src="https://images.unsplash.com/photo-1546550830-8f00ce70d4cb?q=80&w=1200&auto=format&fit=crop" alt="Retro joystick and arcade buttons glowing cyan" />
+          </div>
+          <div class="meta">
+            <span class="tag">PCB</span>
+            <span class="price">$349</span>
+          </div>
+        </article>
+        <article class="game">
+          <div class="media">
+            <img src="https://images.unsplash.com/photo-1610056494062-12550cf4bb71?q=80&w=1200&auto=format&fit=crop" alt="Cartridge stack with neon highlights" />
+          </div>
+          <div class="meta">
+            <span class="tag">Cart</span>
+            <span class="price">$119</span>
+          </div>
+        </article>
+        <article class="game">
+          <div class="media">
+            <img src="https://images.unsplash.com/photo-1537633552985-df8429e8048b?q=80&w=1200&auto=format&fit=crop" alt="Arcade cabinet in a dark room with magenta glow" />
+          </div>
+          <div class="meta">
+            <span class="tag">Cab</span>
+            <span class="price">$2,799</span>
+          </div>
+        </article>
+        <article class="game">
+          <div class="media">
+            <img src="https://images.unsplash.com/photo-1607156577912-3e40b2f2f235?q=80&w=1200&auto=format&fit=crop" alt="Pixel screen close-up with scanlines" />
+          </div>
+          <div class="meta">
+            <span class="tag">Mod</span>
+            <span class="price">$189</span>
+          </div>
+        </article>
+        <article class="game">
+          <div class="media">
+            <img src="https://images.unsplash.com/photo-1520975916090-3105956dac38?q=80&w=1200&auto=format&fit=crop" alt="Retro handheld console in cyan light" />
+          </div>
+          <div class="meta">
+            <span class="tag">Handheld</span>
+            <span class="price">$229</span>
+          </div>
+        </article>
+        <article class="game">
+          <div class="media">
+            <img src="https://images.unsplash.com/photo-1607853554439-0069ec0f29ea?q=80&w=1200&auto=format&fit=crop" alt="Neon arcade hallway" />
+          </div>
+          <div class="meta">
+            <span class="tag">Set</span>
+            <span class="price">$649</span>
+          </div>
+        </article>
+        <article class="game">
+          <div class="media">
+            <img src="https://images.unsplash.com/photo-1520975867597-0af37a22e31a?q=80&w=1200&auto=format&fit=crop" alt="Arcade buttons close-up" />
+          </div>
+          <div class="meta">
+            <span class="tag">Parts</span>
+            <span class="price">$39</span>
+          </div>
+        </article>
+        <article class="game">
+          <div class="media">
+            <img src="https://images.unsplash.com/photo-1523821741446-edb2b68bb7a0?q=80&w=1200&auto=format&fit=crop" alt="Retro TV scanline glow" />
+          </div>
+          <div class="meta">
+            <span class="tag">CRT</span>
+            <span class="price">$499</span>
+          </div>
+        </article>
+      </div>
+    </section>
+
+    <section class="section" id="newsletter">
+      <h2 class="h2">Stay in the Glow</h2>
+      <div class="newsletter">
+        <div>
+          <div class="kicker">Drops, restocks, secrets</div>
+          <p class="muted">Be first in line for rare boards, cabinet restocks, and late-night flash sales.</p>
+        </div>
+        <form onsubmit="event.preventDefault(); alert('Thanks! You’re on the list.');" aria-label="Newsletter signup">
+          <label class="sr-only" for="email">Email</label>
+          <div class="field">
+            <svg aria-hidden="true" width="18" height="18" viewBox="0 0 24 24" fill="none"><path d="M4 6h16v12H4z" stroke="#86faff" stroke-width="2"/><path d="M4 7l8 6 8-6" stroke="#86faff" stroke-width="2"/></svg>
+            <input id="email" type="email" placeholder="you@noircade.gg" required>
+          </div>
+          <button class="btn" type="submit">Get Notified</button>
+          <div class="toggle" title="Toggle scanlines">
+            <div class="switch" id="scan-switch" role="switch" aria-checked="true" tabindex="0"><i></i></div>
+            <span>Scanlines</span>
+          </div>
+        </form>
+      </div>
+    </section>
+  </main>
+
+  <footer>
+    <div class="foot">
+      <div class="muted">© <span id="year"></span> Noircade. Built for the night shift.</div>
+      <div class="social" aria-label="Social links">
+        <a href="#" aria-label="Instagram">
+          <svg width="18" height="18" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true"><path d="M7 2h10a5 5 0 0 1 5 5v10a5 5 0 0 1-5 5H7a5 5 0 0 1-5-5V7a5 5 0 0 1 5-5Zm5 5a5 5 0 1 0 0 10 5 5 0 0 0 0-10Zm6.5-.25a1.25 1.25 0 1 0 0 2.5 1.25 1.25 0 0 0 0-2.5Z"/></svg>
+        </a>
+        <a href="#" aria-label="Twitter">
+          <svg width="18" height="18" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true"><path d="M22 5.8c-.7.3-1.5.5-2.2.6.8-.5 1.4-1.2 1.7-2.2-.8.5-1.7.8-2.6 1C18 4.4 17 4 16 4c-2.1 0-3.7 1.9-3.3 4-3-.1-5.7-1.7-7.5-4-1 1.7-.5 3.9 1.2 5-.6 0-1.2-.2-1.7-.5 0 2 1.4 3.7 3.3 4.1-.6.2-1.2.2-1.8.1.5 1.6 2 2.8 3.8 2.8C7.8 17.1 6 17.7 4 17.6c1.9 1.2 4.1 1.9 6.4 1.9 7.7 0 12-6.5 11.6-12.3.8-.6 1.5-1.3 2-2.1Z"/></svg>
+        </a>
+        <a href="#" aria-label="YouTube">
+          <svg width="18" height="18" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true"><path d="M23 7.5s-.2-1.7-.8-2.4c-.8-.8-1.7-.8-2.2-.9C16.9 4 12 4 12 4h0s-4.9 0-7.9.2c-.5.1-1.4.1-2.2.9C1.3 5.8 1 7.5 1 7.5S.8 9.5.8 11.6v1c0 2 .2 4 .2 4s.2 1.7.8 2.4c.8.8 1.9.8 2.4.9 1.8.2 7.8.2 7.8.2s4.9 0 7.9-.2c.5-.1 1.4-.1 2.2-.9.6-.8.8-2.4.8-2.4s.2-2 .2-4v-1c0-2-.2-4-.2-4ZM9.8 9.7l6.4 3.7-6.4 3.7V9.7Z"/></svg>
+        </a>
+      </div>
+    </div>
+  </footer>
+
+  <script>
+    // Year
+    document.getElementById('year').textContent = new Date().getFullYear();
+
+    // Scanline toggle
+    const scanSwitch = document.getElementById('scan-switch');
+    const scanOverlay = document.querySelector('.scanlines');
+    function setScan(on){
+      scanSwitch.classList.toggle('on', on);
+      scanSwitch.setAttribute('aria-checked', on ? 'true' : 'false');
+      scanOverlay.style.display = on ? 'block' : 'none';
+    }
+    scanSwitch.addEventListener('click', ()=> setScan(!scanSwitch.classList.contains('on')));
+    scanSwitch.addEventListener('keydown', (e)=>{ if(e.key===' '||e.key==='Enter'){ e.preventDefault(); setScan(!scanSwitch.classList.contains('on')); }});
+    setScan(true);
+
+    // CRT button toggles body flicker class
+    const crtBtn = document.getElementById('toggle-crt');
+    let crtOn = true;
+    crtBtn.addEventListener('click', ()=>{
+      crtOn = !crtOn;
+      document.body.style.filter = crtOn ? 'contrast(1.02) saturate(1.05)' : 'none';
+      crtBtn.textContent = crtOn ? 'CRT' : 'Clean';
+    });
+
+    // Starfield
+    (function(){
+      const c = document.getElementById('stars');
+      const ctx = c.getContext('2d');
+      let w, h, dpr;
+      let stars = [];
+      function resize(){
+        dpr = Math.min(window.devicePixelRatio || 1, 2);
+        w = c.width = Math.floor(window.innerWidth * dpr);
+        h = c.height = Math.floor(window.innerHeight * dpr);
+        c.style.width = window.innerWidth + 'px';
+        c.style.height = window.innerHeight + 'px';
+        spawn();
+      }
+      function spawn(){
+        const count = Math.floor((w*h) / (9000 * dpr));
+        stars = new Array(count).fill(0).map(()=>({
+          x: Math.random()*w,
+          y: Math.random()*h,
+          z: Math.random()*1 + 0.3,
+          s: Math.random()*0.9 + 0.2,
+          tw: Math.random()*Math.PI*2
+        }));
+      }
+      function tick(t){
+        ctx.clearRect(0,0,w,h);
+        for(const st of stars){
+          st.y += st.z*0.2;
+          if(st.y > h) st.y = -2;
+          st.tw += 0.03*st.z;
+          const alpha = 0.6 + Math.sin(st.tw)*0.4;
+          ctx.fillStyle = `rgba(64,249,255,${0.45*alpha})`;
+          ctx.fillRect(st.x, st.y, st.s, st.s);
+          // magenta ghost
+          ctx.fillStyle = `rgba(255,59,157,${0.12*alpha})`;
+          ctx.fillRect(st.x+1, st.y, st.s, st.s);
+        }
+        requestAnimationFrame(tick);
+      }
+      window.addEventListener('resize', resize, {passive:true});
+      resize(); tick();
+    })();
+  </script>
+</body>
+</html>
\ No newline at end of file
diff --git a/examples/gpt-5/outputs/retro_light.html b/examples/gpt-5/outputs/retro_light.html
new file mode 100644
index 0000000000..017e411d6d
--- /dev/null
+++ b/examples/gpt-5/outputs/retro_light.html
@@ -0,0 +1,461 @@
+Here’s a single-file, responsive landing page you can save as index.html. It’s light, pastel, and flowery with gentle retro vibes (no external images needed).
+
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width,initial-scale=1" />
+  <title>Bloom & Bits — Retro Games, Sweet and Simple</title>
+  <meta name="description" content="A pastel, flower-powered retro games store. Consoles, cartridges, handhelds—play it sweet and retro." />
+  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+  <link href="https://fonts.googleapis.com/css2?family=Fredoka:wght@400;500;600;700&family=Press+Start+2P&display=swap" rel="stylesheet">
+  <style>
+    :root{
+      --sky:#EAF6FF;
+      --sun:#FFEAA7;
+      --cloud:#FFFFFF;
+      --ink:#314154;
+      --ink-soft:#506176;
+      --accent:#FF9EC1;
+      --accent-2:#B8E0FF;
+      --accent-3:#FFE7A3;
+      --grass:#CDECB6;
+      --hill-1:#BDE5AE;
+      --hill-2:#A7DBA0;
+      --flower-pink:#FFB7C3;
+      --flower-yellow:#FFE7A3;
+      --flower-blue:#C8DCFF;
+      --chip:#FDF7FF;
+      --btn:#FFD1DC;
+      --btn-2:#BDE3FF;
+      --shadow: 0 10px 24px rgba(49,65,84,.08), 0 2px 8px rgba(49,65,84,.06);
+      --radius:18px;
+    }
+    *{box-sizing:border-box}
+    html,body{margin:0;padding:0}
+    body{
+      font-family: "Fredoka", system-ui, -apple-system, Segoe UI, Roboto, Ubuntu, "Helvetica Neue", Arial, "Apple Color Emoji", "Segoe UI Emoji";
+      color:var(--ink);
+      background:
+        radial-gradient(420px 420px at 80% -80%, var(--sun) 0 45%, transparent 46%) no-repeat,
+        linear-gradient(to bottom, var(--sky), #F7FCFF 60%);
+      min-height:100vh;
+      overflow-x:hidden;
+    }
+    .container{width:min(1120px, 92vw); margin-inline:auto}
+    a{color:inherit; text-decoration:none}
+    button{font:inherit}
+    .site-header{
+      position:sticky; top:0; z-index:50; background:rgba(255,255,255,.7); backdrop-filter: blur(8px);
+      border-bottom:1px solid rgba(49,65,84,.06)
+    }
+    .nav{
+      display:flex; align-items:center; justify-content:space-between; gap:16px; padding:14px 0;
+    }
+    .brand{display:flex; align-items:center; gap:12px}
+    .brand-mark{
+      width:40px; height:40px; border-radius:10px; background:linear-gradient(135deg, var(--accent), var(--accent-2));
+      box-shadow: var(--shadow); position:relative; overflow:hidden;
+    }
+    .brand-mark::before, .brand-mark::after{
+      content:""; position:absolute; background:var(--flower-yellow); border-radius:50%;
+    }
+    .brand-mark::before{ width:20px; height:20px; left:6px; top:10px; box-shadow: 18px 0 0 0 var(--flower-pink)}
+    .brand-mark::after{ width:8px; height:8px; left:16px; top:16px; background:#fff }
+    .brand-name{
+      display:flex; flex-direction:column; line-height:1;
+    }
+    .brand-name strong{font-family:"Press Start 2P", monospace; font-size:12px; letter-spacing:.5px}
+    .brand-name span{font-size:12px; color:var(--ink-soft)}
+    .nav-links{display:flex; gap:18px; align-items:center}
+    .nav-links a{padding:8px 12px; border-radius:10px; color:var(--ink-soft)}
+    .nav-links a:hover{background:#fff}
+    .nav-cta{
+      display:flex; gap:10px; align-items:center
+    }
+    .btn{
+      display:inline-flex; align-items:center; justify-content:center;
+      padding:12px 16px; border-radius:14px; border:0; cursor:pointer;
+      background:var(--btn); color:#5b2b35; box-shadow: var(--shadow)
+    }
+    .btn:hover{filter:brightness(1.02)}
+    .btn.alt{background:var(--btn-2); color:#1e4366}
+    .menu-toggle{display:none}
+    @media (max-width: 880px){
+      .menu-toggle{display:inline-flex; padding:8px 10px; background:#fff; border:1px solid rgba(49,65,84,.1); border-radius:10px}
+      .nav-links{display:none}
+    }
+
+    /* Hero */
+    .hero{
+      position:relative; overflow:hidden;
+      padding:56px 0 120px;
+    }
+    .hero-grid{
+      display:grid; grid-template-columns: 1.1fr .9fr; gap:32px; align-items:center;
+    }
+    @media (max-width: 960px){
+      .hero-grid{grid-template-columns: 1fr}
+    }
+    .eyebrow{
+      display:inline-flex; align-items:center; gap:8px; padding:8px 12px; border-radius:999px;
+      background:#fff; color:var(--ink-soft); font-size:13px; box-shadow: var(--shadow)
+    }
+    .hero h1{
+      font-family:"Press Start 2P", monospace; font-size: clamp(22px, 4vw, 36px); line-height:1.3; margin:16px 0 10px;
+      letter-spacing:.5px
+    }
+    .hero p{
+      font-size: clamp(16px, 2vw, 18px); color:var(--ink-soft); margin:0 0 22px
+    }
+    .cta-row{display:flex; gap:12px; flex-wrap:wrap}
+    .chip-row{display:flex; gap:10px; margin-top:18px; flex-wrap:wrap}
+    .chip{background:var(--chip); border:1px dashed rgba(49,65,84,.12); padding:8px 12px; border-radius:999px; font-size:13px}
+    .hero-art{
+      position:relative; height:380px; border-radius:24px; background:
+        linear-gradient(180deg, #FFFFFF 0%, #F7FBFF 60%, #E9FFE9 100%);
+      box-shadow: var(--shadow);
+      overflow:hidden;
+    }
+    /* Clouds */
+    .cloud{ position:absolute; background:var(--cloud); border-radius:40px; height:34px; width:120px; filter: drop-shadow(0 6px 10px rgba(49,65,84,.08)) }
+    .cloud::before, .cloud::after{content:""; position:absolute; background:var(--cloud); border-radius:50%}
+    .cloud::before{width:44px; height:44px; left:12px; top:-18px}
+    .cloud::after{width:56px; height:56px; left:48px; top:-28px}
+    .c1{ left:12%; top:16%; animation: float 9s ease-in-out infinite }
+    .c2{ right:8%; top:8%; transform: scale(.9); animation: float 11s ease-in-out infinite reverse }
+    .c3{ left:56%; top:32%; transform: scale(1.1); animation: float 10s ease-in-out infinite }
+    @keyframes float{
+      0%,100%{ transform: translateY(0) }
+      50%{ transform: translateY(-8px) }
+    }
+    /* Hills + flowers */
+    .ground{
+      position:absolute; inset:auto 0 0 0; height:46%; pointer-events:none;
+      background:
+        radial-gradient(90% 100% at 20% 100%, var(--hill-1) 0 60%, transparent 61%) left bottom/50% 100% no-repeat,
+        radial-gradient(90% 100% at 80% 100%, var(--hill-2) 0 60%, transparent 61%) right bottom/60% 100% no-repeat,
+        linear-gradient(to top, var(--grass), var(--grass) 80%, transparent 81%) bottom/100% 70% no-repeat;
+      border-top-left-radius:24px; border-top-right-radius:24px;
+    }
+    .flower{
+      position:absolute; width:18px; height:18px; left:var(--x,10%); bottom:var(--y, 18%);
+      transform-origin: bottom center; animation: sway 3.8s ease-in-out infinite;
+    }
+    .flower i, .flower i::before, .flower i::after{
+      content:""; position:absolute; width:12px; height:12px; background:var(--petal, var(--flower-pink)); border-radius:50%;
+    }
+    .flower i{ left:3px; top:-2px }
+    .flower i::before{ left:-8px; top:8px }
+    .flower i::after{ left:8px; top:8px }
+    .flower b{ position:absolute; left:8px; top:12px; width:2px; height:22px; background:#6BB07E; border-radius:2px}
+    .flower span{ position:absolute; width:6px; height:6px; background:#fff; border-radius:50%; left:6px; top:4px}
+    @keyframes sway{
+      0%,100%{ transform: rotate(-2deg) }
+      50%{ transform: rotate(2deg) }
+    }
+
+    /* Collections */
+    .section{padding:54px 0}
+    .section h2{ font-family:"Press Start 2P"; font-size:20px; margin:0 0 18px }
+    .muted{ color:var(--ink-soft); margin:0 0 26px }
+    .grid-3{ display:grid; grid-template-columns: repeat(3, 1fr); gap:18px }
+    @media (max-width: 900px){ .grid-3{ grid-template-columns: 1fr 1fr } }
+    @media (max-width: 620px){ .grid-3{ grid-template-columns: 1fr } }
+    .card{
+      background:#fff; border-radius:20px; padding:18px; box-shadow: var(--shadow); display:flex; gap:14px; align-items:center
+    }
+    .icon{
+      width:64px; height:64px; border-radius:14px; display:grid; place-items:center;
+      background: linear-gradient(135deg, var(--accent-2), #FFFFFF)
+    }
+    .card h3{margin:0 0 6px; font-size:18px}
+    .card p{margin:0; color:var(--ink-soft); font-size:14px}
+
+    /* Scroller */
+    .scroller{
+      display:grid; grid-auto-flow: column; grid-auto-columns: minmax(240px, 1fr); gap:14px;
+      overflow-x:auto; padding-bottom:2px; scroll-snap-type: x mandatory;
+    }
+    .scroller::-webkit-scrollbar{height:10px}
+    .scroller::-webkit-scrollbar-thumb{background:rgba(49,65,84,.12); border-radius:999px}
+    .product{
+      background:#fff; border-radius:18px; box-shadow: var(--shadow); scroll-snap-align: start; overflow:hidden
+    }
+    .product .img{
+      height:150px; background:
+        repeating-linear-gradient(45deg, #F9F5FF, #F9F5FF 10px, #F3ECFF 10px, #F3ECFF 20px);
+      display:flex; align-items:center; justify-content:center; position:relative
+    }
+    .pixel-star{
+      width:54px; height:54px; background: linear-gradient(#FFF9C4, #FFE082); border:2px solid #E6C260; border-radius:8px;
+      box-shadow: 0 2px 0 #E6C260, 0 6px 16px rgba(49,65,84,.12);
+      transform: rotate(8deg)
+    }
+    .product .body{ padding:14px }
+    .product .name{ font-weight:600; margin:0 0 6px }
+    .price-row{ display:flex; align-items:center; justify-content:space-between; gap:8px }
+    .price{ font-weight:700 }
+    .small{ font-size:12px; color:var(--ink-soft) }
+
+    /* Newsletter */
+    .newsletter{
+      background: linear-gradient(180deg, #FFFFFF, #F7FBFF);
+      border:1px solid rgba(49,65,84,.06); border-radius:24px; padding:22px; box-shadow: var(--shadow)
+    }
+    .input-row{ display:flex; gap:8px; flex-wrap:wrap }
+    .input-row input{
+      flex:1; min-width:220px; padding:12px 14px; border:1px solid rgba(49,65,84,.12); border-radius:12px; background:#fff; font:inherit
+    }
+
+    /* Footer */
+    .site-footer{ padding:40px 0 60px; color:var(--ink-soft) }
+    .foot-grid{ display:grid; grid-template-columns: 2fr 1fr 1fr; gap:18px }
+    @media (max-width: 820px){ .foot-grid{ grid-template-columns: 1fr 1fr } }
+    @media (max-width: 560px){ .foot-grid{ grid-template-columns: 1fr } }
+    .foot-col h4{ margin:0 0 10px; color:var(--ink) }
+    .foot-col a{ color:var(--ink-soft) }
+    .tiny{ font-size:12px; margin-top:8px }
+
+    /* Motion safety */
+    @media (prefers-reduced-motion: reduce){
+      *{ animation:none !important; transition:none !important }
+    }
+  </style>
+</head>
+<body>
+  <header class="site-header">
+    <div class="container nav">
+      <div class="brand">
+        <div class="brand-mark" aria-hidden="true"></div>
+        <div class="brand-name">
+          <strong>Bloom & Bits</strong>
+          <span>Retro Game Store</span>
+        </div>
+      </div>
+      <nav class="nav-links" aria-label="Primary">
+        <a href="#collections">Collections</a>
+        <a href="#new">New Arrivals</a>
+        <a href="#about">About</a>
+        <a href="#newsletter">Newsletter</a>
+      </nav>
+      <div class="nav-cta">
+        <button class="btn alt" aria-label="Search">Search</button>
+        <button class="btn" aria-label="Cart">Cart (0)</button>
+        <button class="menu-toggle" aria-label="Menu">☰</button>
+      </div>
+    </div>
+  </header>
+
+  <main>
+    <section class="hero">
+      <div class="container hero-grid">
+        <div>
+          <span class="eyebrow">Soft colors. Big nostalgia.</span>
+          <h1>Play it sweet and retro</h1>
+          <p>Consoles, cartridges, and handhelds curated with pastel charm. Level up your shelf and your smile.</p>
+          <div class="cta-row">
+            <a class="btn" href="#collections">Shop collections</a>
+            <a class="btn alt" href="#new">Browse new arrivals</a>
+          </div>
+          <div class="chip-row">
+            <span class="chip">Authentic & tested</span>
+            <span class="chip">30-day returns</span>
+            <span class="chip">Worldwide shipping</span>
+          </div>
+        </div>
+        <div class="hero-art" role="img" aria-label="Pastel sky with clouds, hills, and flowers">
+          <div class="cloud c1"></div>
+          <div class="cloud c2"></div>
+          <div class="cloud c3"></div>
+
+          <div class="ground"></div>
+          <div class="flower" style="--x:18%; --y:18%; --petal: var(--flower-pink)">
+            <b></b><i></i><span></span>
+          </div>
+          <div class="flower" style="--x:30%; --y:20%; --petal: var(--flower-yellow)">
+            <b></b><i></i><span></span>
+          </div>
+          <div class="flower" style="--x:44%; --y:16%; --petal: var(--flower-blue)">
+            <b></b><i></i><span></span>
+          </div>
+          <div class="flower" style="--x:62%; --y:18%; --petal: var(--flower-pink)">
+            <b></b><i></i><span></span>
+          </div>
+          <div class="flower" style="--x:78%; --y:22%; --petal: var(--flower-yellow)">
+            <b></b><i></i><span></span>
+          </div>
+        </div>
+      </div>
+    </section>
+
+    <section id="collections" class="section container">
+      <h2>Shop collections</h2>
+      <p class="muted">From pastel handhelds to classic consoles, pick your power-up.</p>
+      <div class="grid-3">
+        <a href="#" class="card">
+          <div class="icon" aria-hidden="true">
+            <svg width="40" height="40" viewBox="0 0 64 64" fill="none" aria-hidden="true">
+              <rect x="8" y="18" width="48" height="22" rx="6" fill="#BDE3FF" stroke="#7FBDED" stroke-width="2"/>
+              <circle cx="22" cy="29" r="5" fill="#FF9EC1"/>
+              <rect x="36" y="26" width="12" height="6" rx="2" fill="#FFFFFF"/>
+              <rect x="36" y="34" width="12" height="2" rx="1" fill="#FFFFFF" opacity=".7"/>
+            </svg>
+          </div>
+          <div>
+            <h3>Consoles</h3>
+            <p>Refurbished classics in gentle hues.</p>
+          </div>
+        </a>
+        <a href="#" class="card">
+          <div class="icon" aria-hidden="true" style="background: linear-gradient(135deg, #FFD1DC, #FFFFFF)">
+            <svg width="40" height="40" viewBox="0 0 64 64" fill="none" aria-hidden="true">
+              <rect x="14" y="16" width="36" height="28" rx="4" fill="#FFB7C3" stroke="#E993A7" stroke-width="2"/>
+              <rect x="18" y="20" width="28" height="6" rx="2" fill="#FFFFFF"/>
+              <rect x="18" y="28" width="20" height="4" rx="2" fill="#FFFFFF" opacity=".8"/>
+            </svg>
+          </div>
+          <div>
+            <h3>Cartridges</h3>
+            <p>Tested carts with guaranteed saves.</p>
+          </div>
+        </a>
+        <a href="#" class="card">
+          <div class="icon" aria-hidden="true" style="background: linear-gradient(135deg, #FFE7A3, #FFFFFF)">
+            <svg width="40" height="40" viewBox="0 0 64 64" fill="none" aria-hidden="true">
+              <rect x="18" y="10" width="28" height="44" rx="6" fill="#FFE7A3" stroke="#E1C770" stroke-width="2"/>
+              <circle cx="32" cy="40" r="5" fill="#B8E0FF"/>
+              <rect x="24" y="18" width="16" height="10" rx="2" fill="#FFFFFF"/>
+            </svg>
+          </div>
+          <div>
+            <h3>Handhelds</h3>
+            <p>Pocket joy in pastel shells.</p>
+          </div>
+        </a>
+      </div>
+    </section>
+
+    <section id="new" class="section container">
+      <h2>New arrivals</h2>
+      <p class="muted">Fresh finds that feel like a sunny Saturday morning.</p>
+      <div class="scroller" aria-label="New products">
+        <div class="product">
+          <div class="img">
+            <div class="pixel-star" aria-hidden="true"></div>
+          </div>
+          <div class="body">
+            <p class="name">Mint Micro Handheld</p>
+            <div class="price-row">
+              <span class="price">$129</span>
+              <button class="btn alt" aria-label="Add Mint Micro Handheld to cart">Add</button>
+            </div>
+            <div class="small">Refurbished • Grade A</div>
+          </div>
+        </div>
+        <div class="product">
+          <div class="img">
+            <div class="pixel-star" style="transform:rotate(-6deg); background:linear-gradient(#FFDEE3,#FFC2D1); border-color:#E6A0AF" aria-hidden="true"></div>
+          </div>
+          <div class="body">
+            <p class="name">Peach Console Duo</p>
+            <div class="price-row">
+              <span class="price">$199</span>
+              <button class="btn alt" aria-label="Add Peach Console Duo to cart">Add</button>
+            </div>
+            <div class="small">Controller + Cables</div>
+          </div>
+        </div>
+        <div class="product">
+          <div class="img">
+            <div class="pixel-star" style="transform:rotate(2deg); background:linear-gradient(#DAF0FF,#BFE3FF); border-color:#8FC6EA" aria-hidden="true"></div>
+          </div>
+          <div class="body">
+            <p class="name">Sky Cartridge Pack</p>
+            <div class="price-row">
+              <span class="price">$59</span>
+              <button class="btn alt" aria-label="Add Sky Cartridge Pack to cart">Add</button>
+            </div>
+            <div class="small">3-in-1 Bundle</div>
+          </div>
+        </div>
+        <div class="product">
+          <div class="img">
+            <div class="pixel-star" style="transform:rotate(10deg); background:linear-gradient(#FFF9C4,#FFE082);" aria-hidden="true"></div>
+          </div>
+          <div class="body">
+            <p class="name">Sunshine Pocket</p>
+            <div class="price-row">
+              <span class="price">$149</span>
+              <button class="btn alt" aria-label="Add Sunshine Pocket to cart">Add</button>
+            </div>
+            <div class="small">Limited shell</div>
+          </div>
+        </div>
+      </div>
+    </section>
+
+    <section id="about" class="section container">
+      <div class="newsletter">
+        <h2>About Bloom & Bits</h2>
+        <p class="muted">We refurbish and re-home retro gear with gentle aesthetics. No gritty neon—just clouds, flowers, and good games. Every item is cleaned, tested, and packed with care.</p>
+        <div style="display:flex; gap:18px; flex-wrap:wrap">
+          <div class="chip">1-year hardware support</div>
+          <div class="chip">Eco-friendly packaging</div>
+          <div class="chip">Save data battery service</div>
+        </div>
+      </div>
+    </section>
+
+    <section id="newsletter" class="section container">
+      <h2>Get sweet drops</h2>
+      <p class="muted">New stock, gentle deals, and cheerful updates. No spam—just charm.</p>
+      <form class="input-row" onsubmit="event.preventDefault(); alert('Thanks for joining!')">
+        <label for="email" class="visually-hidden">Email</label>
+        <input id="email" name="email" type="email" placeholder="your@email.com" required aria-label="Email address"/>
+        <button class="btn" type="submit">Join newsletter</button>
+      </form>
+    </section>
+  </main>
+
+  <footer class="site-footer">
+    <div class="container foot-grid">
+      <div class="foot-col">
+        <div class="brand" style="margin-bottom:8px">
+          <div class="brand-mark" aria-hidden="true" style="width:30px; height:30px"></div>
+          <div class="brand-name">
+            <strong>Bloom & Bits</strong>
+            <span>Retro Game Store</span>
+          </div>
+        </div>
+        <div class="tiny">Pastel-powered nostalgia. © <span id="year"></span></div>
+      </div>
+      <div class="foot-col">
+        <h4>Shop</h4>
+        <div><a href="#">Consoles</a></div>
+        <div><a href="#">Cartridges</a></div>
+        <div><a href="#">Handhelds</a></div>
+      </div>
+      <div class="foot-col">
+        <h4>Help</h4>
+        <div><a href="#">Support</a></div>
+        <div><a href="#">Shipping</a></div>
+        <div><a href="#">Returns</a></div>
+      </div>
+    </div>
+  </footer>
+
+  <style>
+    /* Utility for a11y */
+    .visually-hidden{ position:absolute !important; height:1px; width:1px; overflow:hidden; clip:rect(1px,1px,1px,1px); white-space:nowrap }
+  </style>
+  <script>
+    document.getElementById('year').textContent = new Date().getFullYear();
+  </script>
+</body>
+</html>
+
+Notes:
+- Colors and mood are controlled by CSS variables near the top.
+- No third-party images; shapes use CSS/SVG. You can swap icons or add product images later.
+- The font mix gives light, playful vibes with a subtle retro headline. You can remove Press Start 2P if you want an even softer look.
\ No newline at end of file
diff --git a/examples/gpt-5/outputs/snake_game.html b/examples/gpt-5/outputs/snake_game.html
new file mode 100644
index 0000000000..5ddc494c04
--- /dev/null
+++ b/examples/gpt-5/outputs/snake_game.html
@@ -0,0 +1,720 @@
+Here’s a complete, single-file neon cyberpunk Snake game. Save it as neon-snake.html and open it in a modern browser.
+
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>Neon Snake // Cyberpunk Edition</title>
+<link href="https://fonts.googleapis.com/css2?family=Orbitron:wght@600;800&family=Share+Tech+Mono&display=swap" rel="stylesheet">
+<style>
+  :root{
+    --bg-main:#05060a;
+    --bg-deep:#020308;
+    --neon-1:#00f6ff;  /* cyan */
+    --neon-2:#ff00e6;  /* magenta */
+    --neon-3:#24ff87;  /* electric green */
+    --hud:#c6f7ff;
+    --danger:#ff3b6b;
+    --glow: 0 0 12px rgba(0,246,255,0.6), 0 0 32px rgba(255,0,230,0.35);
+  }
+
+  html, body {
+    height: 100%;
+    margin: 0;
+    background:
+      radial-gradient(1200px 800px at 80% -20%, rgba(255,0,230,0.06), transparent 60%),
+      radial-gradient(1200px 800px at -20% 120%, rgba(0,246,255,0.06), transparent 60%),
+      linear-gradient(180deg, #06070d 0%, #020308 100%);
+    color: #e6faff;
+  }
+
+  .scanlines::before {
+    pointer-events: none;
+    content:"";
+    position: fixed;
+    inset: 0;
+    background: repeating-linear-gradient(
+      to bottom,
+      rgba(255,255,255,0.02) 0px,
+      rgba(255,255,255,0.02) 1px,
+      transparent 2px,
+      transparent 4px
+    );
+    mix-blend-mode: screen;
+    opacity: .35;
+  }
+  .vignette::after {
+    pointer-events: none;
+    content:"";
+    position: fixed;
+    inset: 0;
+    background: radial-gradient(80% 80% at 50% 50%, transparent 55%, rgba(0,0,0,0.45) 100%);
+  }
+
+  .wrap {
+    max-width: 920px;
+    margin: 24px auto 48px;
+    padding: 0 16px;
+    position: relative;
+  }
+
+  .title {
+    font-family: "Orbitron", system-ui, sans-serif;
+    letter-spacing: 0.18em;
+    font-weight: 800;
+    font-size: clamp(28px, 6vw, 56px);
+    text-align: center;
+    line-height: 1.1;
+    color: var(--neon-1);
+    text-shadow:
+      0 0 2px rgba(0,246,255,0.9),
+      0 0 22px rgba(0,246,255,0.6),
+      0 0 44px rgba(255,0,230,0.35);
+    margin: 10px 0 4px;
+  }
+  .title .accent { color: var(--neon-2); }
+
+  .subtitle {
+    font-family: "Share Tech Mono", ui-monospace, monospace;
+    letter-spacing: 0.18em;
+    opacity: 0.8;
+    text-align: center;
+    margin: 0 0 18px;
+    font-size: clamp(12px, 2.2vw, 14px);
+    color: #9feaff;
+  }
+
+  .hud {
+    display: grid;
+    grid-template-columns: 1fr auto auto auto 1fr;
+    gap: 12px 18px;
+    align-items: center;
+    font-family: "Share Tech Mono", ui-monospace, monospace;
+    letter-spacing: .08em;
+    color: var(--hud);
+    margin: 8px 0 14px;
+    user-select: none;
+  }
+  .hud .l, .hud .r { opacity: 0.35; font-size: 12px; }
+  .hud .stat {
+    display: inline-flex;
+    gap: 6px;
+    align-items: baseline;
+    font-size: clamp(14px, 2.4vw, 16px);
+  }
+  .hud .value {
+    color: #ffffff;
+    text-shadow: var(--glow);
+    min-width: 40px;
+    text-align: right;
+  }
+
+  .panel {
+    position: relative;
+    background: linear-gradient(180deg, rgba(2,10,22,0.7) 0%, rgba(2,8,18,0.7) 100%);
+    border: 1px solid rgba(0,246,255,0.2);
+    box-shadow:
+      0 0 0 1px rgba(0,246,255,0.08) inset,
+      0 0 60px rgba(255,0,230,0.08);
+    border-radius: 16px;
+    padding: 16px;
+  }
+
+  .canvas-wrap {
+    position: relative;
+    display: grid;
+    place-items: center;
+  }
+
+  canvas#game {
+    width: min(88vw, 720px);
+    height: min(88vw, 720px);
+    max-width: 720px;
+    max-height: 720px;
+    display: block;
+    background:
+      radial-gradient(120% 120% at 20% 20%, rgba(255,0,230,0.06), transparent 50%),
+      radial-gradient(120% 120% at 80% 80%, rgba(0,246,255,0.06), transparent 50%),
+      #05060a;
+    border-radius: 12px;
+    border: 1px solid rgba(0,246,255,0.18);
+    box-shadow:
+      0 0 0 1px rgba(255,0,230,0.08) inset,
+      0 0 32px rgba(0,246,255,0.18),
+      0 0 120px rgba(255,0,230,0.12);
+  }
+
+  .overlay {
+    position: absolute;
+    inset: 0;
+    display: none;
+    place-items: center;
+    border-radius: 12px;
+    background: radial-gradient(100% 100% at 50% 50%, rgba(5,6,10,0.2), rgba(5,6,10,0.7));
+    backdrop-filter: blur(2px);
+  }
+  .overlay.show { display: grid; }
+  .overlay .box {
+    text-align: center;
+    padding: 20px 22px;
+    border-radius: 12px;
+    background: linear-gradient(180deg, rgba(3,8,16,0.8), rgba(3,6,14,0.8));
+    border: 1px solid rgba(0,246,255,0.22);
+    box-shadow: 0 0 0 1px rgba(255,0,230,0.1) inset, 0 0 40px rgba(255,0,230,0.15);
+  }
+  .overlay h2 {
+    font-family: "Orbitron", system-ui, sans-serif;
+    letter-spacing: 0.2em;
+    margin: 0 0 8px;
+    color: var(--neon-2);
+    text-shadow: var(--glow);
+    font-size: clamp(20px, 4vw, 28px);
+  }
+  .overlay p {
+    font-family: "Share Tech Mono", ui-monospace, monospace;
+    color: #cfefff;
+    margin: 6px 0;
+    letter-spacing: .08em;
+    opacity: 0.9;
+  }
+
+  .controls {
+    display: flex;
+    gap: 10px;
+    flex-wrap: wrap;
+    justify-content: center;
+    margin-top: 14px;
+  }
+  .btn {
+    font-family: "Share Tech Mono", ui-monospace, monospace;
+    letter-spacing: .15em;
+    background: linear-gradient(180deg, rgba(2,12,20,0.7), rgba(2,10,18,0.7));
+    color: #dffbff;
+    border: 1px solid rgba(0,246,255,0.3);
+    box-shadow:
+      0 0 0 1px rgba(255,0,230,0.1) inset,
+      0 0 12px rgba(0,246,255,0.25);
+    border-radius: 10px;
+    padding: 10px 14px;
+    cursor: pointer;
+    transition: transform .06s ease, box-shadow .2s ease, background .2s ease, opacity .2s ease;
+  }
+  .btn:hover { box-shadow: 0 0 24px rgba(0,246,255,0.4); transform: translateY(-1px); }
+  .btn:active { transform: translateY(0px) scale(0.98); }
+  .btn.secondary { border-color: rgba(255,0,230,0.3); box-shadow: 0 0 12px rgba(255,0,230,0.25); }
+  .btn.small { padding: 8px 10px; font-size: 12px; opacity: .9; }
+
+  .mobile-pad {
+    margin-top: 16px;
+    display: grid;
+    grid-template-columns: 60px 60px 60px;
+    grid-template-rows: 60px 60px 60px;
+    justify-content: center;
+    gap: 8px;
+    touch-action: manipulation;
+  }
+  .pad-btn {
+    display: grid; place-items: center;
+    background: linear-gradient(180deg, rgba(2,12,20,0.5), rgba(2,10,18,0.5));
+    border: 1px solid rgba(0,246,255,0.25);
+    border-radius: 10px;
+    color: #dffbff;
+    font-family: "Share Tech Mono", ui-monospace, monospace;
+    text-shadow: var(--glow);
+    user-select: none;
+  }
+  .pad-btn:active { filter: brightness(1.2); }
+  .pad-empty { visibility: hidden; }
+
+  .help {
+    margin-top: 10px;
+    text-align: center;
+    font-family: "Share Tech Mono", ui-monospace, monospace;
+    color: #a9f4ff;
+    opacity: 0.8;
+    font-size: 12px;
+    letter-spacing: .08em;
+  }
+
+  @keyframes glowPulse {
+    0%,100% { text-shadow: 0 0 10px rgba(0,246,255,0.5), 0 0 24px rgba(255,0,230,0.2); }
+    50% { text-shadow: 0 0 18px rgba(0,246,255,0.9), 0 0 40px rgba(255,0,230,0.35); }
+  }
+  .pulse { animation: glowPulse 2.2s ease-in-out infinite; }
+</style>
+</head>
+<body class="scanlines vignette">
+  <div class="wrap">
+    <h1 class="title">NEON <span class="accent">SNAKE</span></h1>
+    <p class="subtitle">ARROW KEYS / WASD • P TO PAUSE • R TO RESTART</p>
+
+    <div class="panel">
+      <div class="hud">
+        <div class="l">// cybergrid.online</div>
+        <div class="stat">Score: <span id="score" class="value">0</span></div>
+        <div class="stat">High: <span id="high" class="value">0</span></div>
+        <div class="stat">Lvl: <span id="level" class="value">1</span></div>
+        <div class="r">v1.0 neon</div>
+      </div>
+
+      <div class="canvas-wrap">
+        <canvas id="game" width="720" height="720" aria-label="Neon Snake Game"></canvas>
+
+        <div id="overlay" class="overlay">
+          <div class="box">
+            <h2 id="overlayTitle" class="pulse">PAUSED</h2>
+            <p id="overlaySub">Press P or tap Resume</p>
+            <div class="controls">
+              <button id="resumeBtn" class="btn">RESUME</button>
+              <button id="restartBtn" class="btn secondary">RESTART</button>
+            </div>
+          </div>
+        </div>
+      </div>
+
+      <div class="controls">
+        <button id="btnPause" class="btn small">PAUSE (P)</button>
+        <button id="btnRestart" class="btn small secondary">RESTART (R)</button>
+        <button id="btnSound" class="btn small">SOUND: ON</button>
+      </div>
+
+      <div class="mobile-pad" aria-hidden="false">
+        <div class="pad-empty"></div>
+        <button class="pad-btn" data-dir="up">▲</button>
+        <div class="pad-empty"></div>
+        <button class="pad-btn" data-dir="left">◀</button>
+        <button class="pad-btn" data-dir="down">▼</button>
+        <button class="pad-btn" data-dir="right">▶</button>
+        <div class="pad-empty"></div>
+        <div class="pad-empty"></div>
+        <div class="pad-empty"></div>
+      </div>
+
+      <div class="help">Eat the pulsing neon node. Don’t crash. Each 5 bites increases speed. Good luck, runner.</div>
+    </div>
+  </div>
+
+<script>
+(() => {
+  const canvas = document.getElementById('game');
+  const ctx = canvas.getContext('2d', { alpha: false });
+  const overlay = document.getElementById('overlay');
+  const overlayTitle = document.getElementById('overlayTitle');
+  const overlaySub = document.getElementById('overlaySub');
+  const scoreEl = document.getElementById('score');
+  const highEl = document.getElementById('high');
+  const levelEl = document.getElementById('level');
+  const btnPause = document.getElementById('btnPause');
+  const btnRestart = document.getElementById('btnRestart');
+  const btnSound = document.getElementById('btnSound');
+  const resumeBtn = document.getElementById('resumeBtn');
+  const restartBtn = document.getElementById('restartBtn');
+
+  const DPR = Math.min(window.devicePixelRatio || 1, 2);
+  function setupCanvas() {
+    const cssSize = Math.min(720, Math.floor(window.innerWidth * 0.88));
+    canvas.style.width = cssSize + 'px';
+    canvas.style.height = cssSize + 'px';
+    canvas.width = Math.floor(cssSize * DPR);
+    canvas.height = Math.floor(cssSize * DPR);
+    ctx.setTransform(DPR, 0, 0, DPR, 0, 0);
+    return cssSize;
+  }
+  let CSS_SIZE = setupCanvas();
+  window.addEventListener('resize', () => {
+    CSS_SIZE = setupCanvas();
+    CELL = Math.floor(CSS_SIZE / GRID);
+    // Re-center visuals but keep logical grid unchanged
+  });
+
+  // Grid settings
+  const GRID = 30;
+  let CELL = Math.floor(CSS_SIZE / GRID);
+
+  // Game state
+  let snake, dir, nextDir, food, score, high, level, bites, stepMs, gameOver, paused, lastStep;
+  let particles = [];
+  let hueBase = 190; // cyan-ish
+  const STEP_INIT = 120;
+  const STEP_MIN = 55;
+  const STEP_DELTA = 6;
+
+  // Audio (WebAudio minimal beeps)
+  let audioCtx = null;
+  let soundOn = true;
+  function beep(freq=440, dur=0.08, type='sine', gain=0.03) {
+    if (!soundOn) return;
+    try {
+      if (!audioCtx) audioCtx = new (window.AudioContext || window.webkitAudioContext)();
+      const t0 = audioCtx.currentTime + 0.01;
+      const osc = audioCtx.createOscillator();
+      const g = audioCtx.createGain();
+      osc.type = type;
+      osc.frequency.value = freq;
+      g.gain.value = gain;
+      osc.connect(g).connect(audioCtx.destination);
+      osc.start(t0);
+      osc.stop(t0 + dur);
+      // Simple envelope
+      g.gain.setValueAtTime(0, t0);
+      g.gain.linearRampToValueAtTime(gain, t0 + 0.01);
+      g.gain.exponentialRampToValueAtTime(0.0001, t0 + dur);
+    } catch (e) {}
+  }
+
+  function resetGame() {
+    const cx = Math.floor(GRID/2), cy = Math.floor(GRID/2);
+    snake = [{x: cx-1, y: cy}, {x: cx, y: cy}, {x: cx+1, y: cy}]; // moving right
+    dir = {x: 1, y: 0};
+    nextDir = {x: 1, y: 0};
+    score = 0;
+    bites = 0;
+    level = 1;
+    stepMs = STEP_INIT;
+    gameOver = false;
+    paused = false;
+    lastStep = performance.now();
+    spawnFood();
+    particles.length = 0;
+    updateHUD();
+    hideOverlay();
+  }
+
+  function updateHUD() {
+    scoreEl.textContent = String(score);
+    levelEl.textContent = String(level);
+    high = Number(localStorage.getItem('neonSnakeHighScore') || 0);
+    if (score > high) {
+      high = score;
+      localStorage.setItem('neonSnakeHighScore', String(high));
+    }
+    highEl.textContent = String(high);
+  }
+
+  function spawnFood() {
+    let x, y;
+    retry:
+    for (;;) {
+      x = Math.floor(Math.random() * GRID);
+      y = Math.floor(Math.random() * GRID);
+      for (let i=0;i<snake.length;i++) {
+        if (snake[i].x === x && snake[i].y === y) continue retry;
+      }
+      break;
+    }
+    food = {x, y, t: 0};
+  }
+
+  function setDir(nx, ny) {
+    // Prevent reversing
+    if (nx === -dir.x && ny === -dir.y) return;
+    nextDir = {x: nx, y: ny};
+  }
+
+  // Input
+  window.addEventListener('keydown', (e) => {
+    const k = e.key.toLowerCase();
+    if (k === 'arrowup' || k === 'w') setDir(0,-1);
+    else if (k === 'arrowdown' || k === 's') setDir(0,1);
+    else if (k === 'arrowleft' || k === 'a') setDir(-1,0);
+    else if (k === 'arrowright' || k === 'd') setDir(1,0);
+    else if (k === 'p') togglePause();
+    else if (k === 'r') resetGame();
+  });
+
+  document.querySelectorAll('.pad-btn').forEach(btn => {
+    btn.addEventListener('click', () => {
+      const dirName = btn.dataset.dir;
+      if (dirName === 'up') setDir(0,-1);
+      if (dirName === 'down') setDir(0,1);
+      if (dirName === 'left') setDir(-1,0);
+      if (dirName === 'right') setDir(1,0);
+    });
+  });
+
+  // Simple swipe
+  let touchStart = null;
+  canvas.addEventListener('touchstart', (e) => {
+    if (e.touches[0]) {
+      touchStart = {x: e.touches[0].clientX, y: e.touches[0].clientY};
+    }
+  }, {passive: true});
+  canvas.addEventListener('touchend', (e) => {
+    if (!touchStart) return;
+    const t = e.changedTouches[0];
+    const dx = t.clientX - touchStart.x;
+    const dy = t.clientY - touchStart.y;
+    const ax = Math.abs(dx), ay = Math.abs(dy);
+    if (Math.max(ax, ay) > 24) {
+      if (ax > ay) setDir(Math.sign(dx), 0);
+      else setDir(0, Math.sign(dy));
+    }
+    touchStart = null;
+  });
+
+  // Buttons
+  btnPause.addEventListener('click', togglePause);
+  btnRestart.addEventListener('click', () => { resetGame(); });
+  resumeBtn.addEventListener('click', togglePause);
+  restartBtn.addEventListener('click', () => { resetGame(); });
+  btnSound.addEventListener('click', () => {
+    soundOn = !soundOn;
+    btnSound.textContent = `SOUND: ${soundOn ? 'ON' : 'OFF'}`;
+    if (soundOn) beep(880, 0.05, 'triangle', 0.02);
+  });
+
+  function togglePause() {
+    if (gameOver) { resetGame(); return; }
+    paused = !paused;
+    if (paused) {
+      showOverlay('PAUSED', 'Press P or tap Resume');
+    } else {
+      hideOverlay();
+      lastStep = performance.now();
+      requestAnimationFrame(loop);
+    }
+  }
+
+  function showOverlay(title, sub) {
+    overlayTitle.textContent = title;
+    overlaySub.textContent = sub || '';
+    overlay.classList.add('show');
+  }
+  function hideOverlay() {
+    overlay.classList.remove('show');
+  }
+
+  // Game logic
+  function step() {
+    if (gameOver || paused) return;
+    dir = nextDir;
+    const head = snake[snake.length - 1];
+    const nx = head.x + dir.x;
+    const ny = head.y + dir.y;
+
+    // Collisions: walls
+    if (nx < 0 || nx >= GRID || ny < 0 || ny >= GRID) {
+      lose();
+      return;
+    }
+    // Collisions: self
+    for (let i=0;i<snake.length;i++) {
+      if (snake[i].x === nx && snake[i].y === ny) {
+        lose();
+        return;
+      }
+    }
+
+    const newHead = {x: nx, y: ny};
+    snake.push(newHead);
+
+    // Eat?
+    if (food && nx === food.x && ny === food.y) {
+      score += 10;
+      bites += 1;
+      updateHUD();
+      spawnParticles(food.x, food.y);
+      beep(760, 0.06, 'square', 0.02);
+      // Level up every 5 bites
+      if (bites % 5 === 0 && stepMs > STEP_MIN) {
+        level += 1;
+        stepMs = Math.max(STEP_MIN, stepMs - STEP_DELTA);
+        updateHUD();
+        hueBase = (hueBase + 22) % 360;
+        beep(980, 0.08, 'triangle', 0.03);
+      }
+      spawnFood();
+    } else {
+      snake.shift(); // move forward
+    }
+  }
+
+  function lose() {
+    gameOver = true;
+    beep(140, 0.12, 'sawtooth', 0.03);
+    setTimeout(() => beep(90, 0.18, 'sawtooth', 0.03), 80);
+    updateHUD();
+    showOverlay('GAME OVER', 'Press R to restart');
+  }
+
+  // Particles
+  function spawnParticles(x, y) {
+    const cx = x * CELL + CELL/2;
+    const cy = y * CELL + CELL/2;
+    const count = 14;
+    for (let i=0;i<count;i++) {
+      const a = Math.random()*Math.PI*2;
+      const sp = 60 + Math.random()*120;
+      particles.push({
+        x: cx, y: cy,
+        vx: Math.cos(a)*sp, vy: Math.sin(a)*sp,
+        life: 0.55, age: 0, hue: (hueBase + 20 + Math.random()*40) % 360
+      });
+    }
+  }
+
+  // Rendering
+  function drawGrid(t) {
+    ctx.save();
+    // Subtle animated neon grid
+    const alpha = 0.08 + 0.02*Math.sin(t*0.002);
+    ctx.strokeStyle = `rgba(0,246,255,${alpha})`;
+    ctx.lineWidth = 1;
+    ctx.beginPath();
+    for (let i=0;i<=GRID;i++) {
+      const p = Math.floor(i*CELL) + 0.5;
+      ctx.moveTo(0, p); ctx.lineTo(GRID*CELL, p);
+      ctx.moveTo(p, 0); ctx.lineTo(p, GRID*CELL);
+    }
+    ctx.stroke();
+
+    // Border
+    ctx.strokeStyle = `rgba(255,0,230,0.25)`;
+    ctx.lineWidth = 2;
+    ctx.strokeRect(1, 1, GRID*CELL-2, GRID*CELL-2);
+    ctx.restore();
+  }
+
+  function drawFood(t) {
+    if (!food) return;
+    const cx = food.x * CELL + CELL/2;
+    const cy = food.y * CELL + CELL/2;
+    const pulse = 0.35 + 0.15 * Math.sin(t*0.01);
+    const r = Math.max(3, CELL*0.32 + CELL*0.08*pulse);
+
+    // Glow ring
+    ctx.save();
+    ctx.shadowColor = `hsla(${(hueBase+300)%360}, 100%, 60%, 0.9)`;
+    ctx.shadowBlur = 22;
+    ctx.fillStyle = `hsla(${(hueBase+320)%360}, 100%, 60%, 0.85)`;
+    ctx.beginPath();
+    ctx.arc(cx, cy, r, 0, Math.PI*2);
+    ctx.fill();
+
+    // Core
+    ctx.shadowBlur = 0;
+    ctx.fillStyle = `hsla(${(hueBase+20)%360}, 100%, 85%, 0.9)`;
+    ctx.beginPath();
+    ctx.arc(cx, cy, Math.max(2, r*0.35), 0, Math.PI*2);
+    ctx.fill();
+    ctx.restore();
+  }
+
+  function drawSnake(t) {
+    const n = snake.length;
+    for (let i=0;i<n;i++) {
+      const seg = snake[i];
+      const f = i / (n-1 || 1);
+      const hue = (hueBase + 220*f) % 360;
+      const x = seg.x * CELL;
+      const y = seg.y * CELL;
+      const r = Math.floor(CELL*0.82);
+
+      ctx.save();
+      ctx.shadowColor = `hsla(${hue}, 100%, 60%, 0.9)`;
+      ctx.shadowBlur = 18 + 8*Math.sin((t*0.004)+i*0.6);
+      ctx.fillStyle = `hsla(${hue}, 100%, ${f<0.95? 55:75}%, 0.95)`;
+      // Rounded rectangle segment
+      roundRect(ctx, x+CELL*0.09, y+CELL*0.09, CELL*0.82, CELL*0.82, CELL*0.22, true, false);
+      ctx.restore();
+    }
+
+    // Eyes on head
+    const head = snake[snake.length-1];
+    const hx = head.x * CELL + CELL/2;
+    const hy = head.y * CELL + CELL/2;
+    const eyeOff = 4;
+    let ex1 = 0, ey1 = 0, ex2 = 0, ey2 = 0;
+    if (dir.x === 1) { ex1 = 4; ey1 = -eyeOff; ex2 = 4; ey2 = eyeOff; }
+    else if (dir.x === -1) { ex1 = -4; ey1 = -eyeOff; ex2 = -4; ey2 = eyeOff; }
+    else if (dir.y === 1) { ex1 = -eyeOff; ey1 = 4; ex2 = eyeOff; ey2 = 4; }
+    else if (dir.y === -1) { ex1 = -eyeOff; ey1 = -4; ex2 = eyeOff; ey2 = -4; }
+    ctx.save();
+    ctx.fillStyle = `hsla(${(hueBase+90)%360}, 100%, 85%, 0.95)`;
+    ctx.shadowColor = ctx.fillStyle;
+    ctx.shadowBlur = 10;
+    ctx.beginPath(); ctx.arc(hx+ex1, hy+ey1, 2.2, 0, Math.PI*2); ctx.fill();
+    ctx.beginPath(); ctx.arc(hx+ex2, hy+ey2, 2.2, 0, Math.PI*2); ctx.fill();
+    ctx.restore();
+  }
+
+  function drawParticles(dt) {
+    for (let i = particles.length - 1; i >= 0; i--) {
+      const p = particles[i];
+      p.age += dt;
+      const k = p.age / p.life;
+      if (k >= 1) { particles.splice(i,1); continue; }
+      p.x += p.vx * dt;
+      p.y += p.vy * dt;
+      p.vx *= 0.98; p.vy *= 0.98;
+      const a = 1 - k;
+      ctx.save();
+      ctx.globalAlpha = a;
+      ctx.fillStyle = `hsla(${p.hue}, 100%, ${60+20*(1-k)}%, ${0.9*a})`;
+      ctx.shadowColor = `hsla(${p.hue}, 100%, 60%, ${0.9*a})`;
+      ctx.shadowBlur = 16*a;
+      ctx.beginPath();
+      ctx.arc(p.x, p.y, 2 + 2*(1-k), 0, Math.PI*2);
+      ctx.fill();
+      ctx.restore();
+    }
+  }
+
+  function clear() {
+    // Subtle trail fade for extra glow
+    ctx.fillStyle = 'rgba(5,6,10,0.35)';
+    ctx.fillRect(0, 0, GRID*CELL, GRID*CELL);
+  }
+
+  // Utility: rounded rect
+  function roundRect(ctx, x, y, w, h, r, fill, stroke) {
+    if (w<2*r) r = w/2; if (h<2*r) r = h/2;
+    ctx.beginPath();
+    ctx.moveTo(x+r, y);
+    ctx.arcTo(x+w, y, x+w, y+h, r);
+    ctx.arcTo(x+w, y+h, x, y+h, r);
+    ctx.arcTo(x, y+h, x, y, r);
+    ctx.arcTo(x, y, x+w, y, r);
+    if (fill) ctx.fill();
+    if (stroke) ctx.stroke();
+  }
+
+  // Main loop
+  let lastTime = performance.now();
+  function loop(now) {
+    if (gameOver || paused) return;
+    const dt = Math.min(0.032, (now - lastTime) / 1000);
+    lastTime = now;
+
+    // Step logic based on stepMs
+    if (now - lastStep >= stepMs) {
+      lastStep = now;
+      step();
+    }
+
+    // Render
+    clear();
+    drawGrid(now);
+    drawFood(now);
+    drawSnake(now);
+    drawParticles(dt);
+
+    requestAnimationFrame(loop);
+  }
+
+  // Start
+  resetGame();
+  lastTime = performance.now();
+  lastStep = lastTime;
+  requestAnimationFrame(loop);
+})();
+</script>
+</body>
+</html>
+
+Notes:
+- Save as neon-snake.html and open it. Works on desktop and mobile (supports touch and on-screen D-pad).
+- Controls: Arrow keys/WASD. P to pause, R to restart. Toggle sound with the button.
+- High score persists via localStorage.
+- Typography uses Orbitron and Share Tech Mono with neon glow.
\ No newline at end of file
diff --git a/examples/gpt-5/outputs/your_website.html b/examples/gpt-5/outputs/your_website.html
new file mode 100644
index 0000000000..ae9ed6fa95
--- /dev/null
+++ b/examples/gpt-5/outputs/your_website.html
@@ -0,0 +1,14 @@
+Here are cleaner, more user-friendly options. Pick based on where it appears:
+
+- Heading: What kind of website would you like to build?
+- Friendly: What type of site do you want to build today?
+- Conversational: Tell us about the website you want to build.
+- Direct/CTA: Choose your website type.
+- Goal-focused: What’s your website for?
+
+If it’s a form:
+- Label: Website type
+- Helper text: e.g., portfolio, blog, online store. You can change this later.
+- Button: Continue or Start building
+
+Want me to tailor it to your brand voice and placement (headline, field label, modal, etc.)?
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook.ipynb b/examples/gpt-5/prompt-optimization-cookbook.ipynb
new file mode 100644
index 0000000000..80a901f7f5
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook.ipynb
@@ -0,0 +1,994 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "4c84498c",
+   "metadata": {},
+   "source": [
+    "# GPT-5 Prompt Migration and Improvement using the new prompt optimizer"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a3942231",
+   "metadata": {},
+   "source": [
+    "The GPT-5 Family of models are the smartest models we’ve released to date, representing a step change in the models’ capabilities across the board. GPT-5 is particularly specialized in agentic task performance, coding, and steerability, making it a great fit for everyone from curious users to advanced researchers. \n",
+    "\n",
+    "GPT-5 will benefit from all the traditional [prompting best practices](https://cookbook.openai.com/examples/gpt-5/gpt-5_prompting_guide), but to make optimizations and migrations easier, we are introducing the **[GPT-5  Prompt Optimizer](https://platform.openai.com/chat/edit?optimize=true) in our Playground to help users get started on **improving existing prompts** and **migrating prompts** for GPT-5 and other OpenAI models.**\n",
+    "\n",
+    "![optimize_image](../../images/image_optimize_landing_2.png)\n",
+    "\n",
+    "In this cookbook we will show you how to use the Prompt Optimzer to get spun up quickly to solve your tasks with GPT-5, while demonstrating how prompt optimize can have measurable improvements. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f066a2db",
+   "metadata": {},
+   "source": [
+    "### Migrating and Optimizing Prompts\n",
+    "\n",
+    "Crafting effective prompts is a critical skill when working with LLMs. The goal of the Prompt Optimizer is to give your prompt the best practices and formatting most effective for our models. The Optimizer also removes common prompting failure modes such as:  \n",
+    "\n",
+    "•   Contradictions in the prompt instructions  \n",
+    "•\tMissing or unclear format specifications  \n",
+    "•\tInconsistencies between the prompt and few-shot examples  \n",
+    "\n",
+    "Along with tuning the prompt for the target model, the Optimizer is cognizant of the specific task you are trying to accomplish and can apply crucial practices to boost performance in Agentic Workflows, Coding and Multi-Modality. Let's walk through some before-and-afters to see where prompt optimization shines. \n",
+    "\n",
+    "> Remember that prompting is not a one-size-fits-all experience, so we recommend running thorough experiments and iterating to find the best solution for your problem."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8fcbc964",
+   "metadata": {},
+   "source": [
+    "\n",
+    "> Ensure you have set up your OpenAI API Key set as `OPENAI_API_KEY` and have access to GPT-5\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "5a0d077c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "OPENAI_API_KEY is set!\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "\n",
+    "required = ('OPENAI_API_KEY',)\n",
+    "missing = [k for k in required if not os.getenv(k)]\n",
+    "print('OPENAI_API_KEY is set!' if not missing else 'Missing environment variable: ' + ', '.join(missing) + '. Please set them before running the workflow.')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f664a575",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "## Let's install our required packages\n",
+    "%pip install -r requirements.txt --quiet"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fad827dc",
+   "metadata": {},
+   "source": [
+    "----------------"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b750b040",
+   "metadata": {},
+   "source": [
+    "\n",
+    "### Coding and Analytics: Streaming Top‑K Frequent Words \n",
+    "\n",
+    "We start with a task in a field that model has seen significant improvements: Coding and Analytics. We will ask the model to generate a Python script that computes the exact Top‑K most frequent tokens from a large text stream using a specific tokenization spec. Tasks like these are highly sensitive to poor prompting as they can push the model toward the wrong algorithms and approaches (approximate sketches vs multi‑pass/disk‑backed exact solutions), dramatically affecting accuracy and runtime.\n",
+    "\n",
+    "For this task, we will evaluate:\n",
+    "1. Compilation/Execution success over 30 runs\n",
+    "2. Average runtime (successful runs)\n",
+    "3. Average peak memory (successful runs)\n",
+    "4. Exactness: output matches ground‑truth Top‑K with tie‑break: by count desc, then token asc\n",
+    "\n",
+    "Note: Evaluated on an M4 Max MacBook Pro; adjust constraints if needed.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "750300af",
+   "metadata": {},
+   "source": [
+    "### Our Baseline Prompt\n",
+    "For our example, let's look at a typical starting prompt with some minor **contradictions in the prompt**, and **ambiguous or underspecified instructions**. Contradictions in instructions often reduce performance and increase latency, especially in reasoning models like GPT-5, and ambiguous instructions can cause unwanted behaviors. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "377cc6f4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "baseline_prompt = \"\"\"\n",
+    "Write Python to solve the task on a MacBook Pro (M4 Max). Keep it fast and lightweight.\n",
+    "\n",
+    "- Prefer the standard library; use external packages if they make things simpler.\n",
+    "- Stream input in one pass to keep memory low; reread or cache if that makes the solution clearer.\n",
+    "- Aim for exact results; approximate methods are fine when they don't change the outcome in practice.\n",
+    "- Avoid global state; expose a convenient global like top_k so it's easy to check.\n",
+    "- Keep comments minimal; add brief explanations where helpful.\n",
+    "- Sort results in a natural, human-friendly way; follow strict tie rules when applicable.\n",
+    "\n",
+    "Output only a single self-contained Python script inside one Python code block, with all imports, ready to run.\n",
+    "\"\"\"\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "01b0e8b3",
+   "metadata": {},
+   "source": [
+    "This baseline prompt is something that you could expect from asking ChatGPT to write you a prompt, or talking to a friend who is knowledgeable about coding but not particularly invested in your specific use case. Our baseline prompt is intentionally shorter and friendlier, but it hides mixed signals that can push the model into inconsistent solution families.\n",
+    "\n",
+    "First, we say to prefer the standard library, then immediately allow external packages “if they make things simpler.” That soft permission can nudge the model toward non‑portable dependencies or heavier imports that change performance and even execution success across environments.\n",
+    "\n",
+    "Next, we encourage single‑pass streaming to keep memory low, but we also say it’s fine to reread or cache “if that makes the solution clearer.” That ambiguity opens the door to multi‑pass designs or in‑memory caches that defeat the original streaming constraint and can alter runtime and memory profiles.\n",
+    "\n",
+    "We also ask for exact results while permitting approximate methods “when they don’t change the outcome in practice.” This is a judgment call the model can’t reliably verify. It may introduce sketches or heuristics that subtly shift counts near the Top‑K boundary, producing results that look right but fail strict evaluation.\n",
+    "\n",
+    "We advise avoiding global state, yet suggest exposing a convenient global like `top_k`. That mixes interface contracts: is the function supposed to return data, or should callers read globals? Models may implement both, causing side effects that complicate evaluation and reproducibility.\n",
+    "\n",
+    "Documentation guidance is similarly split: “keep comments minimal” but “add brief explanations.” Depending on how the model interprets this, you can get under‑explained code or prose interleaved with logic, which sometimes leaks outside the required output format.\n",
+    "\n",
+    "Finally, we ask for “natural, human‑friendly” sorting while also mentioning strict tie rules. These aren’t always the same. The model might pick convenience ordering (e.g., `Counter.most_common`) and drift from the evaluator’s canonical `(-count, token)` sort, especially on ties—leading to subtle correctness misses.\n",
+    "\n",
+    "**Why this matters**: the softened constraints make the prompt feel easy to satisfy, but they create forks in the road. The model may pick different branches across runs—stdlib vs external deps, one‑pass vs reread/cache, exact vs approximate—yielding variability in correctness, latency, and memory.\n",
+    "\n",
+    "**Our evaluator remains strict**: fixed tokenization `[a-z0-9]+` on lowercased text and deterministic ordering by `(-count, token)`. Any divergence here will penalize exactness even if the rest of the solution looks reasonable.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9377fe68",
+   "metadata": {},
+   "source": [
+    "### Let's see how it performs: Generating 30 code scripts with the baseline prompt \n",
+    "\n",
+    "Using the OpenAI Responses API we'll invoke the model 30 times with our baseline prompt and save each response as a Python file in the `results_topk_baseline`. This may take some time. \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1b3a3b39",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from scripts.gen_baseline import generate_baseline_topk\n",
+    "\n",
+    "MODEL = \"gpt-5\"\n",
+    "N_RUNS = 30\n",
+    "CONCURRENCY = 10\n",
+    "OUTPUT_DIR = \"results_topk_baseline\"\n",
+    "\n",
+    "USER_PROMPT = \"\"\"\n",
+    "Task:\n",
+    "Given globals text (str) and k (int), produce the Top-K most frequent tokens.\n",
+    "\n",
+    "Tokenization:\n",
+    "- Case-insensitive tokenization using an ASCII regex; produce lowercase tokens. Whole-string lowercasing is not required.\n",
+    "- Tokens are ASCII [a-z0-9]+ sequences; treat all other characters as separators.\n",
+    "\n",
+    "Output:\n",
+    "- Define top_k as a list of (token, count) tuples.\n",
+    "- Sort by count desc, then token asc.\n",
+    "- Length = min(k, number of unique tokens).\n",
+    "\n",
+    "Notes:\n",
+    "- Run as-is with the provided globals; no file or network I/O.\n",
+    "\"\"\"\n",
+    "\n",
+    "generate_baseline_topk(\n",
+    "    model=MODEL,\n",
+    "    n_runs=N_RUNS,\n",
+    "    concurrency=CONCURRENCY,\n",
+    "    output_dir=OUTPUT_DIR,\n",
+    "    dev_prompt=baseline_prompt,\n",
+    "    user_prompt=USER_PROMPT,\n",
+    ")\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "53f063b6",
+   "metadata": {},
+   "source": [
+    "### Evaluate Generated Scripts - Baseline Prompt\n",
+    "\n",
+    "We then benchmark every script in ``results_topk_baseline`` On larger datasets this evaluation is intentionally heavy and can take several minutes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "391da952",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from scripts.topk_eval import evaluate_folder\n",
+    "\n",
+    "evaluate_folder(\n",
+    "    folder_path=\"results_topk_baseline\",\n",
+    "    k=500,\n",
+    "    scale_tokens=5_000_000,\n",
+    "    csv_path=\"run_results_topk_baseline.csv\",\n",
+    ")\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "92a02c33",
+   "metadata": {},
+   "source": [
+    "### Optimizing our Prompt "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "56da7b3f",
+   "metadata": {},
+   "source": [
+    "Now let's use the prompt optimization tool in the console to improve our prompt and then review the results. We can start by going to the [OpenAI Optimize Playground](https://platform.openai.com/chat/edit?optimize=true), and pasting our existing prompt in the Developer Message section.\n",
+    "\n",
+    "From there press the **Optimize** button. This will open the optimization panel. At this stage, you can either provide specific edits you'd like to see reflected in the prompt or simply press **Optimize** to have it refined according to best practices for the target model and task. To start let's do just this.\n",
+    "\n",
+    "![optimize_image](../../images/image_optimize_1.png)\n",
+    "\n",
+    "\n",
+    "\n",
+    "Once it's completed you'll see the result of the prompt optimization. In our example below you'll see many changes were made to the prompt. It will also give you snippets of what it changed and why the change was made. You can interact with these by opening the comments up or using the inline reviewer mode.\n",
+    "\n",
+    "We'll add an additional change we'd like which include:\n",
+    "\n",
+    "- Enforcing the single-pass streaming\n",
+    "\n",
+    "This is easy using the iterative process of the Prompt Optimizer.\n",
+    "\n",
+    "![optimize_image](../../images/image_optimize_2.png)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a983e50d",
+   "metadata": {},
+   "source": [
+    "Once we are happy with the optimized version of our prompt, we can save it as a [Prompt Object](#https://platform.openai.com/docs/guides/prompt-engineering#reusable-prompts) using a button on the top right of the optimizer. We can use this object within our API Calls which can help with future iteration, version management, and reusability across different applications.  \n",
+    "\n",
+    "![optimize_image](../../images/image_optimize_3.png)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f5bc98ab",
+   "metadata": {},
+   "source": [
+    "###  Let's see how it performs: Evaluating our improved prompt \n",
+    "\n",
+    "For visibility we will provide our new optimized prompt here, but you can also pass the ``prompt_id`` and ``version``. Let's start by writing out our optimized prompt. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "8bf4c55d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimized_prompt = \"\"\"\n",
+    "# Objective\n",
+    "Generate a single, self-contained Python script that exactly solves the specified task on a MacBook Pro (M4 Max).\n",
+    "\n",
+    "# Hard requirements\n",
+    "- Use only Python stdlib. No approximate algorithms.\n",
+    "- Tokenization: ASCII [a-z0-9]+ on the original text; match case-insensitively and lowercase tokens individually. Do NOT call text.lower() on the full string.\n",
+    "- Exact Top‑K semantics: sort by count desc, then token asc. No reliance on Counter.most_common tie behavior.\n",
+    "- Define `top_k` as a list of (token, count) tuples with length = min(k, number of unique tokens).\n",
+    "- When globals `text` (str) and `k` (int) exist, do not reassign them; set `top_k` from those globals. If you include a `__main__` demo, guard it to run only when globals are absent.\n",
+    "- No file I/O, stdin, or network access, except optionally printing `top_k` as the last line.\n",
+    "\n",
+    "# Performance & memory constraints\n",
+    "- Do NOT materialize the entire token stream or any large intermediate list.\n",
+    "- Do NOT sort all unique (token, count) items unless k >= 0.3 * number_of_unique_tokens.\n",
+    "- When k < number_of_unique_tokens, compute Top‑K using a bounded min‑heap of size k over counts.items(), maintaining the correct tie-break (count desc, then token asc).\n",
+    "- Target peak additional memory beyond the counts dict to O(k). Avoid creating `items = sorted(counts.items(), ...)` for large unique sets.\n",
+    "\n",
+    "# Guidance\n",
+    "- Build counts via a generator over re.finditer with re.ASCII | re.IGNORECASE; lowercase each matched token before counting.\n",
+    "- Prefer heapq.nsmallest(k, cnt.items(), key=lambda kv: (-kv[1], kv[0])) for exact selection without full sort; avoid heapq.nlargest.\n",
+    "- Do NOT wrap tokens in custom comparator classes (e.g., reverse-lex __lt__) or rely on tuple tricks for heap ordering.\n",
+    "- Keep comments minimal; include a brief complexity note (time and space).\n",
+    "\n",
+    "# Output format\n",
+    "- Output only one Python code block; no text outside the block.\n",
+    "\n",
+    "# Examples \n",
+    "```python\n",
+    "import re, heapq\n",
+    "from collections import Counter\n",
+    "from typing import List, Tuple, Iterable\n",
+    "\n",
+    "_TOKEN = re.compile(r\"[a-z0-9]+\", flags=re.ASCII | re.IGNORECASE)\n",
+    "\n",
+    "def _tokens(s: str) -> Iterable[str]:\n",
+    "    # Case-insensitive match; lowercase per token to avoid copying the whole string\n",
+    "    for m in _TOKEN.finditer(s):\n",
+    "        yield m.group(0).lower()\n",
+    "\n",
+    "def top_k_tokens(text: str, k: int) -> List[Tuple[str, int]]:\n",
+    "    if k <= 0:\n",
+    "        return []\n",
+    "    cnt = Counter(_tokens(text))\n",
+    "    u = len(cnt)\n",
+    "    key = lambda kv: (-kv[1], kv[0])\n",
+    "    if k >= u:\n",
+    "        return sorted(cnt.items(), key=key)\n",
+    "    # Exact selection with bounded memory\n",
+    "    return heapq.nsmallest(k, cnt.items(), key=key)\n",
+    "\n",
+    "# Compute from provided globals when available; demo only if missing and running as main\n",
+    "try:\n",
+    "    text; k  # type: ignore[name-defined]\n",
+    "except NameError:\n",
+    "    if __name__ == \"__main__\":\n",
+    "        demo_text = \"A a b b b c1 C1 c1 -- d! d? e\"\n",
+    "        demo_k = 3\n",
+    "        top_k = top_k_tokens(demo_text, demo_k)\n",
+    "        print(top_k)\n",
+    "else:\n",
+    "    top_k = top_k_tokens(text, k)  # type: ignore[name-defined]\n",
+    "# Complexity: counting O(N tokens), selection O(U log k) via heapq.nsmallest; extra space O(U + k)\n",
+    "```\n",
+    "\"\"\"\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "95c97164",
+   "metadata": {},
+   "source": [
+    "### Generating 30 code scripts with the Optimized prompt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e003656a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from scripts.gen_optimized import generate_optimized_topk\n",
+    "\n",
+    "MODEL = \"gpt-5\"\n",
+    "N_RUNS = 30\n",
+    "CONCURRENCY = 10\n",
+    "OUTPUT_DIR = \"results_topk_optimized\"\n",
+    "\n",
+    "USER_PROMPT = \"\"\"\n",
+    "Task:\n",
+    "Given globals text (str) and k (int), produce the Top-K most frequent tokens.\n",
+    "\n",
+    "Tokenization:\n",
+    "- Case-insensitive tokenization using an ASCII regex; produce lowercase tokens. Whole-string lowercasing is not required.\n",
+    "- Tokens are ASCII [a-z0-9]+ sequences; treat all other characters as separators.\n",
+    "\n",
+    "Output:\n",
+    "- Define top_k as a list of (token, count) tuples.\n",
+    "- Sort by count desc, then token asc.\n",
+    "- Length = min(k, number of unique tokens).\n",
+    "\n",
+    "Notes:\n",
+    "- Run as-is with the provided globals; no file or network I/O.\n",
+    "\"\"\"\n",
+    "\n",
+    "generate_optimized_topk(\n",
+    "    model=MODEL,\n",
+    "    n_runs=N_RUNS,\n",
+    "    concurrency=CONCURRENCY,\n",
+    "    output_dir=OUTPUT_DIR,\n",
+    "    dev_prompt=optimized_prompt,\n",
+    "    user_prompt=USER_PROMPT,\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b2fe4c92",
+   "metadata": {},
+   "source": [
+    "### Evaluate Generated Scripts - Optimized Prompt\n",
+    "\n",
+    "We run the same evaluation as above, but now with our optimized prompt to see if there were any improvements"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "eea51c83",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from scripts.topk_eval import evaluate_folder\n",
+    "\n",
+    "evaluate_folder(\n",
+    "    folder_path=\"results_topk_optimized\",\n",
+    "    k=500,\n",
+    "    scale_tokens=5_000_000,\n",
+    "    csv_path=\"run_results_topk_optimized.csv\",\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bf35e47b",
+   "metadata": {},
+   "source": [
+    "### Adding LLM-as-a-Judge Grading \n",
+    "\n",
+    "Along with more quantitative evaluations we can measure the models performance on more qualitative metrics like code quality, and task adherence. We have created a sample prompt for this called ``llm_as_judge.txt``. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "cb68a647",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from scripts.llm_judge import judge_folder"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "40cdec99",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "# Run LLM-as-judge for baseline results\n",
+    "judge_folder(\n",
+    "    results_dir=\"results_topk_baseline\",\n",
+    "    out_dir=None,  # auto-map to results_llm_as_judge_baseline\n",
+    "    model=\"gpt-5\",\n",
+    "    system_prompt_path=\"llm_as_judge.txt\",\n",
+    "    task_text=None,  # use default task description\n",
+    "    concurrency=6,\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "626f4797",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "# Run LLM-as-judge for optimized results\n",
+    "judge_folder(\n",
+    "    results_dir=\"results_topk_optimized\",\n",
+    "    out_dir=None,  # auto-map to results_llm_as_judge_optimized\n",
+    "    model=\"gpt-5\",\n",
+    "    system_prompt_path=\"llm_as_judge.txt\",\n",
+    "    task_text=None,\n",
+    "    concurrency=6,\n",
+    ")\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "50361139",
+   "metadata": {},
+   "source": [
+    "### Summarizing the results \n",
+    "\n",
+    "We can now demonstrate from both a quantitative standpoint, along with a qualitative standpoint from our LLM as Judge results. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "a6dd05b0",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABcsAAAMQCAYAAAD4vT0AAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjUsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvWftoOwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAzJtJREFUeJzs3Qd8VFX6//EngUDo0kEU6QhSlSIqiKhgwV2Rn7IKKihS1GUFKSogSBEUEBWkCYoKKCpYWFQUXayAYEVpUmWlSS+hhDD/1/f4v7OTkEBIJpmZzOftawyZcufMTO489z7nnOfE+Hw+nwEAAAAAAAAAEMViQ90AAAAAAAAAAABCjWQ5AAAAAAAAACDqkSwHAAAAAAAAAEQ9kuUAAAAAAAAAgKhHshwAAAAAAAAAEPVIlgMAAAAAAAAAoh7JcgAAAAAAAABA1CNZDgAAAAAAAACIeiTLAQSVz+cLdRMAAAAAADkc554AsgLJcoSthx9+2KpXr24vvfSSRZP//ve/7nWf7vL6669bOJowYYJNmzbN//u4ceNce7PaI488csb37M4777S5c+e6f+s9DqUFCxbYHXfcka77Hj9+3K677jr78ccfs7xdABAM0Rq/ly5dekrsufDCC+3iiy+2f/zjH/bZZ59lyfMqvumSkbjZrFmzNBMNo0eP9sfPnCwwJnvHYDpeSGnJkiVWr149u+mmm2z37t2pHq9ddNFF7j19/PHHbc+ePf7H7t2715o3b25btmzJ1tcGAOHku+++s3/+8592+eWXW+3ate3qq6+2AQMG2Pr16zO8vS5dulikS+1cVscOt912m3388cfZ2paMnr/rNbRo0SJL2gSEQu6QPCtwBgcPHrSFCxdatWrVbPbs2dapUyeLiYmxaNK9e3d3YpWa888/38LRc889Zw8++KD/91tvvdWaNm2a5c97//33u0REYNJ+5cqVNn78eP91BQsWtGLFirm/p1KlSlmo6AT7iSeesBdffDFd98+TJ4/17t3b+vXrZ++9957Fx8dneRsBIKOI3+YSpUqaihLR+/fvdx0HilWTJ0+2K6+80sJBbGys7dixw77//nu75JJLTrn9gw8+sJwuvTH522+/tW7dulnFihXdZ1m0aFF/x3vg8dqxY8ds48aNLtmwbt06mzVrlrte9+/YsaM99thj9uqrr0bdPgEAU6ZMsWeeecauuOIK911YsmRJ27x5sxsE1qZNGxsxYoTdeOONZ7XNt956K8OJ9nCj98M7dz158qQ7dvj3v/9tPXr0cIPR1MEAIPuQLEdYUmCQ/v3729133+1G8zRp0sSiSfny5d0IpkhWpkwZd8mO90oXj5LiSjKn9v7ptlCaOHGi1alTx59ISY9rrrnGnn32WXcwqcQTAIQr4rdZlSpVTok/DRo0cAlVJUrDJVletmxZl8z/8MMPT0mWazaTEunq9MjJ0hOTly1bZl27dnWfqxLlhQsXPu3xWuPGjS0uLs4lg3777TerWrWqu16j1/V8n3zyibVs2TILXxUAhJf//Oc/NmbMGDeqPHBgVaNGjezmm292M9I0Mlkxx/vOjDapnbvquOGHH35wgw9IlgPZizIsCEtz5sxxJ9eXXnqpXXDBBfbGG2/4b7vnnnvslltuOeUxGrH1t7/9zf/78uXLrUOHDla3bl0XiDUyN3BKrKbY1qxZ0/VIK/joPhoFlJSU5Hq+W7du7U6gFLQ0alkn/IEWLVrk2qH7tGrVyiUIrr32WjeayLNv3z43wuyyyy5zU800lWrx4sVBe590sKHtbtiwwX+dnr9GjRpuFJRHr1E99bVq1XJBV/fR6wz0+eefu9ep16sef7X7wIEDp52Opeu81+vdrh5x79+pPU4j1fS+1a9f373veh71nAe2X++j3l9NdVab9f6+++67mX6/UpZh0UHZvffe6w5AlJDWZ6n3QKPCdFCn59ffj0bIr1q1Ktm2zvT3lRrd/vbbb7u/rUCvvPKKK7Wiz1Ij8QcPHmyHDh1Kdh+15eWXX3ZlWQAgXBG/U6fZTRqVvHXr1rN6Dr1ujXy+6qqrXDzUa33ggQdOW07syy+/dPdVh8WZarkq9miKd8r7KVarXeecc84pjznTMUVmYuvXX3/tkspK3ivprATKtm3bTvvZz5w508V2bT+QZmPpeCjw8emJyYH0t6gp/tr+9OnTT0mUp6VIkSLuZ+AIciVC9Pem2QUAEE10flipUiUXv1JS5+KQIUMsV65c/lk+aZXECiz1oX+/88479scffyS7r86hhg4d6s6pdBzQtm1bF/c9ileKG4pFik+KYyo7pplBgc+TneeIaVEMKVSoULJYorZpMMKgQYNcqZYbbrjBvSaNRtcxkI5nvPPn1157Ldn20nucFEjHLXqPdNzk5QZ07v7oo4+619ewYUMbNWqUe/6UTnfer8EDKlWnMmWeF154wX2WgcdCmq2o+6kDPyvzBEBKJMsRdjQKZ8WKFa6XWfTz008/tV27drnfdUL966+/umlbHn1xf/HFF/b3v//dPwpI011VskIjcjW6R8nju+66y44ePZosYGiU0PDhw90XfuXKlV2wVBmPdu3a2dSpU12w1Qntv/71Lzty5Ih7nAKKTu41Kktf2u3bt3cBK/CETAFXgUxt79mzpztI0Cjrzp07p+uEWwHnxIkTp1wCT0iVVM2fP797bvnll19s0qRJLiGh4CU6KRs4cKBLXug2tVUHIrrOo6CvUVPFixd375fKfigwqd3ppYMJ+b//+z//v1PS+9qrVy8XmJ9//nl3wKRaoaqHGvi5/Pnnn+6gSZ+XAvp5553nDjSyYpqdeutnzJjhDjw0/U/PoRNj/VvviaYL6nPVe+JJ799XSkpI6DNU0sOjJI0OMPS5aIqd3hOd4OvvLmVCQwcJgZ0gABBOiN9pU0enTv69WVDpeQ4lsBWHlEBWDFKMUCe5bvfifkp6/3QfnUQOGzbsjOU+dJLtlWIJPP746KOPUp0On55jiozGVp3s6vhFn41u1+eq7ejzVLmUtD57nfTnzZvXxc5A2p7aqe2lNyanrIV73333uRN3vffq8DjT8Zr+RlevXu3+DtVhpNHoKWO5jtVSJvYBIKdSoljfe/quTSsmqWNWHbSKiemlWK6ZWipfonNPJXQVHxRH5s2b52KNvou9JL2S2KKErWKRkuCa7aM4pnil7QV2HGfnOaLHiyWJiYkuiayEso6tbr/99mT302vRcyu5rE5ldTQoL6Dzax1rKT4r3jz55JPuPp70HCcF0jm5Xo8+Hw3aUoexYp6OVTTQTufnI0eOdMcQKUu3nem8X5+X3u/ARL33b72PHh0jqpO8dOnS2Z4nQJTzAWFmxIgRvkaNGvmOHTvmft+6davvwgsv9E2cONH9fvjwYV+9evV848eP9z/mrbfecvfZvn27+71du3a+1q1b+06cOOG/z4YNG3w1atTwzZgxw/0+Z84cX7Vq1Xzvvvtusufv1auXb/r06cmuW7BggbvvDz/84H6/4447fH/72998J0+e9N/n3//+t7vP888/736fPXu2+/3HH3/030f3b9++ve+WW25J8/Vv2bLFPS6ti157oPnz57vr33zzTd+NN97ou/nmm/3v3YEDB3x16tTxPf7448keo/vqMWvXrnW/t2nTxj0u8PVouy1btvT9+eef7jXp/ikFvt7Ufg983L59+3y1atXyDRw4MNk2li1b5u7jfS7eY7755hv/ff744w933bRp03zp0a9fP99VV111yvXeZ6732Luffl+3bp3/PnqvUj6/nlfX7d+/P91/X6n517/+5f5uAun9aNWqlS8pKcl/3Xvvved79dVXT3l8w4YNfU8//XS63gMAyG7RHr+XLFnijx+JiYnucuTIERdj1Dbd9vnnn6f7OfSe3HnnnS5OBho6dKiLp54OHTq4y08//eSrX7++r0+fPsliypni5NVXX+226Vm6dKmvdu3avoMHD/q3fTbHFBmJrWrv5Zdf7rvnnnuSbXvz5s2+iy66yPfUU0+d8bPX6/E+123btrm/q3nz5p1VTPaOwRSb9V5Wr17dHQsdOnTorI7XtB+sWbPmlMfoPdTtM2fOTLNdAJCT/Pzzz8nO9dIycuRIdz+dM3rfr/rOP905XsrfP/vsM/e4Tz75xH+d4ouOLcaNG+f77bff3O2TJ09Otl3FFF2/aNGikJwjes+X2mXQoEHJYrp3X8W5wOdQvEr5usaOHevi+Z49e9J9nOSdi+sxyi3cdNNN/sfLf/7zn2THM97xXePGjf2fRXrP+3UO7N0nISHBxXvlJbzjDmnevLn/+CwYeQIgvRhZjrCiXtT333/f9fSqx1EjzgoUKOCm47755puuJ1MjqXV7YO/l/Pnz3egh9TiqV/Snn35yPc3qrfR6aLUopkaeaYRWIE3RDaR6ahrtpV5w9dpqSrna5I0M00U9zao3Gdg7rt7b3Ln/twyARn6pp1t1MANHhatXXb3rgaVHUqORYZoenPKiaWMpR4Vp+pF6ybds2eJ6jDXVV9ROvY+arhY4Ot2bvqb3QrdrMUy9p4GvR9tV72+JEiUsGFT/VO9dyunOquNarly5U0ZMB9Zs8+qeJyQkWLBpqrT+Ljze69XUOY83DV1/j2f79xVIn496vwNp5JlGmGmKmkYWalSmRgSq1z2lc88997RT7wEgVIjf/6NRWHqsLooliqfa5oABA6xZs2bpfg69JxpVpvdQ3/16/ZpSrRFcKUtyaZq0RkHrfdPxgBbvTC+1L7AUiz4TjfhKOZI6PccUGY2tioMaLZbyGEEj8TV9O+UxQsrPXrPaNBXfGzmoUeX6+9N07bOJyR6NUtTxiUbkaSaERrGl53hNZYfGjh3rSu5oartmUgTSdHqNzCOWA4gWXmxRuZXT0ejowPtnhGYE6Xm8uCSKh/pu1ne1F0tSzpzS73r+pUuXhuQcUXRMEHjOr9JfarOOZfr27ZvsvnrewHXBNCJbz5lafNZMNr0v6TlOCqTR4xrVrtHxWqTao8fpPVaZG4+O7wLXY0nveb+ONb755ptkn51GjOt91ONVYs8rAxOKPAGiGwt8Iqyo/pSm2npBIrU6nPoi1nRtfbFrqqsClwKbphl5wUon5ZoW7NU9C6SpuoH05R5IyUrVB9XPfPnyuSm0SlKKgpCmKumEViVLAinABtb21P104pfWolG6zatpmRoFEtUwTQ+tIK7EdoUKFdwJWmAbRFPGUrNz5053Qq7XlfL1BJuXXEgt+a7rDh48mOw6vfce76Q/MwdPaUlrWnXKvwvP2f59BVINvcDX5SUptL1Zs2a56WoqC6DPXlP6dFsgPTZlLXMACAfE7/9RG7zHatu6r9oRmKBP73PovfKmequNShJrendKSr5qvRG9n+p41bTx9FKsUXkVJeF1AqrEuaZzp5SeY4qMxlZv22kdI6hT/3TbUcezEt9Kkqt+qn7qdZ1tTPbob1XvowYfeFP0VW81sLZ+WsdrSu7r8V49d02HD0QsBxBN9B0p6tA8HXVgqpNTsS6j35GKJXp8Wh3G3vmoEtOB1GGuhHDg+Wh2niOK4k3Kc38NJlDbVNKlU6dO/mMGvU+pxdDUyqeJyq2l5zgpkJL/iqtKsKsD2XtP9R7qPU5ZUifwPU3veb9ipcq76BhGgwhUg12vWQl+Jcw1eEDbVW3yUOQJEN1IliOsqHdTva+qQxlIX37qWVWvsL5U9SWqL84PP/zQ/VTw0UgxL3joy1sju1ILGGmdGIkCs3pRVZ9SI6tU40xfwKrJpWS06CRbvZ5eDVaPgqMXqLzRQ0pea6R3atIazXS2FMhUO02rh69du9bV8dRrEG8hKrVBbUktWOlAQO9XyoVHFKTUS63ecy8YKsng9fofPnz4rNrpJRb0vul9TZkU0OceCTLz95XyIMyjXndddNtXX33lDrD69OnjRhN69dm8gzDvgAYAwgnx+3/UaX2mzu70PIdGb6kOp2YaaaExLx48/fTT/lFiHh0DKOGtE2odB+j9S2+HuxbOUptVp1wjxxX/U47iSu8xRUZ5nRUpPxvvGCFwVFtq9HejgQMaea/arhqp/tRTT532MWnFZG+2gTdLT/FYI9/UgaDOBK/u/Onob1l/g4H1+QNj+ZleDwDkFIq9+u5ULFZt7NQS2YrhGnntjQgPPPcMdKbRw4qtiuc69ghM5qrDVdd556OKK14SX7wa4Zn5bs7MMczpeIlixZO0Oti9+PzKK6+ckkgXnT+m5zgpkLalxUs1a02z3PS6RO+R3qvAvIAEHkel97xfI82Vi1CiXHkHzZbXsY6OMdT5r2MdHY+caf0VICtQhgVhQ1+cGnmm4NK4ceNkF40Y0omLvszVM6ovZpWq0MKUOrnTtG6vl1dfuFoEYsOGDe5E0btUrVrVjfAJnF6Vkh6jL3pN/1FPqxfMtbCEd0Kt51avZ8oFSD777DM33cmjBTY1EkwHCIHt0IGAFtQIDC6Zod7e7du3u9emlbe1gIa3wIUS3UoM6D0LbIN6qDVSTb24Cqgaqab3MpBes0aPaaSY17Ou5/GkPFGX0037Vlt04qkFLQMpGaDpVXpPI0Fm/r50oBK4iJw89NBD/pXhdYB3/fXXuwVm9LcUOEpPB3j6HAMP7AAgHBC/z156nkNlT9Tuf/7zn/5EuU5OvSnLui0w2azYrniiKckq+RL4mtJbikUlclS6JLURcOk5psgoJevVeZLyGEEjDTWdOz3HCCpnpkS0kuSa8h44VT69MTk1Gsmvhbg1JVyLsSqpciZKwithf8EFFyS7XqPtNMiBjm8A0USd5vpOVKxISXFNi1ars9Yb8OWde3ojokXfvT///PNpzz2VfNX9vNjvnUNpMWh1KCv2ipLFgfS72qGBShmVmWOY0/Fec8p4kvJ1i5LYgc+twXDPPfecOz5Kz3FSIMVklY7Tuam24cV4DXrQ8cXChQv991V8DCwzk97zfh1TaNaWjsuUmPc+Hx07asai7p/WItxAVmNkOcKGpszqizet6UM333yzvfXWW672qU4cNZVbo6f0RZ9yqpNWXlaiV6tDa8qsgp/uq+k8SkSe7mRNgU5TZnXyp4t6Wr0p5d4q0T169HAjvfRTdTL1pa8gIl7Pp07aNG1XU6a6detmZcuWdSe4aquS2meq2/b777+7E8TUqLdWbVW9Lz2HTt7UA6vE6yeffOKmX2sUn3p+ddChtqk3WYkLHXTod7VTo8m819O9e3f3vul9Vi+wDmaUxNBoNbVVo9dVB1Wj27zVt1P2XKtXW9O4tYK1F7QDT+T1mehx2p4Cn4Ku2qKArRFhkSKjf186GNBoSp1EKzHuHQzoAFEn9zog0Ym+pn7r8/Q+H9GsAT0usD4cAIQD4vfZS89z1KlTx91X9bLbtm3rEq1at0QlbLwRdimniWvkmmKK3sNp06ZZ165d050sV3x+7733XEmw1KT3mCIj9Legz14JDe+z10m/4qGOefQ+nYkS0JdddpmboaVSZmeSWkw+3cg+/f3pter4SCP+0zpe0zGUOjy8UXyBvIEGKpkDANFC5y86P9XMKCVFFdNKlSrlzgVff/11d51mpnlxRN/7Kmml2UJKEut3jW5WQj2wDIrOPfWdqw55Df7SKGQ9Ts+l82KNYFZc00CyoUOH+s85NbhMxwUq26XnVqxRTMvseVZGj2G8hHNgLNFxlc71J06c6GJGWqPKRaPF9XwDBw505W4Us9Q5oTU0NFNN55XeMcOZjpNSUs1yDYjQsYWOK5QsV3vUKa/yexrIpc9GiXmvzN3ZnPdr1qGeQ5+rN4pen4VyGeq4V1wHQoFkOcLG3LlzXc+rkrOpUU+vvux1wq1go2Cq++pkSl/agfQFri9zBT6dEOtLWgFGNbECF4RISSdLOklUINc0MW/UtU5oNQVJvZuaHqZEsHqI9YWvtihIKDgpae0lkPWFr5NajfzWiCSdjOl+Cp733HPPGd8PBUZdUnP11Ve7adA6qdR7oAS26LmV0FbiWydqOknWgYJ6hlUTW9fpYEPvl4K5d3KoAKbAqfdLo9KKFSvmRv4pqeElIZTMVXsU+DRiSwccugTSCb/eP71XgQu4ebQ9TdPW+6naZwqkGnGoNqZV/y0cZfTvS++zDkx0wOHVI9cCYBoBoQMCfUYawabPR9O+AxMy6vXX5xgpI/ABRA/i99lLz3PoZFExXa9do/AVP3WdF6uVeA1cUMuj6zSVWSep+playZSUdPKqz0SzBE53YpqeY4rMdCDoM9DoP70+ndQrcaFtp6wvmxYlSjSdWx0yZ5JaTD4dHVMpFuvz0HvkrRETeLympL/eB/3N6u845cABPV6dIMwSAxBt1OmpRLbKe+i8UslVfber41KJcsWhQCNHjnTnmkrKKh6og1vHEzqWCIwbSpQrZuiYQeep6nTWebLivBLASiQrYe11QOu5lIBX+TjdV0l7jbbWMcHZLI6dmowew4jib7t27fy/67GKFWqbNwv5dDSwTfFT55SaDa7EtWKb4rZmq6X3OCklvT+Kw+q41+AIDYDQ69N7rE4HlW7T89x2223JZu6l97xfxyzqcNc5rrfYuo51dJ1+ZrR8DZBZMT4q4QNnTYFA05wDe3i1WrTqTisIKZkNpEYHffpbUQ98eulrWgmPO+64w18vDgBw9ojfOZtGcmskmjoKsiomZ5RG9Sn5rySRZu4BAAAgPDGyHMgATfHVyGlN89XIIk1D1qgiLWDB1Fqcjkbfq1SB6s95IxzORHVkNY1Po9ABABlH/M6ZlBzXlHN9vhr1npUxOaM02k8zMOiQAQAACG+MLAcyQPXSNLVLdb60CKOmFWm0kKZPa7oRcDpK1GgUm06cz0T161QS58knn8zUojMAAOJ3TqX6t6odrjJ0Z1sq52xickap3ICmrnv1dwEAABC+SJYDAAAAABDBtNie6jyrDr/qCGvxQi1Gq7WGxFtE8ZdffnHrE6m0n+ohAwCA5DK3ggEAAAAAAAgpLQK4efNmmzJlir399ttu0XglxLXIoRZU1gKL5cuXdwsb6r5aoE//BgAAyVGzHAAAAACACLV//34rV66cde3a1apVq+auu//+++3vf/+7W8R28eLFFhcXZ0OGDLHcuXO70eZeYl1ljAAAwP8wshwAAAAAgAhVpEgRGzNmjD9Rrjr506dPtzJlyliVKlVs+fLl1qhRI5co91x66aW2adMm27VrVwhbDgBA+In4keU//PCDqey6esoBAIgEiYmJFhMTY/Xr17doRgwHAESacI/hAwcOtDfffNPy5MljEydOtPz589v27dv9iXRPqVKl3M9t27ad9QLHxG8AQE6O4RGfLFeQZo3SyKDPSX+YOqjSHyeA4GM/iwzErb8QwyMD3ytA1mM/ixzhHrfuvvtua9eunc2cOdPVJp81a5YdPXrUJc8D5c2b1/3UYqAZjd/Hjx8PWrtTtg+IFMHcD7Ia+xki1fFs3s8iPlnu9WbXrl071E3BGSQkJLhV2DUVUCMcAAQf+1lkWLFiRaibEBaI4ZGB7xUg67GfRY5wj+H6G5Lhw4fbTz/9ZDNmzHCLfaZMNHhJ8oz8vSl+K1nuPVdmqYMoX7589tq2hbbj+N6gbBPIaqXzFLU7y17jFtEN9040YT9DJCod5P1s3bp16RqUEPHJcgAAAAAAopVqlGsRz1atWvnrksfGxrpk9s6dO13tcv0M5P1eunTpDD2nkg3B7th5a+cX9uvhzUHdJpBVLipwgUviKQEdSdjPEM37WUw6Z++xwCcAAAAAABFKi3T26tXLJcw9KuuzcuVKq1y5sjVs2NC+++47S0pK8t++ZMkSq1ixohUvXjxErQYAIDyRLAcAAAAAIEJp8c5mzZrZsGHDbNmyZbZ27Vp75JFH7MCBA9axY0dr27atHTp0yPr37++moM+dO9emT59uXbt2DXXTAQAIOyTLAQAAAACIYM8884w1adLEevbsabfeeqvt27fPLfJ57rnnutHjU6dOtY0bN1qbNm1s/Pjx1rdvX/dvAACQHDXLAQAAAACIYIUKFbLBgwe7S2rq1Kljs2fPzvZ2AQAQaUKSLD9x4oS98MIL9u6777oe75o1a1qfPn2sXr16oWgOAAAAAAAAAFi8xVnRmAIWY+lbEBJZo7ivoB09ejRd942Li7NcuXJFbrJ84sSJ9tZbb9nIkSPt/PPPtxdffNE6d+5sH3zwgZUqVSoUTQIAAAAAAAAQpZQab5OroV0Vd5HFxeYmVR5icTG5XQmx9DrnnHOsTJkyFhMTE3nJ8oULF1rr1q3tiiuucL9r8RElz3/88Udr2bJlKJoEAAAAAAAAIEopUX5j/MV2ToliFhOfi5HlIZYnNs4q5Ct9xvv5fD5LSEiwnTt3ut/Lli0beclyLTDyn//8xzp06OBegGqn5cmTxy688MJQNAcAAAAAAABAlMpnedyIciXKcxXJG+rmwMxyxea2+Pj4dN03X7587qcS5qpakpmSLCFJlvfv39/+9a9/2dVXX+0aHxsba+PGjbPy5ctnaHteDwLC25EjR5L9BBB87GeRQXErs1PDAAAAAADBcU5M/r9Kr8QHp+41sl/+/Pndz8TExMhLlq9bt86t1q1FPkuXLu1KsPTu3dtmzJhhNWrUOOvt6U1YtWpVlrQVwbdp06ZQNwHI8djPwp9mVAEAAAAAQk8lVzScidIrkStYA9KyPVm+bds2e/jhh2369OnWoEEDd13t2rVdAl2jyydMmHDW29SKp1WqVMmC1iKYNNJVCbwKFSr4p0cACC72s8igmAcAAAAACH9xMbksV0xoRpwn+ZIs0ZcUkueOVtmeLP/pp5/cSHAlyAPVrVvXvvjiiwz3HHhD7RH+lMDj8wKyFvtZeKMECwAAAABERqK8Sr5yljs2NMnyEyeTbN2RPzKUMP/ig8/sw9nv2+/rNrpz0HIVz7erb77OWra9MUvamlNke7K8TJky7ueaNWusTp06/uvXrl3rRkIi59KOqQQeSSIAACIH8RsAAADRSiPKlSjvuXaSrT+yNVufu3K+c21stW6uDWebLP/0vQX28qiJ1qlPd6tR7yK3btZPS763l0ZNsv2799mtXdpnWbsjXbYny5Ugv+SSS6xfv342aNAglzx/9913bfHixfb6669bqLHoWtbRiXbNmjVD3Ywci79dANGO78GsQfzOevztAgAAhDclyn89vNkixYK3/m0t/t7Krv57K/915Sqcb3t27rb5r79DsjyckuWxsbE2ceJEe/bZZ+3RRx+1/fv3W7Vq1VwNc5ViCTWdqGz47y47ejwx1E0B0i0+T5xVOq9EqJsBACFFDEckIoYDAAAg2GJjY2zNzyvt0IGDVrBwIf/1bTrdZi3+3tL9u3vru6z5Tddau653+m/vnuK6db+usZnjX7bfVqy2vPnirfFVl9vdPe9z/9aAjw9ef88WvD3Pdm3/00qVK2P/d+/tdsV1V7nH7t65y14Z+6L9+M1yi80VaxfWrWl39+xiZcuXc7fv37PPXhw53n5d/rMdO3rUKl5Yxe54oKNddMlflUjW/LLKBj3bx1atWmW5c+e2Sy+91OWSzz333JyVLJciRYq4UeW6hCOdZCcc5UQbAIBIQwwHAAAAEO3+ftetNvbREdblug5Wq0Edq3FxbavdsK5VrlnNChQqmK5t7Phjuw3u2s8atbjcnpz+rCUcOmzjHh/tEtwPPtHb3nv1bXtrygy7p093l+D+/utl9vzjo+yc4sWsSq3qNqhLX6tUo6oNeXGUGzw9b+Zce/Tuf9mY2ZOseKkSNmXEOEs8nmhDXnzacufJY3OnvW5P9XrCpnw00+LyxNmQHv3t9nb/sKeeesoOHDhgjz/+uD322GNuwHWOS5YDAAAAAAAAAIKvyTVNrXjpEjb/9XddrXIlsuXcC8rZ/Y/3sgvrXXTGbSyc+4EVLFLYHni8l+XK/dcCp90HPuRGrGtU+fxZ79gNt9/sFg2VG/7xdzt+7LidOHHCvl6wyBIOHrZ/De2b7LG/Lv/JFr7zoRu5vuO/26x8lQpWqlxZyxuf1zr17mZNr7/KJdaPHE6wA/v2W6lSpaxcuXJ2/vnnuyolu3fvtqxGshwAAAAAAAAAcpBqtWu4y8mTJ23T2g32w9fL7MPZ79vwHgNt/LsvnfHxm9dtsko1qviT3VKrYV13ObB3v+3dtceq1b4w2WNuvvtW91Ojz1UC5u7mbZPdfvz4cftj4xb371vva2/PD3zalnz6lUve1730Epcsz5M3j7u0vbudDR061J5//nlXguXKK6+066+/3rIayXIAAHIA9bCPHDnSvvzySzt27Jg1bNjQLaZduXJld/uAAQPsrbfeSvYY9dB/9tln7t86gBo/fry7z8GDB93jNc1NPfge1YobPny4/fLLL1asWDHr2LGj3XXXXdn8SgEAAAAAadm940+b+/Jsu6VTOyteuqQbqV3pwiru0qh5E+t5Wzdb+f2KVB+blHTS/2/VCU9LrtPcJr6TPjv3gvOs39jBp9wWny/e/Wzc4nKb0nCW/bh4uf289Af798y59taLM23E9LF2fuUK1vFfXeyBu7va559/bosXL3aJ86lTp9q7775refLksawSm2VbBgAA2eaBBx6wzZs325QpU+ztt9+2+Ph4l8w+cuSIu33NmjXWrVs3++qrr/wX3c8zYcIEmzVrljsAeeONN1zyvHPnzq7nX/bu3WudOnWy8uXL25w5c9zzjR492v0bAAAAABAe4vLksU/f+ci++PA/p9yW///XKy9SvKjljotz5U48qkm+f/de/+/nVSpvG1evs6SkJP91Sz/72i0CqprixUoWt3W/rk22/dF9h9n0Zybb+VUusD+37bACBQtY2fPPdZeSZUrZzHEv2arvf7HE48fd/Xb8sc0ub3mlK9Ey/r2XLTYmxr77apn9sWmLvTB8rBUvXtxuv/12N7pcifL169fb6tWrLSuRLAcAIMLt37/fjRIfNmyY1alTx40mv//++23nzp3222+/uXpy69ats1q1alnJkiX9F40OFyXEX3rpJevRo4c1b97cLrzwQhs7dqxt377dPv74Y3efN9980+Li4mzIkCFu+23btnXJeCXnAQAAAADhoXDRIvb3u2+1Nya8YrNemG4b16x39cGXf7HURvUearUa1LWa9Wu5Ei3ffPyFrf5ppW3ZsNkmDBmbrOTKdbfdZAf3H7QpT46z/2783Y1Gf+25qVa7UT1XJuXmjre5muhffPCpbd+y1f172aLF1vDKJtbs+qutYJFCLnm+dsVqV3pl/KDRrhRM+aoVXEJfifbJw5+ztStW2c6t223RvE/s6JGjVq1ODSt8ThH74qPP3GxnJcg3btxo77zzjhUpUsQqVaqUpe8fZVgAAIhwOmAYM2aM//c9e/a4FcLLlCljVapUsd9//90SEhLSPKhQz/zhw4etSZMm/usKFy5sNWvWtGXLllnr1q1t+fLl1qhRo2RT8VQ3bvLkybZr1y4rUaJEFr9KAAAAAAiNyvnOjajnvP3+u61s+XJuMc2P3pxnx48esxJlS9nlLZtZm07/cPe548GONnn4ARvS/VErUKiA3dShrR0+eMi/DY0cH/jCcHvtuWnW544HrGDhQnZZyyvtjgc6utuvb/c3t6DnGxNfdfXL9Xw9Rz5qF11Sx90+5MXR9uqzL9qwB/u7mcsqAzNwwgg7r2J5d3uvkY/Z9DGTbWTPwZZwKMHKVTjPegzr6xL5Mnj8SHvzhVfttttuc6Pb69WrZy+//LIVLPjX6PisQrIcAIAcZODAgW4UuGq4TZw40fLnz29r1/41Ne61116zL774wtWsa9asmfXs2dMKFSrkRpBL2bJlk21LK497t+lntWrVTrldtm3bRrIcAAAAQI6T5EuyEyeTbGy1biF5fj232pARzVtf4y5pKV6qhD323JBk1/3tzuQLclavU9OGTfvfwKxAMTExbkFPb1HPlEqXK2N9Rg1M8/mVjFfCPC016l5kM2bMsOxGshwAgBzk7rvvtnbt2tnMmTNdXXHVIVeyXAlyJbcnTZrkRpo//fTTrkTLK6+84q9rnnKRlLx587oSL3L06NFUbxctKJpRKhGjUe+ZpQO1fPnyZXo7QKhoP9T+gOjkfQ97PxG+tJ8q5gAAokOiL8nWHfnDcsX8rzxJdlKiXG1A9iFZDgBADqKyKzJ8+HD76aefXE+8/n3HHXdY0aJF3W0aIa6a5ZrOtmLFCrcYqFe73Pu3lwT3EtC63lvsM/B20ej1jEpMTLRVq1ZZZqmdKhsDRCrVYSRRik2bNoW6CUiHlJ3HAICcTclqEtbRg2Q5AAARTjXKFy9ebK1atfLXFNdIciXOtcin/u0lyj1Vq1b1l1fxyq/ovuXL/1U/zvu9evXq7t+qf67fA3m/ly5dOsNt16KhXoI/Mxjlh0hXsWJFRpZHMXWUKFFeoUIFZsmEOS2YDQAAci6S5QAARDgtsNmrVy+bOnWqNW3a1D9ie+XKldaiRQvr27evS2xr0U+PRpSLEtXnn3++WyRl6dKl/mT5gQMH3OM7dOjgfm/YsKG98cYbbmGVXLn+moK4ZMkSl+ArXrx4ppLcmRmZDuQUJEjh/R3wnRje6JwFACBniw11AwAAQOaorIoW7Bw2bJgtW7bM1Sh/5JFHXMK7Y8eObsS5Rp6PHz/e1Sv//PPP7bHHHrPWrVtb5cqV3XRyJcVHjx5tn376qa1evdot/qnR5C1btnTP0bZtWzt06JD179/fjaqbO3euS7537do11C8fAAAAAICgYGQ5AAA5wDPPPGNjxoxxSe6DBw9agwYN3CKf5557rrs8++yzNmXKFHvxxRetUKFCdtNNN9lDDz3kf3yPHj3sxIkTNmDAALeYp0aST5s2zZVJEY0e18h11T9v06aNq3muEev6NwAAAAAAOQHJcgAAcgAlwAcPHuwuqbn++uvdJS0qrdKnTx93SUudOnVs9uzZQWkvAAAAAADhhjIsAAAAAAAAAICoR7IcAAAAAAAAABD1KMMCAAAAAAAAAKmIi8lluWJyheS5k3xJluhLCslzRyuS5QAAAAAAAACQSqK8Wr5zLTY2NCnUkydP2NojW9OdMB/Upa8dOZxgT88cn+rtE4c+a5/P/9ROJCba4MlPWa0Gdc+4zV+W/2SDu/azCfOmW6lzy6SrHat//NV8Pp/VqF/Ldm7dbvff1DHdzxdqJMsBAAAAAAAAIAWNKFei/Njn99jJ/Wuy9blji1S3vFe+5NqQ3mT51Te3sucHjrI/Nm6xchXPT3bb8WPHbfHCL61dtzuteetrrGCRQlnUcrMB9z5sDwzq5ZLlxUuXtBcXzMrS5wsmkuUAAAAAAAAAkAYlyn27f8re58zAYxq3uMLyPzXBvvjwM7v9/ruT3fbtom/s2JGjLlFetEQxyy65cuXK1ufLLBb4BAAAAAAAAIAIlzc+r13Rqrl99dGiU25b9O+FdvEVjSzx+HH7v0uuc+VVJCkpyebNnGs9brnXbm9yk/u54O35aT7HoQMHXTmXLte1t3aNbrR7rmnnflciXrRteeGJZ2z8oNGuDMvZPJ/ud1ujG2zZl0usdevWVqtWLbvuuuts4cKFlh1IlgMAAAAAAABADtDi7y1txx/bbM3PK/3X7d21x35e+r1dffNfiexAr4590eZMnWW33tfBnpk9yVrdepO9PHqS/XvWO6luf/zgMbZxzXrrPWqgjXt3mnXs1dXVQf/knQ/d7Sq5Ip0e7madenfP0POdTDppLz83xfr372///ve/rVq1atavXz87fPiwZTXKsAAAAAAAAABADlDloupWvkoF+/LD/1j1OjXddV988JmdU6yo1b+8ge3e8af/vgmHDtuCt/5td/fqYk2vv8pdd2P5crZz6w575+XZduPtN5+y/bqNL7aaF9e2C6pWdL9r0c8PZ79vv6/b6H73Sq7kL5jfChQqYIcPHszQ8935wD3WpEkT9+/777/fFixYYGvXrrX69etbVmJkOQAAAAAAAADkEC3+3sq++eQLSzrx18Kgn89faFe2vsbVDw/0x6b/2okTJ+zCehclu/6ii2vb/j373CWlVre2th3/3WavPDPFRvYcZA/8rZOt+3WNGw1+JmfzfOdXLO//d8GCBd3PxMREy2okywEAAAAAAAAgh2h2fQtLOJRgPy35zjasXmdb1m92CfSUfD5fqo8/6fsr8Z0rd/KiJCdPnrQRDw2yl0ZNdLdddu2V9uhzT1j1un+NYD+Ts3m+uDx50v34YKIMCwAAAAAAAADkEIWLFrEGzRrb1x9/YeeUKOrKppQ9/9xT7ndexfMtd+7ctvrHX61i9cr+61f98KudU7yoFSz814huz6Y16+2Hr5fZk9OftWq1L3TXnUg8Ydu3bLXS5cqesV1n+3yhQLIcAAAAAAAAAHIQLeb5XP+RVqBQIWvXrUOq98lfsIBd2/YGmz3pVStUpJBVvqi6/bh4uasrfscDHS0mJibZ/c8pUcyVcln8yRdWpNg5dnD/AZs77Q3bt3tvshIp8fnz2X83bbGD+w5k6vmiIlm+dOlSu+uuu1K97bzzzrNPP/00u5sEAAAAAAAAAKmKLVLdTobgOTOj7qUXW3y+fC6h3bjFFWner2OvrlbonMI24/mXbN+efVa2/Ll2b9/77dpbrj/lvsVKFrcHn+htsye/Zh+9Nc+NBr+kaWNr3b6NLf98if9+N3W4xd575W37Y+Pvdk+f7hl+vqhIlmvF0q+++irZdT/++KP985//dCubAgAAAAAAAECoJfmS7OTJE5b3ypdC8vx6brUhI2JjY23SB6+dcn2pc8vY29995P89V+5cdluXDu6SmloN6ia7f9Prr3KXlJQE97Treqe7eDLyfPGxeZINsF6zZo3lyGR5njx5rGTJkv7fExISbMSIEdamTRtr27ZtdjcHAAAAAAAAAE6R6EuytUe2Wq6YXCF5fiXK1QZEUc3ySZMm2ZEjR6xfv36hbgoAAAAAABFn37599swzz9iiRYvs0KFDVr16dXv44YetQYMG7vZOnTrZN998k+wxjRo1stdeO3XEIQAgOSWrSVhHj5Amy/fs2WPTp093Qfycc87J8HZ8Pp8boZ5ZKiKfL1++TG8HCBV1PGl/QHT/DQT+RHjSfhoOC5cAAICcoVevXvbnn3+6hHnx4sVdEvzee++1d955xypVquSmrg8ePNiuueYa/2Pi4uJC2mYAAMJRSJPls2bNskJakbVdu0xtR6utrlq1KtPtUaK8Zs2amd4OECobN26MiCSpDsxz5w75xJYcS99lO3bsCHUzcqQTJ04kW+E7s2XJAAAAMmvz5s329ddfu/PrSy65xF03cOBA+/LLL23evHnWoUMH2717t9WtWzdZSVQAAHCqkGar3n33Xbv55pstPj4+04m3KlWqZLo9jPJDpKtYsWLYjyzXfpYnb7zlimV/Q+RJOumz48eOZno/W7duXdDaBAAAolvRokVtypQpVrt27WTH3LocOHDAjSrXv3WuAAAAwjRZvnr1atuyZYvddNNNmd6WAn/+/PmD0i4gkkVSGaHJ35ywbfvDO7EPBCpbJMa6XpY7KPsZnbMAACBYChcubFdeeWWy6xYsWOBGnD/22GO2du1aN6N7yJAhbgS6zp2vu+46u//++5npBgBAuCTLly9f7mqpXXjhhaFqAoAQUqJ8895QtwI4G3TuAACA8Pf999/bo48+ai1btrTmzZu7hPmxY8esTp06bqFPlTB9+umnbevWre5nKNcNE9YOQySLlHXD2M8QyU6ePJmu/SwpKcndV/ulfmZ07bCQJctXrlzpVugGAAAAAACZt3DhQuvdu7ddfPHFNnr0aHedRpT369fPihQp4n6vVq2aK2Xas2dP69u3r5UoUSJk64YJa4chkkXKumHsZ4hkx44dSzX5ndr9tM7Yhg0b0rxPemZUhSxZrpW6zznnnFA9PQAAAAAAOcaMGTNs+PDhrsTKU0895U8I5M6d258o91StWtX93L59e4aS5cFaN0woT4dIFgnrhgn7GSJZ3rx5072fKeaVL1/ePSaja4eFLFn+4osvhuqpAQAAAADIMWbNmmVDhw61O++80/r3758sMabrzjvvPBsxYoT/uhUrVriEd4UKFTL0fKwbBvyF0ibRIS4ml+WKyRWS507yJVmiL+msHvN4lz628rsVqd52U4e2dnfP+077+F+W/2SDu/azCfOmW6lzy1j31ndZ85uutXZd77RQiI2NTdf9cuXK5e6r/TI+Pj7DnUYhS5YDAAAAAIDMl4F48skn7dprr7WuXbvarl27/LcpWdCqVSt3u2qWX3HFFS5Rrlrl9957rxUsWDCkbQeASEiUV4s/12JzhSaFejLphK09uvWsE+aXXdvMOvXudsr18flOTSKnVL1uTXtxwSwrXDT5rKRoQbIcAAAAAIAItWDBAldD/JNPPnGXQG3atLGRI0e60XSvvfaaS5qXLFnSOnbsaF26dAlZmwEgUmhEuRLlh0eMsJO//56tzx1bvrwVePRR14azTZbnyZvHipYolqHnjYuLy/BjcwKS5QAAAAAARKhu3bq5y+m0b9/eXQAAGaNEeVI6a16Hu0MHDtprz02zH75eZvv37LMChQtawyub2D29u1nefPGnlGGJNiTLAQAAAAAAACAKjB88xvbs3G29Rw20c4qfY6t/XGkThoy18ytfYK3vaGPRjmQ5AAAAAAAAAOQQX374H1vy6VfJrruwfi0bMG6Y1W18sdW8uLZdULWiu16jxz+c/b79vm5jiFobXkiWAwAAAAAAAEAO0eDKS61Dj3tPqWMurW5tbcs/X2KL5n1i27b8YVvW/247t263chXOC1Frw0tsqBsAAAAyb/fu3danTx+79NJLrX79+m7RrvXr1/tvX7VqlXXo0MHq1atnLVq0sFdffTXZ40+ePGnPP/+8NW3a1N3nvvvusy1btiS7z5m2AQAAAAAIvXz581nZ889NdileqoQ77xvx0CB7adREy5U7t1127ZX26HNPWPW6NUPd5LBBshwAgBzggQcesM2bN9uUKVPs7bfftvj4eOvYsaMdOXLE9u7da506dbLy5cvbnDlz3H1Hjx7t/u2ZMGGCzZo1y4YOHWpvvPGGO4jq3LmzHT9+3N2enm0AAAAAAMLXpjXr3cKevZ7qbx163GPNbmhhZc4717Zv2Wo+X6hbFx4owwIAQITbv3+/lStXzrp27WrVqlVz191///3297//3X777TdbvHixxcXF2ZAhQyx37txWuXJlf2K9bdu2LiH+0ksvWe/eva158+bu8WPHjnWjzD/++GNr3bq1vfnmm6fdBgAAAAAgvJ1TopjlypXLFn/yhRUpdo4d3H/A5k57w/bt3muJiYmhbl5YIFkOAECEK1KkiI0ZM8b/+549e2z69OlWpkwZq1Klio0bN84aNWrkktwelWuZPHmy7dq1y7Zu3WqHDx+2Jk2a+G8vXLiw1axZ05YtW+aS5cuXLz/tNkqUKJGNrxgAAAAAsk9s+fI54jmLlSxuDz7R22ZPfs0+emuenVO8qF3StLG1bt/G1TEHyXIAAHKUgQMHulHgefLksYkTJ1r+/Plt+/bt/hHnnlKlSrmf27Ztc7dL2bJlT7mPd9uZtpHRZLnP57OEhATLrJiYGMuXL1+mtwOEikomaX9A9H7+gT8RvrSfKuYAAKJDki/JTiadsAKPPhqS59dzqw1nY8iUUae9ven1V7lLSh17dXU/azWoa29/95H/+on/jq61qkiWAwCQg9x9993Wrl07mzlzpqsrrjrkR48edcnzQHnz5nU/jx075k/OpHYflXiRM20jozTVTwuHZpYS5RoJD0SqjRs3kiiFbdq0KdRNQDqkjIcAgJwr0Zdka49utVwxuULy/EqUqw3IPiTLAQDIQVR2RYYPH24//fSTzZgxwy326S3U6fES3Bp5rttF9/H+7d3HG619pm1klOqge23ODEb5IdJVrFiRkeVRTB0lSpRXqFCBWTJhbt26daFuAgAgmylZTcI6epAsBwAgwqlGuRbxbNWqlb+meGxsrEtC79y509Uu189A3u+lS5e2EydO+K8rH1AXT79Xr17d/ftM28hMkjszyXYgpyBBCu/vgO/E8EbnLAAAOVtsqBsAAAAyRwts9urVyyXMA8ubrFy50ipXrmwNGza07777zpKS/jcaYsmSJW4ka/Hixe3CCy+0ggUL2tKlS/23HzhwwD1ej5UzbQMAAAAAgEhHshwAgAinhTebNWtmw4YNs2XLltnatWvtkUcecQnvjh07Wtu2be3QoUPWv39/N3187ty5Nn36dOvatau/9mqHDh1s9OjR9umnn9rq1autZ8+ebjR5y5Yt3X3OtA0AAAAAACIdZVgAAMgBnnnmGRszZoxLch88eNAaNGjgFvk899xz3e1Tp051dczbtGljJUuWtL59+7p/e3r06OHKsQwYMMAt5qmR5NOmTXM1xUWjx8+0DQAAAACIRD73318/KbgVmYK1/g/JcgAAcoBChQrZ4MGD3SU1derUsdmzZ6f5+Fy5clmfPn3cJS1n2gYAAAAARKKDvqOW5DtplsSC65HKW4vLW8croyjDAgAAAAAAACBqHbajtvfkIUs6nBjqpiCDVIZUg8B0yQxGlgMAAAAAAACIWhpP/l7icuu6/xwrmieXxcTnshgKsoRUUuwJOxp7NF3lVw4fPuyS5WXLlrWYmMx9biTLAQAAAAAAAES15Sc32HnHvrdmO2pavtg8pMpDLC4mt/nyJKTrvkqQn3POOVakSJFMPy/JcgAAAAAAAAAW7aPL30labh8l/WznxORnZHmIVcl3rk2s2CNd942Li8t0+RUPyXIAAAAAAAAAMLMjdtyO+I6HuhlRr2hMYYuPj8/252WBTwAAAAAAAABA1CNZDgAAAAAAAACIeiTLAQAAAAAAAABRj2Q5AAAAAAAAACDqhSxZ/u6779oNN9xgtWvXthtvvNE+/PDDUDUFAAAAAAAAABDlQpIsf++996x///7Wvn17mz9/vrVu3dp69eplP/zwQyiaAwAAAAAAAACIctmeLPf5fPbcc8/ZXXfd5ZLl5cuXt+7du9tll11m3377bXY3BwAAAAAAAAAAy53dT7hx40b7448/7Kabbkp2/bRp07K7KQAAAAAAAAAAhGZkuZLlkpCQYPfee681adLEbr31Vvvss8+yuykAAAAAAAAAAIRmZPmhQ4fcz379+tmDDz5ovXv3tgULFtj9999vL7/8skueZ6S0i5LvmRUTE2P58uXL9HaAUDly5IjbH8IZ+xkiXTD2Mz1e+wIAAAAAAIjiZHlcXJz7qVHlbdq0cf+uUaOGrVy5MsPJ8sTERFu1alWm26YEXs2aNTO9HSBUNHNDibxwxn6GSBes/SxPnjxBaQ8AAAAAAIjQZHnp0qXdz2rVqiW7vkqVKrZo0aIMJ+D1+MxilB8iXcWKFSNiZDkQ7fvZunXrgtYeAAAAAAAQocnyiy66yAoUKGA//fSTNWjQwH/92rVrrXz58hlOvuXPnz+IrQQiE+VNgMjYz+g0AgAAAAAg/GR7sjw+Pt46d+5sL7zwghtlXqdOHZs/f759/fXXNn369OxuDgAAAAAAAAAA2Z8sFy3mqZF5Y8eOtR07dljlypVt3Lhx1rhx41A0BwAAAAAAAAAQ5UKSLJdOnTq5CwAAAAAAAAAAoRYb6gYAAAAAAAAAABBqJMsBAAAAAAAAAFGPZDkAAAAAAAAAIOqRLAcAAAAAAAAARD2S5QAAAAAAAACAqEeyHAAAAAAAAAAQ9UiWAwAAAAAQwfbt22ePP/64NWvWzC6++GK7/fbbbfny5f7bFy9ebLfccovVrVvXrrvuOps/f35I2wsAQLgiWQ4AAAAAQATr1auX/fDDD/bMM8/YnDlzrEaNGnbvvffahg0bbP369da1a1dr2rSpzZ0712699Vbr27evS6ADAIDkcqf4HQAAAAAARIjNmzfb119/bbNmzbJLLrnEXTdw4ED78ssvbd68ebZ7926rXr269ezZ091WuXJlW7lypU2dOtWaNGkS4tYDABBeGFkOAAAAAECEKlq0qE2ZMsVq167tvy4mJsZdDhw44MqxpEyKX3rppfbdd9+Zz+cLQYsBAAhfJMsBAIiCWqWdOnVyo8oCL3feeaf/9mPHjtkTTzzhTqbr169vDz/8sO3ZsyfZc1DvFACA8FO4cGG78sorLU+ePP7rFixY4Eacq/TK9u3brUyZMskeU6pUKTty5Ijt3bs3BC0GACB8UYYFAIAcUqv0zz//dLVKixcvbq+99pqrVfrOO+9YpUqVbM2aNTZ48GC75ppr/I+Ji4vz/1u3Kbk+btw4d7I9aNAg69Gjh82YMcPd7tU7VdJ91KhRtmjRIlfvtFixYkzhBgAgjHz//ff26KOPWsuWLa158+Z29OjRZIl08X4/fvx4hp5DI9ITEhKC0l6NgM+XL19QtgVkN3U6RcIMDfYzRLIjQdrPtA3tC2dCshwAgBxeq7RDhw6uXqlGhJcsWfKUx+/YscPeffddmzRpkjVo0MBdp6S7Ro9rsTCNNH/llVeodwoAQJhbuHCh9e7d280yGz16tLsub968pyTFvd8zmjxLTEy0VatWBaHFf7WhZs2aQdkWkN02btzoEnnhjv0MkWxjEPezlJ3HqSFZDgBADq9VqlHl+nfFihVTfbxqlnr1Sz26b+nSpW3ZsmUuWa5R54Gj0r37Dx8+PN099AAAIOtoNpjisjq7n3rqKX9CoGzZsrZz585k99Xv+fPnt0KFCmXouTQ7rUqVKkFpN8cQiGQ6Zo6UkeVAtO9n69atS9f9SJYDAJBDapUG8mqVPvbYY7Z27Vp3MjxkyBA3Al0nxzqRvv/++92JtEaWK+GukWcp65mqzqmcqd6pyrGEcho3U0sR6SJlGjeyhjdaKhJGJ0a7cO0g1uyyoUOHuvVI+vfvn6yNmjX27bffJrv/kiVL3Ojz2NiMLWOm7et4Aoh2HH8CkbOfpTd+kywHACCH1ypVwlwLeNapU8fVHNe06aefftq2bt3qfio5k9p0NCXP9TjJinqnwZzGzdRSRLpImcaNrLVp06ZQNwFBmsKd3d8fTz75pF177bVufZFdu3b5b4uPj3cJ9DZt2riyLPr5+eef20cffeRKqQEAgORIlgMAkMNrlWpEeb9+/axIkSLu92rVqrnp06o/rkU6dSKdWsJbiXKvFz8r6p0Gcxp3OI7yA3LiNG5kDXWUKFFeoUIFRimGufRO4c5Omk2mzudPPvnEXQIpOT5y5EibMGGCW6Bba5Ccd9557t+sOQIAwKlIlgMAkMNrlebOndufKPdUrVo1WXmVffv2ueR34Gg51TNV3fKsqncqTOMG/kKCFN7fAd+J4S0cO2e7devmLqfTrFkzdwEAAKeXsQJlAAAgLGuVtm/f3p555plkSW9Nv1ZZlkArVqxwo7o1ivGSSy6xkydP+hf69KZ0q5Z5w4YNs6zeKQAAAAAA4YSzWwAAIlxqtUr//PNPdzl48KC1atXK3nvvPXv99ddty5Yt9sEHH7ha5ffee68VLFjQjR6/8cYbbcCAAbZ06VL7+eefrVevXtaoUSOrV6+eP+Gu61XaZf369fbSSy+5eqedO3cO9csHAAAAACAoKMMCAECES0+tUk0bf+2111xSvWTJktaxY0fr0qWL/34ala7bHnzwQfe7pmoreR5YtoV6pwAAAACAnIxkOQAAES49tUpVnkWXtKhG7rBhw9wlLdQ7BQAAAADkZJRhAQAAAAAAAABEPZLlAAAAAAAAAICoR7IcAAAAAAAAABD1SJYDAAAAAAAAAKIeyXIAAAAAAAAAQNTLHYon3bFjhzVr1uyU60eMGGG33HJLKJoEAAAAAAAAAIhiIUmWr1692vLmzWsLFy60mJgY//WFChUKRXMAAAAAAAAAAFEuJMnytWvXWoUKFaxUqVKheHoAAAAAAAAAAEJfs3zNmjVWuXLlUDw1AAAAAAAAAADhkSzXyPI9e/ZY+/bt7bLLLrPbb7/dvvjii1A0BQAAAAAAAACA7C/DcuLECduwYYNVqVLFHnnkEStYsKDNnz/funTpYi+//LI1adLkrLfp8/ksISEh021T/fR8+fJlejtAqBw5csTtD+GM/QyRLhj7mR4fuGYHAAAAAACIwmR57ty5benSpZYrVy6Lj49319WqVct+++03mzZtWoaS5YmJibZq1apMt00JvJo1a2Z6O0CobNy40SXywhn7GSJdsPazPHnyBKU9AAAAAAAgghf4LFCgwCnXVa1a1b766qsMbS8uLs6NVM8sRvkh0lWsWDEiRpYD0b6frVu3LmjtAQAAAAAAEZos1wjydu3a2cSJE61x48b+63/55ZcMJ7yVfMufP38QWwlEJsqbAJGxn9FpBAAAAABA+Mn2BT4rV65slSpVsiFDhtjy5ctt/fr1NmLECPvxxx+te/fu2d0cAAAAAAAAAACyf2R5bGysTZo0ycaMGWMPPfSQHThwwNUv1uKe1apVy+7mAAAAAAAAAAAQmprlJUqUcKPJAQAAAAAAAACIyjIsAAAAAAAAAACEG5LlAAAAAAAAAICoR7IcAAAAAAAAABD1SJYDAAAAAAAAAKIeyXIAAAAAAAAAQNQjWQ4AAAAAAAAAiHokywEAAAAAAAAAUY9kOQAAAAAAAAAg6pEsBwAAAAAAAABEPZLlAAAAAAAAAICoR7IcAAAAAAAAABD1SJYDAAAAAAAAAKIeyXIAAAAAAAAAQNQjWQ4AQA6wb98+e/zxx61Zs2Z28cUX2+23327Lly/337548WK75ZZbrG7dunbdddfZ/Pnzkz3+2LFj9sQTT1iTJk2sfv369vDDD9uePXuS3edM2wAAAAAAIJKRLAcAIAfo1auX/fDDD/bMM8/YnDlzrEaNGnbvvffahg0bbP369da1a1dr2rSpzZ0712699Vbr27evS357Bg8ebF999ZWNGzfOXnnlFfe4Hj16+G9PzzYAAAAAAIhkuUPdAAAAkDmbN2+2r7/+2mbNmmWXXHKJu27gwIH25Zdf2rx582z37t1WvXp169mzp7utcuXKtnLlSps6daobSb5jxw579913bdKkSdagQQN3HyXdNXpcCXiNNFcC/XTbAAAAAAAg0jGyHACACFe0aFGbMmWK1a5d239dTEyMuxw4cMCVY0mZ0L700kvtu+++M5/P535613kqVqxopUuXtmXLlrnfz7QNAAAAAAAiHclyAAAiXOHChe3KK6+0PHny+K9bsGCBG3Gusinbt2+3MmXKJHtMqVKl7MiRI7Z37143slwJ97x5855yHz1WzrQNAAAAAAAiHWVYAADIYb7//nt79NFHrWXLlta8eXM7evRoskS6eL8fP37cJbxT3i5KnmvhTznTNjJKo9ITEhIsszSKPl++fJneDhAq2g+ZpRHdn3/gT4Qv7aeKOQAAIGciWQ4AQA6ycOFC6927t1188cU2evRof9I7ZULb+10J5vj4+FQT3kqUewnoM20joxITE23VqlWWWWpDzZo1M70dIFQ2btxIohS2adOmUDcB6ZBaBzMAAMgZSJYDAJBDzJgxw4YPH+4W5nzqqaf8J/Nly5a1nTt3Jruvfs+fP78VKlTIlVfZt2+fS34HJgB0H9UtT882MiouLs6qVKlimcUoP0Q6rRPAyPLopY4SJcorVKjALJkwt27dulA3AQAAZCGS5QAA5ACzZs2yoUOH2p133mn9+/dPljxu0KCBffvtt8nuv2TJEjf6PDY21i655BI7efKkW6zTW8RTo1xVy7xhw4bp2kZGqZ1KuAPRjgQpvL8DvhPDG52zAADkbCzwCQBAhFNi+8knn7Rrr73Wunbtart27bI///zTXQ4ePOgS6D///LMry7J+/Xp76aWX7KOPPrLOnTu7x2v0+I033mgDBgywpUuXuvv26tXLGjVqZPXq1XP3OdM2AABAeJg8ebKL24EU46tXr57s0qJFi5C1EQCAcMXIcgAAItyCBQtc7e9PPvnEXQK1adPGRo4caRMmTLBRo0bZK6+8Yuedd577tzeKXDQqXQn3Bx980P3erFkzd2LtqVq16hm3AQAAQmvmzJn27LPPuhlhgdasWWPdunWzDh06+K/LlStXCFoIAEB4I1kOAECE08mvLqej5LcuadG0/2HDhrlLRrcBAABCQ6XTBg0a5GaIqfZ9IK2HoFrrXbp0sZIlS4asjQAARALKsAAAAAAAEMF+/fVXt2j2+++/b3Xr1k122++//24JCQlWqVKlkLUPAIBIwchyAAAAAAAimOqPp1WDfO3ate7na6+9Zl988YVbmFszxXr27GmFChXK0PNptLoS8MFaNJVFjhGpjhw54vaHcMd+hkh2JEj7mbaRnoW6SZYDAAAAAJBDKVmuBHmpUqVs0qRJbqT5008/bb/99ptbh0S3nS2tlbJq1aqgtE8JvJo1awZlW0B227hxo0vkhTv2M0SyjUHcz/LkyRPeyXK92FtuucUGDhzofgIAAAAAgODp3r273XHHHVa0aFH3e7Vq1Vzt8ttuu81WrFhxStmW9FDJlypVqgSlfekZ5QeEq4oVK0bMyHIg2vezdevWpet+IUuWqye6d+/eQZu6BQAAAAAAktPIcS9R7qlatar7uX379gwly5V40+LgQLSjtAkQOftZejuNQrbA57hx46xgwYKhenoAAAAAAHK8vn37WseOHZNdpxHlEqzR4QAA5BQhSZYvW7bMZs+ebSNHjgzF0wMAAAAAEBVatWplixcvtvHjx7t65Z9//rk99thj1rp1a6tcuXKomwcAQFjJ9jIsBw4ccD3bAwYMsLJlywZlm8FaiZvVgRHpImElbvYzRLpg7GfpXYUbAAAgs66++mp79tlnbcqUKfbiiy9aoUKF7KabbrKHHnoo1E0DACDsZHuyfPDgwVa/fn0XnIMlWCtxszowIl0krMTNfoZIF6z9LD2rcAMAAJyt1GZwX3/99e4CAADCKFn+7rvv2vLly23evHlB3W6wVuJmlB8iXSSsxM1+hkgXjP0svatwAwAAAACAHJosnzNnju3evduaN2+e7PpBgwbZBx98YFOnTs3QdlmJG/gL5U2AyNjP6DQCAAAAACDKk+WjR4+2o0ePJruuZcuW1qNHD/vb3/6WnU0BAAAAAAAAACA0yfLSpUunen3x4sXTvA0AAAAAAAAAgKwWm+XPAAAAAAAAAABAmMvWkeWpWbNmTaibAAAAAAAAAACIcowsBwAAAAAAAABEPZLlAAAAAAAAAICoR7IcAAAAAAAAABD1SJYDAAAAAAAAAKIeyXIAAAAAAAAAQNQjWQ4AAAAAAAAAiHokywEAAAAAAAAAUY9kOQAAAAAAAAAg6pEsBwAAAAAAAABEPZLlAAAAAAAAAICoR7IcAAAAAAAAABD1SJYDAAAAAAAAAKIeyXIAAAAAAAAAQNQjWQ4AAAAAAAAAiHokywEAAAAAAAAAUY9kOQAAAAAAAAAg6pEsBwAgh5k8ebLdeeedya4bMGCAVa9ePdmlRYsW/ttPnjxpzz//vDVt2tTq1atn9913n23ZsiXZNlatWmUdOnRwt+uxr776ara9JgAAAAAAshrJcgAAcpCZM2fas88+e8r1a9assW7dutlXX33lv7z99tv+2ydMmGCzZs2yoUOH2htvvOGS5507d7bjx4+72/fu3WudOnWy8uXL25w5c+yBBx6w0aNHu38DAAAAAJAT5A51AwAAQObt2LHDBg0aZEuXLrUKFSoku83n89m6deusS5cuVrJkyVMeq4T4Sy+9ZL1797bmzZu768aOHetGmX/88cfWunVre/PNNy0uLs6GDBliuXPntsqVK9vmzZttypQp1rZt22x7nQAAAAAAZBVGlgMAkAP8+uuvLpn9/vvvW926dZPd9vvvv1tCQoJVqlQp1ceuXr3aDh8+bE2aNPFfV7hwYatZs6YtW7bM/b58+XJr1KiRS5R7Lr30Utu0aZPt2rUry14XAAAAAADZhZHlAADkAKohHliDPNDatWvdz9dee82++OILi42NtWbNmlnPnj2tUKFCtn37dnd72bJlkz2uVKlS/tv0s1q1aqfcLtu2bbMSJUpkyesCAAAAACC7kCwHACCHU7JcCXIltydNmuRGmj/99NP222+/2SuvvGJHjhxx98uTJ0+yx+XNm9f279/v/n306NFUb5djx45luG0qEaNR75kVExNj+fLly/R2gFDRfqj9AdHJ+x72fiJ8aT9VzAEAADkTyXIAAHK47t272x133GFFixZ1v2uEuGqX33bbbbZixQqLj4/31y73/u0lwb0EtK73FvsMvF3y58+f4bYlJibaqlWrLLPUTpWNASLVxo0bSZTClbZC+EvZeQwAAHIOkuUAAORwGlXuJco9VatW9ZdX8cqv7Ny508qXL++/j36vXr26+3eZMmXc74G830uXLp3htqnOepUqVSyzGOWHSFexYkVGlkcxdZQoUa4FmpklE960YDYAAMi5SJYDAJDD9e3b1yW2p0+f7r9OI8pFierzzz/fChYsaEuXLvUnyw8cOGArV660Dh06uN8bNmxob7zxhiUlJVmuXLncdUuWLHEJvuLFi2cqyZ2ZkelATkGCFN7fAd+J4Y3OWQAAcrbYUDcAAABkrVatWtnixYtt/Pjxrl75559/bo899pi1bt3aKleu7KaTKyk+evRo+/TTT2316tVu8U+NJm/ZsqXbRtu2be3QoUPWv39/N6pu7ty5LvnetWvXUL88AAAAAACCgpHlAADkcFdffbU9++yzNmXKFHvxxRetUKFCdtNNN9lDDz3kv0+PHj3sxIkTNmDAALeYp0aST5s2zZVJEY0enzp1qg0fPtzatGnjap5rxLr+DQAAAABAThCSZPnu3btt5MiR9uWXX7rFwXRC3q9fPze6DQAAZI5ibErXX3+9u6RFpVX69OnjLmmpU6eOzZ49O2jtBAAAAADAor0MywMPPGCbN292I9zefvtti4+Pt44dO7qFbQAAAAAAAAAAyPHJ8v3791u5cuVs2LBhboSaRpPff//9buGx3377LbubAwAAAAAAAABA9pdhKVKkiI0ZM8b/+549e9wCYVpErEqVKtndHAAAAAAAAAAAQrvA58CBA+3NN9+0PHny2MSJEy1//vwZ2o7P57OEhIRMtycmJsby5cuX6e0AoaJSRtofwhn7GSJdMPYzPV77AgAAAAAACB8hTZbffffd1q5dO5s5c6arYz5r1iy76KKLzno7iYmJtmrVqky3Rwm8mjVrZno7QKhs3Lgx7Gv/s58h0gVrP1NHMQAAAAAACB8hTZZ7ZVeGDx9uP/30k82YMcNGjBhx1tuJi4sLSgkXRvkh0lWsWDEiRpYD0b6frVu3LmjtAQAAAAAAEZosV43yxYsXW6tWrSx37r+ePjY21iW7tchnRpNvGS3hAuQklDcBImM/o9MIAAAAAIDwE5vdT7hr1y7r1auXS5gHllFZuXKlVa5cObubAwAAAAAAAABA9ifLq1WrZs2aNbNhw4bZsmXLbO3atfbII4/YgQMHrGPHjtndHAAAAAAAcozJkyfbnXfemew6rfHVoUMHq1evnrVo0cJeffXVkLUPAIBwlu3JcnnmmWesSZMm1rNnT7v11ltt3759bpHPc889NxTNAQAAAAAg4um8+tlnn0123d69e61Tp05Wvnx5mzNnjj3wwAM2evRo928AABAGC3wWKlTIBg8e7C4AAAAAACDjduzYYYMGDbKlS5dahQoVkt325ptvWlxcnA0ZMsStG6byp5s3b7YpU6ZY27ZtQ9ZmAADCUUhGlgMAAAAAgOD49ddfXUL8/ffft7p16ya7bfny5daoUSOXKPdceumltmnTJremGAAACPHIcgAAAAAAEByqQ65LarZv3+7WDgtUqlQp93Pbtm1WokSJs34+n89nCQkJFgwxMTGWL1++oGwLyG5Hjhxx+0O4Yz9DJDsSpP1M29C+cCYkywEAAAAAyKGOHj1qefLkSXZd3rx53c9jx45laJuJiYlu0dBgUAKvZs2aQdkWkN02btzoEnnhjv0MkWxjEPezlPEwNSTLAQAAAADIoeLj4+348ePJrvOS5Pnz58/QNlXypUqVKkFpX3pG+QHhqmLFihEzshyI9v1s3bp16bofyXIAAAAAAHKoMmXK2M6dO5Nd5/1eunTpDCfeMppoB3ISSpsAkbOfpbfTiAU+AQAAAADIoRo2bGjfffedJSUl+a9bsmSJG6lXvHjxkLYNAIBwQ7IcAAAAAIAcqm3btnbo0CHr37+/m4I+d+5cmz59unXt2jXUTQMAIOyQLAcAAAAAIIfS6PGpU6e6BdLatGlj48ePt759+7p/AwCA5KhZDgAAAABADjFy5MhTrqtTp47Nnj07JO0BACCSMLIcAAAAAAAAABD1SJYDAAAAAAAAAKIeyXIAAAAAAAAAQNQjWQ4AAAAAAAAAiHokywEAAAAAAAAAUY9kOQAAAAAAAAAg6pEsBwAAAAAAAABEPZLlAAAAAAAAAICoR7IcAAAAAAAAABD1SJYDAAAAAAAAAKIeyXIAAAAAAAAAQNQjWQ4AQA4zefJku/POO5Ndt2rVKuvQoYPVq1fPWrRoYa+++mqy20+ePGnPP/+8NW3a1N3nvvvusy1btpzVNgAAAAAAiGQkywEAyEFmzpxpzz77bLLr9u7da506dbLy5cvbnDlz7IEHHrDRo0e7f3smTJhgs2bNsqFDh9obb7zhkuedO3e248ePp3sbAAAAAABEstyhbgAAAMi8HTt22KBBg2zp0qVWoUKFZLe9+eabFhcXZ0OGDLHcuXNb5cqVbfPmzTZlyhRr27atS4i/9NJL1rt3b2vevLl7zNixY90o848//that259xm0AAAAAABDpGFkOAEAO8Ouvv7pk9vvvv29169ZNdtvy5cutUaNGLsntufTSS23Tpk22a9cuW716tR0+fNiaNGniv71w4cJWs2ZNW7ZsWbq2AQAAAABApGNkOQAAOYBqiOuSmu3bt1u1atWSXVeqVCn3c9u2be52KVu27Cn38W470zZKlCiRoXb7fD5LSEiwzIqJibF8+fJlejtAqBw5csTtD4jezz/wJ8KX9lPFHAAAkDORLAcAIIc7evSo5cmTJ9l1efPmdT+PHTvmT86kdp/9+/enaxsZlZiY6BYOzSwlyjUSHohUGzduJFEKN1sH4S9lPAQAADkHyXIAAHK4+Ph4/0KdHi/BnT9/fne76D7ev737eKO1z7SNjFLpmCpVqlhmMcoPka5ixYqMLI9i6ihRolxrTjBLJrytW7cu1E0AAAA5LVm+b98+e+aZZ2zRokV26NAhq169uj388MPWoEGDUDQHAIAcrUyZMrZz585k13m/ly5d2k6cOOG/rnz58snuoxidnm1kJsmdmWQ7kFOQIIX3d8B3YnijcxYAgJwtJAt89urVy3744QeXMJ8zZ47VqFHD7r33XtuwYUMomgMAQI7WsGFD++677ywpKcl/3ZIlS9xI1uLFi9uFF15oBQsWtKVLl/pvP3DggK1cudI9Nj3bAAAAAAAg0mV7snzz5s329ddf2+DBg91Icp1kDxw40C0SNm/evOxuDgAAOV7btm3dTK7+/fu76eNz58616dOnW9euXf21Vzt06GCjR4+2Tz/91FavXm09e/Z0o8lbtmyZrm0AAAAAABDpsr0MS9GiRW3KlClWu3btZFPZdNEoNgAAEFwa+T116lQbPny4tWnTxkqWLGl9+/Z1//b06NHDlWMZMGCAW8xTI8mnTZvmaoqndxsAAAAAAESybE+WFy5c2K688spk1y1YsMCNOH/ssccytE0thpSQkJDptilhT71IRPriUOG+OBj7GSJdMPYzPT4ra56OHDnylOvq1Kljs2fPTvMxuXLlsj59+rhLWs60DQAAAAAAIllIFvgM9P3339ujjz7qpnk3b948Q9tITEy0VatWZbotSuDVrFkz09sBQmXjxo0ukRfO2M8Q6YK1n6n0CQAAAAAACB8hTZYvXLjQevfubRdffLGrk5pRmiJepUqVTLeHlc0R6bQGQCSMLAeifT9TzW8AAAAAABBeQpYsnzFjhqt7et1119lTTz2VqRF2Sr7lz58/qO0DIhHlTYDI2M/oNAIAAAAAIPzEhuJJZ82aZUOHDrX27dvbM888w1R0AAAAAAAAAEB0jSxXrdcnn3zSrr32Wuvatavt2rXLf1t8fLwVKlQou5sEAAAAAAAAAIhy2Z4sX7BggVuQ85NPPnGXQG3atLGRI0dmd5MAAAAAAAAAAFEu25Pl3bp1cxcAAAAAAAAAAKK6ZjkAAAAAAAAAAOGEZDkAAAAAAAAAIOqRLAcAAAAAAAAARD2S5QAAAAAAAACAqEeyHAAAAAAAAAAQ9UiWAwAAAAAAAACiHslyAAAAAAAAAEDUI1kOAAAAAAAAAIh6JMsBAAAAAAAAAFGPZDkAAAAAAAAAIOqRLAcAAAAAAAAARD2S5QAAAAAAAACAqJc71A0AAAAAAABZZ8eOHdasWbNTrh8xYoTdcsstIWkTAADhiGQ5AAAAAAA52OrVqy1v3ry2cOFCi4mJ8V9fqFChkLYLAIBwQ7IcAAAAAIAcbO3atVahQgUrVapUqJsCAEBYo2Y5AAAAAAA52Jo1a6xy5cqhbgYAAGGPZDkAAAAAADl8ZPmePXusffv2dtlll9ntt99uX3zxRaibBQBA2KEMCwAAAAAAOdSJEydsw4YNVqVKFXvkkUesYMGCNn/+fOvSpYu9/PLL1qRJk7Peps/ns4SEhKC0TzXU8+XLF5RtAdntyJEjbn8Id+xniGRHgrSfaRuB63akhWQ5AAAAAAA5VO7cuW3p0qWWK1cui4+Pd9fVqlXLfvvtN5s2bVqGkuWJiYm2atWqoLRPCbyaNWsGZVtAdtu4caNL5IU79jNEso1B3M/y5MlzxvuQLAcAAAAAIAcrUKDAKddVrVrVvvrqqwxtLy4uzo1UD4b0jPIDwlXFihUjZmQ5EO372bp169J1P5LlAAAAAADkUBpB3q5dO5s4caI1btzYf/0vv/yS4YS3Em/58+cPYiuByERpEyBy9rP0dhqxwCcAAAAAhEEtWUb+IStUrlzZKlWqZEOGDLHly5fb+vXrbcSIEfbjjz9a9+7dQ908AADCCiPLAQAAAKTLSZ/PYknoBh21ZLNeNP/txsbG2qRJk2zMmDH20EMP2YEDB9zfmxb3rFatWqibBwBAWCFZDgAAACBdlGyc/M0J27Y//OuzAp6yRWKs62XRfepbokQJN5ocAACcXnQfMQAAEEV27NhhzZo1O+V6nTzfcssttmrVKhs+fLirYVqsWDHr2LGj3XXXXf77nTx50saPH29vvfWWHTx40Bo2bGiPP/64nX/++dn8SgCEkhLlm/eGuhXA2aBzBwAApA/JcgAAosTq1astb968tnDhwmR1cQsVKmR79+61Tp06WYsWLeyJJ55wdUz1s0CBAta2bVt3vwkTJtisWbNs5MiRVqZMGRs1apR17tzZ5s2bZ3ny5AnhKwMAAAAAIPNIlgMAECXWrl1rFSpUsFKlSp1y2yuvvGJxcXFu8a/cuXO7xcA2b95sU6ZMccny48eP20svvWS9e/e25s2bu8eMHTvWmjZtah9//LG1bt06BK8IAAAAAIDgibUQmzx5st15552hbgYAADnemjVrXBI8NcuXL7dGjRq5RLnn0ksvtU2bNtmuXbvcqPTDhw9bkyZN/LcXLlzYLRC2bNmybGk/AAAAAAA5dmT5zJkz7dlnn7UGDRqEshkAAETNyPKiRYta+/btbePGjXbBBRdY9+7dXR3z7du3W7Vq1ZLd3xuBvm3bNne7lC1b9pT7eLdlhM/ns4SEBMsslZXJly9fprcDhMqRI0fc/hDO2M8Q6YKxn+nxgaXMAABAzpI7VAuMDRo0yJYuXeqmgwMAgKx14sQJ27Bhg1WpUsUeeeQRK1iwoM2fP9+6dOliL7/8sh09evSUuuOqby7Hjh1zCQZJ7T779+/PcLsSExPdwqKZpQSeRrkDkUodWN5+Fq7YzxDpgrWfsU4HAAA5V0iS5b/++quri/r+++/bCy+8YH/88UcomgEAQNRQeRV1UufKlcvi4+PddbVq1bLffvvNpk2b5q5TXfJASpJL/vz5/Y/Rfbx/e/fJzEhTHQ8ogZ9ZjPJDpKtYsWJEjCwHon0/W7duXdDaAwAAwk9IkuUtWrRwFwAAkH0KFChwynVVq1a1r776ysqUKWM7d+5Mdpv3e+nSpd3IdO+68uXLJ7tP9erVM5V8UzIeiHaUNwEiYz+j0wgAgJwtpDXLg4V6p8BfqHcKZL1IrXeqEeTt2rWziRMnWuPGjf3X//LLL25kd40aNeyNN96wpKQkN/pclixZ4kbhFS9e3AoVKuRKt2h0upcsP3DggK1cudI6dOiQra8FAAAAAICskCOS5dQ7Bf5CvVMg60VqvdPKlStbpUqVbMiQIfbEE0+4hT7ffPNN+/HHH23OnDkuIT516lTr37+/de7c2X7++WebPn26u6/XXiXFR48ebcWKFbNy5crZqFGj3Ij0li1bZutrAQAAAAAgK+SIZDn1ToG/UO8UyHqRWu80NjbWJk2aZGPGjLGHHnrIjQpXx5UW96xWrZq7j5Llw4cPtzZt2ljJkiWtb9++7t+eHj16uHIsAwYMcAuCNmzY0NU7VxwGAAAAACDS5YhkOfVOgb9Q3gTIepFc77REiRI2YsSING+vU6eOzZ49O83bVZ6lT58+7gIAAAAAQE4TG+oGAAAAAAAAAAAQaiTLAQAAAAAAAABRL+RlWEaOHBnqJgAAAAAAAAAAohwjywEAAAAAAAAAUY9kOQAAAAAAAAAg6pEsBwAAAAAAAABEPZLlAAAAAAAAAICoR7IcAAAAAAAAABD1SJYDAAAAAAAAAKIeyXIAAAAAAAAAQNQjWQ4AAAAAAAAAiHokywEAAAAAAAAAUY9kOQAAAAAAAAAg6pEsBwAAAAAAAABEPZLlAAAAAAAAAICoR7IcAAAAAAAAABD1SJYDAAAAAAAAAKIeyXIAAAAAAAAAQNQjWQ4AAAAAAAAAiHokywEAAAAAAAAAUY9kOQAAAAAAAAAg6pEsBwAAAAAAAABEPZLlAAAAAAAAAICoR7IcAAAAAAAAABD1SJYDAAAAAAAAAKIeyXIAAAAAAAAAQNQjWQ4AAAAAAAAAiHokywEAAAAAAAAAUY9kOQAAAAAAAAAg6pEsBwAAAAAAAABEvZAky0+ePGnPP/+8NW3a1OrVq2f33XefbdmyJRRNAQAA6UT8BgAgMhHDAQAI42T5hAkTbNasWTZ06FB74403XODu3LmzHT9+PBTNAQAA6UD8BgAgMhHDAQAI02S5gvFLL71kPXr0sObNm9uFF15oY8eOte3bt9vHH3+c3c0BAADpQPwGACAyEcMBAAjjZPnq1avt8OHD1qRJE/91hQsXtpo1a9qyZcuyuzkAACAdiN8AAEQmYjgAAGGcLFfvtZQtWzbZ9aVKlfLfBgAAwgvxGwCAyEQMBwAg/XJbNjty5Ij7mSdPnmTX582b1/bv33/W20tMTDSfz2c///xzUNoXExNjJ5JOWqzPF5TtAdnh2PEYW7Fil9sXIoH2s5YlzU4UD3VLgPTLHWu2YoUFZT9T7NJ+EEmCHb+FGA4Qw4HsQAwP73Nw0XvaK6mVncibFLRtAlkpd1IuW7FiRcTEb2E/Q7TvZ4npjOHZniyPj4/3103z/i3Hjh2zfPnynfX2vBcZzAOW3LlCsu4pkGmRdOBeKG+oWwCEbj/TNiJpf82K+C3EcOB/Iuk7gRiOSEUMD99zcCkeVzio2wOyQ6R9H7CfIZr3s5h0xvBsT5Z7U7927txp5cuX91+v36tXr37W26tfv35Q2wcAALI+fgsxHACArMc5OAAA6Zftw6+08nbBggVt6dKl/usOHDhgK1eutIYNG2Z3cwAAQDoQvwEAiEzEcAAA0i/bR5arTlqHDh1s9OjRVqxYMStXrpyNGjXKypQpYy1btszu5gAAgHQgfgMAEJmI4QAAhHGyXHr06GEnTpywAQMG2NGjR11v9rRp0ywuLi4UzQEAAOlA/AYAIDIRwwEASJ8YXyQt3QsAAAAAAAAAQE6oWQ4AAAAAAAAAQLghWQ4AAAAAAAAAiHokywEAAAAAAAAAUY9kOQAAAAAAAAAg6pEsBwAAAAAAAABEPZLlAAAAAAAAAICoR7IcAAAAAAAAABD1SJZHuerVq9vcuXND2oY777zTHnnkEffvpUuXujb997//DWmbgFDaunWrzZ8/3/97ixYtbNy4cRneXmYffyb6DtF+CyB7EcOB8EMMB5AexHAg/BDD4ckd6gYAgerXr29fffWVFStWLNRNAUKmX79+Vq5cObvxxhvd72+//bblzZs3w9vL7OMBID2I4QAxHEBkIoYDxHD8D8lyhJU8efJYyZIlQ90MIKxk9qCVg14A2YEYDpyKGA4gEhDDgVMRw6MXZVhgGzZssH/84x9Wq1Ytu/766+3DDz/033by5EmbPHmytWrVyt1+8cUXW+fOne3333/33+fzzz+3W265xerWrWtNmjRxU7n279/vv339+vV23333ud7qK664wh5++GH7888/U21LyulfmrYybdo0++c//+ke37hxYxs2bJidOHHC/5jvv//e2rdvb3Xq1LHmzZvbE088YYcOHcqidws4s3379rm/wyuvvNL9XWr/0t+2aBrW7bffbi+88IL7e27QoIE9+uij/r9ZTYf89ttv7Z133nF//ymnb+lnx44dbfz48XbZZZe5/eLxxx+3bdu2WdeuXd1+eO2119qiRYv87Ql8vPav1C7anhw/ftxGjRplTZs2ddu+7bbb3CiTQJ988onddNNNVrt2bbvjjjvcdDUAoUEMB4KLGA4guxDDgeAihiNYSJbDXnnlFbv55ptt3rx5Lhj37NnTfvnlF3fbq6++6oKkAu+CBQvcF8umTZts5MiR7vY9e/bYgw8+aG3btrUPPvjA7ejLli2zp59+2t2+Y8cOtxNfcMEFbgrKpEmT3JdRu3btLCEhIV3te+6556xhw4b2/vvvW9++fW3GjBn273//2922evVq69Spk/tC0e2jR4+2X3/91e655x7z+XxZ9p4BaUlKSnJ/f8uXL3fBTnXEqlWrZvfee6/9/PPP7j4rVqxwge+ll15y+5T2mYceesjdpmCq4KgDZu0zqdG2N27caDNnzrQBAwbY7Nmz7f/+7//cY/R8lStXdvtsavuAnjfwcsMNN1ipUqXs1ltvdbfrgOHrr792+5IOFLTNbt26+YO+Dop10KzvCu1zbdq0sSlTpmThOwrgdIjhQPAQwwFkJ2I4EDzEcASVD1GtWrVqvieffDLZde3atfM9/PDD7t+ffvqp77PPPkt2+6hRo3xXX321+/fKlSvdNgLvs3btWt+qVavcv8eOHev729/+luzxCQkJvjp16vjmzJnjfu/QoYOvX79+7t9Llixx29uyZYv7/aqrrvJ179492eP//ve/+wYOHOj+3bt371Nu//333902tC0guy1atMj9/a1Zs8Z/3cmTJ30333yzr0ePHr7nn3/eV6tWLd/27dv9t3/++efuMevXrz9ln/D2Az1O9LNGjRq+gwcP+m9v3Lixr1evXqe0YceOHac8PtDLL7/sq1u3ru+XX35xv2/atMk9Tvt1oL59+7o2Sc+ePX233357stuHDRvmHgcgexHDgeAihgPILsRwILiI4QgmapbDLrnkkmS/a/rIkiVL/NNGfvrpJ9errB40XdatW2elS5d2t9eoUcNat27terxU4+zyyy93U7A0/URWrlxpv/32m+uhC3Ts2DE3LSw91DsXqFChQpaYmOjf/ubNm0/Zvmj7ml4DZKe1a9e6v1H1YntiYmLcNC/1IFepUsUqVKjg34dE0yq9x1aqVOmMz1G8eHErWLCg//f8+fNb+fLl/b/Hx8f7p3Kl5bPPPnM97mPHjrWLLrrIvz+JRqEE0v5WuHBhfxu1nwfS/qfRLwCyHzEcCB5iOIDsRAwHgocYjmAiWQ6LjY09ZfqKFvgQTevQ9BRN8VAdNNVo+vTTT23+/Pn++48ZM8YeeOAB++KLL+ybb76xPn36uMCvaWWqtXbppZfaoEGDTnlefZGlh9eWQN60Fm1fNZt0kJASiykgFNKadqjrc+f+6ys3Li7ulH1OcuXKla7nSPn41Pbj01m1apWrWdijRw9r2bLlKW3XtLICBQqkun0dcGi/O1N7AGQPYjgQPMRwANmJGA4EDzEcwUTNcrjaYoFUC6lq1aru36ptpgA8ePBgV9+sXr16rlaatzOrt/vJJ590vXAK4Arq+l094rt373bbUc9y2bJlXb00XYoUKeLuo56xzNL21cPubVsXLToyYsQIt9ACkN20SMfBgweT/X1rf/nuu+9cb7ZoZIju4/nhhx/cz5o1a2Z5+1S/UAuQKDjrZyBvv9fCP4H7lOqv6SIXXnihv70er7YigOxHDAeChxgOIDsRw4HgIYYjmEiWw6ZPn+4WENBq3F7w1KrZouCqRQYUCHW7pop8/PHH/mklmoIya9YsN41E07D0WC0wouktRYsWddNI9GXUu3dvtwiILlq4RAsrBE6PySgt4KApK1rxWAcD+vJQT50OJNQGILtppXlNi9TfoVbT1t/lkCFD3L5x9913u/toUR0tkqPrNApEt2uBj3Llyrnb1Zv8xx9/2Pbt24PaNj2vRn+ce+65rn27du1yAVkXrRyuIH3VVVe5ESiaHrZlyxZ78cUXbfLkyf7pZdrntB8/9dRT7mBDi4tosR8AoUEMB4KHGA4gOxHDgeAhhiOYSJbD7r//fnvttdfsb3/7m/tSUa90xYoV3W1aTfvo0aNule0OHTq4LxUFRPVWb9261dUx06rB6sHWSt633367m8KiHVvTRc4//3y3Ax8+fNjdpm1oqojqKgVjepZ62KdOneqms2iKWvfu3V3bdeCR2rQxIKvp71+ra6t32luhXvUC9Tepv1fv4FeBvH379tarVy+7+uqr/Svbyz/+8Q+3r2mf9KaGBYMOjnVQq4NZrVyvmmc6qNBFK2uLDsTV2/3444+7A4d3333Xhg8f7vYvUbu1fy9dutS1T68rtemXALIHMRwIHmI4gOxEDAeChxiOYIrRKp9B3SIAIE06qNUIEvUYAwCAyEEMBwAgMhHDcTYYWQ4AAAAAAAAAiHokywEAAAAAAAAAUY8yLAAAAAAAAACAqMfIcgAAAAAAAABA1CNZDgAAAAAAAACIeiTLAQAAAAAAAABRj2Q5AAAAAAAAACDqkSwHAAAAAAAAAEQ9kuUAAAAAAAAAgKhHshwAAAAAAAAAEPVIlgMAAAAAAAAAoh7JcgAAAAAAAABA1CNZDgAAAAAAAACIeiTLAQAAAAAAAABRj2Q5AAAAAAAAACDqkSwHAAAAAAAAAEQ9kuUAAAAAAAAAgKhHshwAAAAAAAAAEPVIlgMAAAAAAAAAoh7JciBEfD5fqJsQFm2IxrYDALIGsSFnv2+R0k4AAABELpLlyPEeeeQRq169epqXyy+/PNvb9Omnn1q/fv1Oe59x48a59tWuXdsOHTqU6n1ef/11d58WLVqc1fNv377dunTpYn/88cdZvY9n+zze41J73+vXr2833XSTvfzyy2e9zd9++81uv/12C6Zu3brZW2+95f6dmJhojz/+uDVs2NBatWpln3/+ebL7Hj161K688kr77rvvTtlOhw4d7IMPPghq2wAg0q1du9Z69uzpYm6tWrXsiiuusIceeshWr16drbE1vbwYnB6LFy+2Bx980Jo2bWp169Z1ceOpp56y3bt3WyRQ7FN7M/La00LsB4Doduedd7rL6aQn3ixdutQfQ7766qtU77N+/Xr/ff773/9auMjo+XNq9Nr0fmUXxTrFyMaNG7vjtubNm9tjjz1mW7ZsybY2AKGUO6TPDmSTkiVL2vjx41O9LS4uLtvbM3369HTf98SJE/bZZ5/Z3/72t1Nuy+iJ2TfffHPKSWB2vv8aGbZr1y574403bOTIkZY3b16744470r29jz76yH744YegtW/u3Lm2Y8cOa9u2rfv9zTfftE8++cRGjBhhK1ascAmehQsXWrFixdztr7zyitWsWdMuueSSU7alg4h7773XHVgUL148aG0EgEilJGe7du2sXr16NmDAAPfdqE7bGTNm2G233Wavvvqquy07Y2uwjB492qZOnWrXXXed9e/f38455xxbs2aNvfjii/bxxx+711i2bFkLZxMnTrRGjRoFfbvEfgBAsMTGxro4oM72lOisDC4NAujcubNde+21Nnz4cCtUqJD9/vvv9tJLL9n//d//uU7m8uXLh7qZQJZiZDmiQp48edyJeGqXiy66KNTNO62LL77YPvzww1Ou1wne8uXLrUaNGhZp779Glin4Tpo0ycqUKeNOWENFI8WU7FDPuQ7CvM6EG264wa655ho38lHX//zzz+62vXv3ugOFXr16pbo9nUjXqVPHJR8AAOZGERctWtQlkK+//nqXmFUHsJLbSi5PmDDBItH8+fPda9LIsWeffdYlzC+99FK7++67XZJ8z5497iQzWhH7AQDBPCdWh6YGkqWWLI+Ec+JIoTitmKZjG8VEdQTfeuutrtNY8TMjs8OASEOyHPj/fvnlF5c410mvR1OomzRpYp06dfLXyVy2bJkbPaRpupqSpKlVmhJ18uRJ/+NUNmXo0KFuSrZOEDVqadGiRe42TUf79ttv3UXTqTS17HR04qYpZylLsahnvWLFinbhhRcmuz4pKcmmTJlirVu3dkFOz/+Pf/zDlixZ4m7Xyemjjz7q/n311Vf7X69enxIXSmTocTqhnTZt2in1QfV4TU9WeRglOzIzQl2j+vPly2cxMTH+6xSAx4wZYy1btnTvrw6M9P6vWrXK3a732hupFjgdTe+/Xrfarcepja+99toZ2zBnzhw7duyYXXXVVf7r1B6NePP+nTt3bve+ipI6+syrVq2a5jY1xfztt992iRIAiHYaTaxYEhgnJX/+/G5EruJOypPeW265xSVXVbZFpTH279/vv13f+/quVyxQ4l2jzBSPUout+/btc4+/7LLLXNzSSHaNmAqkGKDRxHouPadipK47E8WcKlWquOR4ShUqVLA+ffq47XlxVNt84YUXXFJdbVGc0zYC3xcdI/Tu3dt69Ojh4rfin6aU6zXp5FSPVakXxS6vvE3Xrl1drNTlgQceOGWK9M6dO115Gh3PqD0qGeKN0FY8U0m2d955J9Xp6zNnznTXb9y4Mdn17733nktMbNu2zc4WsR8AcLZ0TqyY7p3TelTObdOmTaccS6RF39FPPPGE+/5X3NBxhGJnYPzTKGqvBIlirmbHBWNWtuJIYK7BO7dOGX91LKPn9Eq7qTM3JcV2zYBS+5WX0LHO2LFjTyn7olHgN954o7+UiuKnF9vOdNyWUqlSpdwMwcAytunJIXz99dduJplmZuk9ffjhh5MdP+g9UKez2qpt6zWtW7fO3aYZXjom1HGTbhs2bJglJCQkO34YPHiwNWvWzL1GHSfp+YHMIlmOqKFe6NQu3he5vlzvu+8+d8LonUgr6OhETNOFdeKkYNyxY0c3Ek7BSCOIGjRo4E7gvNHfCj733HOPzZs3z53A6gSrUqVKLghrJPigQYNcMNBl9uzZZxzZrgCpbaoUS8pkggJfShoppedUgNXUcCXtdWDxr3/9y44cOeKCZPfu3d191e7777/f/fvpp592FwVY9SZripW2pZNQj4Kafte2FGj1nuiEPj11WQPf8+PHj7sDAiUndAJ+8803++/Xt29fdxKrmuoaxaWkhabwK6jqs1Kvttomev/0uyhIPv/88y5hovYrUD755JMuMXE677//vntPNALOowSFOjc0el8BWgFZfx9KQCiY6zWfjt5DfWYa/QAA0U7fsVu3bnUdt0q+qraoF3v1Xd2mTRv/fRW/NHpX38P6TlfsXLBggUsi64TIo+3pxFWxWHHimWeeOSW2KhmqRLZqmeuEUjFPI5o1tTgwYa6ktkpwKGZrFJUS82cq6fLnn3+6YwK9tsCkbyCdGKpzXbfr9erEW3FZccuLU3o+HRcE0vFEgQIF3DGG2upR3NVximK1ThgVP/WeKgar5rhGsStOqa63F5cPHz7sflfngV6n3gMlhHWcouSCfle5FNXi1vumE+GUCWDdX8nxQO+++65Lvp+pxAyxHwAQDOqcVoelBoylnOWl5Kpi2ZkonijWK3mrjmklVbXmiI4JvFisc3/dR+fNirc6LtG5v86fN2/ebFnt119/dTFapU8U3+66665TZjUpnur45vvvv3eDDhRXdUyi+Blo8uTJNnDgQBevFSPbt2/vZsTputNRfFSnuo691Akc2Amv+KvR5p4z5RB0vKDXo+MFHaspvmvbylUE5hAUP9V+HcvoPpUrV3b5FB0HKpeiuK7PSvFb+QvvOFIx/4svvnCDAvR5ajCg2uMNKgAyiprliAoaNZVWUlonaDqZFX0ZKymt3madsOlk6bnnnrPSpUu72xWENDpt1KhR/mm7OmHVY3QiquS1vqx/+ukn94XuBRJNy1aQUU+4vuQLFizork9PjdYSJUq43mKdPHt1y/V69BwKBCmn/Hq9zIELquhE95///Kero6rn9GqMaVTYeeedZwcOHHA1YzXaTCfTotepZIBG0uuAwTt40OtS8PK2q86DH3/80QWms33/NfJOBybegl0K/DqxV4+1Rg+IDn40ql4dFurlVqJDl8D3TyfdSnToQEKfm2ikoRIUOkhQwkIlAFLSdlWXNOVIBL0Pek06UNBnpQ4H/Q3opF2jEnXApFEBCvTqHVdA1yi5wNGSeo904KUDAQCIZvoOVjzRScyQIUPcdfpO1ve0TgI1EkmUpFZM0/esOqs91apVcyd4OvHRT1HyVSdG6rD2pIytiguK2/qp0VmikUeKjzqR0/aUkFUyXklXLxZpVpiSxN6optR4I6IUQ9NDxwYaGaYTRa+jW8cP8fHx7jhD74M3alkjr3Uc4iVyvdFmilVefW1RTFLsUWLfe+06Idaxh5Lyen80AMAbOe5NUdeobSWqFd910qvnUV3u1I5JChcu7EaJ6eRUHeWKq6o3r+MZHQudDrEfABBM+t7WOatitmb/eAPI1BmdHjpP1vd24PGDvs81klwdsaIE7oYNG1xCVh3JouMUdS4rXmU1xS+tfaHjIW9tNcUynd97FJPVRh3HqFPXyzcEJrEPHjzoH0Cn+OrFSMUy/a7ZW2nNllK81+OVKNcod1EM1vuhc38lr+VMOQR18Ot4S8+r2WMeHYco3uu4ULkYjz5HxWBRMlyP1TGZfgYeQ6gNGjCh+6p9Op7yjq30eSoes34IMotkOaKCeprTqiMZOCpKAUmjs3TyqIW6NNpNo5Q8OrnURaPVdJKm3mVNEVZPaGJion/laG0ncAqUEuta0CqjFEw05UgneDqBUw+6TkAvuOCCU+7rBSJNMVMQVRv/85//uOvSCvA6OVTiQdOfA3mB1aNA7SXKA5MECqbpff8VVBW4dVCik2BNCffohN2bNqWRXXqPNfLtTO3XSbsCqt7zwDp2+l3Pq88k8OAhMNmhzy5lskPJCx0QaRSjOgR04q0yPV9++aVbsE0jAZUs0OtQQkO9/jroClSuXLmwWo0dAEJJJ146udH3qJKJ6mDWiKF///vfblSUksWKRfqeVxmxQDqh1XeqToi8ZLmcqT6pnkfxR/EyMDZo6rU6m5Wc14wvSRmzNavrdMly7yQ9ZWmZtKjtekzgMYWoE1zJct3unbTqJDRwxHNar1exT0llxSzv9ekYQe+XN2Vb8U8xLvCxShSogyC9NEpMn5PeK3Xea5SYRr4riX46xH4AQDDpnFjfvfr+VwJWg8cUN3QOq1lkgVLWNs+VK5frAFVyV7FD39U6T9b5skZoe7FGA9U0il2jr1UKVc+jjnavjGla205rltnZUuzScYqXKBe9Pj2HR6///PPP9yfKvfivx3ll6NSxq3iWWowUja5PK1muuKzBDRpsp6S0nk/bVYeCZlqp419tOlMOQTMJlThXp3MgDdzTcYCXiPcEHqvoc1HM1aC9wPbrOESvVe1XslzJceVZdF8l83XRAEggs0iWIyroC191rtJDX9KqG6YTpMBalqKAo5FGmo6sL22daOmLXifA3lQglTxRj6038jwYdEKqgKUR7Dqx1ihzjXpLjUZL6SROP3VCrGB/7rnnuttSqz3mtVk0sux01EsbyDsoOFOyIOX7r95kjY5Tb7Nqk6n2ukcnpZpOpQCpk3HVZPee90ztT60sjeggKjVekj/l6wo8cfZoBJ1mIOizVZJBveDqONAUePV2pzxh1nt/pk4EAIgmRYoUcYlwLxm+cuVKNxJJ36+KaV5dcp2opqTrUn6nKkacjmKDTtLSmlmm27znTDkC+UzTudXRrhio0dNp0bZ1fKB26t96jsCT3cDnCXxtab2ulLFKr08j6nRJyYvnuk9mR1dptJqOd5Qk95LlSlh49b3TQuwHAAST4obO1VWKRUlsxT/91PFFICXCU856VqkS1b7WqGwle9Vxqu92bS/we1+xXeVA1OmqslqKeUpcq/NV59j6jk9r28HgHS8E0rFE4HVadDq12B54nRcjvZlXqY2yPxMdo6jD3CuDpqS5jts0sl/vx5lyCN7taR3X6TgwUGBc9h6r91yXtNqvAY4a9a7PVXkaXZSfURtTru0GnA2S5UAK6jFVolxfrqqZpSnNmoYs+l0nSxpdpClG3he67uNRfTF9uevkLrCHWcFA152pRnlqFIB0sqoDA00D07Ty1EbKa+S56psq2a/R5xqdpqS9eoRPN4rMe30aje5Nq/JqwmoUmBbjCCadTGpkmaaFqZf+9ddfd++Vnks9wQq+moKmHnNdrxq3OpE+U/u1QndqSQavsyAl76BDI97ONH1ePeOqw+ZNz9PBlejgTFPEU9I2U5v+DQDRRAlLJUg1styrM+1RfXFNK/YWpfROdvWdGhiLvMS2YsLZUDzWdN3A6buBlAD2vqf1nIGxwjtJS4sep3iu2KQTx9RGlGmUskY7aYS0XptObjWiOTBh7p3sZSRe6PXpWERTqdMa+a77pDbSWaPo1KbA2WJp0WvTTDstnKnSKRr5rVl4Z4vYDwDILK98h8p56dxYtcdT0vobKiGSMuZrhpQ6OVWOTR2hXqlVzTbTiG6PrleyVc+h8249j2p96/td8Su1bWtGl2KrSq56FPNTdiynXFwzcLFKUZxJGV+UQwhc6Fzt0wyslAJrgHsxUsdAOhZKKbUEtmi0vuqzq7M4cCFPUT5C75s6B3RMc6YcQuAxVko6rjtdvPS2rU5qzaJLyTtmVMe82quLnlfHXJoBptHsyocAGcUCn0AAjRDTCaB6T3VypJ5jJcg9CqKa6qMTOi9RrsS6AoQ3ulrTn1WSRSdZgQFOgVUngZKRUec6MNBUMAVnJa+92p2BNCJLJ/iazq4R5d7zeG3x2pjy+ZWAV4+5N+XZo1511QJNORIuGPScqgGqKWLqsffeS5W4UQ+4pmd5yQfvZNkbXZay/V7NOQVtjWLzLvpcNL09raSHDjT02jRtKy16z3SQoQMfrzapeu0V4EU/U+vZ1zY1HRsAoplOxpS4nTVrlvt+Ty1u6URSZcVUV1wnPSr5EUgntzoB0sjk00kZG3RypZFj+o4OjA2auqua3vr+14mfpFwwLGU8TI1OGNeuXWszZsw45TaVcFEtUSWz9R6oLZqRlvJ5NBJKMtIprW3qeTQqznttmpKtGubeIpOKj+qIUG12jz4HTa32TvbTc0yiEXNKBOsYSQl2rwb82SL2AwAyW7dc3+86V1cCObV1s7yZTYEXJWYVe/T9rhjoJcqVvPZKl+k23Uex++eff3bxSDFWHftaP0XHImltW3kCtUkLg3p0DBJ4zq7yISljT2CS3huEp3P3wO0oHnolX734r45wlYMNnAEf2MGsOK3zew1aCGyrjsk0sj6tkmFKrOu5Va4mtdnj6jDXiHMN5jtTDkFlXnTflMd1Oi5RCZfTHdcp+a44q3YGtl+fm8rOaiCiXrPK5nkLm6qTXOX6NONMnxWQGYwsR1RQDTJ9IadFI7E1/UrTeHRSpB5M9VY+9NBDblqwvoRV30sBQSVQNBpKJ4veCG8FUi+gqXaWpv5oESg9XiOkVLZFo5M0LcjrKVUgVj1VjaxLOXUsrVIs6t3WSbDamdbUNAVhBWoFQl00otw7Ifba6PXU6mRaNdj0WpRg17Z1AKAArF5lvU69F8EsKRNI74/eTwU8vT6N0lOb1ZOtVbP1uaku2qJFi5L1vHvtV+DVgYA+P5WnUW05dXgoWaBAPnbsWNfTn1pvuqjDQ0FaBymqpZsafXY6ifemn3mfsd4rHRhpRFvKgzR1sigxodcAANFMSUmNztLIYY0w10mMYo7ikZLWGj2sUedeHFTCVAtJ6+RLpdB0kqTEpzqANbr5dFLGViV4lcjWyGstGqXSKToh1ugwLUal51CSXiOdFS+UzNZJsb73tSB2ejqxtT2tKaKYqXrkiis6wX755ZddjNBtolirznbV8dSJq2avqVan2qLXpdd3trT4mMqBqJ6nRnyr00Gz47Q4uWq6it4DjQjXiKsePXq4NukEWCfdWgDTe9900qn2eIutpqQTUCUP1Gmf2ii+s0HsB4DooMSwvjdTUuJZMcWT2n30nZ9aaROdWytpqkFoiiFpldRKjRfjVN5UxyRKtus4ROf0XrzR8YPyAjoHVlJdHd6K9UpM63w5LYoJGtGsmKRt63hEnf3e+b/ouEbt1kVxTCVWVdokkI6XFMfVIa8Z4+oA1qz2wBrmKmc3ZcoUd18dQ+m90nGHRpZ7s6oUq/R4HUNp9rmOQXT8od+Vu0irRImOxzT6XnkHHSeog1vvuWKccgdaMFydydqGEuZnyiEoaa5BgxrprZitDm7NvNPzpDYzLvD4UZ0UWvBd/9Z7561/otehYwd9Tvqp7en90XGBjgPURuVvgEzxATlcv379fNWqVTvtZeXKlb4ZM2a4f3/wwQf+xyYlJfnatm3ru/zyy3179+51l169evkaNWrkq1evnq9169a+V155xTdw4EB3nxMnTrjHHThwwPf444/7mjRp4u7Xrl0739KlS/3bXbx4sa958+a+iy66yPf++++n2u7nn3/etSdQ165dfTVr1vTt3r072eu76qqr/L8vWbLEd8stt/jq1Knjnv+ee+7xLV++3Fe/fn3fU0895e5z6NAhX8eOHd3z33fffe66kydP+qZOneq75pprfLVq1fJdd911vtdffz3N55EtW7a4Ns6ZM+e073/KxwXy3veRI0e63z/88EPfjTfe6Ktdu7bviiuu8D344IO+b7/91le9enV3X9m+fbv7XNT+QYMGuesSExN948eP91199dXu+mbNmrnb9Jmdzquvvupr2LCh7+jRo6fcpuuuvPJK16ZA2maXLl18F198se+BBx5wn3eg+fPnu/af6bkBIFr88ssvvp49e7rvZsUYfX926NDBt2DBglPuO2vWLN8NN9zgvssVWwcPHuzbt2/faeNjWrF1165dvkcffdTFQz1vq1atfC+++KKL7x7F7ueee87XtGlTFzv1vT5hwoRUnyM1ei69Fj2HHq/4OWrUKN+ePXuS3S8hIcHFOj2P2qi2KO4GtkXb0SW9sVbv67333utivI43brvtNt/ChQuT3UcxU8cuDRo0cO+7jgtWrVrlv33evHn+92fZsmVpvr+KlzVq1PDt2LHjjO8JsR8AoptiWVrn3o899pi7jxdvUrvonNQ7t9Xv+umZNm2au+6TTz7xX6cYqesUM09HMUUxQzFPxwyKV9qOHrto0SJ3n40bN7o4pNio2KL49MYbb5zxNSsOKD+gWKAYqBivc2zP4cOHfQMGDHDxRzH7oYce8n366aentFuxXe+fjim0HR1nXHbZZe798mzdutXFIm1H8X3IkCG+f/7zn+75U75e75hK23j44Yd9f/zxxxlfyzfffOPr1q2bOw7TY5X/6Ny5c7LPIT05BPnoo498bdq0cdtp3Lixr3fv3q796fns9J7qsdq22qA2rV692n/7wYMHfUOHDvUf/+k4QMcWR44cOeNrBE4nRv/LXLodACKXRjeqrI5qzt58881B2ebdd9/tRkykNQMAAIBIoxFqGr2ukf+RjtgPAIhUmsWkMnYtW7ZMtmaKZkOp7ItGWgPIHMqwAIhqKrujKXZaKOamm27KdH32FStWuKl8aS0oBwBAJFFyXNOaVYJFtedzAmI/ACBSqVyMyq+oTIpK0aju+gcffODWAMlsqTQAf2FkOQCY2X333edqzan+a2booEUX1ZIDACDSqfbq77//7uqe57R63MR+AEAk0oLh6vDVumhK6anWuuL0FVdcEeqmATkCyXIAAAAAAAAAQNSLDXUDAAAAAAAAAAAINZLlAAAAAAAAAICoR7IcAAAAAAAAABD1cluE++GHH9yCBnFxcaFuCgAA6ZKYmGgxMTFWv359i2bEcABApCGGE78BADk7hkf8yHIFadYojQz6nI4fP87nBWQh9rPIQOz6C+9DZOB7Bch67GeRg9jFexCO+A4BwhP7ZmTGr4gfWe71ZteuXTvUTcEZJCQk2KpVq6xKlSqWP3/+UDcHyJHYzyLDihUrQt2EsEAMjwx8rwBZj/0schDDid/hiO8QIDyxb0ZmDI/4keUAAAAAAAAAAGQWyXIAAAAAAAAAQNSL+DIsAAAAAAAgbTt27LBmzZqdcv2IESPslltuCUmbAAAIRyTLAQAAAADIwVavXm158+a1hQsXWkxMjP/6QoUKhbRdAACEG5LlAAAAAADkYGvXrrUKFSpYqVKlQt0UAADCGslyAAAAAABysDVr1ljlypVD3QwAOCtJSUmWmJhokerYsWP+n7GxLBuZleLi4ixXrlxB2RbJcgAAAAAAcvjI8qJFi1r79u1t48aNdsEFF1j37t1TrWOeHj6fzxISEoLeTmTMkSNHkv0EIp2+Y3bv3m0HDx60SH8duXPntj/++CNZCSxkDZUWK168eJrvtT6P9HwOJMsBAAAAAMihTpw4YRs2bLAqVarYI488YgULFrT58+dbly5d7OWXX7YmTZqc9TY10nPVqlVZ0l5k3KZNm0LdBCCoI4VLlCjh1lsg0YzTURJco/d37dplf/7552nvmydPHsvSZPnkyZPtq6++stdee81/nQLm8OHD7ZdffrFixYpZx44d7a677vLffvLkSRs/fry99dZbroeoYcOG9vjjj9v555+fmaYAAICzQAwHACA6aFTj0qVL3fT0+Ph4d12tWrXst99+s2nTpmUoWa4klpLvCA8aUa5EuerS58uXL9TNATJdeuX33393ayzonCQnJHFJ+GcPxaadO3da+fLlUy3Jsm7dunRtJ8PJ8pkzZ9qzzz5rDRo08F+3d+9e69Spk7Vo0cKeeOIJ+/HHH93PAgUKWNu2bd19JkyYYLNmzbKRI0damTJlbNSoUda5c2ebN29eurL7AAAgc4jhAABEF8XzlKpWreo6zjNCSZ/8+fMHoWUIJiXK+VwQ6Y4ePerqe2sWTLBqUIcy8e99Z0b6a4kE+pvR6HIlzb3O4UDp7bA46+ryO3bssG7dutno0aNdr2WgN9980zVoyJAhbvEQnVxrVNqUKVPc7cePH7eXXnrJevToYc2bN7cLL7zQxo4da9u3b7ePP/74bJsCAADOAjEcAIDooxHkF198sRtdHkgzyRgdDiBcMRIbofqbOetk+a+//upOpt9//32rW7dustuWL19ujRo1ctO8PJdeeqmbDqTM/urVq+3w4cPJpnkVLlzYatasacuWLcvsawEAAKdBDAcAIPqoE7xSpUquQ1zxfv369TZixAg3i0yLfAIAgEwkyzU9e9y4canWJ9XoMk3LDqQaQ7Jt2zZ3u5QtW/aU+3i3AQCArEEMBwAg+qicwaRJk6xOnTr20EMPWZs2beynn35yi3tWq1Yt1M0DgHRL8vki9rkPHTrkBixddtllbpHk9J67ydy5c6169eqZen6kX6YW+EytrlDKmqUqYi8qaK9FJyS1++zfvz9TBfMTEhIsGJjmkXU0hV811PST9zlraF+IBHz+WYf9LDL2M20j3D4fYjjSwvdK9iCGRzf2s+yRU2N4epQoUcKNJgeASJYrJsY6f7Pf1u7/qxZ4dqlWJJdNvazIWT9O8UIdlvo5f/58K168uP3555/2ySef2A033JAlbUWYJctVPF0HeIF0gi1aZMIrrq77BBZa130ys2KzemRWrVplmaWp6RddVMty5TrrAfdIB33G55xzTqibkWMlJZ20X3/9JV09lKGk/azmRbUsN/tZlmA/y1onkk7ayiDtZ+G2ICYxHGnheyXrEcPBfpb1cnIMB4CsHE2tBHU4UaL8p70nLBIoUa5zJyXL58yZY02bNrWtW7faG2+8QbI8jDupg5os1/TtnTt3JrvO+7106dJ24sQJ/3Xly5dPdp/MTCfQgXswFib5a3XaWNvw31129Hh4n6wAgeLzxFml80q4Fe3DfWSa9jOdZE/+5oRt2x/ebQUClS0SY10vyx2U/WzdunUWbojhQGgQw4Gsl9NjOADkpJHcpXIdtwdKnDTfwRMWe+x/SfG8sWYVCwU1jXnWNh48YcdOpv/+heNi7Nz8ueyHb39z5a9ua3OPVTjvgI0cPdC+X7Leyp9f0d3v0KGDNnb8cPvq68/cGlJ33tHFkk74LOGAz3b9cdIO7v0rdr0ybY5Nf22i7dq1wypWrGoP/2ugXVTjr7WoEhOP24svP28LPplnhw8fsooVq1jnjj2sccPL3e3zP3rHXpkxyS679Er7YME7dnG9xjZy6HjbtHm9jZv4lP3083dukNTF9S+1f3bva8WLlXSPe7DnXe459u3fY4u++MRO+k7a5U2usj49B1uB/AXcff77x2YbN/Fp++Gnby1XrlzW6JLL7aEHH7OiRYv/9dwfzrWZs6fZtu1/WNky5ezmm9rZ/7Xp4DoTTid3nNk5pbJ/kEZQ/8oaNmzoekeSkpLcmyNLliyxihUruqkGhQoVsoIFC7pVuL0T7QMHDtjKlSutQ4cOmTpw1wcaLDrJTjjKiTYiT2ZGd2Y3nWRv3hvqVgBnwxe0/Swcp28Tw4HQIoYDWSlnx3AAyEkjuc/Pk2THi/ns6AmfxcQGdHD+dYoSUseSfHbkLPoN4v9/m9+bN9fy5ctvDes1s2PHj1ru3ENs7ruz7cEuj7jbBwzuaTv+3GZPDp5g+fMVsAkvPm3bd2y1k0lmJ46Znfz/b/978960x/uNtrx5423MuME28Ime9uYrn7nbhj71mG3+fYMN6DvKShYvZV8vXWR9+3e3YQOftyaNmrtt/LH1dzfYaeq4ua4d27futPv/1cGuueomu7/zI3b06BF7ecY46/LA7TZ90vuWLz6/+U6azX77FbutbSeb/NybtnnLBhsysredV7aCdWz/gB08dMDu/9edVqlCNRs7YrqLk2qbXtNzT79q73/wpr04/Rl76P6BVqN6Hftt/Sp7dsJQ27Fjh3W/t4+Fo6Cm59u2besK1vfv39/1uKsA/fTp061r167+6Wo6oR49erR9+umntnr1auvZs6cbzdayZctgNgUAAJwFYjgAAAAABJdm6C745H27vHELl+QuXOgca3jx5bZg4bt27Pgx+/2/G23Z91/bQ90HWN1aDaxq5Ro2sN8oyxN3asmvvg8NcwlnJabb3dLJduzcZnv37bb/bt1sny6ab4/0Gm716zSy88pVsHa3dLSrr7zB3nj7pWTbuPuO7nZu2fOt4gVV7b35r1vJEmWsR7fH7ILzK1n1qhfZ4EfHum0u+nKB/zEXlK9iXTr2dNu9/NIW1uDiy+yXlT+42/7zxYeWkHDYBj0yxj2+WpWa1vehoXZRjXquhOerr0+0u27vblc3v9E975VXtLT7Ova0ue/PdK8/HAV1ZLlGnk2dOtWGDx/uVtguWbKk9e3b1/3b06NHD/eHMmDAALeYmEayTZs2zU3DBgAAoUEMBwAAAIDg+vzzz23P3l3W4sr/1ShX4njxt4ts0ZcfWd48f60HdWG12v7bixUtYWXLnH/Kts4vV8H/70KF/lpw9Nixo260tvyzd/IZvydOJFrBgoWTXXfeuRf4/7123UrbuOk3u67NJcnuc/z4Mdv8+3r/7165GE/BAoXs0OGD7t8bNq2188pd4G+PVK5Y3V327dtjf+7ablOmj7Vprz7vv12lXPQc27b/1yqUr2w5Klk+cuTIU66rU6eOzZ49O83HaGp3nz593AUAAIQGMRwAAAAAspZm7MrAof885bb3P5htt7Xp6E8gB1Lt8pS8cpmBVKjGd/Kvxz4/6jXL///riPsfE5v8MRrd7jnp81n9uo2t54OPn7LdggX+l2RPbZS7/f81QHLnSju17L0mlZu5pH6TU24vXbKshSOWsgcAAAAAAACAINq3Z7cbWX7jdbfY1BfmJrvc0PIWV8qk3Ll/rQf1y8rv/Y9THXDVF0+vihWqup979vzpRo57lw8/fsc++PivZH1qKl1Q1dUgL1WirP8xhQsVsfGTR7gR4+lxQfnKboFPb6S5rF33q/39H5e7ke3nFClmW7dvSdautb/9atNeec7Lt4cdkuUAAAAAAAAAEESffjDPlbFs/4/Ors544KVDu64WGxtr//7oLWve9Dp7dsIwW/7DNy5JPXxUP0tMPJ7u51H9cS3iOWb8E/b1kv/Y1m1bbNZbU23mm1OsXNm/kvGpubn17Xb48EEb9nQfW7dhtbsMHtHLVq/9xSXS0+Paq25yJVjU5vUb19ia3361MeOecK+xVMmydsetnW3uezNcjXJ1AHzx9Sf2zPghlidvvFsXK8fXLAcAAAAAAACArFCtSK6Iec6P33/XLrvsMrugfEU7kWItS40ov6LJ1fbJZ/Ps7RmLbNK00fbEiF6uNMrfrr/N9u/fc1bPNfjRZ2zqK8/amHGD7ODB/W4xTS0Iet21N6f5mLJlzrPnnn7Vprz8jD34cHtX5qVWzfr27Mjpds45xdL1vPHx+WzUsBfthRefsvt73u7KvDRpdKXdf19fd3u7tp0sT968LmGu+6ge+03X32qdOpxaliZcxPh84TroPX1WrFjhftau/b9C+Jm1csM2SziaGLTtAVktf3yc1awUnrWe0jL4w0TbvDfUrQDS74KiZoOvjwvb2BWJiOEAMRzIDsTw4OI9CD8JCQm2bt06q1q1quXLly/UzUEO0+zDPfbT3hPZ9nzn50m0Mf+vvfsAk6o6/wf+LixVwI4oFhCCggKCDRMLYmyxJEqiUbFjN/wiIsaOXWMXS1AsMcgfjSBq1BA10STGrrFiR6xIQBGVDvt/zjVsWEVdYHZnZ+/n8zzjzsyduXMW5+w78733nNPu01i17TpR9t/FL5NGDSLWW748GjUoi2KYu6AiXvtsXsytOrX4d1qxSVm0a1EeUz5Y8I2wnO9X3iRilbbVnxRl1qxZMWHChGjfvn00bfq/986S1i9nlgMAAACUqLKystigy4bRsNxMu8tiwYKKaFCkIJbvl0LqFFaXF+l/0byKr9pA/ScsBwAAAChhKSi/99o5MfUDad7SWLltg9jlqLo5fzL/k8JqY0ipacJyAAAAgBKXgvLJE0t6pt0icpAB+IoxOgAAAAAA5J6wHAAAAACA3BOWAwAAAACQe8JyAAAAAAByT1gOAAAAAEDuCcsBAAAAAMi98mI3AAAAAADguzRqEFFeVpzXnlcRMXdBcV6b2iUsBwAAAADqdFDeuVV5NGxYnLR8/vyKGD993hIH5vPmzYvbR4+IP//l7nj3/QnRuFGT+EGHzrHf3odHz+6bL1ObbhpxVfz5gTvjtt8/tEz7mTJ1coy644b41xMPx3+mfhzLt1whum64cezz80OiU8cNopDuf+DOuODSk+OR+8dnt/c+cLvYafs94uB+x0ZFRUWMe/Cu2HzTrWLFFVaOYhGWAwAAAAB1VjqjPAXl9147J6Z+ULuneK/ctkHsclTjrA1zl+B5c2bPjgMOPyzef+/DOKTfgNiwy0Yxe87suG/c6Dj+5EPi5EEXxvbb7hrF9Obbr8agU/rHOmutG8cdc3qstWa7LDy/856RcfRx+8SJA8+r0TYOu+KP0bhJk+z68y8+FedfelKMuvnBKCZhOQAAAABQ56WgfPLEilp+1aUL52/53dB47bXX4pbhd8fKy69eef+vjjw5vpzxZQz93bnxo17bRvNmy0UxzJ8/P866YFB06tglzh9ybTRs2DC7v81qbWPDLj1ilZVbx8VXnB4brN891lh9rRppwworrFR5vbb/r34bC3wCAAAAABTIvHlz4893jYk999wzVmv9v6B8of4H/l9ceNZ10aRx0+z29M+nxWVXnxU/33/b2P6nG8Uxx+8bz73wZJXn3H3f7bHvITtm208acnRM//yzKtu/+PLzuOiK02P3vX8YP+m7afz6NwfFq6+/9K1tfPq5f8XE996Kww46rjIoX9Qh+/8qyhqUxT333145hco2O3eu8piv3/fx5A/jzPMHxk9/+aPos2vX+Hm/3vG7Gy6OBQsWf8AhTcOSppNJv+uvTzwwu++XB/04e81d9vxRXHXVVVUeP2rUqNhyyy2z6W1qirAcAAAAAKBAJn/wfnz+2WfRs2fPxW5PZ213Xq9rFlKnM7zTVCgvvPRMnHrChXH9lXfEuu06ZfeNf+3F7PEPPnxvXH7N2fGLPQ+MG6++M7p26RFj/zSycn9pvu8TTz8iPpr0Xlxw5rVx7eW3RZf1u8exx+8br7/5ymLbkF6vWbPm0XHd9Re7vUmTprFh5x7x4ivPVfv3PvnMY+KLGV/EJefdECOuvy/27ntw/L87bohHH//rdz5vw84bxdmnXpFd/93lt8cOfXaPHX+8W9x9991VHjd27NjYfffdo7y85iZLEZYDAAAAABTIF9O/Out7+eWX/97HPvXso/HaGy/HaSdeFBt12yzardMxBh57RrRfp2OMGn1j9pjRd/0h+myzc+yx676x1prtY9+9Dosfbr5t5T6e/ffj8fL4f8eQky/LQvI0B/nhBx2XXU/PXZzPpn8aLZq3jLKyb180dflWK8a0aVOr9TvPnj0rC7lPGHBmFsCnqVt+sceBsdKKq8Tb77z+nc9t1KhxtGy5QuXULCmo33XnPWPixInx3HNfhfUTJkzIrqez9WuSOcsBAAAAAAqk1YpfzcU9bdq0iHW++7EpSG6xXMvsbPKFUoDdfcNN4slnH81uT3jnjdiu9y5VnrdB543izbfGZ9dff+uV7OzyvQ7Yrspj5sydk10WZ4XlV8ymbknP+7bAfPoXn0WLFq2q8ytnAfceu+0Xj/xzXLzy2gvxwYcT4+0Jr8cnn0751mlYvsu67TtF165ds7PJe/Tokf3s1q1bdOzYMWqSsBwAAAAAoEBar7FmrLjyyvHss8/GZt13+sb2d959K4b+7rw49ojfpDlUFruPBRUVUd7wv9FtWUTF1wLnRaciSduWa94irht6xzf207hR48Xuv9uGm8QfRg3L5jVPU8J83ew5s2P8qy/E9n12+9bfc/78/80dPnPWjBhwwv4xe/bs6L3VjrHT9ntE5/W6xa8G9Yul1bdv37jsssvilFNOiXvuuSf69+8fNc00LAAAAAAABdKgQYPY8ad9Y8yYMfHx5I++sT3N4/3qGy9Fm9Xaxrrt18vO8F50qpJ0tveLLz8T7dbukN3uuG7nb8wd/trrL1deb9/uB/HljC9i3ty5seYa61ReRv5xePzzscXPF77xRltkz7v+5ktj3n9D73cmvpktIpoW2PzD/7s2Zsz4In66yy+zbeXljbKfX375ReU+3v9gYuX1p575ZzY/+uUX3pwtDtpn651juebLxafTpma/z/dZ3Lntu+66axa+33TTTTFlypTsdk0TlgMAAAAAFNA+hxwe7dq1i6MG7BfjHrorPvjw3WzBzgsuPSX+8tBdccKAs6JZ0+axac8fZWH42ReeEP9+4cnsrPO0mOfb77wRP//ZAdm+9turf/zjXw9kIfv7H7wTo+8akU13stBmG2+V7WPIBQPj2eefiPc/nBhXXXdB/Pkvd1YG7l+XFhcd8ptLY+J7b8dxvzkonnrm0Wwqle16/yQuGTokO+t83736Vz5/g/W7Z9O13HTrVfHRxx/E3/7x5/jzg2Mr97fqKm2ynw/89Z6Y9PEH2QKiJ595bMybNzfmfstUMItq1my57GeaWmbGzC+z6y1btoztt98+rrnmmthuu+2iVavqTQmzLEzDAgAAAFCivmtxPqhvVm6bzvtdUITXXHJNmzWLESNGxFWX3xAjb78+O8M8hdGdOnaJyy/8fTYn+cLQ+pJzh8c1w38bp549IAuW1/vBBnHZ+Tdm85InW2zWO04bfFHcdOvVceMtV0aXzhvFXn0Pjof+9qf/7eO8G+LaGy6KIecdF7Nmz8xC7rNPGxo9N+r1rW1Mi4leP3R0jLrjxrjs6rPiP1MmZXOU/6hXn1h1ldXijrF/iFmzZsbRh52YLdg58Nghcettw+KuP/2/6LpBzzjy0EFx/iUnZftKU64cc/iJ8cc7b4nht1wRq668WrYoaetV22RTvXyfddv9IHptunWcef7AOOyg42K/fQ/O7k8LeqYpWGp6Yc+Fyiqqcx58Hfbiiy9mP9OE74XyytsfxYxZcwu2P6hpzZs2ii7rrh6lZMj9c2Pip8VuBVTfOitGDNn5q2FndbF2lSI1HNRwqA1qeGHVxL/B/IqKaCjwXWa3nDorJk8s6YinaFqvUxYHnNO02M2ok7a+/5N4/tP/zUtd09ZqPDcuafdprNp2nShr/L//J40aRHRuVR4NGxbnb8X8+RUxfvq8mLsEOf2KTcqiXYvymPLBgpg3O0rSu+9PiCef+Wf8/Kf71/prlzeJWKVtg2wqm6FDh8ZDDz2UTW/zbWbNmhUTJkyI9u3bR9OmTZe6fjmzHAAAACiaFJT3/9dn8fpn84vdlJL04zUaxendWxa7GVCjUkidwuryIh1Xm1fxVRvyZu0122eXYkhzsj/27Dtx5ZVXRr9+/b4zKC8kYTkAAABQVCkor82zV+uTTq0aFrsJUCtSWG0MaX68PP75uHrYRdG7d+848MADa+11heUAAAAAANQZe/503zj86H61/rq1c/46AAAAAADUYcJyAAAAAAByT1gOAAAAABRdRUX6T3at2E2hxFRkb55lJywHAAAAAIruk/kNY86CiJgzq9hNocTMmDEj+9moUaNl2o8FPgEAAACAopuxoEHc/2nT+Hmj/8QK6Y7GTSOiLErR/CiLWeXlMXfegpg3v9itKT0V8yJmzWpQrTPKU1A+efLkWGGFFaJhw4bL9LrCcgAAAACgThj5Scvs585zJ0fjBiWblceM8rKY06RBfDGtIhbMK3ZrSk+D8ohpM6r/Pz8F5W3atFnm1xWWAwAAAAB1QkWUxa2ftIoxn7aIlcvnR1mJhuU7rdE4zlm/ZYy9fHZ88qE52JfUSmuUxc9+3aRaj01TryzrGeULCcsBAAAAgDplZkWDeH9u6S63OK2icTRt2jTmfBEx41Nh+ZJq0aos+/erbaX7jgMAAAAAgAIRlgMAAAAAkHvCcgAAAAAAck9YDgAAAABA7gnLAQAAAADIPWE5AAAAAAC5JywHAAAAACD3hOUAAAAAAOSesBwAAAByYsKECdGjR48YM2ZMsZsCAHWOsBwAAAByYO7cuTFo0KCYMWNGsZsCAHWSsBwAAAByYOjQodGiRYtiNwMA6ixhOQAAANRzTz31VNx2221xwQUXFLspAFBnCcsBAACgHps+fXoMHjw4Tj311Fh99dWL3RwAqLPKC73DefPmxdVXXx1jx46NadOmRZcuXeKEE06IjTbaKNs+fvz4OPfcc+Oll16KlVZaKQ466KA44IADCt0MAGAJqeEAUD8NGTIkW9Rzt912K8j+KioqCjbveVlZWTRr1qwg+4JlNXPmzOz9jb5J/euXaR/pfV3rYfm1114bf/zjH7OhXWuttVZcf/310b9//7jvvvuiUaNGcfDBB0efPn3izDPPjH//+9/Zz+WWWy769u1b6KYAAEtADQeA+icdBH/66afjnnvuKehCoekgeiGkMC4doIe6YMKECVkwh75J/eyXjRs3rv2w/MEHH4xdd901ttxyy+z2b37zm+yLd/pSnX659GX7rLPOivLy8ujQoUNMnDgxrrvuOl+0AaDI1HAAqH9Gjx4dU6dOjd69e1e5/4wzzsgOiA8fPnyJ95k+E3Ts2LEg7avOWX5QW9q3b+/M8v/SN6lv/fLNN9+s1uMKHpavvPLK8be//S369euXzYWWFhBJqf3666+ffeHebLPNsi/ZC/Xq1SuGDRsWU6ZMiVVWWaXQzQEAqkkNB4D65+KLL45Zs2ZVuW+HHXaIAQMGxO67777UIVrz5s0L1EKoO0w7AvW3X1b3AFDBw/JTTjkl/u///i+22267aNiwYTRo0CCGDh0aa6+9dkyaNCk6depU5fGtW7fOfn700Ue+aANAEanhAFD/rLbaat96kPzbtgFAXhU8LE+ntLds2TJbICwV3nQm2qBBg2LEiBHZ0eyvzw3TpEmT7Ofs2bOLvriIxQsodaWwGIl+RqkrRD+r7sIitU0Nh+JRw6Hm1ecaDgDUwbA8nVl2/PHHx8033xybbLJJdl/Xrl2zL9/pzLSmTZvGnDlzqjxn4RfsZRnCVajFRSxeQKkrhcVI9DNKXaH6WXUWFqlNajgUlxoONa++1vCl8dprrxW7CQBQ/8Py559/PvvSm75cL6p79+7x97//PdZYY42YPHlylW0Lby/L8K9CLS7iDAFKXSksRqKfUeoK0c+qu7BIbVLDobjUcKh59bWGAwB1NCxv06ZN5VHqbt26Vd7/+uuvR7t27bIv3KNGjYr58+dnc6Emjz/+ePahJc2XtrQsLgJfMTQaSqOf1cXASQ2H4lLDoebV1xoOABROgwLuK/tyvfHGG8eJJ56YfYF+55134vLLL4/HHnssDj/88Ojbt2988cUX2QJi6Yj8mDFjsuHeRxxxRCGbAQAsITUcAACAvCvomeUNGjSIa6+9NvtyfdJJJ8Vnn30WnTp1yr5MpzPSkuHDh8e5554be+yxR6y66qoxePDg7DoAUDxqOAAAAHlX0LA8WX755eOMM87ILt925tptt91W6JcFAJaRGg4AAECeFXQaFgAAAAAAKEXCcgAAAAAAck9YDgAAAABA7gnLAQAAAADIPWE5AAAAAAC5JywHAAAAACD3hOUAAAAAAOSesBwAAAAAgNwTlgMAAAAAkHvCcgAAAAAAck9YDgAAAABA7gnLAQAAAADIPWE5AAAAAAC5JywHAAAAACD3hOUAAAAAAOSesBwAAAAAgNwTlgMAAAAAkHvCcgAAAAAAck9YDgAAAABA7gnLAQAAAADIPWE5AAAAAAC5JywHAAAAACD3hOUAAAAAAOSesBwAAAAAgNwTlgMAAAAAkHvCcgAAAAAAck9YDgAAAABA7gnLAQAAAADIPWE5AAAAAAC5JywHAAAAACD3hOUAAAAAAOSesBwAAAAAgNwTlgMAAAAAkHvCcgAAAAAAck9YDgAAAABA7gnLAQAAAADIPWE5AAAAAAC5JywHAAAAACD3hOUAAAAAAOSesBwAAAAAgNwTlgMAAAAAkHvCcgAAAAAAck9YDgAAAABA7gnLAQAAAADIPWE5AAAAAAC5JywHAAAAACD3hOUAAABQj02dOjVOOOGE6NWrV/To0SMOP/zweOutt4rdLACoc4TlAAAAUI8dc8wxMXHixLjuuuvijjvuiKZNm8ZBBx0UM2fOLHbTAKBOEZYDAABAPfXZZ59F27Zt45xzzolu3bpFhw4d4uijj47JkyfHG2+8UezmAUCdUl7sBgAAAAA1Y/nll49LLrmk8vYnn3wSN998c7Rp0yY6duxY1LYBQC7OLB87dmz85Cc/ia5du8Yuu+wS999/f+W2999/P4444ojo2bNnbLnllnH55ZfH/Pnza6IZAMASUsMBoP467bTTYosttoh77703zj333GjevHmxmwQA9fvM8rvuuitOOeWUOPnkk2OrrbbKivDAgQOzo9YbbrhhHHroodGuXbsYNWpUvPvuu9ljGzRoEAMGDCh0UwCAJaCGA0D9duCBB8bee+8dt956azaP+ciRI2ODDTZY4v1UVFTEjBkzCtKmsrKyaNasWUH2BcsqzeOf3t/om9S/fpn2kd7XtRqWpxe94oor4oADDoj99tsvu++oo46Kp59+Op588sn44IMP4sMPP4zbb789GwrWqVOnbFXu3/72t3HkkUdG48aNC9kcAKCa1HAAqP8WTruSzip//vnnY8SIEXH++ecv8X7mzp0b48ePL0ibUhjXpUuXguwLltWECRMsfPtf+ib1sV9W53treaEbn75M77bbblXuv+GGG7KfQ4YMyY5apy/ZC/Xq1Su++OKLrNB27969kM0BAKpJDQeA+inNUf7YY4/FjjvuGOXlX0UAaWRYCs7TIp9Lo1GjRgWb77w6Z/lBbWnfvr0zy/9L36S+9cs333yzWo8reFiepOFYaaj2K6+8EmuuuWZ2ZlqfPn1i0qRJ2VDuRbVu3Tr7+dFHH/miDQBFooYDQP00ZcqUbFq14cOHZ9OsLTwzPNX6VOOXNkQz3zn1kWlHoP72y+oeACpoWJ7OLktOPPHEOPbYY2PQoEExbty4OProo+Omm26KWbNmRatWrao8p0mTJtnP2bNnL/XrFmq+NPMxUepKYX41/YxSV4h+Vt250mqTGg7FpYZDzauvNfz7pKnTtt566zjnnHOySxolNmzYsJg+fXocdNBBxW4eANQpBQ3L01CsJJ2Rtscee2TXO3funB2xTl+0mzZtGnPmzKnynIVfsJflqHSh5kszHxOlrhTmV9PPKHWF6md1bY5vNRyKSw2Hmldfa3h1XHrppXHJJZfEcccdF59//nlssskm2SKfa6yxRrGbBgD1NyxfbbXVKo9cLyrNZfbwww/HZpttFq+//nqVbQvnSFv43GLOl1ZqZwhAKc6vpp9R6grRz6o7V1ptUsOhuNRwqHn1tYZXR8uWLbP1R9IFAKilsDwt/LXccstlq2qnI9ULpS/Xa6+9dmy66aYxduzYbKh3ixYtsm2PP/549pz1119/qV/XfGnwFUOjoeYVop/VxcBJDYfiUsOh5tXXGg4AFE6DAu4rG6Ldv3//uPrqq+NPf/pTvPvuu3HttdfGo48+GgcffHD8+Mc/jlVXXTV+/etfx6uvvhoPPvhgNhzskEMOKcmhbABQX6jhAAAA5F1BzyxP0kJg6Yj9ZZddFh9//HF06NAhhg4dGptvvnm2Pa3AfeaZZ8Zee+2VLSyy7777Zs8BAIpLDQcAACDPCh6WJ+kMtHRZnHXWWSduvPHGmnhZAGAZqeEAAADkVUGnYQEAAAAAgFIkLAcAAAAAIPeE5QAAAAAA5J6wHAAAAACA3BOWAwAAAACQe8JyAAAAAAByT1gOAAAAAEDuCcsBAAAAAMg9YTkAAAAAALknLAcAAAAAIPeE5QAAAAAA5J6wHAAAAACA3BOWAwAAAACQe8JyAAAAAAByT1gOAAAAAEDuCcsBAAAAAMg9YTkAAAAAALknLAcAAAAAIPeE5QAAAAAA5J6wHAAAAACA3BOWAwAAAACQe8JyAAAAAAByT1gOAAAAAEDuCcsBAAAAAMg9YTkAAAAAALknLAcAAAAAIPeE5QAAAAAA5J6wHAAAAACA3BOWAwAAAACQe8JyAAAAAAByT1gOAAAAAEDuCcsBAAAAAMg9YTkAAAAAALknLAcAAAAAIPeE5QAAAAAA5J6wHAAAAACA3BOWAwAAAACQe8JyAAAAAAByT1gOAAAAAEDuCcsBAAAAAMg9YTkAAAAAALknLAcAAAAAIPeE5QAAAAAA5J6wHAAAAACA3BOWAwAAAACQe8JyAAAAAAByT1gOAAAAAEDuCcsBAAAAAMg9YTkAAADUY9OmTYvTTz89tt566+jZs2fss88+8fTTTxe7WQBQ5wjLAQAAoB4bOHBgPPfcc3HppZfG6NGjo3PnznHooYfG22+/XeymAUB+wvIJEyZEjx49YsyYMZX3jR8/Pvr16xcbbbRR9OnTJ2655ZaabAIAsBTUcACoHyZOnBiPPvpoDBkyJDbZZJNo3759nHbaadG6deu45557it08AMhHWD537twYNGhQzJgxo/K+Tz/9NA4++OBYe+21s6PZxxxzTFx88cXZdQCgblDDAaD+WHHFFeO6666Lrl27Vt5XVlaWXaZPn17UtgFAXVNeUzseOnRotGjRosp9t99+ezRq1CjOOuusKC8vjw4dOmRHuVPh7tu3b001BQBYAmo4ANQfrVq1im222abKfePGjcvq+Mknn7xU+6yoqKhyUH1ZpNC+WbNmBdkXLKuZM2dm72/0Tepfv0z7SO/rooTlTz31VNx2220xduzY6N27d+X9aQGRzTbbLPuSvVCvXr1i2LBhMWXKlFhllVVqojkAQDWp4QBQvz377LNx0kknxQ477FCl1i/pKLQ0PVshpDCuS5cuBdkXFGIqwhTMoW9SP/tl48aNaz8sT8O4Bg8eHKeeemqsvvrqVbZNmjQpOnXqVOW+NE9a8tFHH/miDQBFpIYDQP324IMPZlOt9ezZM5tObWml0WYdO3YsSJuqc5Yf1JY0p78zy7+ib1Lf+uWbb75ZrccVPCxPi4akBcF22223b2ybNWvWNxL8Jk2aZD9nz5691K9ZqCFghphQ6kphyJh+RqkrRD+r7vCv2qaGQ/Go4VDz6nMNr44RI0bEueeeGzvttFNceOGF1Tq77tukf4PmzZsXtH1QF6hzUH/7ZXXrd0HD8jRkOw3T/rYVtZs2bRpz5sypct/CL9jLUmgLNQTMEBNKXSkMGdPPKHWF6mfL8gW1JqjhUFxqONS8+lrDq2PkyJFx9tlnx/777x+nnHJKyQb+AFDTChqWjx49OqZOnfqNec/OOOOMuO+++6JNmzYxefLkKtsW3l5ttdWKPgTMBwZKXSkMGdPPKHWF6GfVHf5Vm9RwKC41HGpefa3h1TlIcN5558X2228fRxxxRLbWyKIHw1u2bFnU9gFAvQ3L05xnaZj2otKiIQMGDIjdd9897rrrrhg1alTMnz8/GjZsmG1//PHHsw8tK6+88lK/riFg8BVDxqA0+lldDJzUcCguNRxqXn2t4d9n3Lhx2UiuBx54ILssao899ogLLrigaG0DgHodln/bmWXpS3Ta1rdv3xg+fHg27Kt///7xwgsvxM033xxnnnlmIZsBACwhNRwA6qcjjzwyuwAA369B1KL0hTt90U7DwNIR7KuuuioGDx6cXQcA6i41HAAAgPquoGeWL85rr71W5Xa3bt3itttuq+mXBQCWkRoOAABAntTqmeUAAAAAAFAXCcsBAAAAAMg9YTkAAAAAALknLAcAAAAAIPeE5QAAAAAA5J6wHAAAAACA3BOWAwAAAACQe8JyAAAAAAByT1gOAAAAAEDuCcsBAAAAAMg9YTkAAAAAALknLAcAAAAAIPeE5QAAAAAA5J6wHAAAAACA3BOWAwAAAACQe8JyAAAAAAByT1gOAAAAAEDuCcsBAAAAAMg9YTkAAAAAALknLAcAAAAAIPeE5QAAAAAA5J6wHAAAAACA3BOWAwAAAACQe8JyAAAAAAByT1gOAAAAAEDuCcsBAAAAAMg9YTkAAAAAALknLAcAAAAAIPeE5QAAAAAA5J6wHAAAAACA3BOWAwAAAACQe8JyAAAAAAByT1gOAAAAAEDuCcsBAAAAAMg9YTkAAAAAALknLAcAAAAAIPeE5QAAAAAA5J6wHAAAAACA3BOWAwAAAACQe8JyAAAAAAByT1gOAAAAAEDuCcsBAAAAAMg9YTkAAAAAALknLAcAAAAAIPeE5QAAAAAA5J6wHAAAAACA3BOWAwAAAACQe8JyAAAAAAByT1gOAAAAAEDuCcsBAAAgJ4YNGxb7779/sZsBAPkIy6dNmxann356bL311tGzZ8/YZ5994umnn67c/thjj8Wee+4Z3bt3j5122inuvffeQjcBAFgKajgA1G+33nprXH755cVuBgDkJywfOHBgPPfcc3HppZfG6NGjo3PnznHooYfG22+/HW+99VYcccQRsdVWW8WYMWPiF7/4RQwePDj78g0AFJcaDgD108cffxxHHnlkXHzxxdGuXbtiNwcA6qzyQu5s4sSJ8eijj8bIkSNj4403zu477bTT4h//+Efcc889MXXq1FhvvfXiuOOOy7Z16NAhXnnllRg+fHhsscUWhWwKALAE1HAAqL9efvnlaNSoUdx9991x9dVXxwcffFDsJgFA/T+zfMUVV4zrrrsuunbtWnlfWVlZdpk+fXo2lPvrX6h79eoVzzzzTFRUVBSyKQDAElDDAaD+6tOnTwwdOjTWWmutYjcFAPJzZnmrVq1im222qXLfuHHjsrPVTj755LjzzjujTZs2Vba3bt06Zs6cGZ9++mmstNJKhWwOAFBNajgAUF3pQPmMGTMKsq90YL5Zs2YF2Rcsq/TZ1okgX9E3qW/9Mu0jva9rNSz/umeffTZOOumk2GGHHaJ3794xa9asaNy4cZXHLLw9Z86cohdqfwgodaVQ2PUzSl0h+ll1i3QxqeFQu9RwqHl5qeG1Ye7cuTF+/PiC7Cv9XenSpUtB9gXLasKECdnfCvRN6me//Pp32loNyx988MEYNGhQ9OzZM1tEJGnSpMk3vlAvvL0sH7wLVaj9IaDUlUJh188odYXqZ9Up0sWihkPtU8Oh5uWhhteWNP95x44dC7IvBx+oS9q3b1/nD17XFn2T+tYv33zzzWo9rkbC8hEjRsS5554bO+20U1x44YWVHyZWX331mDx5cpXHptvNmzePli1bFr1Q+0NAqSuFwq6fUeoK0c+qW6SLQQ2H4lDDoebV9xpe238P0mcAqG+MoIL62y+r+1m24GH5yJEj4+yzz479998/TjnllCoN2WSTTeLJJ5+s8vjHH388O3OtQYOlX2tUoYavKOxQGv2srgZOajgUjxoONa8+13AAoDDKCz2s7bzzzovtt98+jjjiiJgyZUrltqZNm2ZfvvfYY49sSHf6+cgjj8Sf//znGD58eCGbAQAsITUcAACAvCtoWD5u3Lhs7tEHHngguywqfbG+4IIL4pprromLLroofv/738eaa66ZXd9iiy0K2QwAYAmp4QCQD6mmAwC1EJYfeeSR2eW7bL311tkFAKg71HAAAADybuknGQUAAAAAgHpCWA4AAAAAQO4JywEAAAAAyD1hOQAAAAAAuScsBwAAAAAg94TlAAAAAADknrAcAAAAAIDcE5YDAAAAAJB7wnIAAAAAAHJPWA4AAAAAQO4JywEAAAAAyD1hOQAAAAAAuScsBwAAAAAg94TlAAAAAADknrAcAAAAAIDcE5YDAAAAAJB7wnIAAAAAAHJPWA4AAAAAQO4JywEAAAAAyD1hOQAAAAAAuScsBwAAAAAg94TlAAAAAADknrAcAAAAAIDcE5YDAAAAAJB7wnIAAAAAAHJPWA4AAAAAQO4JywEAAAAAyD1hOQAAAAAAuScsBwAAAAAg94TlAAAAAADknrAcAAAAAIDcE5YDAAAAAJB7wnIAAAAAAHJPWA4AAAAAQO4JywEAAAAAyD1hOQAAAAAAuScsBwAAAAAg94TlAAAAAADknrAcAAAAAIDcE5YDAAAAAJB7wnIAAAAAAHJPWA4AAAAAQO4JywEAAAAAyD1hOQAAAAAAuScsBwAAAAAg94TlAAAAAADknrAcAAAAAIDcE5YDAAAAAJB7wnIAAAAAAHJPWA4AAAAAQO4VJSxfsGBBXHnllbHVVlvFRhttFIcddli89957xWgKAFBN6jcAlCY1HADqcFh+zTXXxMiRI+Pss8+OUaNGZYW7f//+MWfOnGI0BwCoBvUbAEqTGg4AdTQsT8X4xhtvjAEDBkTv3r1j/fXXj8suuywmTZoUf/nLX2q7OQBANajfAFCa1HAAqMNh+auvvhpffvllbLHFFpX3tWrVKrp06RJPPfVUbTcHAKgG9RsASpMaDgB1OCxPR6+T1Vdfvcr9rVu3rtwGANQt6jcAlCY1HACqrzxq2cyZM7OfjRs3rnJ/kyZN4rPPPlvi/c2dOzcqKirihRdeKEj7ysrKYt78BdGgoqIg+4PaMHtOWbz44pSsL5SC1M92WDVi3srFbglUX3mDiBdfjIL0s1S7Uj8oJYWu34kaDmo41AY1vG5/B0/Sv+mZqy6Iuf62LJVmDVMtKYv1dq6IH8wvdmtKU4OG6e9EWcnU49qiby4bfbNu9cvq1vBaD8ubNm1aOW/awuvJ7Nmzo1mzZku8v4W/ZCE/sJQ3LMq6p7DMSumDe8smxW4BFK+fpX2UUn+tifqdqOHwP6X0N0ENp1Sp4XX3O3iyShM1fFk1b1Va7826qNT6d23QN5edvlk3+mV1a3ith+ULh35Nnjw51l577cr70+311ltviffXo0ePgrYPAKj5+p2o4QBQ83wHB4Dqq/XDQ2nl7RYtWsQTTzxRed/06dPjlVdeiU033bS2mwMAVIP6DQClSQ0HgOqr9TPL0zxp/fr1i4svvjhWWmmlaNu2bVx00UXRpk2b2GGHHWq7OQBANajfAFCa1HAAqMNheTJgwICYN29enHrqqTFr1qzsaPYNN9wQjRo1KkZzAIBqUL8BoDSp4QBQPWUVlvoFAAAAACDnLGkLAAAAAEDuCcsBAAAAAMg9YTkAAAAAALknLAcAAAAAIPeE5QAAAAAA5J6wHAAAAACA3BOWAwAAAACQe8LynFtvvfVizJgxRW3D/vvvH7/5zW+y60888UTWpvfff7+obYJi+vDDD+Pee++tvN2nT58YOnToUu9vWZ//fdLfkNRvgdqlhkPdo4YDC6nTUH+o7/lSXuwGwKJ69OgR//znP2OllVYqdlOgaE488cRo27Zt7LLLLtntO+64I5o0abLU+1vW5wNUhxoOajhQd6nTsPTU93wRllOnNG7cOFZdddViNwPqlGX9QOsDMVAb1HD4JjUcqCvUaSgc9b1+Mw0L8fbbb8cvf/nL2HDDDWPnnXeO+++/v3LbggULYtiwYbHjjjtm23v27Bn9+/ePd999t/IxjzzySOy5557RvXv32GKLLbJhXp999lnl9rfeeisOO+yw7Ej2lltuGccff3z85z//WWxbvj40LA1NueGGG+JXv/pV9vzNN988zjnnnJg3b17lc5599tnYb7/9olu3btG7d+8488wz44svvqihfy34ftOmTcveh9tss032vkz9K723kzTUap999omrr746ez9vsskmcdJJJ1W+Z9NQySeffDLuvPPO7P3/9SFa6edBBx0UV111Vfzwhz/M+sXpp58eH330URxxxBFZP9x+++3j4YcfrmzPos9P/Wtxl7S/ZM6cOXHRRRfFVlttle17r732ys5AWdQDDzwQu+22W3Tt2jX23XffbEgaUBxqOBSWGg4UkjoNdYP6zpIQlhO///3v42c/+1ncc889WaE+7rjj4qWXXsq23XLLLVkBTUV53Lhx2R+Pd955Jy644IJs+yeffBLHHnts9O3bN+67776sMz/11FPx29/+Ntv+8ccfZx11nXXWyYaZ/O53v8v+4Oy9994xY8aMarXviiuuiE033TTuvvvuGDx4cIwYMSL+9Kc/ZdteffXVOPjgg7M/Gmn7xRdfHC+//HIccsghUVFRUWP/ZvBt5s+fn73/nn766aygpbnCOnXqFIceemi88MIL2WNefPHFrLjdeOONWZ9KfebXv/51ti0VzFQA04fp1GcWJ+17woQJceutt8app54at912W/z85z/PnpNer0OHDlmfXVwfSK+76OUnP/lJtG7dOn7xi19k29OHgkcffTTrS+nDQNrnkUceWVnY0wfm9IE6/a1IfW6PPfaI6667rgb/RYHvooZD4ajhQKGp01B86jtLrIJc69SpU8V5551X5b6999674vjjj8+uP/TQQxV//etfq2y/6KKLKrbbbrvs+iuvvJLtY9HHvP766xXjx4/Prl922WUVu+++e5Xnz5gxo6Jbt24Vo0ePzm7369ev4sQTT8yuP/7449n+3nvvvez2tttuW3HUUUdVef5Pf/rTitNOOy27PmjQoG9sf/fdd7N9pH1BbXv44Yez999rr71Wed+CBQsqfvazn1UMGDCg4sorr6zYcMMNKyZNmlS5/ZFHHsme89Zbb32jTyzsB+l5SfrZuXPnis8//7xy++abb14xcODAb7Th448//sbzF3XTTTdVdO/eveKll17Kbr/zzjvZ81K/XtTgwYOzNiXHHXdcxT777FNl+znnnJM9D6hdajgUlhoOFJI6DXWD+s6SMmc5sfHGG1e5nYaIPP7445VDQ55//vnsiHM6SpYub775Zqy22mrZ9s6dO8euu+6aHdVK85/96Ec/yoZnpSEmySuvvBJvvPFGdhRuUbNnz86GjFVHOgK3qJYtW8bcuXMr9z9x4sRv7D9J+09DaKA2vf7669l7NB2pXqisrCwbypWOEnfs2DHatWtX2YeSNORy4XPXXXfd732NlVdeOVq0aFF5u3nz5rH22mtX3m7atGnlcK1v89e//jU7qn7ZZZfFBhtsUNmfknSGyqJSf2vVqlVlG1M/X1Tqf+nMGKD2qeFQOGo4UGjqNBSf+s6SEpYTDRo0+MYQlbT4R5KGbqQhKGkYR5ojLc3D9NBDD8W9995b+fhLLrkkjjnmmPj73/8e//rXv+KEE07IPhSkIWdpHrZevXrFGWec8Y3XTX+sqmNhWxa1cOhK2n+alyl9gPg6CyZQDN82JDHdX17+1Z/cRo0afaPPJQ0bNqzWa3z9+Yvrx99l/Pjx2XyGAwYMiB122OEbbU9Dx5ZbbrnF7j99qEj97vvaA9QONRwKRw0HCk2dhuJT31lS5iwnm3dsUWm+ox/84AfZ9TTvWSrOQ4YMyeY+22ijjbJ51BZ22HQk/LzzzsuOtKXingp+up2Olk+dOjXbTzrqvPrqq2dzqaXL8ssvnz0mHf1aVmn/6ej7wn2nS1qQ5Pzzz88WU4Dalhbi+Pzzz6u8v1N/eeaZZ7Ij1kk6ayQ9ZqHnnnsu+9mlS5cab1+a2zAtMpIKcPq5qIX9Pi0KtGifSnOspUuy/vrrV7Z3oYXzLgK1Tw2HwlHDgUJTp6H41HeWlLCcuPnmm7NFAtJK3QsLa1pRO0mFNy0kkIpk2p6Gg/zlL3+pHDqShpmMHDkyGyqShmil56bFR9IQlhVXXDEbKpL+4AwaNChbICRd0qImafGERYfALK20SEMalpJWNU4fFNIfiHQ0Ln3ISG2A2pZWoU9DJtP7MK2Ynd6XZ511VtY3DjzwwOwxacGdtIBOui+dIZK2p0U82rZtm21PR4w/+OCDmDRpUkHbll43nRmyxhprZO2bMmVKVnTTJa0Ongrxtttum52dkoaAvffee3H99dfHsGHDKoeQpT6X+vGFF16YfaBIC4ikhYCA4lDDoXDUcKDQ1GkoPvWdJSUsJ44++uj4wx/+ELvvvnv2hyMdsW7fvn22La20PWvWrGwF7n79+mV/OFKxTEeyP/zww2yOs7QycDq6nVb53meffbJhKqnzpiEha621VtZJv/zyy2xb2kcaDpLmTirE0K109H348OHZkJU0fO2oo47K2p4+lCxuSBnUtPT+TytopyPQC1evT3MJpvdker8u/GCcivV+++0XAwcOjO22265y1fvkl7/8ZdbXUp9cOPyrENIH5/SBN33QTavap3nN0geHdEmrZyfpQ3o6on366adnHw7Gjh0b5557bta/ktTu1L+feOKJrH3p91rc0EygdqjhUDhqOFBo6jQUn/rOkipLq3wu8bMAWCrpA286uyQdFQYASocaDgD1j/rO1zmzHAAAAACA3BOWAwAAAACQe6ZhAQAAAAAg95xZDgAAAABA7gnLAQAAAADIPWE5AAAAAAC5JywHAAAAACD3hOUAAAAAAOSesBwAAAAAgNwTlgMAAAAAkHvCcgAAAAAAck9YDgAAAABA5N3/B9wfDPCFVFJTAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 1500x800 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "### Prompt Optimization Results - Coding Tasks\n",
+       "\n",
+       "| Metric                      | Baseline | Optimized | Δ (Opt − Base) |\n",
+       "|----------------------------|---------:|----------:|---------------:|\n",
+       "| Avg Time (s)                |    7.906 |     6.977 |        -0.929 |\n",
+       "| Peak Memory (KB)            |   3626.3 |     577.5 |       -3048.8 |\n",
+       "| Exact (%)                   |    100.0 |     100.0 |           0.0 |\n",
+       "| Sorted (%)                  |    100.0 |     100.0 |           0.0 |\n",
+       "| LLM Adherence (1–5)         |     4.40 |      4.90 |         +0.50 |\n",
+       "| Code Quality (1–5)          |     4.73 |      4.90 |         +0.16 |"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "### Prompt Optimization Results - Coding Tasks\n",
+      "\n",
+      "| Metric                      | Baseline | Optimized | Δ (Opt − Base) |\n",
+      "|----------------------------|---------:|----------:|---------------:|\n",
+      "| Avg Time (s)                |    7.906 |     6.977 |        -0.929 |\n",
+      "| Peak Memory (KB)            |   3626.3 |     577.5 |       -3048.8 |\n",
+      "| Exact (%)                   |    100.0 |     100.0 |           0.0 |\n",
+      "| Sorted (%)                  |    100.0 |     100.0 |           0.0 |\n",
+      "| LLM Adherence (1–5)         |     4.40 |      4.90 |         +0.50 |\n",
+      "| Code Quality (1–5)          |     4.73 |      4.90 |         +0.16 |\n"
+     ]
+    }
+   ],
+   "source": [
+    "from pathlib import Path\n",
+    "import importlib\n",
+    "import scripts.results_summarizer as rs\n",
+    "from IPython.display import Markdown, display\n",
+    "\n",
+    "importlib.reload(rs)\n",
+    "\n",
+    "fig = rs.render_charts(\n",
+    "    quant_baseline=Path(\"results_topk_baseline\")/\"run_results_topk_baseline.csv\",\n",
+    "    quant_optimized=Path(\"results_topk_optimized\")/\"run_results_topk_optimized.csv\",\n",
+    "    judge_baseline=Path(\"results_llm_as_judge_baseline\")/\"judgement_summary.csv\",\n",
+    "    judge_optimized=Path(\"results_llm_as_judge_optimized\")/\"judgement_summary.csv\",\n",
+    "    auto_display=True,\n",
+    "    close_after=True,\n",
+    ")\n",
+    "md = rs.build_markdown_summary(\n",
+    "    quant_baseline=Path(\"results_topk_baseline\")/\"run_results_topk_baseline.csv\",\n",
+    "    quant_optimized=Path(\"results_topk_optimized\")/\"run_results_topk_optimized.csv\",\n",
+    "    judge_baseline=Path(\"results_llm_as_judge_baseline\")/\"judgement_summary.csv\",\n",
+    "    judge_optimized=Path(\"results_llm_as_judge_optimized\")/\"judgement_summary.csv\",\n",
+    ")\n",
+    "\n",
+    "display(Markdown(md))\n",
+    "\n",
+    "print(md)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7d076297",
+   "metadata": {},
+   "source": [
+    "Even though GPT-5 already produced correct code, prompt optimization tightened constraints and clarified any ambiguity. Showing overall improvements to the results!\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c3dec50a",
+   "metadata": {},
+   "source": [
+    "--------------------------------------------------------------------"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f1e0f019",
+   "metadata": {},
+   "source": [
+    "### Context and Retrieval: Simulating a Financial Question Answering\n",
+    "\n",
+    "Most production use cases face imperfect queries and noisy context. **FailSafeQA** is an excellent benchmark that deliberately perturbs both the **query** (misspellings, incompleteness, off-domain phrasing) and the **context** (missing, OCR-corrupted, or irrelevant docs) and reports **Robustness**, **Context Grounding**, and **Compliance**—i.e., can the model answer when the signal exists and abstain when it doesn’t.\n",
+    "\n",
+    "![FailSafeQA diagram](../../images/image_optimize_4.png)\n",
+    "\n",
+    "**Links**\n",
+    "- Paper (arXiv): *Expect the Unexpected: FailSafe Long Context QA for Finance* — https://arxiv.org/abs/2502.06329  \n",
+    "- Dataset (Hugging Face): https://huggingface.co/datasets/Writer/FailSafeQA  \n",
+    "- Authors/Makers: Kiran Kamble, Melisa Russak, Dmytro Mozolevskyi, Muayad Ali, Mateusz Russak, Waseem AlShikh (Writer.ai) — see author list on the arXiv page above\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "433925a6",
+   "metadata": {},
+   "source": [
+    "We will run FailSafeQA evaluations via the helper script and compare Baseline vs Optimized prompts side by side."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "774410c9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define the Baseline FailSafeQA system prompt here for reuse\n",
+    "baseline_prompt_fsqa = (\n",
+    "    \"You are a finance QA assistant. Answer ONLY using the provided context.\\n\"\n",
+    "    \"If the context is missing or irrelevant, politely refuse and state that you need the relevant document.\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0a817cd8",
+   "metadata": {},
+   "source": [
+    "We can use the prompt optimizer once again to construct a new prompt that is more suitable for this use case. Drawing on best practices for long-context question answering, we know that we should remind our answer model to rely on information in the context section and refuse answers to questions if the context is insufficient. By using the Optimize button once without any arguments we get a reasonable structure for the prompt and end up with this as our optimized prompt.\n",
+    "\n",
+    "\n",
+    "![optimize_image](../../images/image_optimize_5.png)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "aede3e7d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimized_fsqa_prompt = \"\"\"You are a finance document QA assistant.\n",
+    "\n",
+    "Behavioral priorities (in order):\n",
+    "1) Grounding: Use ONLY the text inside [Context]. Do NOT use outside knowledge or assumptions.\n",
+    "2) Evidence check: Before answering, verify that the answer text (numbers, entities, dates, phrasing) is explicitly present or directly entailed by [Context]. If not, refuse (see Refusal policy).\n",
+    "3) Robustness to query noise: The user question may contain misspellings, missing words, or non-financial phrasing. Infer intent using the context and answer if the meaning is clear and supported by the context.\n",
+    "4) OCR noise handling: The context may include OCR artifacts (repeated characters, stray symbols, broken words). Ignore junk characters and reconstruct meaning when the underlying sentence is still recoverable. Do not guess beyond what the context supports.\n",
+    "\n",
+    "Refusal policy:\n",
+    "- If [Context] is empty or lacks the information to answer, reply with a brief refusal and guidance. Do NOT attempt a general-knowledge answer.\n",
+    "- If the question is unrelated to the content of [Context] (out of scope), reply with a brief refusal and guidance. Do NOT speculate.\n",
+    "- If the question is incomplete but the correct answer is unambiguous from [Context], infer the intent and answer exactly; do NOT refuse.\n",
+    "\n",
+    "Answer style:\n",
+    "- Default to the **shortest exact answer** needed to satisfy the question (e.g., the precise number/string/date as written). Preserve units, signs, casing, currency symbols, commas, and parentheses from the context. Do NOT round numbers unless asked.\n",
+    "- If the user explicitly asks to “write”, “draft”, or “generate” content, you may produce multi-sentence or formatted text—but still source every factual claim strictly from [Context].\n",
+    "- If the question is ambiguous, state the needed clarification in one short sentence, then provide the best supported answer if possible.\n",
+    "\n",
+    "Output format:\n",
+    "- If answerable from the context:\n",
+    "  FINAL: <exact answer here>\n",
+    "  (optional) EVIDENCE: \"<very short quoted span from the context that contains the answer>\"\n",
+    "- If refusing:\n",
+    "  FINAL: Insufficient information in the provided context to answer this question. Please upload the relevant document or refine your question to include the necessary details.\"\"\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2516f981",
+   "metadata": {},
+   "source": [
+    "Let's now run our evaluations, for demonstration we will display the results of a single comparison, but you can also run the full evaluation. Note: This will take time."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2881639a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import importlib\n",
+    "import run_FailSafeQA\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "from openai import OpenAI\n",
+    "\n",
+    "# Ensure latest function signature is used after code edits\n",
+    "importlib.reload(run_FailSafeQA)\n",
+    "run_failsafeqa = run_FailSafeQA.run_failsafeqa\n",
+    "\n",
+    "# Set idx to an integer for a quick single-example comparison; set to None for full run\n",
+    "idx = 0  # e.g., 0 for a single datapoint\n",
+    "\n",
+    "#Helper functions:\n",
+    "class OpenAIAnswer:\n",
+    "    def __init__(self):\n",
+    "        self.client = OpenAI()\n",
+    "\n",
+    "    def __call__(self, system_prompt: str, user_prompt: str, model: str) -> str:\n",
+    "        resp = self.client.responses.create(\n",
+    "            model=model,\n",
+    "            input=[\n",
+    "                {\"role\": \"developer\", \"content\": [{\"type\": \"input_text\", \"text\": system_prompt}]},\n",
+    "                {\"role\": \"user\", \"content\": [{\"type\": \"input_text\", \"text\": user_prompt}]},\n",
+    "            ],\n",
+    "            text={\"format\": {\"type\": \"text\"}, \"verbosity\": \"medium\"},\n",
+    "            reasoning={\"effort\": \"medium\", \"summary\": \"auto\"},\n",
+    "            tools=[],\n",
+    "        )\n",
+    "        return resp.output_text\n",
+    "class OpenAIJudge:\n",
+    "    def __init__(self):\n",
+    "        self.client = OpenAI()\n",
+    "\n",
+    "    def __call__(self, prompt: str, model: str) -> str:\n",
+    "        resp = self.client.responses.create(\n",
+    "            model=model,\n",
+    "            input=[{\"role\": \"user\", \"content\": [{\"type\": \"input_text\", \"text\": prompt}]}],\n",
+    "            text={\"format\": {\"type\": \"text\"}, \"verbosity\": \"medium\"},\n",
+    "            reasoning={\"effort\": \"medium\", \"summary\": \"auto\"},\n",
+    "            tools=[],\n",
+    "        )\n",
+    "        return resp.output_text\n",
+    "\n",
+    "if idx is not None:\n",
+    "    # Single example mode (with detailed prompt/response logging)\n",
+    "    run_failsafeqa(\n",
+    "        out=\"results_failsafeqa_baseline.csv\",\n",
+    "        system_prompt=baseline_prompt_fsqa,\n",
+    "        indices=[idx],\n",
+    "        log_prompts=True,\n",
+    "        log_chars=800,\n",
+    "        log_file=\"failsafeqa_debug.log\",\n",
+    "    )\n",
+    "    run_failsafeqa(\n",
+    "        out=\"results_failsafeqa_optimized.csv\",\n",
+    "        system_prompt=optimized_fsqa_prompt,\n",
+    "        indices=[idx],\n",
+    "        log_prompts=True,\n",
+    "        log_chars=800,\n",
+    "        log_file=\"failsafeqa_debug.log\",\n",
+    "    )\n",
+    "\n",
+    "    base_df = pd.read_csv(\"results_failsafeqa_baseline.csv\")\n",
+    "    opt_df = pd.read_csv(\"results_failsafeqa_optimized.csv\")\n",
+    "\n",
+    "    b_one = base_df[base_df[\"idx\"] == idx]\n",
+    "    o_one = opt_df[opt_df[\"idx\"] == idx]\n",
+    "\n",
+    "    comparison_df = pd.concat([b_one, o_one], ignore_index=True)\n",
+    "\n",
+    "    # Keep only relevant columns\n",
+    "    comparison_df = comparison_df[[\"run\", \"kind\", \"rating\", \"compliance\"]]\n",
+    "\n",
+    "    # Display as table\n",
+    "    display(comparison_df)\n",
+    "\n",
+    "else:\n",
+    "    # Full run mode\n",
+    "    run_failsafeqa(out=\"results_failsafeqa_baseline.csv\", system_prompt=baseline_prompt_fsqa)\n",
+    "    run_failsafeqa(out=\"results_failsafeqa_optimized.csv\", system_prompt=optimized_fsqa_prompt)\n",
+    "\n",
+    "    base_df = pd.read_csv(\"results_failsafeqa_baseline.csv\")\n",
+    "    opt_df = pd.read_csv(\"results_failsafeqa_optimized.csv\")\n",
+    "\n",
+    "    def per_kind_summary(df: pd.DataFrame) -> pd.DataFrame:\n",
+    "        out = df.groupby(\"kind\").agg(\n",
+    "            mean_rating=(\"rating\", lambda x: pd.to_numeric(x, errors=\"coerce\").mean()),\n",
+    "            compliance_rate=(\"compliance\", lambda x: pd.to_numeric(x, errors=\"coerce\").fillna(0).mean()),\n",
+    "            count=(\"rating\", \"count\"),\n",
+    "        )\n",
+    "        return out.round(3)\n",
+    "\n",
+    "    base_summary = per_kind_summary(base_df)\n",
+    "    opt_summary = per_kind_summary(opt_df)\n",
+    "\n",
+    "    summary = base_summary.join(opt_summary, lsuffix=\"_base\", rsuffix=\"_opt\").fillna(\"NA\")\n",
+    "\n",
+    "    print(\"Per-kind comparison (baseline vs optimized):\")\n",
+    "    display(summary)\n",
+    "\n",
+    "    # Plot compliance rate comparison per kind\n",
+    "    kinds = summary.index.tolist()\n",
+    "    x = range(len(kinds))\n",
+    "    base_vals = summary[\"compliance_rate_base\"].astype(float).tolist()\n",
+    "    opt_vals = summary[\"compliance_rate_opt\"].astype(float).tolist()\n",
+    "\n",
+    "    fig, ax = plt.subplots(figsize=(10, 4))\n",
+    "    width = 0.35\n",
+    "    ax.bar([i - width/2 for i in x], base_vals, width=width, label=\"Baseline\", color=\"#cbd5e1\")\n",
+    "    ax.bar([i + width/2 for i in x], opt_vals, width=width, label=\"Optimized\", color=\"#60a5fa\")\n",
+    "    ax.set_xticks(list(x))\n",
+    "    ax.set_xticklabels(kinds, rotation=45, ha=\"right\")\n",
+    "    ax.set_ylim(0, 1)\n",
+    "    ax.set_ylabel(\"Compliance rate\")\n",
+    "    ax.set_title(\"FailSafeQA — Per-kind Compliance (Baseline vs Optimized)\")\n",
+    "    ax.legend()\n",
+    "    plt.tight_layout()\n",
+    "    plt.show()\n",
+    "\n",
+    "    # Overall metrics\n",
+    "    def overall(df: pd.DataFrame):\n",
+    "        return {\n",
+    "            \"mean_rating\": float(pd.to_numeric(df[\"rating\"], errors=\"coerce\").mean()),\n",
+    "            \"mean_compliance\": float(pd.to_numeric(df[\"compliance\"], errors=\"coerce\").fillna(0).mean()),\n",
+    "        }\n",
+    "\n",
+    "    print(\"Overall — Baseline:\", overall(base_df))\n",
+    "    print(\"Overall — Optimized:\", overall(opt_df))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "c20097e6",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/markdown": [
+       "## FailSafeQA — Summary\n",
+       "\n",
+       "**Compliance threshold:** ≥ 6\n",
+       "\n",
+       "| Metric                                    | Baseline | Optimized | Δ (Opt − Base) |\n",
+       "| ----------------------------------------- | -------- | --------- | -------------- |\n",
+       "| Robustness (avg across datapoints)        | 0.320    | 0.540     | +0.220         |\n",
+       "| Context Grounding (avg across datapoints) | 0.800    | 0.950     | +0.150         |\n",
+       "\n",
+       "_Source files:_ `results_failsafeqa.csv` · `results_failsafeqa.csv`"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "## FailSafeQA — Summary\n",
+      "\n",
+      "**Compliance threshold:** ≥ 6\n",
+      "\n",
+      "| Metric                                    | Baseline | Optimized | Δ (Opt − Base) |\n",
+      "| ----------------------------------------- | -------- | --------- | -------------- |\n",
+      "| Robustness (avg across datapoints)        | 0.320    | 0.540     | +0.220         |\n",
+      "| Context Grounding (avg across datapoints) | 0.800    | 0.950     | +0.150         |\n",
+      "\n",
+      "_Source files:_ `results_failsafeqa.csv` · `results_failsafeqa.csv`\n"
+     ]
+    }
+   ],
+   "source": [
+    "from IPython.display import Markdown, display\n",
+    "\n",
+    "def build_markdown_summary_from_metrics(\n",
+    "    robust_base: float, ground_base: float,\n",
+    "    robust_opt: float, ground_opt: float,\n",
+    "    threshold: int = 6,\n",
+    "    src_base: str = \"results_failsafeqa.csv\",\n",
+    "    src_opt: str = \"results_failsafeqa.csv\",\n",
+    ") -> str:\n",
+    "    d_r = robust_opt - robust_base\n",
+    "    d_g = ground_opt - ground_base\n",
+    "\n",
+    "    # Data rows\n",
+    "    rows = [\n",
+    "        [\"Metric\", \"Baseline\", \"Optimized\", \"Δ (Opt − Base)\"],\n",
+    "        [\"Robustness (avg across datapoints)\", f\"{robust_base:.3f}\", f\"{robust_opt:.3f}\", f\"{d_r:+.3f}\"],\n",
+    "        [\"Context Grounding (avg across datapoints)\", f\"{ground_base:.3f}\", f\"{ground_opt:.3f}\", f\"{d_g:+.3f}\"],\n",
+    "    ]\n",
+    "\n",
+    "    # Calculate column widths for alignment\n",
+    "    col_widths = [max(len(str(row[i])) for row in rows) for i in range(len(rows[0]))]\n",
+    "\n",
+    "    # Build table lines with padding\n",
+    "    lines = []\n",
+    "    for i, row in enumerate(rows):\n",
+    "        padded = [str(cell).ljust(col_widths[j]) for j, cell in enumerate(row)]\n",
+    "        lines.append(\"| \" + \" | \".join(padded) + \" |\")\n",
+    "        if i == 0:  # after header\n",
+    "            sep = [\"-\" * col_widths[j] for j in range(len(row))]\n",
+    "            lines.append(\"| \" + \" | \".join(sep) + \" |\")\n",
+    "\n",
+    "    table = \"\\n\".join(lines)\n",
+    "\n",
+    "    return f\"\"\"\n",
+    "## FailSafeQA — Summary\n",
+    "\n",
+    "**Compliance threshold:** ≥ {threshold}\n",
+    "\n",
+    "{table}\n",
+    "\n",
+    "_Source files:_ `{src_base}` · `{src_opt}`\n",
+    "\"\"\".strip()\n",
+    "\n",
+    "# Usage\n",
+    "md = build_markdown_summary_from_metrics(\n",
+    "    robust_base=0.320, ground_base=0.800,\n",
+    "    robust_opt=0.540, ground_opt=0.950,\n",
+    "    threshold=6,\n",
+    "    src_base=\"results_failsafeqa.csv\",\n",
+    "    src_opt=\"results_failsafeqa.csv\",\n",
+    ")\n",
+    "\n",
+    "# Notebook pretty\n",
+    "display(Markdown(md))\n",
+    "\n",
+    "print(md)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0a84939c",
+   "metadata": {},
+   "source": [
+    "GPT-5-mini crushes this task, so even the baseline prompt gets scores of >= 4 almost all of the time. However if we compare the percent of perfect scores (6/6) for the judge, we see that the optimize prompt has way significantly more perfect answers when evaluated in the two categories of FailSafeQA answer quality: robustness and context grounding."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ebd5453b",
+   "metadata": {},
+   "source": [
+    "### Conclusion\n",
+    "\n",
+    "We’re excited for everyone to try **Prompt Optimization for GPT-5** in the OpenAI Playground. GPT-5 brings state-of-the-art intelligence, and a strong prompt helps it reason more reliably, follow constraints, and produce cleaner, higher quality results.\n",
+    "\n",
+    "\n",
+    "Give the [Prompt Optimizer](https://platform.openai.com/chat/edit?optimize=true) a try on your task today!"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/gpt-5/prompt-optimization-cookbook/llm_as_judge.txt b/examples/gpt-5/prompt-optimization-cookbook/llm_as_judge.txt
new file mode 100644
index 0000000000..7b5f3d04a3
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/llm_as_judge.txt
@@ -0,0 +1,93 @@
+# SYSTEM PROMPT
+
+You are an expert judge responsible for evaluating the quality of outputs produced by language models, specifically focusing on how well they follow provided task instructions and the overall code quality (if the output is code). Your evaluation must be fair, thorough, and well-reasoned.
+
+First, carefully read and understand:
+- The task instructions provided.
+- The output (text or code) produced by the model.
+
+**Your tasks:**
+1. **Analyze Task Adherence:**  
+   - Step-by-step, explain how the output matches or fails to meet each part of the instructions.  
+   - Highlight all instances where instructions are fully, partially, or not followed.  
+   - Consider any ambiguities and how reasonable the model's choices are.
+
+2. **Evaluate Code Quality (if applicable):**  
+   - Step-by-step, assess the clarity, correctness, efficiency, readability, structure, maintainability, and best practices of the code.
+   - Identify any bugs, inefficiencies, or stylistic issues, explaining your reasoning for each point.
+   - If the output is not code, skip this step and say so.
+
+**Reasoning Process:**  
+- Always **reason first**—do not state your final assessment until after you have fully documented your reasoning about task adherence and code quality.
+- Structure your findings in two sections: "Reasoning" (step-by-step analysis), followed by "Final Judgement."
+
+**Output Format:**  
+Respond ONLY in the following JSON structure (replace bracketed areas with your content):
+
+{
+  "reasoning": {
+    "task_adherence": "[Step-by-step analysis of how well the output follows all instructions, including any missed or ambiguous points.]",
+    "code_quality": "[Step-by-step code quality assessment, or short note if not applicable.]"
+  },
+  "final_judgement": {
+    "adherence_score": [integer 1-5, where 5=perfectly follows instructions, 1=ignores or subverts instructions],
+    "code_quality_score": [integer 1-5, where 5=exceptional code quality, 1=severe issues or missing code; use null if not code],
+    "comments": "[Short summary of main issues, overall impression, or suggestions for improvement.]"
+  }
+}
+
+**Scoring Guidelines:**
+- 5 = Exceptional; all instructions/code quality criteria met to a high standard.
+- 4 = Good; minor issues.
+- 3 = Average; some issues or minor omissions.
+- 2 = Major issues or omissions.
+- 1 = Severe failure to follow task or produce usable code.
+
+**EXAMPLES:**
+
+**Example 1:**
+Input Instructions: "Write a function that returns the sum of two numbers."  
+Model Output:  
+def add(a, b):  
+  return a + b
+
+JSON Output:
+{
+  "reasoning": {
+    "task_adherence": "The output defines a function named 'add' with two arguments and returns their sum as instructed.",
+    "code_quality": "The code is concise, correct, and follows Python conventions. No issues."
+  },
+  "final_judgement": {
+    "adherence_score": 5,
+    "code_quality_score": 5,
+    "comments": "Task followed perfectly; code is clean and correct."
+  }
+}
+
+**Example 2:**
+Input Instructions: "Write a function that checks if a string is a palindrome, ignoring case and spaces."  
+Model Output:  
+def is_palindrome(s):  
+  return s == s[::-1]
+
+JSON Output:
+{
+  "reasoning": {
+    "task_adherence": "The output defines a function, but it does not ignore case and spaces, as required.",
+    "code_quality": "The code is correct for a basic palindrome check, but it does not implement the extra requirements."
+  },
+  "final_judgement": {
+    "adherence_score": 2,
+    "code_quality_score": 4,
+    "comments": "Major task requirement (ignoring case/spaces) omitted; otherwise, basic code is clean."
+  }
+}
+
+**Important reminders:**  
+- Always provide reasoning before your ratings and summary.
+- Never start with a conclusion.
+- Use the JSON schema strictly.
+- Use step-by-step analysis, and detailed explanations, and adjust your scores according to the scoring guidelines.
+
+**Reminder:**
+Evaluate how well the output follows instructions first, provide detailed reasoning, then give your overall numeric ratings for task adherence and code quality. Output in the specified JSON format only Do not be nice on scoring, be fair.
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/requirements.txt b/examples/gpt-5/prompt-optimization-cookbook/requirements.txt
new file mode 100644
index 0000000000..e7d8f9dccb
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/requirements.txt
@@ -0,0 +1,4 @@
+openai
+matplotlib 
+seaborn
+datasets
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_failsafeqa_baseline.csv b/examples/gpt-5/prompt-optimization-cookbook/results_failsafeqa_baseline.csv
new file mode 100644
index 0000000000..a399a32644
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_failsafeqa_baseline.csv
@@ -0,0 +1,1541 @@
+idx,kind,rating,compliance,answer_model,judge_model
+0,missing_context,6,1,gpt-5,gpt-5
+2,missing_context,6,1,gpt-5,gpt-5
+0,baseline,5,0,gpt-5,gpt-5
+2,incomplete,5,0,gpt-5,gpt-5
+0,ocr,5,0,gpt-5,gpt-5
+1,baseline,5,0,gpt-5,gpt-5
+1,incomplete,5,0,gpt-5,gpt-5
+0,misspelled,5,0,gpt-5,gpt-5
+1,out_of_domain,5,0,gpt-5,gpt-5
+0,out_of_domain,5,0,gpt-5,gpt-5
+1,misspelled,5,0,gpt-5,gpt-5
+0,incomplete,5,0,gpt-5,gpt-5
+1,missing_context,6,1,gpt-5,gpt-5
+2,misspelled,5,0,gpt-5,gpt-5
+1,out_of_scope,6,1,gpt-5,gpt-5
+0,out_of_scope,6,1,gpt-5,gpt-5
+2,baseline,5,0,gpt-5,gpt-5
+2,out_of_domain,5,0,gpt-5,gpt-5
+2,ocr,5,0,gpt-5,gpt-5
+1,ocr,5,0,gpt-5,gpt-5
+3,missing_context,6,1,gpt-5,gpt-5
+3,incomplete,6,1,gpt-5,gpt-5
+4,missing_context,6,1,gpt-5,gpt-5
+3,misspelled,6,1,gpt-5,gpt-5
+5,incomplete,5,0,gpt-5,gpt-5
+2,out_of_scope,5,0,gpt-5,gpt-5
+5,missing_context,6,1,gpt-5,gpt-5
+5,out_of_domain,5,0,gpt-5,gpt-5
+4,out_of_domain,1,0,gpt-5,gpt-5
+5,baseline,5,0,gpt-5,gpt-5
+3,out_of_domain,6,1,gpt-5,gpt-5
+4,incomplete,6,1,gpt-5,gpt-5
+3,out_of_scope,6,1,gpt-5,gpt-5
+3,ocr,6,1,gpt-5,gpt-5
+4,out_of_scope,6,1,gpt-5,gpt-5
+6,missing_context,6,1,gpt-5,gpt-5
+6,baseline,5,0,gpt-5,gpt-5
+6,incomplete,6,1,gpt-5,gpt-5
+3,baseline,6,1,gpt-5,gpt-5
+4,misspelled,3,0,gpt-5,gpt-5
+4,baseline,3,0,gpt-5,gpt-5
+6,misspelled,6,1,gpt-5,gpt-5
+6,ocr,5,0,gpt-5,gpt-5
+4,ocr,6,1,gpt-5,gpt-5
+7,missing_context,6,1,gpt-5,gpt-5
+6,out_of_domain,6,1,gpt-5,gpt-5
+5,out_of_scope,6,1,gpt-5,gpt-5
+8,baseline,5,0,gpt-5,gpt-5
+6,out_of_scope,6,1,gpt-5,gpt-5
+7,baseline,6,1,gpt-5,gpt-5
+7,out_of_scope,6,1,gpt-5,gpt-5
+8,incomplete,3,0,gpt-5,gpt-5
+8,out_of_scope,6,1,gpt-5,gpt-5
+8,ocr,6,1,gpt-5,gpt-5
+8,missing_context,6,1,gpt-5,gpt-5
+5,ocr,5,0,gpt-5,gpt-5
+9,out_of_domain,5,0,gpt-5,gpt-5
+7,out_of_domain,6,1,gpt-5,gpt-5
+8,out_of_domain,1,0,gpt-5,gpt-5
+9,misspelled,5,0,gpt-5,gpt-5
+9,incomplete,5,0,gpt-5,gpt-5
+8,misspelled,5,0,gpt-5,gpt-5
+9,missing_context,6,1,gpt-5,gpt-5
+7,misspelled,6,1,gpt-5,gpt-5
+9,baseline,5,0,gpt-5,gpt-5
+7,incomplete,6,1,gpt-5,gpt-5
+10,incomplete,5,0,gpt-5,gpt-5
+10,missing_context,6,1,gpt-5,gpt-5
+10,misspelled,5,0,gpt-5,gpt-5
+9,ocr,5,0,gpt-5,gpt-5
+10,ocr,5,0,gpt-5,gpt-5
+10,baseline,5,0,gpt-5,gpt-5
+7,ocr,6,1,gpt-5,gpt-5
+10,out_of_domain,5,0,gpt-5,gpt-5
+9,out_of_scope,6,1,gpt-5,gpt-5
+10,out_of_scope,6,1,gpt-5,gpt-5
+12,missing_context,6,1,gpt-5,gpt-5
+11,missing_context,6,1,gpt-5,gpt-5
+11,incomplete,6,1,gpt-5,gpt-5
+13,baseline,5,0,gpt-5,gpt-5
+13,out_of_domain,5,0,gpt-5,gpt-5
+13,misspelled,5,0,gpt-5,gpt-5
+13,ocr,5,0,gpt-5,gpt-5
+13,incomplete,5,0,gpt-5,gpt-5
+11,ocr,5,0,gpt-5,gpt-5
+13,missing_context,6,1,gpt-5,gpt-5
+11,misspelled,6,1,gpt-5,gpt-5
+12,baseline,4,0,gpt-5,gpt-5
+11,out_of_domain,6,1,gpt-5,gpt-5
+13,out_of_scope,6,1,gpt-5,gpt-5
+12,misspelled,4,0,gpt-5,gpt-5
+11,baseline,6,1,gpt-5,gpt-5
+12,incomplete,6,1,gpt-5,gpt-5
+14,baseline,5,0,gpt-5,gpt-5
+14,missing_context,6,1,gpt-5,gpt-5
+12,out_of_domain,6,1,gpt-5,gpt-5
+12,ocr,6,1,gpt-5,gpt-5
+14,incomplete,5,0,gpt-5,gpt-5
+11,out_of_scope,5,0,gpt-5,gpt-5
+15,baseline,6,1,gpt-5,gpt-5
+14,ocr,5,0,gpt-5,gpt-5
+15,missing_context,6,1,gpt-5,gpt-5
+14,misspelled,5,0,gpt-5,gpt-5
+15,incomplete,6,1,gpt-5,gpt-5
+16,missing_context,6,1,gpt-5,gpt-5
+14,out_of_domain,6,1,gpt-5,gpt-5
+15,misspelled,6,1,gpt-5,gpt-5
+12,out_of_scope,1,0,gpt-5,gpt-5
+14,out_of_scope,5,0,gpt-5,gpt-5
+15,ocr,6,1,gpt-5,gpt-5
+16,misspelled,5,0,gpt-5,gpt-5
+15,out_of_domain,6,1,gpt-5,gpt-5
+16,baseline,5,0,gpt-5,gpt-5
+16,out_of_domain,5,0,gpt-5,gpt-5
+17,missing_context,6,1,gpt-5,gpt-5
+15,out_of_scope,6,1,gpt-5,gpt-5
+17,misspelled,4,0,gpt-5,gpt-5
+16,ocr,5,0,gpt-5,gpt-5
+16,incomplete,6,1,gpt-5,gpt-5
+19,baseline,5,0,gpt-5,gpt-5
+17,out_of_domain,5,0,gpt-5,gpt-5
+17,out_of_scope,6,1,gpt-5,gpt-5
+18,missing_context,6,1,gpt-5,gpt-5
+16,out_of_scope,6,1,gpt-5,gpt-5
+17,incomplete,4,0,gpt-5,gpt-5
+19,missing_context,6,1,gpt-5,gpt-5
+18,out_of_scope,6,1,gpt-5,gpt-5
+19,incomplete,5,0,gpt-5,gpt-5
+19,misspelled,5,0,gpt-5,gpt-5
+17,ocr,4,0,gpt-5,gpt-5
+19,ocr,5,0,gpt-5,gpt-5
+19,out_of_domain,5,0,gpt-5,gpt-5
+20,incomplete,5,0,gpt-5,gpt-5
+17,baseline,4,0,gpt-5,gpt-5
+20,out_of_domain,5,0,gpt-5,gpt-5
+20,missing_context,6,1,gpt-5,gpt-5
+20,ocr,5,0,gpt-5,gpt-5
+18,incomplete,6,1,gpt-5,gpt-5
+21,baseline,5,0,gpt-5,gpt-5
+18,baseline,4,0,gpt-5,gpt-5
+20,misspelled,5,0,gpt-5,gpt-5
+21,out_of_domain,5,0,gpt-5,gpt-5
+21,misspelled,5,0,gpt-5,gpt-5
+20,baseline,5,0,gpt-5,gpt-5
+21,missing_context,6,1,gpt-5,gpt-5
+18,misspelled,4,0,gpt-5,gpt-5
+18,ocr,6,1,gpt-5,gpt-5
+21,ocr,5,0,gpt-5,gpt-5
+21,incomplete,5,0,gpt-5,gpt-5
+22,misspelled,6,1,gpt-5,gpt-5
+18,out_of_domain,4,0,gpt-5,gpt-5
+23,missing_context,6,1,gpt-5,gpt-5
+23,incomplete,5,0,gpt-5,gpt-5
+23,out_of_domain,5,0,gpt-5,gpt-5
+21,out_of_scope,6,1,gpt-5,gpt-5
+20,out_of_scope,4,0,gpt-5,gpt-5
+22,baseline,6,1,gpt-5,gpt-5
+23,ocr,5,0,gpt-5,gpt-5
+23,baseline,5,0,gpt-5,gpt-5
+22,incomplete,6,1,gpt-5,gpt-5
+23,misspelled,5,0,gpt-5,gpt-5
+22,out_of_domain,6,1,gpt-5,gpt-5
+22,out_of_scope,6,1,gpt-5,gpt-5
+24,missing_context,6,1,gpt-5,gpt-5
+22,ocr,6,1,gpt-5,gpt-5
+25,misspelled,5,0,gpt-5,gpt-5
+24,misspelled,6,1,gpt-5,gpt-5
+25,missing_context,6,1,gpt-5,gpt-5
+24,out_of_scope,6,1,gpt-5,gpt-5
+25,out_of_scope,6,1,gpt-5,gpt-5
+25,baseline,5,0,gpt-5,gpt-5
+24,out_of_domain,6,1,gpt-5,gpt-5
+22,missing_context,6,1,gpt-5,gpt-5
+25,out_of_domain,5,0,gpt-5,gpt-5
+23,out_of_scope,6,1,gpt-5,gpt-5
+24,baseline,6,1,gpt-5,gpt-5
+25,incomplete,5,0,gpt-5,gpt-5
+24,incomplete,5,0,gpt-5,gpt-5
+24,ocr,6,1,gpt-5,gpt-5
+26,missing_context,6,1,gpt-5,gpt-5
+25,ocr,5,0,gpt-5,gpt-5
+27,baseline,5,0,gpt-5,gpt-5
+26,incomplete,6,1,gpt-5,gpt-5
+19,out_of_scope,6,1,gpt-5,gpt-5
+26,out_of_domain,6,1,gpt-5,gpt-5
+27,ocr,5,0,gpt-5,gpt-5
+26,baseline,6,1,gpt-5,gpt-5
+27,missing_context,6,1,gpt-5,gpt-5
+27,misspelled,5,0,gpt-5,gpt-5
+26,misspelled,6,1,gpt-5,gpt-5
+27,incomplete,5,0,gpt-5,gpt-5
+28,missing_context,6,1,gpt-5,gpt-5
+27,out_of_domain,5,0,gpt-5,gpt-5
+28,out_of_domain,6,1,gpt-5,gpt-5
+28,ocr,6,1,gpt-5,gpt-5
+26,out_of_scope,6,1,gpt-5,gpt-5
+28,misspelled,6,1,gpt-5,gpt-5
+29,missing_context,6,1,gpt-5,gpt-5
+27,out_of_scope,5,0,gpt-5,gpt-5
+30,missing_context,6,1,gpt-5,gpt-5
+28,baseline,6,1,gpt-5,gpt-5
+30,baseline,6,1,gpt-5,gpt-5
+28,incomplete,6,1,gpt-5,gpt-5
+26,ocr,6,1,gpt-5,gpt-5
+28,out_of_scope,6,1,gpt-5,gpt-5
+30,incomplete,6,1,gpt-5,gpt-5
+30,out_of_scope,6,1,gpt-5,gpt-5
+30,out_of_domain,6,1,gpt-5,gpt-5
+29,baseline,6,1,gpt-5,gpt-5
+31,missing_context,6,1,gpt-5,gpt-5
+29,out_of_scope,4,0,gpt-5,gpt-5
+30,misspelled,6,1,gpt-5,gpt-5
+32,incomplete,5,0,gpt-5,gpt-5
+29,ocr,6,1,gpt-5,gpt-5
+29,incomplete,6,1,gpt-5,gpt-5
+29,out_of_domain,6,1,gpt-5,gpt-5
+32,misspelled,5,0,gpt-5,gpt-5
+29,misspelled,6,1,gpt-5,gpt-5
+32,baseline,5,0,gpt-5,gpt-5
+32,out_of_domain,5,0,gpt-5,gpt-5
+32,missing_context,6,1,gpt-5,gpt-5
+32,ocr,5,0,gpt-5,gpt-5
+31,out_of_scope,6,1,gpt-5,gpt-5
+31,baseline,6,1,gpt-5,gpt-5
+33,missing_context,6,1,gpt-5,gpt-5
+32,out_of_scope,5,0,gpt-5,gpt-5
+34,baseline,6,1,gpt-5,gpt-5
+31,out_of_domain,6,1,gpt-5,gpt-5
+34,misspelled,6,1,gpt-5,gpt-5
+34,out_of_domain,5,0,gpt-5,gpt-5
+34,incomplete,6,1,gpt-5,gpt-5
+31,misspelled,6,1,gpt-5,gpt-5
+34,ocr,5,0,gpt-5,gpt-5
+34,missing_context,6,1,gpt-5,gpt-5
+33,baseline,6,1,gpt-5,gpt-5
+31,incomplete,6,1,gpt-5,gpt-5
+31,ocr,6,1,gpt-5,gpt-5
+33,incomplete,6,1,gpt-5,gpt-5
+35,missing_context,6,1,gpt-5,gpt-5
+35,ocr,5,0,gpt-5,gpt-5
+35,misspelled,5,0,gpt-5,gpt-5
+35,baseline,5,0,gpt-5,gpt-5
+30,ocr,5,0,gpt-5,gpt-5
+33,misspelled,6,1,gpt-5,gpt-5
+33,out_of_domain,6,1,gpt-5,gpt-5
+34,out_of_scope,5,0,gpt-5,gpt-5
+36,missing_context,6,1,gpt-5,gpt-5
+33,ocr,6,1,gpt-5,gpt-5
+35,out_of_domain,5,0,gpt-5,gpt-5
+37,baseline,5,0,gpt-5,gpt-5
+35,out_of_scope,5,0,gpt-5,gpt-5
+37,incomplete,5,0,gpt-5,gpt-5
+36,out_of_domain,5,0,gpt-5,gpt-5
+35,incomplete,6,1,gpt-5,gpt-5
+37,out_of_domain,5,0,gpt-5,gpt-5
+37,missing_context,6,1,gpt-5,gpt-5
+37,misspelled,5,0,gpt-5,gpt-5
+36,misspelled,6,1,gpt-5,gpt-5
+36,out_of_scope,4,0,gpt-5,gpt-5
+38,baseline,5,0,gpt-5,gpt-5
+36,incomplete,6,1,gpt-5,gpt-5
+38,missing_context,6,1,gpt-5,gpt-5
+39,baseline,5,0,gpt-5,gpt-5
+36,baseline,6,1,gpt-5,gpt-5
+37,out_of_scope,5,0,gpt-5,gpt-5
+37,ocr,5,0,gpt-5,gpt-5
+38,out_of_domain,5,0,gpt-5,gpt-5
+38,incomplete,5,0,gpt-5,gpt-5
+39,incomplete,5,0,gpt-5,gpt-5
+39,missing_context,6,1,gpt-5,gpt-5
+38,ocr,5,0,gpt-5,gpt-5
+38,out_of_scope,6,1,gpt-5,gpt-5
+39,ocr,5,0,gpt-5,gpt-5
+38,misspelled,5,0,gpt-5,gpt-5
+39,misspelled,5,0,gpt-5,gpt-5
+40,misspelled,6,1,gpt-5,gpt-5
+40,incomplete,6,1,gpt-5,gpt-5
+40,baseline,6,1,gpt-5,gpt-5
+39,out_of_domain,5,0,gpt-5,gpt-5
+39,out_of_scope,5,0,gpt-5,gpt-5
+41,baseline,5,0,gpt-5,gpt-5
+40,out_of_domain,6,1,gpt-5,gpt-5
+41,missing_context,6,1,gpt-5,gpt-5
+40,missing_context,6,1,gpt-5,gpt-5
+41,incomplete,5,0,gpt-5,gpt-5
+41,misspelled,5,0,gpt-5,gpt-5
+42,baseline,6,1,gpt-5,gpt-5
+42,misspelled,5,0,gpt-5,gpt-5
+41,out_of_domain,5,0,gpt-5,gpt-5
+40,ocr,6,1,gpt-5,gpt-5
+42,out_of_domain,5,0,gpt-5,gpt-5
+41,ocr,5,0,gpt-5,gpt-5
+42,out_of_scope,6,1,gpt-5,gpt-5
+36,ocr,6,1,gpt-5,gpt-5
+42,missing_context,6,1,gpt-5,gpt-5
+42,incomplete,6,1,gpt-5,gpt-5
+43,incomplete,5,0,gpt-5,gpt-5
+43,misspelled,5,0,gpt-5,gpt-5
+40,out_of_scope,5,0,gpt-5,gpt-5
+33,out_of_scope,6,1,gpt-5,gpt-5
+41,out_of_scope,6,1,gpt-5,gpt-5
+43,missing_context,6,1,gpt-5,gpt-5
+43,out_of_domain,5,0,gpt-5,gpt-5
+43,baseline,5,0,gpt-5,gpt-5
+43,out_of_scope,6,1,gpt-5,gpt-5
+44,ocr,4,0,gpt-5,gpt-5
+43,ocr,5,0,gpt-5,gpt-5
+44,missing_context,6,1,gpt-5,gpt-5
+44,incomplete,5,0,gpt-5,gpt-5
+44,out_of_domain,4,0,gpt-5,gpt-5
+44,baseline,5,0,gpt-5,gpt-5
+45,missing_context,6,1,gpt-5,gpt-5
+42,ocr,3,0,gpt-5,gpt-5
+46,missing_context,6,1,gpt-5,gpt-5
+44,out_of_scope,6,1,gpt-5,gpt-5
+44,misspelled,5,0,gpt-5,gpt-5
+46,misspelled,4,0,gpt-5,gpt-5
+46,baseline,4,0,gpt-5,gpt-5
+46,out_of_scope,6,1,gpt-5,gpt-5
+45,out_of_scope,5,0,gpt-5,gpt-5
+45,baseline,6,1,gpt-5,gpt-5
+47,missing_context,6,1,gpt-5,gpt-5
+45,incomplete,6,1,gpt-5,gpt-5
+45,misspelled,6,1,gpt-5,gpt-5
+45,out_of_domain,6,1,gpt-5,gpt-5
+47,baseline,6,1,gpt-5,gpt-5
+46,ocr,5,0,gpt-5,gpt-5
+46,incomplete,4,0,gpt-5,gpt-5
+45,ocr,6,1,gpt-5,gpt-5
+48,baseline,5,0,gpt-5,gpt-5
+47,misspelled,6,1,gpt-5,gpt-5
+48,missing_context,6,1,gpt-5,gpt-5
+47,out_of_domain,6,1,gpt-5,gpt-5
+47,ocr,6,1,gpt-5,gpt-5
+48,ocr,5,0,gpt-5,gpt-5
+48,incomplete,5,0,gpt-5,gpt-5
+48,out_of_domain,5,0,gpt-5,gpt-5
+49,missing_context,6,1,gpt-5,gpt-5
+48,misspelled,5,0,gpt-5,gpt-5
+47,incomplete,6,1,gpt-5,gpt-5
+50,baseline,6,1,gpt-5,gpt-5
+47,out_of_scope,5,0,gpt-5,gpt-5
+46,out_of_domain,4,0,gpt-5,gpt-5
+48,out_of_scope,4,0,gpt-5,gpt-5
+50,missing_context,6,1,gpt-5,gpt-5
+49,out_of_scope,6,1,gpt-5,gpt-5
+49,out_of_domain,6,1,gpt-5,gpt-5
+50,misspelled,5,0,gpt-5,gpt-5
+51,missing_context,6,1,gpt-5,gpt-5
+50,ocr,6,1,gpt-5,gpt-5
+49,baseline,6,1,gpt-5,gpt-5
+49,misspelled,6,1,gpt-5,gpt-5
+50,out_of_domain,6,1,gpt-5,gpt-5
+50,incomplete,6,1,gpt-5,gpt-5
+51,out_of_domain,2,0,gpt-5,gpt-5
+52,baseline,6,1,gpt-5,gpt-5
+52,incomplete,6,1,gpt-5,gpt-5
+51,misspelled,6,1,gpt-5,gpt-5
+51,incomplete,6,1,gpt-5,gpt-5
+50,out_of_scope,5,0,gpt-5,gpt-5
+49,incomplete,6,1,gpt-5,gpt-5
+52,missing_context,6,1,gpt-5,gpt-5
+49,ocr,6,1,gpt-5,gpt-5
+52,out_of_scope,5,0,gpt-5,gpt-5
+51,out_of_scope,5,0,gpt-5,gpt-5
+53,missing_context,6,1,gpt-5,gpt-5
+52,out_of_domain,6,1,gpt-5,gpt-5
+51,ocr,6,1,gpt-5,gpt-5
+51,baseline,6,1,gpt-5,gpt-5
+52,misspelled,6,1,gpt-5,gpt-5
+53,misspelled,6,1,gpt-5,gpt-5
+52,ocr,6,1,gpt-5,gpt-5
+53,ocr,6,1,gpt-5,gpt-5
+53,baseline,6,1,gpt-5,gpt-5
+54,missing_context,6,1,gpt-5,gpt-5
+55,baseline,6,1,gpt-5,gpt-5
+54,out_of_scope,6,1,gpt-5,gpt-5
+53,out_of_scope,4,0,gpt-5,gpt-5
+54,misspelled,6,1,gpt-5,gpt-5
+55,missing_context,6,1,gpt-5,gpt-5
+54,out_of_domain,6,1,gpt-5,gpt-5
+55,incomplete,6,1,gpt-5,gpt-5
+53,out_of_domain,6,1,gpt-5,gpt-5
+55,out_of_domain,6,1,gpt-5,gpt-5
+55,misspelled,6,1,gpt-5,gpt-5
+56,baseline,5,0,gpt-5,gpt-5
+54,incomplete,6,1,gpt-5,gpt-5
+56,incomplete,5,0,gpt-5,gpt-5
+54,ocr,6,1,gpt-5,gpt-5
+56,missing_context,6,1,gpt-5,gpt-5
+55,out_of_scope,4,0,gpt-5,gpt-5
+55,ocr,4,0,gpt-5,gpt-5
+56,ocr,5,0,gpt-5,gpt-5
+57,misspelled,5,0,gpt-5,gpt-5
+56,out_of_domain,5,0,gpt-5,gpt-5
+57,baseline,5,0,gpt-5,gpt-5
+54,baseline,6,1,gpt-5,gpt-5
+57,ocr,5,0,gpt-5,gpt-5
+58,baseline,5,0,gpt-5,gpt-5
+57,missing_context,6,1,gpt-5,gpt-5
+53,incomplete,6,1,gpt-5,gpt-5
+57,incomplete,6,1,gpt-5,gpt-5
+56,out_of_scope,6,1,gpt-5,gpt-5
+58,missing_context,6,1,gpt-5,gpt-5
+59,misspelled,5,0,gpt-5,gpt-5
+57,out_of_domain,5,0,gpt-5,gpt-5
+59,baseline,5,0,gpt-5,gpt-5
+58,incomplete,4,0,gpt-5,gpt-5
+57,out_of_scope,5,0,gpt-5,gpt-5
+59,out_of_domain,5,0,gpt-5,gpt-5
+59,missing_context,6,1,gpt-5,gpt-5
+59,ocr,5,0,gpt-5,gpt-5
+58,out_of_domain,5,0,gpt-5,gpt-5
+58,ocr,5,0,gpt-5,gpt-5
+58,misspelled,5,0,gpt-5,gpt-5
+59,out_of_scope,6,1,gpt-5,gpt-5
+60,missing_context,6,1,gpt-5,gpt-5
+58,out_of_scope,6,1,gpt-5,gpt-5
+59,incomplete,5,0,gpt-5,gpt-5
+61,missing_context,6,1,gpt-5,gpt-5
+61,incomplete,6,1,gpt-5,gpt-5
+61,ocr,6,1,gpt-5,gpt-5
+60,out_of_scope,4,0,gpt-5,gpt-5
+61,out_of_scope,6,1,gpt-5,gpt-5
+61,misspelled,6,1,gpt-5,gpt-5
+62,missing_context,6,1,gpt-5,gpt-5
+60,out_of_domain,6,1,gpt-5,gpt-5
+61,baseline,6,1,gpt-5,gpt-5
+60,incomplete,4,0,gpt-5,gpt-5
+60,baseline,6,1,gpt-5,gpt-5
+62,out_of_scope,6,1,gpt-5,gpt-5
+63,missing_context,6,1,gpt-5,gpt-5
+61,out_of_domain,6,1,gpt-5,gpt-5
+63,out_of_scope,6,1,gpt-5,gpt-5
+64,baseline,5,0,gpt-5,gpt-5
+64,incomplete,6,1,gpt-5,gpt-5
+64,missing_context,6,1,gpt-5,gpt-5
+64,out_of_domain,6,1,gpt-5,gpt-5
+62,ocr,6,1,gpt-5,gpt-5
+64,misspelled,5,0,gpt-5,gpt-5
+60,ocr,4,0,gpt-5,gpt-5
+64,ocr,5,0,gpt-5,gpt-5
+62,out_of_domain,6,1,gpt-5,gpt-5
+62,misspelled,6,1,gpt-5,gpt-5
+62,baseline,6,1,gpt-5,gpt-5
+65,baseline,5,0,gpt-5,gpt-5
+63,out_of_domain,6,1,gpt-5,gpt-5
+65,misspelled,5,0,gpt-5,gpt-5
+63,baseline,6,1,gpt-5,gpt-5
+65,out_of_domain,5,0,gpt-5,gpt-5
+62,incomplete,6,1,gpt-5,gpt-5
+64,out_of_scope,5,0,gpt-5,gpt-5
+65,out_of_scope,6,1,gpt-5,gpt-5
+66,missing_context,6,1,gpt-5,gpt-5
+65,ocr,5,0,gpt-5,gpt-5
+66,baseline,5,0,gpt-5,gpt-5
+66,misspelled,5,0,gpt-5,gpt-5
+65,incomplete,6,1,gpt-5,gpt-5
+65,missing_context,6,1,gpt-5,gpt-5
+63,incomplete,6,1,gpt-5,gpt-5
+60,misspelled,6,1,gpt-5,gpt-5
+63,misspelled,6,1,gpt-5,gpt-5
+66,ocr,5,0,gpt-5,gpt-5
+66,out_of_domain,5,0,gpt-5,gpt-5
+66,incomplete,5,0,gpt-5,gpt-5
+67,missing_context,6,1,gpt-5,gpt-5
+67,out_of_scope,6,1,gpt-5,gpt-5
+68,missing_context,6,1,gpt-5,gpt-5
+63,ocr,6,1,gpt-5,gpt-5
+67,misspelled,6,1,gpt-5,gpt-5
+66,out_of_scope,6,1,gpt-5,gpt-5
+67,out_of_domain,6,1,gpt-5,gpt-5
+67,baseline,6,1,gpt-5,gpt-5
+69,incomplete,6,1,gpt-5,gpt-5
+67,incomplete,6,1,gpt-5,gpt-5
+68,out_of_scope,5,0,gpt-5,gpt-5
+68,out_of_domain,2,0,gpt-5,gpt-5
+69,missing_context,6,1,gpt-5,gpt-5
+69,out_of_scope,6,1,gpt-5,gpt-5
+69,baseline,5,0,gpt-5,gpt-5
+70,misspelled,5,0,gpt-5,gpt-5
+68,incomplete,4,0,gpt-5,gpt-5
+69,misspelled,5,0,gpt-5,gpt-5
+67,ocr,3,0,gpt-5,gpt-5
+68,misspelled,6,1,gpt-5,gpt-5
+70,baseline,5,0,gpt-5,gpt-5
+70,missing_context,6,1,gpt-5,gpt-5
+70,incomplete,5,0,gpt-5,gpt-5
+68,ocr,6,1,gpt-5,gpt-5
+70,ocr,5,0,gpt-5,gpt-5
+70,out_of_domain,6,1,gpt-5,gpt-5
+71,missing_context,6,1,gpt-5,gpt-5
+71,ocr,5,0,gpt-5,gpt-5
+69,ocr,5,0,gpt-5,gpt-5
+70,out_of_scope,6,1,gpt-5,gpt-5
+71,baseline,5,0,gpt-5,gpt-5
+71,misspelled,6,1,gpt-5,gpt-5
+68,baseline,4,0,gpt-5,gpt-5
+71,out_of_domain,5,0,gpt-5,gpt-5
+72,out_of_domain,5,0,gpt-5,gpt-5
+72,missing_context,6,1,gpt-5,gpt-5
+72,misspelled,5,0,gpt-5,gpt-5
+69,out_of_domain,6,1,gpt-5,gpt-5
+72,ocr,5,0,gpt-5,gpt-5
+72,incomplete,5,0,gpt-5,gpt-5
+72,baseline,5,0,gpt-5,gpt-5
+71,out_of_scope,5,0,gpt-5,gpt-5
+73,baseline,5,0,gpt-5,gpt-5
+73,out_of_domain,5,0,gpt-5,gpt-5
+71,incomplete,6,1,gpt-5,gpt-5
+73,missing_context,6,1,gpt-5,gpt-5
+73,incomplete,5,0,gpt-5,gpt-5
+72,out_of_scope,6,1,gpt-5,gpt-5
+73,misspelled,5,0,gpt-5,gpt-5
+74,missing_context,6,1,gpt-5,gpt-5
+74,baseline,2,0,gpt-5,gpt-5
+73,out_of_scope,5,0,gpt-5,gpt-5
+73,ocr,4,0,gpt-5,gpt-5
+75,missing_context,6,1,gpt-5,gpt-5
+75,misspelled,6,1,gpt-5,gpt-5
+76,baseline,5,0,gpt-5,gpt-5
+74,out_of_scope,6,1,gpt-5,gpt-5
+74,ocr,5,0,gpt-5,gpt-5
+76,misspelled,5,0,gpt-5,gpt-5
+74,misspelled,3,0,gpt-5,gpt-5
+75,incomplete,6,1,gpt-5,gpt-5
+74,incomplete,5,0,gpt-5,gpt-5
+75,baseline,6,1,gpt-5,gpt-5
+75,out_of_domain,5,0,gpt-5,gpt-5
+76,incomplete,5,0,gpt-5,gpt-5
+76,ocr,5,0,gpt-5,gpt-5
+5,misspelled,5,0,gpt-5,gpt-5
+75,out_of_scope,5,0,gpt-5,gpt-5
+75,ocr,6,1,gpt-5,gpt-5
+77,missing_context,6,1,gpt-5,gpt-5
+74,out_of_domain,4,0,gpt-5,gpt-5
+76,missing_context,6,1,gpt-5,gpt-5
+78,missing_context,6,1,gpt-5,gpt-5
+76,out_of_domain,6,1,gpt-5,gpt-5
+76,out_of_scope,5,0,gpt-5,gpt-5
+77,baseline,6,1,gpt-5,gpt-5
+77,out_of_scope,4,0,gpt-5,gpt-5
+78,incomplete,6,1,gpt-5,gpt-5
+79,misspelled,5,0,gpt-5,gpt-5
+79,missing_context,6,1,gpt-5,gpt-5
+77,misspelled,6,1,gpt-5,gpt-5
+78,baseline,6,1,gpt-5,gpt-5
+78,out_of_scope,6,1,gpt-5,gpt-5
+78,misspelled,5,0,gpt-5,gpt-5
+79,incomplete,5,0,gpt-5,gpt-5
+79,baseline,5,0,gpt-5,gpt-5
+77,ocr,6,1,gpt-5,gpt-5
+80,missing_context,6,1,gpt-5,gpt-5
+77,out_of_domain,6,1,gpt-5,gpt-5
+79,ocr,5,0,gpt-5,gpt-5
+79,out_of_domain,6,1,gpt-5,gpt-5
+78,out_of_domain,5,0,gpt-5,gpt-5
+77,incomplete,6,1,gpt-5,gpt-5
+79,out_of_scope,6,1,gpt-5,gpt-5
+78,ocr,3,0,gpt-5,gpt-5
+81,missing_context,6,1,gpt-5,gpt-5
+80,incomplete,6,1,gpt-5,gpt-5
+80,out_of_scope,4,0,gpt-5,gpt-5
+81,misspelled,6,1,gpt-5,gpt-5
+80,ocr,4,0,gpt-5,gpt-5
+80,misspelled,4,0,gpt-5,gpt-5
+81,baseline,6,1,gpt-5,gpt-5
+82,out_of_domain,5,0,gpt-5,gpt-5
+81,out_of_domain,6,1,gpt-5,gpt-5
+81,incomplete,6,1,gpt-5,gpt-5
+82,baseline,5,0,gpt-5,gpt-5
+80,baseline,4,0,gpt-5,gpt-5
+82,missing_context,6,1,gpt-5,gpt-5
+82,ocr,5,0,gpt-5,gpt-5
+82,misspelled,5,0,gpt-5,gpt-5
+82,out_of_scope,6,1,gpt-5,gpt-5
+82,incomplete,5,0,gpt-5,gpt-5
+83,incomplete,5,0,gpt-5,gpt-5
+81,ocr,4,0,gpt-5,gpt-5
+80,out_of_domain,4,0,gpt-5,gpt-5
+83,missing_context,6,1,gpt-5,gpt-5
+84,missing_context,6,1,gpt-5,gpt-5
+84,baseline,5,0,gpt-5,gpt-5
+83,baseline,5,0,gpt-5,gpt-5
+84,incomplete,5,0,gpt-5,gpt-5
+84,misspelled,5,0,gpt-5,gpt-5
+81,out_of_scope,4,0,gpt-5,gpt-5
+83,ocr,5,0,gpt-5,gpt-5
+83,misspelled,5,0,gpt-5,gpt-5
+84,out_of_domain,5,0,gpt-5,gpt-5
+85,missing_context,6,1,gpt-5,gpt-5
+86,missing_context,6,1,gpt-5,gpt-5
+86,ocr,5,0,gpt-5,gpt-5
+83,out_of_domain,6,1,gpt-5,gpt-5
+86,baseline,5,0,gpt-5,gpt-5
+83,out_of_scope,5,0,gpt-5,gpt-5
+86,incomplete,5,0,gpt-5,gpt-5
+86,misspelled,5,0,gpt-5,gpt-5
+85,misspelled,3,0,gpt-5,gpt-5
+86,out_of_domain,6,1,gpt-5,gpt-5
+85,out_of_domain,3,0,gpt-5,gpt-5
+86,out_of_scope,6,1,gpt-5,gpt-5
+84,out_of_scope,6,1,gpt-5,gpt-5
+87,missing_context,6,1,gpt-5,gpt-5
+85,baseline,4,0,gpt-5,gpt-5
+85,out_of_scope,6,1,gpt-5,gpt-5
+85,ocr,3,0,gpt-5,gpt-5
+85,incomplete,3,0,gpt-5,gpt-5
+84,ocr,3,0,gpt-5,gpt-5
+88,out_of_scope,6,1,gpt-5,gpt-5
+89,baseline,5,0,gpt-5,gpt-5
+89,misspelled,5,0,gpt-5,gpt-5
+89,incomplete,4,0,gpt-5,gpt-5
+89,missing_context,6,1,gpt-5,gpt-5
+89,out_of_domain,6,1,gpt-5,gpt-5
+87,baseline,6,1,gpt-5,gpt-5
+88,missing_context,6,1,gpt-5,gpt-5
+89,ocr,5,0,gpt-5,gpt-5
+87,out_of_scope,6,1,gpt-5,gpt-5
+90,missing_context,6,1,gpt-5,gpt-5
+87,misspelled,6,1,gpt-5,gpt-5
+87,out_of_domain,6,1,gpt-5,gpt-5
+87,ocr,4,0,gpt-5,gpt-5
+90,incomplete,6,1,gpt-5,gpt-5
+88,baseline,6,1,gpt-5,gpt-5
+90,misspelled,6,1,gpt-5,gpt-5
+90,out_of_scope,4,0,gpt-5,gpt-5
+91,missing_context,6,1,gpt-5,gpt-5
+88,misspelled,6,1,gpt-5,gpt-5
+89,out_of_scope,5,0,gpt-5,gpt-5
+90,baseline,6,1,gpt-5,gpt-5
+88,incomplete,6,1,gpt-5,gpt-5
+88,out_of_domain,4,0,gpt-5,gpt-5
+88,ocr,6,1,gpt-5,gpt-5
+90,ocr,6,1,gpt-5,gpt-5
+91,baseline,4,0,gpt-5,gpt-5
+91,incomplete,6,1,gpt-5,gpt-5
+91,misspelled,6,1,gpt-5,gpt-5
+92,missing_context,6,1,gpt-5,gpt-5
+87,incomplete,6,1,gpt-5,gpt-5
+93,misspelled,5,0,gpt-5,gpt-5
+91,out_of_domain,6,1,gpt-5,gpt-5
+90,out_of_domain,6,1,gpt-5,gpt-5
+91,out_of_scope,6,1,gpt-5,gpt-5
+93,out_of_domain,5,0,gpt-5,gpt-5
+92,out_of_scope,5,0,gpt-5,gpt-5
+93,missing_context,6,1,gpt-5,gpt-5
+93,incomplete,6,1,gpt-5,gpt-5
+93,ocr,5,0,gpt-5,gpt-5
+92,incomplete,6,1,gpt-5,gpt-5
+93,baseline,5,0,gpt-5,gpt-5
+91,ocr,6,1,gpt-5,gpt-5
+92,out_of_domain,4,0,gpt-5,gpt-5
+92,baseline,6,1,gpt-5,gpt-5
+92,ocr,6,1,gpt-5,gpt-5
+94,missing_context,6,1,gpt-5,gpt-5
+92,misspelled,6,1,gpt-5,gpt-5
+94,incomplete,6,1,gpt-5,gpt-5
+94,baseline,5,0,gpt-5,gpt-5
+95,baseline,5,0,gpt-5,gpt-5
+95,incomplete,5,0,gpt-5,gpt-5
+94,out_of_domain,5,0,gpt-5,gpt-5
+93,out_of_scope,6,1,gpt-5,gpt-5
+95,missing_context,6,1,gpt-5,gpt-5
+94,misspelled,5,0,gpt-5,gpt-5
+95,misspelled,5,0,gpt-5,gpt-5
+95,ocr,5,0,gpt-5,gpt-5
+96,missing_context,6,1,gpt-5,gpt-5
+95,out_of_domain,5,0,gpt-5,gpt-5
+94,out_of_scope,6,1,gpt-5,gpt-5
+96,incomplete,5,0,gpt-5,gpt-5
+97,baseline,5,0,gpt-5,gpt-5
+96,misspelled,5,0,gpt-5,gpt-5
+97,missing_context,6,1,gpt-5,gpt-5
+94,ocr,5,0,gpt-5,gpt-5
+97,misspelled,5,0,gpt-5,gpt-5
+96,ocr,5,0,gpt-5,gpt-5
+96,baseline,6,1,gpt-5,gpt-5
+96,out_of_domain,6,1,gpt-5,gpt-5
+96,out_of_scope,5,0,gpt-5,gpt-5
+95,out_of_scope,5,0,gpt-5,gpt-5
+98,incomplete,5,0,gpt-5,gpt-5
+97,ocr,5,0,gpt-5,gpt-5
+98,missing_context,6,1,gpt-5,gpt-5
+99,missing_context,6,1,gpt-5,gpt-5
+98,misspelled,5,0,gpt-5,gpt-5
+97,incomplete,6,1,gpt-5,gpt-5
+98,ocr,5,0,gpt-5,gpt-5
+98,baseline,5,0,gpt-5,gpt-5
+98,out_of_scope,6,1,gpt-5,gpt-5
+97,out_of_domain,6,1,gpt-5,gpt-5
+101,baseline,5,0,gpt-5,gpt-5
+99,out_of_scope,5,0,gpt-5,gpt-5
+99,incomplete,6,1,gpt-5,gpt-5
+99,out_of_domain,4,0,gpt-5,gpt-5
+98,out_of_domain,6,1,gpt-5,gpt-5
+99,baseline,4,0,gpt-5,gpt-5
+101,misspelled,6,1,gpt-5,gpt-5
+99,ocr,6,1,gpt-5,gpt-5
+100,missing_context,6,1,gpt-5,gpt-5
+99,misspelled,4,0,gpt-5,gpt-5
+100,baseline,2,0,gpt-5,gpt-5
+101,incomplete,6,1,gpt-5,gpt-5
+100,incomplete,5,0,gpt-5,gpt-5
+101,missing_context,6,1,gpt-5,gpt-5
+101,out_of_domain,5,0,gpt-5,gpt-5
+97,out_of_scope,6,1,gpt-5,gpt-5
+100,out_of_scope,6,1,gpt-5,gpt-5
+102,missing_context,6,1,gpt-5,gpt-5
+102,baseline,5,0,gpt-5,gpt-5
+100,out_of_domain,2,0,gpt-5,gpt-5
+103,baseline,5,0,gpt-5,gpt-5
+102,incomplete,5,0,gpt-5,gpt-5
+101,ocr,6,1,gpt-5,gpt-5
+102,out_of_domain,5,0,gpt-5,gpt-5
+103,out_of_domain,5,0,gpt-5,gpt-5
+103,missing_context,6,1,gpt-5,gpt-5
+100,ocr,5,0,gpt-5,gpt-5
+102,ocr,5,0,gpt-5,gpt-5
+103,incomplete,5,0,gpt-5,gpt-5
+102,misspelled,5,0,gpt-5,gpt-5
+103,ocr,5,0,gpt-5,gpt-5
+101,out_of_scope,4,0,gpt-5,gpt-5
+102,out_of_scope,4,0,gpt-5,gpt-5
+103,out_of_scope,6,1,gpt-5,gpt-5
+103,misspelled,6,1,gpt-5,gpt-5
+104,missing_context,6,1,gpt-5,gpt-5
+100,misspelled,5,0,gpt-5,gpt-5
+105,missing_context,6,1,gpt-5,gpt-5
+104,out_of_scope,6,1,gpt-5,gpt-5
+104,incomplete,6,1,gpt-5,gpt-5
+106,missing_context,6,1,gpt-5,gpt-5
+105,out_of_scope,6,1,gpt-5,gpt-5
+104,ocr,6,1,gpt-5,gpt-5
+104,misspelled,6,1,gpt-5,gpt-5
+104,baseline,6,1,gpt-5,gpt-5
+106,incomplete,6,1,gpt-5,gpt-5
+106,out_of_scope,6,1,gpt-5,gpt-5
+104,out_of_domain,6,1,gpt-5,gpt-5
+106,baseline,6,1,gpt-5,gpt-5
+107,baseline,6,1,gpt-5,gpt-5
+107,missing_context,6,1,gpt-5,gpt-5
+105,incomplete,6,1,gpt-5,gpt-5
+107,misspelled,6,1,gpt-5,gpt-5
+105,out_of_domain,6,1,gpt-5,gpt-5
+105,baseline,6,1,gpt-5,gpt-5
+107,incomplete,6,1,gpt-5,gpt-5
+106,misspelled,6,1,gpt-5,gpt-5
+107,out_of_scope,6,1,gpt-5,gpt-5
+106,out_of_domain,6,1,gpt-5,gpt-5
+108,missing_context,6,1,gpt-5,gpt-5
+107,out_of_domain,6,1,gpt-5,gpt-5
+108,misspelled,5,0,gpt-5,gpt-5
+108,out_of_domain,5,0,gpt-5,gpt-5
+105,misspelled,6,1,gpt-5,gpt-5
+109,missing_context,6,1,gpt-5,gpt-5
+108,baseline,5,0,gpt-5,gpt-5
+106,ocr,6,1,gpt-5,gpt-5
+108,ocr,5,0,gpt-5,gpt-5
+107,ocr,6,1,gpt-5,gpt-5
+108,incomplete,6,1,gpt-5,gpt-5
+105,ocr,3,0,gpt-5,gpt-5
+110,baseline,5,0,gpt-5,gpt-5
+110,incomplete,5,0,gpt-5,gpt-5
+109,baseline,6,1,gpt-5,gpt-5
+108,out_of_scope,6,1,gpt-5,gpt-5
+110,missing_context,6,1,gpt-5,gpt-5
+110,misspelled,5,0,gpt-5,gpt-5
+110,out_of_domain,5,0,gpt-5,gpt-5
+110,ocr,5,0,gpt-5,gpt-5
+109,out_of_scope,5,0,gpt-5,gpt-5
+111,missing_context,6,1,gpt-5,gpt-5
+111,out_of_domain,6,1,gpt-5,gpt-5
+109,incomplete,6,1,gpt-5,gpt-5
+109,ocr,6,1,gpt-5,gpt-5
+109,out_of_domain,6,1,gpt-5,gpt-5
+110,out_of_scope,4,0,gpt-5,gpt-5
+111,out_of_scope,6,1,gpt-5,gpt-5
+109,misspelled,1,0,gpt-5,gpt-5
+112,missing_context,6,1,gpt-5,gpt-5
+111,misspelled,6,1,gpt-5,gpt-5
+111,incomplete,6,1,gpt-5,gpt-5
+112,misspelled,5,0,gpt-5,gpt-5
+112,baseline,5,0,gpt-5,gpt-5
+112,incomplete,5,0,gpt-5,gpt-5
+113,missing_context,6,1,gpt-5,gpt-5
+111,baseline,6,1,gpt-5,gpt-5
+112,ocr,5,0,gpt-5,gpt-5
+111,ocr,4,0,gpt-5,gpt-5
+114,missing_context,6,1,gpt-5,gpt-5
+113,misspelled,6,1,gpt-5,gpt-5
+112,out_of_domain,5,0,gpt-5,gpt-5
+113,out_of_domain,6,1,gpt-5,gpt-5
+114,out_of_scope,5,0,gpt-5,gpt-5
+113,baseline,6,1,gpt-5,gpt-5
+112,out_of_scope,5,0,gpt-5,gpt-5
+113,ocr,6,1,gpt-5,gpt-5
+113,incomplete,6,1,gpt-5,gpt-5
+115,missing_context,6,1,gpt-5,gpt-5
+114,baseline,6,1,gpt-5,gpt-5
+116,missing_context,6,1,gpt-5,gpt-5
+115,baseline,6,1,gpt-5,gpt-5
+114,ocr,6,1,gpt-5,gpt-5
+114,misspelled,6,1,gpt-5,gpt-5
+115,incomplete,6,1,gpt-5,gpt-5
+115,misspelled,6,1,gpt-5,gpt-5
+116,baseline,5,0,gpt-5,gpt-5
+115,ocr,6,1,gpt-5,gpt-5
+114,incomplete,6,1,gpt-5,gpt-5
+115,out_of_scope,6,1,gpt-5,gpt-5
+116,misspelled,5,0,gpt-5,gpt-5
+113,out_of_scope,6,1,gpt-5,gpt-5
+117,missing_context,6,1,gpt-5,gpt-5
+115,out_of_domain,6,1,gpt-5,gpt-5
+117,baseline,5,0,gpt-5,gpt-5
+116,ocr,5,0,gpt-5,gpt-5
+116,incomplete,5,0,gpt-5,gpt-5
+116,out_of_scope,6,1,gpt-5,gpt-5
+114,out_of_domain,6,1,gpt-5,gpt-5
+118,missing_context,6,1,gpt-5,gpt-5
+117,out_of_domain,6,1,gpt-5,gpt-5
+117,ocr,5,0,gpt-5,gpt-5
+116,out_of_domain,6,1,gpt-5,gpt-5
+118,baseline,6,1,gpt-5,gpt-5
+117,incomplete,6,1,gpt-5,gpt-5
+118,misspelled,6,1,gpt-5,gpt-5
+118,incomplete,5,0,gpt-5,gpt-5
+119,baseline,6,1,gpt-5,gpt-5
+117,misspelled,5,0,gpt-5,gpt-5
+118,out_of_scope,6,1,gpt-5,gpt-5
+118,ocr,6,1,gpt-5,gpt-5
+118,out_of_domain,6,1,gpt-5,gpt-5
+119,ocr,6,1,gpt-5,gpt-5
+119,missing_context,6,1,gpt-5,gpt-5
+119,incomplete,6,1,gpt-5,gpt-5
+119,misspelled,6,1,gpt-5,gpt-5
+119,out_of_domain,6,1,gpt-5,gpt-5
+120,missing_context,6,1,gpt-5,gpt-5
+117,out_of_scope,5,0,gpt-5,gpt-5
+119,out_of_scope,6,1,gpt-5,gpt-5
+121,missing_context,6,1,gpt-5,gpt-5
+122,baseline,5,0,gpt-5,gpt-5
+120,out_of_scope,5,0,gpt-5,gpt-5
+122,incomplete,5,0,gpt-5,gpt-5
+122,missing_context,6,1,gpt-5,gpt-5
+122,out_of_domain,5,0,gpt-5,gpt-5
+120,misspelled,6,1,gpt-5,gpt-5
+56,misspelled,5,0,gpt-5,gpt-5
+122,misspelled,5,0,gpt-5,gpt-5
+121,out_of_scope,6,1,gpt-5,gpt-5
+122,ocr,3,0,gpt-5,gpt-5
+120,baseline,6,1,gpt-5,gpt-5
+123,missing_context,6,1,gpt-5,gpt-5
+122,out_of_scope,6,1,gpt-5,gpt-5
+120,incomplete,6,1,gpt-5,gpt-5
+121,misspelled,6,1,gpt-5,gpt-5
+121,baseline,6,1,gpt-5,gpt-5
+123,misspelled,6,1,gpt-5,gpt-5
+123,baseline,6,1,gpt-5,gpt-5
+120,out_of_domain,6,1,gpt-5,gpt-5
+123,out_of_domain,6,1,gpt-5,gpt-5
+121,out_of_domain,6,1,gpt-5,gpt-5
+123,incomplete,6,1,gpt-5,gpt-5
+123,out_of_scope,6,1,gpt-5,gpt-5
+124,missing_context,6,1,gpt-5,gpt-5
+120,ocr,6,1,gpt-5,gpt-5
+124,out_of_scope,6,1,gpt-5,gpt-5
+125,missing_context,6,1,gpt-5,gpt-5
+123,ocr,5,0,gpt-5,gpt-5
+125,out_of_domain,6,1,gpt-5,gpt-5
+126,missing_context,6,1,gpt-5,gpt-5
+121,ocr,6,1,gpt-5,gpt-5
+121,incomplete,6,1,gpt-5,gpt-5
+126,incomplete,6,1,gpt-5,gpt-5
+125,out_of_scope,6,1,gpt-5,gpt-5
+124,baseline,4,0,gpt-5,gpt-5
+125,incomplete,6,1,gpt-5,gpt-5
+125,misspelled,6,1,gpt-5,gpt-5
+125,ocr,6,1,gpt-5,gpt-5
+125,baseline,4,0,gpt-5,gpt-5
+124,misspelled,6,1,gpt-5,gpt-5
+127,baseline,5,0,gpt-5,gpt-5
+126,ocr,5,0,gpt-5,gpt-5
+127,out_of_domain,5,0,gpt-5,gpt-5
+124,ocr,6,1,gpt-5,gpt-5
+124,out_of_domain,6,1,gpt-5,gpt-5
+126,baseline,6,1,gpt-5,gpt-5
+127,misspelled,5,0,gpt-5,gpt-5
+126,out_of_domain,6,1,gpt-5,gpt-5
+124,incomplete,6,1,gpt-5,gpt-5
+127,incomplete,5,0,gpt-5,gpt-5
+127,missing_context,6,1,gpt-5,gpt-5
+128,baseline,5,0,gpt-5,gpt-5
+128,incomplete,5,0,gpt-5,gpt-5
+128,out_of_domain,5,0,gpt-5,gpt-5
+128,missing_context,6,1,gpt-5,gpt-5
+129,baseline,5,0,gpt-5,gpt-5
+126,misspelled,4,0,gpt-5,gpt-5
+128,misspelled,5,0,gpt-5,gpt-5
+129,out_of_domain,5,0,gpt-5,gpt-5
+129,out_of_scope,6,1,gpt-5,gpt-5
+129,misspelled,5,0,gpt-5,gpt-5
+128,out_of_scope,6,1,gpt-5,gpt-5
+127,out_of_scope,4,0,gpt-5,gpt-5
+126,out_of_scope,6,1,gpt-5,gpt-5
+129,missing_context,6,1,gpt-5,gpt-5
+129,ocr,5,0,gpt-5,gpt-5
+130,baseline,5,0,gpt-5,gpt-5
+130,misspelled,5,0,gpt-5,gpt-5
+129,incomplete,5,0,gpt-5,gpt-5
+130,incomplete,5,0,gpt-5,gpt-5
+128,ocr,3,0,gpt-5,gpt-5
+131,missing_context,6,1,gpt-5,gpt-5
+130,missing_context,6,1,gpt-5,gpt-5
+127,ocr,3,0,gpt-5,gpt-5
+130,ocr,5,0,gpt-5,gpt-5
+132,misspelled,5,0,gpt-5,gpt-5
+132,out_of_domain,5,0,gpt-5,gpt-5
+131,ocr,5,0,gpt-5,gpt-5
+132,incomplete,5,0,gpt-5,gpt-5
+131,baseline,6,1,gpt-5,gpt-5
+130,out_of_domain,5,0,gpt-5,gpt-5
+131,incomplete,6,1,gpt-5,gpt-5
+132,missing_context,6,1,gpt-5,gpt-5
+131,misspelled,6,1,gpt-5,gpt-5
+132,baseline,5,0,gpt-5,gpt-5
+130,out_of_scope,4,0,gpt-5,gpt-5
+133,ocr,5,0,gpt-5,gpt-5
+133,out_of_domain,5,0,gpt-5,gpt-5
+133,missing_context,6,1,gpt-5,gpt-5
+133,incomplete,5,0,gpt-5,gpt-5
+131,out_of_domain,4,0,gpt-5,gpt-5
+134,missing_context,6,1,gpt-5,gpt-5
+133,baseline,5,0,gpt-5,gpt-5
+133,out_of_scope,5,0,gpt-5,gpt-5
+132,out_of_scope,4,0,gpt-5,gpt-5
+133,misspelled,5,0,gpt-5,gpt-5
+135,incomplete,5,0,gpt-5,gpt-5
+134,incomplete,6,1,gpt-5,gpt-5
+134,baseline,6,1,gpt-5,gpt-5
+134,out_of_domain,6,1,gpt-5,gpt-5
+134,misspelled,6,1,gpt-5,gpt-5
+135,missing_context,6,1,gpt-5,gpt-5
+131,out_of_scope,6,1,gpt-5,gpt-5
+134,ocr,6,1,gpt-5,gpt-5
+135,out_of_scope,6,1,gpt-5,gpt-5
+135,misspelled,5,0,gpt-5,gpt-5
+135,baseline,5,0,gpt-5,gpt-5
+132,ocr,4,0,gpt-5,gpt-5
+135,ocr,5,0,gpt-5,gpt-5
+134,out_of_scope,5,0,gpt-5,gpt-5
+136,missing_context,6,1,gpt-5,gpt-5
+137,baseline,6,1,gpt-5,gpt-5
+137,incomplete,6,1,gpt-5,gpt-5
+137,misspelled,6,1,gpt-5,gpt-5
+136,baseline,6,1,gpt-5,gpt-5
+137,missing_context,6,1,gpt-5,gpt-5
+137,ocr,6,1,gpt-5,gpt-5
+135,out_of_domain,6,1,gpt-5,gpt-5
+138,misspelled,5,0,gpt-5,gpt-5
+136,out_of_scope,6,1,gpt-5,gpt-5
+137,out_of_domain,6,1,gpt-5,gpt-5
+138,missing_context,6,1,gpt-5,gpt-5
+138,incomplete,5,0,gpt-5,gpt-5
+136,misspelled,6,1,gpt-5,gpt-5
+138,baseline,5,0,gpt-5,gpt-5
+136,out_of_domain,6,1,gpt-5,gpt-5
+137,out_of_scope,6,1,gpt-5,gpt-5
+136,ocr,6,1,gpt-5,gpt-5
+139,missing_context,6,1,gpt-5,gpt-5
+138,ocr,5,0,gpt-5,gpt-5
+138,out_of_domain,6,1,gpt-5,gpt-5
+138,out_of_scope,5,0,gpt-5,gpt-5
+140,misspelled,5,0,gpt-5,gpt-5
+136,incomplete,6,1,gpt-5,gpt-5
+140,baseline,5,0,gpt-5,gpt-5
+139,misspelled,6,1,gpt-5,gpt-5
+139,baseline,6,1,gpt-5,gpt-5
+139,out_of_domain,6,1,gpt-5,gpt-5
+140,missing_context,6,1,gpt-5,gpt-5
+139,ocr,6,1,gpt-5,gpt-5
+140,out_of_domain,5,0,gpt-5,gpt-5
+140,ocr,5,0,gpt-5,gpt-5
+139,out_of_scope,6,1,gpt-5,gpt-5
+141,missing_context,6,1,gpt-5,gpt-5
+139,incomplete,6,1,gpt-5,gpt-5
+141,baseline,5,0,gpt-5,gpt-5
+141,misspelled,6,1,gpt-5,gpt-5
+140,out_of_scope,6,1,gpt-5,gpt-5
+141,out_of_domain,5,0,gpt-5,gpt-5
+143,baseline,5,0,gpt-5,gpt-5
+140,incomplete,6,1,gpt-5,gpt-5
+141,ocr,6,1,gpt-5,gpt-5
+143,missing_context,6,1,gpt-5,gpt-5
+141,out_of_scope,6,1,gpt-5,gpt-5
+142,missing_context,6,1,gpt-5,gpt-5
+143,incomplete,6,1,gpt-5,gpt-5
+143,ocr,5,0,gpt-5,gpt-5
+142,out_of_scope,6,1,gpt-5,gpt-5
+143,misspelled,5,0,gpt-5,gpt-5
+141,incomplete,6,1,gpt-5,gpt-5
+143,out_of_domain,6,1,gpt-5,gpt-5
+144,missing_context,6,1,gpt-5,gpt-5
+142,misspelled,6,1,gpt-5,gpt-5
+143,out_of_scope,6,1,gpt-5,gpt-5
+142,out_of_domain,6,1,gpt-5,gpt-5
+142,ocr,6,1,gpt-5,gpt-5
+145,missing_context,6,1,gpt-5,gpt-5
+144,out_of_scope,5,0,gpt-5,gpt-5
+145,out_of_domain,4,0,gpt-5,gpt-5
+142,baseline,6,1,gpt-5,gpt-5
+145,out_of_scope,6,1,gpt-5,gpt-5
+146,missing_context,6,1,gpt-5,gpt-5
+146,out_of_domain,5,0,gpt-5,gpt-5
+146,baseline,5,0,gpt-5,gpt-5
+146,ocr,5,0,gpt-5,gpt-5
+144,misspelled,6,1,gpt-5,gpt-5
+146,incomplete,5,0,gpt-5,gpt-5
+146,misspelled,5,0,gpt-5,gpt-5
+142,incomplete,6,1,gpt-5,gpt-5
+144,baseline,6,1,gpt-5,gpt-5
+144,incomplete,6,1,gpt-5,gpt-5
+144,ocr,6,1,gpt-5,gpt-5
+146,out_of_scope,5,0,gpt-5,gpt-5
+147,missing_context,6,1,gpt-5,gpt-5
+145,incomplete,3,0,gpt-5,gpt-5
+144,out_of_domain,6,1,gpt-5,gpt-5
+147,incomplete,6,1,gpt-5,gpt-5
+147,baseline,6,1,gpt-5,gpt-5
+145,ocr,3,0,gpt-5,gpt-5
+147,misspelled,6,1,gpt-5,gpt-5
+147,ocr,6,1,gpt-5,gpt-5
+145,misspelled,6,1,gpt-5,gpt-5
+148,missing_context,6,1,gpt-5,gpt-5
+145,baseline,3,0,gpt-5,gpt-5
+147,out_of_domain,6,1,gpt-5,gpt-5
+147,out_of_scope,5,0,gpt-5,gpt-5
+148,misspelled,6,1,gpt-5,gpt-5
+149,missing_context,6,1,gpt-5,gpt-5
+150,missing_context,6,1,gpt-5,gpt-5
+148,out_of_scope,5,0,gpt-5,gpt-5
+148,out_of_domain,6,1,gpt-5,gpt-5
+148,baseline,6,1,gpt-5,gpt-5
+150,baseline,6,1,gpt-5,gpt-5
+150,misspelled,6,1,gpt-5,gpt-5
+149,out_of_domain,5,0,gpt-5,gpt-5
+150,incomplete,6,1,gpt-5,gpt-5
+148,ocr,6,1,gpt-5,gpt-5
+150,out_of_scope,6,1,gpt-5,gpt-5
+149,out_of_scope,5,0,gpt-5,gpt-5
+148,incomplete,6,1,gpt-5,gpt-5
+151,missing_context,6,1,gpt-5,gpt-5
+150,out_of_domain,6,1,gpt-5,gpt-5
+149,misspelled,6,1,gpt-5,gpt-5
+149,incomplete,6,1,gpt-5,gpt-5
+151,incomplete,6,1,gpt-5,gpt-5
+151,out_of_scope,5,0,gpt-5,gpt-5
+151,baseline,6,1,gpt-5,gpt-5
+151,misspelled,6,1,gpt-5,gpt-5
+152,missing_context,6,1,gpt-5,gpt-5
+152,misspelled,6,1,gpt-5,gpt-5
+152,out_of_scope,6,1,gpt-5,gpt-5
+152,out_of_domain,6,1,gpt-5,gpt-5
+150,ocr,6,1,gpt-5,gpt-5
+152,incomplete,6,1,gpt-5,gpt-5
+149,ocr,6,1,gpt-5,gpt-5
+153,baseline,6,1,gpt-5,gpt-5
+153,incomplete,5,0,gpt-5,gpt-5
+152,ocr,6,1,gpt-5,gpt-5
+152,baseline,6,1,gpt-5,gpt-5
+154,missing_context,6,1,gpt-5,gpt-5
+151,out_of_domain,6,1,gpt-5,gpt-5
+149,baseline,6,1,gpt-5,gpt-5
+153,missing_context,6,1,gpt-5,gpt-5
+151,ocr,6,1,gpt-5,gpt-5
+153,misspelled,6,1,gpt-5,gpt-5
+155,missing_context,6,1,gpt-5,gpt-5
+153,out_of_scope,6,1,gpt-5,gpt-5
+154,incomplete,5,0,gpt-5,gpt-5
+153,ocr,6,1,gpt-5,gpt-5
+153,out_of_domain,6,1,gpt-5,gpt-5
+154,out_of_scope,6,1,gpt-5,gpt-5
+154,out_of_domain,5,0,gpt-5,gpt-5
+154,ocr,5,0,gpt-5,gpt-5
+154,misspelled,5,0,gpt-5,gpt-5
+155,baseline,6,1,gpt-5,gpt-5
+154,baseline,5,0,gpt-5,gpt-5
+157,misspelled,5,0,gpt-5,gpt-5
+155,misspelled,6,1,gpt-5,gpt-5
+156,missing_context,6,1,gpt-5,gpt-5
+155,out_of_scope,5,0,gpt-5,gpt-5
+156,baseline,6,1,gpt-5,gpt-5
+157,incomplete,5,0,gpt-5,gpt-5
+155,ocr,6,1,gpt-5,gpt-5
+157,baseline,5,0,gpt-5,gpt-5
+157,missing_context,6,1,gpt-5,gpt-5
+156,misspelled,6,1,gpt-5,gpt-5
+156,out_of_domain,6,1,gpt-5,gpt-5
+155,incomplete,6,1,gpt-5,gpt-5
+158,missing_context,6,1,gpt-5,gpt-5
+157,out_of_domain,5,0,gpt-5,gpt-5
+157,out_of_scope,5,0,gpt-5,gpt-5
+155,out_of_domain,6,1,gpt-5,gpt-5
+156,out_of_scope,6,1,gpt-5,gpt-5
+158,baseline,5,0,gpt-5,gpt-5
+156,ocr,6,1,gpt-5,gpt-5
+159,misspelled,5,0,gpt-5,gpt-5
+159,missing_context,6,1,gpt-5,gpt-5
+157,ocr,3,0,gpt-5,gpt-5
+156,incomplete,6,1,gpt-5,gpt-5
+159,incomplete,5,0,gpt-5,gpt-5
+159,ocr,5,0,gpt-5,gpt-5
+159,baseline,5,0,gpt-5,gpt-5
+158,misspelled,6,1,gpt-5,gpt-5
+159,out_of_domain,5,0,gpt-5,gpt-5
+158,ocr,6,1,gpt-5,gpt-5
+159,out_of_scope,5,0,gpt-5,gpt-5
+158,incomplete,6,1,gpt-5,gpt-5
+161,missing_context,6,1,gpt-5,gpt-5
+160,out_of_scope,4,0,gpt-5,gpt-5
+161,out_of_scope,6,1,gpt-5,gpt-5
+158,out_of_domain,6,1,gpt-5,gpt-5
+162,misspelled,6,1,gpt-5,gpt-5
+162,missing_context,6,1,gpt-5,gpt-5
+158,out_of_scope,6,1,gpt-5,gpt-5
+162,incomplete,6,1,gpt-5,gpt-5
+160,out_of_domain,6,1,gpt-5,gpt-5
+162,out_of_domain,5,0,gpt-5,gpt-5
+161,incomplete,6,1,gpt-5,gpt-5
+161,misspelled,6,1,gpt-5,gpt-5
+160,baseline,6,1,gpt-5,gpt-5
+160,incomplete,6,1,gpt-5,gpt-5
+160,ocr,6,1,gpt-5,gpt-5
+161,out_of_domain,6,1,gpt-5,gpt-5
+163,missing_context,6,1,gpt-5,gpt-5
+162,ocr,5,0,gpt-5,gpt-5
+161,baseline,6,1,gpt-5,gpt-5
+163,out_of_scope,6,1,gpt-5,gpt-5
+161,ocr,6,1,gpt-5,gpt-5
+164,missing_context,6,1,gpt-5,gpt-5
+163,baseline,6,1,gpt-5,gpt-5
+160,misspelled,6,1,gpt-5,gpt-5
+164,misspelled,3,0,gpt-5,gpt-5
+162,out_of_scope,5,0,gpt-5,gpt-5
+164,ocr,5,0,gpt-5,gpt-5
+163,incomplete,3,0,gpt-5,gpt-5
+164,incomplete,3,0,gpt-5,gpt-5
+163,misspelled,6,1,gpt-5,gpt-5
+164,baseline,3,0,gpt-5,gpt-5
+164,out_of_domain,2,0,gpt-5,gpt-5
+164,out_of_scope,4,0,gpt-5,gpt-5
+166,baseline,5,0,gpt-5,gpt-5
+166,misspelled,5,0,gpt-5,gpt-5
+166,incomplete,6,1,gpt-5,gpt-5
+165,missing_context,6,1,gpt-5,gpt-5
+166,ocr,5,0,gpt-5,gpt-5
+166,out_of_domain,5,0,gpt-5,gpt-5
+166,missing_context,6,1,gpt-5,gpt-5
+163,out_of_domain,6,1,gpt-5,gpt-5
+165,misspelled,6,1,gpt-5,gpt-5
+167,misspelled,5,0,gpt-5,gpt-5
+160,missing_context,6,1,gpt-5,gpt-5
+165,ocr,6,1,gpt-5,gpt-5
+167,missing_context,6,1,gpt-5,gpt-5
+165,incomplete,6,1,gpt-5,gpt-5
+166,out_of_scope,6,1,gpt-5,gpt-5
+165,baseline,6,1,gpt-5,gpt-5
+165,out_of_domain,6,1,gpt-5,gpt-5
+167,baseline,5,0,gpt-5,gpt-5
+165,out_of_scope,5,0,gpt-5,gpt-5
+167,out_of_domain,5,0,gpt-5,gpt-5
+163,ocr,6,1,gpt-5,gpt-5
+167,out_of_scope,6,1,gpt-5,gpt-5
+167,incomplete,5,0,gpt-5,gpt-5
+168,incomplete,5,0,gpt-5,gpt-5
+168,baseline,5,0,gpt-5,gpt-5
+167,ocr,5,0,gpt-5,gpt-5
+169,baseline,5,0,gpt-5,gpt-5
+168,missing_context,6,1,gpt-5,gpt-5
+170,baseline,5,0,gpt-5,gpt-5
+169,missing_context,6,1,gpt-5,gpt-5
+169,misspelled,5,0,gpt-5,gpt-5
+168,misspelled,6,1,gpt-5,gpt-5
+169,incomplete,5,0,gpt-5,gpt-5
+169,out_of_domain,5,0,gpt-5,gpt-5
+170,out_of_domain,5,0,gpt-5,gpt-5
+168,ocr,6,1,gpt-5,gpt-5
+170,misspelled,5,0,gpt-5,gpt-5
+168,out_of_domain,6,1,gpt-5,gpt-5
+170,ocr,5,0,gpt-5,gpt-5
+171,missing_context,6,1,gpt-5,gpt-5
+170,incomplete,5,0,gpt-5,gpt-5
+170,missing_context,6,1,gpt-5,gpt-5
+169,ocr,3,0,gpt-5,gpt-5
+169,out_of_scope,6,1,gpt-5,gpt-5
+172,baseline,6,1,gpt-5,gpt-5
+171,incomplete,5,0,gpt-5,gpt-5
+172,missing_context,6,1,gpt-5,gpt-5
+172,misspelled,5,0,gpt-5,gpt-5
+171,ocr,5,0,gpt-5,gpt-5
+168,out_of_scope,5,0,gpt-5,gpt-5
+171,misspelled,5,0,gpt-5,gpt-5
+171,baseline,6,1,gpt-5,gpt-5
+171,out_of_scope,6,1,gpt-5,gpt-5
+172,incomplete,6,1,gpt-5,gpt-5
+171,out_of_domain,3,0,gpt-5,gpt-5
+172,ocr,5,0,gpt-5,gpt-5
+173,missing_context,6,1,gpt-5,gpt-5
+172,out_of_domain,6,1,gpt-5,gpt-5
+174,misspelled,5,0,gpt-5,gpt-5
+174,baseline,5,0,gpt-5,gpt-5
+174,missing_context,6,1,gpt-5,gpt-5
+174,ocr,5,0,gpt-5,gpt-5
+170,out_of_scope,5,0,gpt-5,gpt-5
+173,baseline,6,1,gpt-5,gpt-5
+172,out_of_scope,4,0,gpt-5,gpt-5
+175,missing_context,6,1,gpt-5,gpt-5
+174,incomplete,5,0,gpt-5,gpt-5
+173,incomplete,6,1,gpt-5,gpt-5
+174,out_of_domain,5,0,gpt-5,gpt-5
+173,ocr,6,1,gpt-5,gpt-5
+173,misspelled,6,1,gpt-5,gpt-5
+174,out_of_scope,6,1,gpt-5,gpt-5
+176,missing_context,6,1,gpt-5,gpt-5
+175,baseline,5,0,gpt-5,gpt-5
+173,out_of_scope,6,1,gpt-5,gpt-5
+162,baseline,5,0,gpt-5,gpt-5
+175,out_of_domain,4,0,gpt-5,gpt-5
+175,incomplete,6,1,gpt-5,gpt-5
+177,baseline,5,0,gpt-5,gpt-5
+176,baseline,4,0,gpt-5,gpt-5
+176,out_of_scope,6,1,gpt-5,gpt-5
+175,misspelled,4,0,gpt-5,gpt-5
+175,out_of_scope,4,0,gpt-5,gpt-5
+175,ocr,4,0,gpt-5,gpt-5
+176,misspelled,4,0,gpt-5,gpt-5
+173,out_of_domain,4,0,gpt-5,gpt-5
+176,incomplete,6,1,gpt-5,gpt-5
+177,ocr,5,0,gpt-5,gpt-5
+177,missing_context,6,1,gpt-5,gpt-5
+177,out_of_domain,5,0,gpt-5,gpt-5
+177,misspelled,5,0,gpt-5,gpt-5
+177,incomplete,5,0,gpt-5,gpt-5
+178,baseline,5,0,gpt-5,gpt-5
+178,misspelled,5,0,gpt-5,gpt-5
+178,missing_context,6,1,gpt-5,gpt-5
+179,baseline,5,0,gpt-5,gpt-5
+176,out_of_domain,4,0,gpt-5,gpt-5
+178,ocr,5,0,gpt-5,gpt-5
+179,out_of_domain,5,0,gpt-5,gpt-5
+178,out_of_domain,5,0,gpt-5,gpt-5
+179,ocr,5,0,gpt-5,gpt-5
+177,out_of_scope,6,1,gpt-5,gpt-5
+179,incomplete,6,1,gpt-5,gpt-5
+179,misspelled,5,0,gpt-5,gpt-5
+180,misspelled,5,0,gpt-5,gpt-5
+180,incomplete,5,0,gpt-5,gpt-5
+179,missing_context,6,1,gpt-5,gpt-5
+178,incomplete,5,0,gpt-5,gpt-5
+180,missing_context,6,1,gpt-5,gpt-5
+180,baseline,5,0,gpt-5,gpt-5
+176,ocr,4,0,gpt-5,gpt-5
+180,ocr,5,0,gpt-5,gpt-5
+180,out_of_domain,5,0,gpt-5,gpt-5
+178,out_of_scope,6,1,gpt-5,gpt-5
+181,out_of_domain,5,0,gpt-5,gpt-5
+181,baseline,6,1,gpt-5,gpt-5
+179,out_of_scope,6,1,gpt-5,gpt-5
+182,missing_context,6,1,gpt-5,gpt-5
+181,missing_context,6,1,gpt-5,gpt-5
+181,ocr,6,1,gpt-5,gpt-5
+183,misspelled,5,0,gpt-5,gpt-5
+180,out_of_scope,5,0,gpt-5,gpt-5
+182,out_of_scope,6,1,gpt-5,gpt-5
+183,incomplete,5,0,gpt-5,gpt-5
+183,ocr,5,0,gpt-5,gpt-5
+183,missing_context,6,1,gpt-5,gpt-5
+183,baseline,5,0,gpt-5,gpt-5
+181,misspelled,6,1,gpt-5,gpt-5
+183,out_of_domain,5,0,gpt-5,gpt-5
+184,missing_context,6,1,gpt-5,gpt-5
+181,incomplete,6,1,gpt-5,gpt-5
+182,misspelled,6,1,gpt-5,gpt-5
+184,misspelled,6,1,gpt-5,gpt-5
+182,out_of_domain,4,0,gpt-5,gpt-5
+184,out_of_scope,6,1,gpt-5,gpt-5
+184,incomplete,6,1,gpt-5,gpt-5
+183,out_of_scope,5,0,gpt-5,gpt-5
+181,out_of_scope,4,0,gpt-5,gpt-5
+184,ocr,6,1,gpt-5,gpt-5
+182,ocr,6,1,gpt-5,gpt-5
+184,out_of_domain,6,1,gpt-5,gpt-5
+184,baseline,6,1,gpt-5,gpt-5
+182,baseline,6,1,gpt-5,gpt-5
+185,missing_context,6,1,gpt-5,gpt-5
+186,missing_context,6,1,gpt-5,gpt-5
+185,ocr,6,1,gpt-5,gpt-5
+187,missing_context,6,1,gpt-5,gpt-5
+186,out_of_scope,6,1,gpt-5,gpt-5
+187,baseline,5,0,gpt-5,gpt-5
+186,out_of_domain,6,1,gpt-5,gpt-5
+185,out_of_domain,4,0,gpt-5,gpt-5
+186,ocr,6,1,gpt-5,gpt-5
+186,baseline,6,1,gpt-5,gpt-5
+185,out_of_scope,6,1,gpt-5,gpt-5
+187,ocr,5,0,gpt-5,gpt-5
+187,incomplete,5,0,gpt-5,gpt-5
+188,baseline,5,0,gpt-5,gpt-5
+185,baseline,6,1,gpt-5,gpt-5
+187,out_of_domain,6,1,gpt-5,gpt-5
+185,misspelled,3,0,gpt-5,gpt-5
+187,out_of_scope,6,1,gpt-5,gpt-5
+188,incomplete,6,1,gpt-5,gpt-5
+188,misspelled,6,1,gpt-5,gpt-5
+188,out_of_domain,5,0,gpt-5,gpt-5
+185,incomplete,6,1,gpt-5,gpt-5
+186,incomplete,6,1,gpt-5,gpt-5
+188,missing_context,6,1,gpt-5,gpt-5
+189,missing_context,6,1,gpt-5,gpt-5
+189,out_of_scope,6,1,gpt-5,gpt-5
+188,out_of_scope,5,0,gpt-5,gpt-5
+187,misspelled,5,0,gpt-5,gpt-5
+188,ocr,6,1,gpt-5,gpt-5
+190,missing_context,6,1,gpt-5,gpt-5
+189,misspelled,6,1,gpt-5,gpt-5
+190,out_of_domain,6,1,gpt-5,gpt-5
+190,baseline,6,1,gpt-5,gpt-5
+189,incomplete,6,1,gpt-5,gpt-5
+191,missing_context,6,1,gpt-5,gpt-5
+189,baseline,6,1,gpt-5,gpt-5
+190,out_of_scope,5,0,gpt-5,gpt-5
+190,ocr,6,1,gpt-5,gpt-5
+190,misspelled,6,1,gpt-5,gpt-5
+190,incomplete,6,1,gpt-5,gpt-5
+189,ocr,6,1,gpt-5,gpt-5
+189,out_of_domain,4,0,gpt-5,gpt-5
+191,out_of_scope,5,0,gpt-5,gpt-5
+192,missing_context,6,1,gpt-5,gpt-5
+191,misspelled,6,1,gpt-5,gpt-5
+193,misspelled,5,0,gpt-5,gpt-5
+193,baseline,4,0,gpt-5,gpt-5
+192,out_of_scope,5,0,gpt-5,gpt-5
+193,missing_context,6,1,gpt-5,gpt-5
+192,out_of_domain,6,1,gpt-5,gpt-5
+193,incomplete,5,0,gpt-5,gpt-5
+193,out_of_domain,5,0,gpt-5,gpt-5
+192,misspelled,6,1,gpt-5,gpt-5
+191,ocr,4,0,gpt-5,gpt-5
+191,baseline,4,0,gpt-5,gpt-5
+193,out_of_scope,6,1,gpt-5,gpt-5
+193,ocr,4,0,gpt-5,gpt-5
+191,incomplete,6,1,gpt-5,gpt-5
+192,incomplete,6,1,gpt-5,gpt-5
+192,baseline,6,1,gpt-5,gpt-5
+194,baseline,6,1,gpt-5,gpt-5
+191,out_of_domain,4,0,gpt-5,gpt-5
+194,misspelled,6,1,gpt-5,gpt-5
+195,missing_context,6,1,gpt-5,gpt-5
+194,out_of_domain,6,1,gpt-5,gpt-5
+192,ocr,6,1,gpt-5,gpt-5
+194,incomplete,6,1,gpt-5,gpt-5
+194,missing_context,6,1,gpt-5,gpt-5
+195,misspelled,5,0,gpt-5,gpt-5
+196,missing_context,6,1,gpt-5,gpt-5
+194,ocr,6,1,gpt-5,gpt-5
+195,baseline,5,0,gpt-5,gpt-5
+197,baseline,5,0,gpt-5,gpt-5
+195,incomplete,5,0,gpt-5,gpt-5
+194,out_of_scope,5,0,gpt-5,gpt-5
+195,out_of_scope,4,0,gpt-5,gpt-5
+197,misspelled,5,0,gpt-5,gpt-5
+197,incomplete,6,1,gpt-5,gpt-5
+197,missing_context,6,1,gpt-5,gpt-5
+195,out_of_domain,6,1,gpt-5,gpt-5
+197,ocr,5,0,gpt-5,gpt-5
+195,ocr,5,0,gpt-5,gpt-5
+197,out_of_domain,5,0,gpt-5,gpt-5
+196,ocr,5,0,gpt-5,gpt-5
+198,missing_context,6,1,gpt-5,gpt-5
+196,baseline,5,0,gpt-5,gpt-5
+199,incomplete,5,0,gpt-5,gpt-5
+199,baseline,5,0,gpt-5,gpt-5
+196,out_of_scope,6,1,gpt-5,gpt-5
+197,out_of_scope,5,0,gpt-5,gpt-5
+199,ocr,5,0,gpt-5,gpt-5
+199,missing_context,6,1,gpt-5,gpt-5
+199,out_of_domain,5,0,gpt-5,gpt-5
+199,misspelled,5,0,gpt-5,gpt-5
+196,misspelled,4,0,gpt-5,gpt-5
+196,out_of_domain,4,0,gpt-5,gpt-5
+198,baseline,6,1,gpt-5,gpt-5
+198,out_of_domain,6,1,gpt-5,gpt-5
+198,incomplete,6,1,gpt-5,gpt-5
+200,missing_context,6,1,gpt-5,gpt-5
+198,ocr,6,1,gpt-5,gpt-5
+196,incomplete,5,0,gpt-5,gpt-5
+199,out_of_scope,4,0,gpt-5,gpt-5
+200,misspelled,5,0,gpt-5,gpt-5
+200,out_of_domain,5,0,gpt-5,gpt-5
+200,baseline,5,0,gpt-5,gpt-5
+198,misspelled,6,1,gpt-5,gpt-5
+198,out_of_scope,6,1,gpt-5,gpt-5
+201,missing_context,6,1,gpt-5,gpt-5
+201,incomplete,5,0,gpt-5,gpt-5
+201,baseline,5,0,gpt-5,gpt-5
+200,incomplete,5,0,gpt-5,gpt-5
+201,ocr,5,0,gpt-5,gpt-5
+202,missing_context,6,1,gpt-5,gpt-5
+200,out_of_scope,6,1,gpt-5,gpt-5
+200,ocr,5,0,gpt-5,gpt-5
+201,misspelled,5,0,gpt-5,gpt-5
+201,out_of_domain,5,0,gpt-5,gpt-5
+203,missing_context,6,1,gpt-5,gpt-5
+201,out_of_scope,4,0,gpt-5,gpt-5
+202,out_of_scope,6,1,gpt-5,gpt-5
+203,misspelled,6,1,gpt-5,gpt-5
+202,baseline,6,1,gpt-5,gpt-5
+204,out_of_domain,5,0,gpt-5,gpt-5
+204,incomplete,5,0,gpt-5,gpt-5
+204,baseline,5,0,gpt-5,gpt-5
+204,missing_context,6,1,gpt-5,gpt-5
+203,out_of_scope,6,1,gpt-5,gpt-5
+204,misspelled,5,0,gpt-5,gpt-5
+204,ocr,5,0,gpt-5,gpt-5
+203,baseline,6,1,gpt-5,gpt-5
+202,out_of_domain,6,1,gpt-5,gpt-5
+203,out_of_domain,6,1,gpt-5,gpt-5
+202,misspelled,6,1,gpt-5,gpt-5
+203,ocr,6,1,gpt-5,gpt-5
+203,incomplete,6,1,gpt-5,gpt-5
+205,baseline,6,1,gpt-5,gpt-5
+205,misspelled,6,1,gpt-5,gpt-5
+205,ocr,6,1,gpt-5,gpt-5
+206,incomplete,5,0,gpt-5,gpt-5
+206,missing_context,6,1,gpt-5,gpt-5
+206,baseline,5,0,gpt-5,gpt-5
+205,out_of_domain,6,1,gpt-5,gpt-5
+202,ocr,6,1,gpt-5,gpt-5
+202,incomplete,6,1,gpt-5,gpt-5
+205,missing_context,6,1,gpt-5,gpt-5
+206,misspelled,5,0,gpt-5,gpt-5
+206,out_of_domain,5,0,gpt-5,gpt-5
+207,missing_context,6,1,gpt-5,gpt-5
+205,out_of_scope,6,1,gpt-5,gpt-5
+207,out_of_scope,6,1,gpt-5,gpt-5
+206,out_of_scope,5,0,gpt-5,gpt-5
+208,missing_context,6,1,gpt-5,gpt-5
+206,ocr,5,0,gpt-5,gpt-5
+204,out_of_scope,6,1,gpt-5,gpt-5
+205,incomplete,6,1,gpt-5,gpt-5
+209,misspelled,6,1,gpt-5,gpt-5
+209,baseline,6,1,gpt-5,gpt-5
+208,out_of_scope,4,0,gpt-5,gpt-5
+208,baseline,2,0,gpt-5,gpt-5
+208,out_of_domain,6,1,gpt-5,gpt-5
+207,incomplete,6,1,gpt-5,gpt-5
+209,incomplete,6,1,gpt-5,gpt-5
+207,misspelled,6,1,gpt-5,gpt-5
+209,missing_context,6,1,gpt-5,gpt-5
+207,baseline,6,1,gpt-5,gpt-5
+209,out_of_domain,6,1,gpt-5,gpt-5
+208,incomplete,4,0,gpt-5,gpt-5
+209,ocr,6,1,gpt-5,gpt-5
+208,ocr,6,1,gpt-5,gpt-5
+210,missing_context,6,1,gpt-5,gpt-5
+207,ocr,6,1,gpt-5,gpt-5
+211,missing_context,6,1,gpt-5,gpt-5
+210,incomplete,6,1,gpt-5,gpt-5
+208,misspelled,6,1,gpt-5,gpt-5
+209,out_of_scope,6,1,gpt-5,gpt-5
+210,misspelled,6,1,gpt-5,gpt-5
+210,baseline,6,1,gpt-5,gpt-5
+211,baseline,3,0,gpt-5,gpt-5
+210,out_of_scope,6,1,gpt-5,gpt-5
+211,ocr,3,0,gpt-5,gpt-5
+210,ocr,3,0,gpt-5,gpt-5
+212,missing_context,6,1,gpt-5,gpt-5
+211,out_of_domain,3,0,gpt-5,gpt-5
+207,out_of_domain,6,1,gpt-5,gpt-5
+210,out_of_domain,5,0,gpt-5,gpt-5
+211,out_of_scope,4,0,gpt-5,gpt-5
+213,missing_context,6,1,gpt-5,gpt-5
+211,misspelled,3,0,gpt-5,gpt-5
+213,baseline,6,1,gpt-5,gpt-5
+213,incomplete,6,1,gpt-5,gpt-5
+211,incomplete,3,0,gpt-5,gpt-5
+212,incomplete,6,1,gpt-5,gpt-5
+212,out_of_scope,5,0,gpt-5,gpt-5
+213,ocr,5,0,gpt-5,gpt-5
+213,out_of_domain,6,1,gpt-5,gpt-5
+214,baseline,5,0,gpt-5,gpt-5
+212,ocr,6,1,gpt-5,gpt-5
+212,baseline,6,1,gpt-5,gpt-5
+213,misspelled,5,0,gpt-5,gpt-5
+212,misspelled,6,1,gpt-5,gpt-5
+212,out_of_domain,6,1,gpt-5,gpt-5
+214,missing_context,6,1,gpt-5,gpt-5
+215,misspelled,5,0,gpt-5,gpt-5
+214,out_of_scope,6,1,gpt-5,gpt-5
+214,ocr,5,0,gpt-5,gpt-5
+215,incomplete,5,0,gpt-5,gpt-5
+215,baseline,5,0,gpt-5,gpt-5
+214,incomplete,6,1,gpt-5,gpt-5
+216,missing_context,6,1,gpt-5,gpt-5
+215,ocr,3,0,gpt-5,gpt-5
+215,missing_context,6,1,gpt-5,gpt-5
+216,out_of_scope,6,1,gpt-5,gpt-5
+214,out_of_domain,6,1,gpt-5,gpt-5
+217,incomplete,6,1,gpt-5,gpt-5
+215,out_of_domain,5,0,gpt-5,gpt-5
+217,out_of_domain,6,1,gpt-5,gpt-5
+217,misspelled,6,1,gpt-5,gpt-5
+215,out_of_scope,5,0,gpt-5,gpt-5
+214,misspelled,5,0,gpt-5,gpt-5
+217,baseline,6,1,gpt-5,gpt-5
+218,missing_context,6,1,gpt-5,gpt-5
+216,ocr,6,1,gpt-5,gpt-5
+216,misspelled,6,1,gpt-5,gpt-5
+217,out_of_scope,6,1,gpt-5,gpt-5
+217,missing_context,6,1,gpt-5,gpt-5
+216,baseline,4,0,gpt-5,gpt-5
+213,out_of_scope,6,1,gpt-5,gpt-5
+217,ocr,6,1,gpt-5,gpt-5
+216,incomplete,6,1,gpt-5,gpt-5
+218,baseline,6,1,gpt-5,gpt-5
+218,misspelled,6,1,gpt-5,gpt-5
+218,incomplete,6,1,gpt-5,gpt-5
+219,baseline,5,0,gpt-5,gpt-5
+219,misspelled,5,0,gpt-5,gpt-5
+219,missing_context,6,1,gpt-5,gpt-5
+216,out_of_domain,6,1,gpt-5,gpt-5
+218,out_of_domain,6,1,gpt-5,gpt-5
+218,ocr,6,1,gpt-5,gpt-5
+219,ocr,5,0,gpt-5,gpt-5
+219,incomplete,6,1,gpt-5,gpt-5
+218,out_of_scope,6,1,gpt-5,gpt-5
+219,out_of_domain,6,1,gpt-5,gpt-5
+219,out_of_scope,5,0,gpt-5,gpt-5
+182,incomplete,6,1,gpt-5,gpt-5
+186,misspelled,6,1,gpt-5,gpt-5
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_failsafeqa_optimized.csv b/examples/gpt-5/prompt-optimization-cookbook/results_failsafeqa_optimized.csv
new file mode 100644
index 0000000000..d1437f1c65
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_failsafeqa_optimized.csv
@@ -0,0 +1,8 @@
+idx,kind,rating,compliance,answer_model,judge_model
+0,missing_context,6,1,gpt-5,gpt-5
+0,out_of_domain,5,0,gpt-5,gpt-5
+0,baseline,5,0,gpt-5,gpt-5
+0,misspelled,5,0,gpt-5,gpt-5
+0,incomplete,5,0,gpt-5,gpt-5
+0,out_of_scope,6,1,gpt-5,gpt-5
+0,ocr,5,0,gpt-5,gpt-5
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/judgement_summary.csv b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/judgement_summary.csv
new file mode 100644
index 0000000000..8374eb3c76
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/judgement_summary.csv
@@ -0,0 +1,31 @@
+File,adherence_score,code_quality_score,parse_error,error
+run_01.py,5,5,,
+run_02.py,5,5,,
+run_03.py,4,5,,
+run_04.py,5,5,,
+run_05.py,4,5,,
+run_06.py,4,5,,
+run_07.py,4,5,,
+run_08.py,5,5,,
+run_09.py,4,4,,
+run_10.py,4,5,,
+run_11.py,5,5,,
+run_12.py,5,5,,
+run_13.py,4,4,,
+run_14.py,4,5,,
+run_15.py,4,5,,
+run_16.py,4,5,,
+run_17.py,5,5,,
+run_18.py,5,4,,
+run_19.py,5,5,,
+run_20.py,4,4,,
+run_21.py,5,5,,
+run_22.py,4,4,,
+run_23.py,4,5,,
+run_24.py,4,4,,
+run_25.py,4,4,,
+run_26.py,4,4,,
+run_27.py,4,5,,
+run_28.py,5,5,,
+run_29.py,4,5,,
+run_30.py,5,5,,
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_01.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_01.json
new file mode 100644
index 0000000000..7af7659b17
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_01.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_01.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"Step-by-step check against the instructions:\\n- Tokenization: The code lowercases the text (s = text.lower()) and uses a regex pattern r'[a-z0-9]+' with re.ASCII to extract tokens, treating non-matching chars as separators. This matches the tokenization specification exactly.\\n- Inputs: It reads the provided globals via globals().get('text', '') and globals().get('k', 0) without reassigning them. It copies them into _text and _k, which complies with the \\\"Do not reassign them\\\" requirement.\\n- Sorting requirement (Top-K by count desc, then token asc): It computes counts in a dict, then sets n = min(k, len(counts)). It uses heapq.nsmallest(n, counts.items(), key=lambda it: (-it[1], it[0])) which yields items sorted by (-count, token), i.e., count descending then token ascending. This matches the specified sort key.\\n- Output shape: The function returns a list of (token, count) tuples from counts.items(), and top_k is assigned to that list. Length is min(k, unique tokens) by design via n. This satisfies the output contract (list of tuples, correct length).\\n- Edge case k <= 0: Handled in two places\u2014early return in compute_top_k when k <= 0, and again after computing n. In both cases, the result is []. This fulfills the requirement. It also returns [] for empty text, which is consistent with expectations though not explicitly required.\\n- No I/O or network: The script performs no printing, I/O, or network access. It runs as-is with the provided globals.\\n- Tie-ordering: It does not use Counter.most_common and explicitly implements the specified sort order via the key function.\\n- End state: top_k is defined at module end as required. The optional printing clause is not used (which is allowed). The inclusion of __all__ = ['top_k'] is acceptable and does not violate any requirement.\\nOverall, the code cleanly satisfies all specified requirements with no violations or omissions.\",\n    \"code_quality\": \"The output is code; assessment:\\n- Correctness: The counting, tokenization, and ordering logic are correct. heapq.nsmallest with key (-count, token) yields the correct Top-K ordering.\\n- Clarity/Readability: Code is reasonably clear with concise comments. Variable names are short but understandable. A return type hint for compute_top_k could improve clarity but is not essential.\\n- Efficiency: Using re.finditer for tokenization and heapq.nsmallest for top-k selection is efficient (O(U log K) for selection). Counting via a dict is standard and efficient.\\n- Structure/Maintainability: Separation into a helper function and a small conversion helper is tidy. No unnecessary complexity. Avoids reliance on unstable tie-ordering.\\n- Best practices: No I/O, no side effects beyond defining top_k. Safe handling of k conversion. Use of re.ASCII ensures correct token class semantics.\\nNo bugs or inefficiencies detected; style is solid overall.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 5,\n    \"code_quality_score\": 5,\n    \"comments\": \"Meets all task requirements precisely and produces the correct Top-K list. Clean, efficient implementation with correct tokenization and ordering. Minor optional improvement: add a return type annotation for compute_top_k for readability.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "Step-by-step check against the instructions:\n- Tokenization: The code lowercases the text (s = text.lower()) and uses a regex pattern r'[a-z0-9]+' with re.ASCII to extract tokens, treating non-matching chars as separators. This matches the tokenization specification exactly.\n- Inputs: It reads the provided globals via globals().get('text', '') and globals().get('k', 0) without reassigning them. It copies them into _text and _k, which complies with the \"Do not reassign them\" requirement.\n- Sorting requirement (Top-K by count desc, then token asc): It computes counts in a dict, then sets n = min(k, len(counts)). It uses heapq.nsmallest(n, counts.items(), key=lambda it: (-it[1], it[0])) which yields items sorted by (-count, token), i.e., count descending then token ascending. This matches the specified sort key.\n- Output shape: The function returns a list of (token, count) tuples from counts.items(), and top_k is assigned to that list. Length is min(k, unique tokens) by design via n. This satisfies the output contract (list of tuples, correct length).\n- Edge case k <= 0: Handled in two places\u2014early return in compute_top_k when k <= 0, and again after computing n. In both cases, the result is []. This fulfills the requirement. It also returns [] for empty text, which is consistent with expectations though not explicitly required.\n- No I/O or network: The script performs no printing, I/O, or network access. It runs as-is with the provided globals.\n- Tie-ordering: It does not use Counter.most_common and explicitly implements the specified sort order via the key function.\n- End state: top_k is defined at module end as required. The optional printing clause is not used (which is allowed). The inclusion of __all__ = ['top_k'] is acceptable and does not violate any requirement.\nOverall, the code cleanly satisfies all specified requirements with no violations or omissions.",
+      "code_quality": "The output is code; assessment:\n- Correctness: The counting, tokenization, and ordering logic are correct. heapq.nsmallest with key (-count, token) yields the correct Top-K ordering.\n- Clarity/Readability: Code is reasonably clear with concise comments. Variable names are short but understandable. A return type hint for compute_top_k could improve clarity but is not essential.\n- Efficiency: Using re.finditer for tokenization and heapq.nsmallest for top-k selection is efficient (O(U log K) for selection). Counting via a dict is standard and efficient.\n- Structure/Maintainability: Separation into a helper function and a small conversion helper is tidy. No unnecessary complexity. Avoids reliance on unstable tie-ordering.\n- Best practices: No I/O, no side effects beyond defining top_k. Safe handling of k conversion. Use of re.ASCII ensures correct token class semantics.\nNo bugs or inefficiencies detected; style is solid overall."
+    },
+    "final_judgement": {
+      "adherence_score": 5,
+      "code_quality_score": 5,
+      "comments": "Meets all task requirements precisely and produces the correct Top-K list. Clean, efficient implementation with correct tokenization and ordering. Minor optional improvement: add a return type annotation for compute_top_k for readability."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_02.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_02.json
new file mode 100644
index 0000000000..af2995d0dd
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_02.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_02.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"- Inputs and globals: The code uses the provided globals text and k only to compute top_k at the end and does not reassign them. Good.\\n- Tokenization: Uses regex r'[a-z0-9]+' with re.ASCII | re.IGNORECASE and lowercases tokens via tok = m.group(0).lower(). This matches the requirement: tokens are ASCII [a-z0-9]+ sequences; all other characters act as separators; tokens are normalized to lowercase.\\n- Counting: Iterates over all regex matches and counts frequencies in a dict. Correct.\\n- Sorting: Sorts items with key=lambda kv: (-kv[1], kv[0]) which exactly implements sort by count desc, then token asc. Correct.\\n- Top-K length: Slices to items[:min(k, len(items))], satisfying length = min(k, unique tokens).\\n- Edge case k <= 0: Early return [] if k <= 0. This ensures top_k = [] for non-positive k. Correct.\\n- Output contract: Defines top_k at the end as a list of (token, count) tuples. No extraneous printing; printing is optional per spec. Correct.\\n- Prohibitions: No input(), file I/O, or network access. Does not rely on Counter.most_common. Correct.\\n- Additional checks: The function also guards against non-str text or non-int k by returning [], which is not required but does not violate the spec.\\nOverall, the implementation follows all specified requirements precisely.\",\n    \"code_quality\": \"- Clarity and readability: The code is clean and readable. Type hints are provided. Variable names are descriptive. A brief comment explains tokenization.\\n- Correctness: Logic for tokenization, counting, sorting, and slicing is correct and matches the task.\\n- Efficiency: Uses a single pass to count and a sort for Top-K. Reasonable for general cases. Local binding get = counts.get is a small micro-optimization.\\n- Maintainability: Straightforward structure with a helper function and a single assignment to top_k. Easy to test and reuse.\\n- Minor nits: Using re.IGNORECASE plus .lower() is slightly redundant; using get(tok, 0) would be a tad clearer than (get(tok) or 0). The early empty-counts check is unnecessary because sorting an empty list and slicing would already yield []. None of these affect correctness or significantly harm readability.\\nNo bugs or anti-patterns detected.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 5,\n    \"code_quality_score\": 5,\n    \"comments\": \"Meets all task requirements precisely, including tokenization, sorting, edge cases, and output shape. Code is clear, correct, and efficient. Only very minor stylistic redundancies.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "- Inputs and globals: The code uses the provided globals text and k only to compute top_k at the end and does not reassign them. Good.\n- Tokenization: Uses regex r'[a-z0-9]+' with re.ASCII | re.IGNORECASE and lowercases tokens via tok = m.group(0).lower(). This matches the requirement: tokens are ASCII [a-z0-9]+ sequences; all other characters act as separators; tokens are normalized to lowercase.\n- Counting: Iterates over all regex matches and counts frequencies in a dict. Correct.\n- Sorting: Sorts items with key=lambda kv: (-kv[1], kv[0]) which exactly implements sort by count desc, then token asc. Correct.\n- Top-K length: Slices to items[:min(k, len(items))], satisfying length = min(k, unique tokens).\n- Edge case k <= 0: Early return [] if k <= 0. This ensures top_k = [] for non-positive k. Correct.\n- Output contract: Defines top_k at the end as a list of (token, count) tuples. No extraneous printing; printing is optional per spec. Correct.\n- Prohibitions: No input(), file I/O, or network access. Does not rely on Counter.most_common. Correct.\n- Additional checks: The function also guards against non-str text or non-int k by returning [], which is not required but does not violate the spec.\nOverall, the implementation follows all specified requirements precisely.",
+      "code_quality": "- Clarity and readability: The code is clean and readable. Type hints are provided. Variable names are descriptive. A brief comment explains tokenization.\n- Correctness: Logic for tokenization, counting, sorting, and slicing is correct and matches the task.\n- Efficiency: Uses a single pass to count and a sort for Top-K. Reasonable for general cases. Local binding get = counts.get is a small micro-optimization.\n- Maintainability: Straightforward structure with a helper function and a single assignment to top_k. Easy to test and reuse.\n- Minor nits: Using re.IGNORECASE plus .lower() is slightly redundant; using get(tok, 0) would be a tad clearer than (get(tok) or 0). The early empty-counts check is unnecessary because sorting an empty list and slicing would already yield []. None of these affect correctness or significantly harm readability.\nNo bugs or anti-patterns detected."
+    },
+    "final_judgement": {
+      "adherence_score": 5,
+      "code_quality_score": 5,
+      "comments": "Meets all task requirements precisely, including tokenization, sorting, edge cases, and output shape. Code is clear, correct, and efficient. Only very minor stylistic redundancies."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_03.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_03.json
new file mode 100644
index 0000000000..d56980fddb
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_03.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_03.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"Step-by-step check against instructions:\\n- Tokenization: The code lowercases letters during scanning and collects only ASCII [a-z0-9] sequences, treating all other characters as separators. This matches the required tokenization semantics. It does not use a regex as suggested, but the implemented scanner is functionally equivalent.\\n- Inputs/globals: It reads the provided globals text and k without reassigning them, copying into local _text and _k. It safely handles NameError and non-int k by defaulting to 0, which keeps behavior well-defined. This respects the \\\"Do not reassign them\\\" constraint.\\n- Requirement 1 (ordering): Uses heapq.nsmallest with key = (-count, token), which yields a list ordered by count descending, then token ascending. This fulfills the exact specified sort order without relying on Counter.most_common.\\n- Requirement 2 (top_k content/length): top_k is set to a list of (token, count) tuples returned from counts.items(), with length m = min(k, number of unique tokens). Correct.\\n- Requirement 3 (edge cases): If k <= 0, _top_k_from_counts returns []. Correct.\\n- Requirement 4 (no I/O): No input(), file, or network access is used. The script runs as-is with provided globals.\\n- Output contract: top_k is defined at the end exactly as described. Printing is omitted, which is allowed since printing is optional and constrained only if used.\\n- Note on tie-ordering: The code explicitly implements the specified ordering and does not rely on Counter.\\nMinor deviation: The instruction suggests using a regex for tokenization; the solution uses a manual scanner instead. Since behavior aligns with the spec, this is a minor stylistic deviation rather than a functional issue.\",\n    \"code_quality\": \"No code to write is required beyond the script itself, so assessing provided code:\\n- Correctness: The tokenization logic correctly accumulates ASCII [a-z0-9]+ tokens, lowercasing A-Z via ordinal manipulation, and flushes on separators and at end. Sorting and selection logic is correct via heapq.nsmallest with key (-count, token).\\n- Clarity/readability: Functions are small and well-named. Inline comments explain intent. The manual ASCII checks with ord() are explicit and clear.\\n- Efficiency: Single pass O(n) tokenization; selection is O(U log m) for U unique tokens and m = min(k, U), which is efficient. Using nsmallest avoids full sort when k << U.\\n- Structure/maintainability: Helper functions separate concerns. Avoids reliance on unspecified tie behavior. Minimal, clean dependencies (only heapq). Type hints could be slightly more specific (e.g., Dict[str, int]) but not critical.\\n- Stylistic considerations: Micro-optimization (binding append) is fine but not necessary. Not using regex deviates from the instruction suggestion but does not harm quality.\\nNo bugs or edge-case gaps identified.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 4,\n    \"code_quality_score\": 5,\n    \"comments\": \"Functionally correct and robust solution that meets all requirements, including exact ordering and edge-case handling. Minor deviation from the \\\"use a regex\\\" suggestion prevents a perfect adherence score; otherwise, code quality is excellent.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "Step-by-step check against instructions:\n- Tokenization: The code lowercases letters during scanning and collects only ASCII [a-z0-9] sequences, treating all other characters as separators. This matches the required tokenization semantics. It does not use a regex as suggested, but the implemented scanner is functionally equivalent.\n- Inputs/globals: It reads the provided globals text and k without reassigning them, copying into local _text and _k. It safely handles NameError and non-int k by defaulting to 0, which keeps behavior well-defined. This respects the \"Do not reassign them\" constraint.\n- Requirement 1 (ordering): Uses heapq.nsmallest with key = (-count, token), which yields a list ordered by count descending, then token ascending. This fulfills the exact specified sort order without relying on Counter.most_common.\n- Requirement 2 (top_k content/length): top_k is set to a list of (token, count) tuples returned from counts.items(), with length m = min(k, number of unique tokens). Correct.\n- Requirement 3 (edge cases): If k <= 0, _top_k_from_counts returns []. Correct.\n- Requirement 4 (no I/O): No input(), file, or network access is used. The script runs as-is with provided globals.\n- Output contract: top_k is defined at the end exactly as described. Printing is omitted, which is allowed since printing is optional and constrained only if used.\n- Note on tie-ordering: The code explicitly implements the specified ordering and does not rely on Counter.\nMinor deviation: The instruction suggests using a regex for tokenization; the solution uses a manual scanner instead. Since behavior aligns with the spec, this is a minor stylistic deviation rather than a functional issue.",
+      "code_quality": "No code to write is required beyond the script itself, so assessing provided code:\n- Correctness: The tokenization logic correctly accumulates ASCII [a-z0-9]+ tokens, lowercasing A-Z via ordinal manipulation, and flushes on separators and at end. Sorting and selection logic is correct via heapq.nsmallest with key (-count, token).\n- Clarity/readability: Functions are small and well-named. Inline comments explain intent. The manual ASCII checks with ord() are explicit and clear.\n- Efficiency: Single pass O(n) tokenization; selection is O(U log m) for U unique tokens and m = min(k, U), which is efficient. Using nsmallest avoids full sort when k << U.\n- Structure/maintainability: Helper functions separate concerns. Avoids reliance on unspecified tie behavior. Minimal, clean dependencies (only heapq). Type hints could be slightly more specific (e.g., Dict[str, int]) but not critical.\n- Stylistic considerations: Micro-optimization (binding append) is fine but not necessary. Not using regex deviates from the instruction suggestion but does not harm quality.\nNo bugs or edge-case gaps identified."
+    },
+    "final_judgement": {
+      "adherence_score": 4,
+      "code_quality_score": 5,
+      "comments": "Functionally correct and robust solution that meets all requirements, including exact ordering and edge-case handling. Minor deviation from the \"use a regex\" suggestion prevents a perfect adherence score; otherwise, code quality is excellent."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_04.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_04.json
new file mode 100644
index 0000000000..335266bcc3
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_04.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_04.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"Step-by-step check against instructions:\\n- Tokenization: Uses regex [A-Za-z0-9]+ with re.finditer and lowercases each matched token via .lower(). This matches the requirement to lowercase and use ASCII [a-z0-9]+ sequences with other chars as separators.\\n- Inputs: The function compute_top_k accepts s and k_value; at the end, top_k = compute_top_k(text, k) uses the provided globals without reassigning them.\\n- Sorting/Top-K: Builds counts dict, then computes a composite key key = lambda item: (-item[1], item[0]) and uses heapq.nsmallest(n, ...) to select the n items with smallest key, which corresponds to highest counts then lexicographically smallest tokens. nsmallest returns the list sorted by the key, so the final order is correct: count desc, token asc.\\n- Length of top_k: n is set to max(0, int(k_value)), and nsmallest will return min(n, number of unique tokens) items, satisfying the required length.\\n- Edge cases: If k <= 0, n becomes 0 and the function returns []. If counts is empty, also returns []. Both match the specified behavior.\\n- No disallowed I/O: No input(), file I/O, or network access used.\\n- Output contract: Defines top_k exactly as specified; no extra prints (printing is optional and constrained, so omitting print is acceptable).\\n- Tie ordering: Does not use Counter.most_common; explicitly implements required sort key.\\nOverall, all task requirements are fully met with no deviations.\",\n    \"code_quality\": \"Clarity and readability: The code is clear, with meaningful names and comments explaining key decisions. Type hints are present for function parameters.\\nCorrectness: Logic correctly tokenizes, counts, handles edge cases, and orders results per the required sort key. Returns a list of (token, count) tuples.\\nEfficiency: Uses a hash map for counting and heapq.nsmallest with a composite key for Top-K selection, giving O(U log k) behavior when k << unique tokens, which is efficient.\\nStructure and maintainability: The functionality is encapsulated in a small function; minimal globals usage; no side effects. Comments accurately describe behavior (including nsmallest ordering).\\nBest practices: Avoids reliance on unspecified tie-breaking. Uses regex appropriately. No unnecessary I/O. Minor note: int(k_value) cast is slightly defensive given k is specified as int, but harmless. Also could precompile the regex for repeated calls, but not necessary here.\\nNo bugs or stylistic issues identified that affect behavior.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 5,\n    \"code_quality_score\": 5,\n    \"comments\": \"Excellent adherence: correct tokenization, sorting, edge-case handling, and output contract. Code is clear, efficient, and maintainable. No issues found.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "Step-by-step check against instructions:\n- Tokenization: Uses regex [A-Za-z0-9]+ with re.finditer and lowercases each matched token via .lower(). This matches the requirement to lowercase and use ASCII [a-z0-9]+ sequences with other chars as separators.\n- Inputs: The function compute_top_k accepts s and k_value; at the end, top_k = compute_top_k(text, k) uses the provided globals without reassigning them.\n- Sorting/Top-K: Builds counts dict, then computes a composite key key = lambda item: (-item[1], item[0]) and uses heapq.nsmallest(n, ...) to select the n items with smallest key, which corresponds to highest counts then lexicographically smallest tokens. nsmallest returns the list sorted by the key, so the final order is correct: count desc, token asc.\n- Length of top_k: n is set to max(0, int(k_value)), and nsmallest will return min(n, number of unique tokens) items, satisfying the required length.\n- Edge cases: If k <= 0, n becomes 0 and the function returns []. If counts is empty, also returns []. Both match the specified behavior.\n- No disallowed I/O: No input(), file I/O, or network access used.\n- Output contract: Defines top_k exactly as specified; no extra prints (printing is optional and constrained, so omitting print is acceptable).\n- Tie ordering: Does not use Counter.most_common; explicitly implements required sort key.\nOverall, all task requirements are fully met with no deviations.",
+      "code_quality": "Clarity and readability: The code is clear, with meaningful names and comments explaining key decisions. Type hints are present for function parameters.\nCorrectness: Logic correctly tokenizes, counts, handles edge cases, and orders results per the required sort key. Returns a list of (token, count) tuples.\nEfficiency: Uses a hash map for counting and heapq.nsmallest with a composite key for Top-K selection, giving O(U log k) behavior when k << unique tokens, which is efficient.\nStructure and maintainability: The functionality is encapsulated in a small function; minimal globals usage; no side effects. Comments accurately describe behavior (including nsmallest ordering).\nBest practices: Avoids reliance on unspecified tie-breaking. Uses regex appropriately. No unnecessary I/O. Minor note: int(k_value) cast is slightly defensive given k is specified as int, but harmless. Also could precompile the regex for repeated calls, but not necessary here.\nNo bugs or stylistic issues identified that affect behavior."
+    },
+    "final_judgement": {
+      "adherence_score": 5,
+      "code_quality_score": 5,
+      "comments": "Excellent adherence: correct tokenization, sorting, edge-case handling, and output contract. Code is clear, efficient, and maintainable. No issues found."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_05.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_05.json
new file mode 100644
index 0000000000..4fff225c10
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_05.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_05.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"- Reads and implements the core task: computes Top-K most frequent tokens from given text.\\n- Tokenization rules:\\n  - Lowercasing: Achieved by manually lowercasing ASCII A-Z during tokenization. Although it doesn't lowercase the entire text up front, the outcome matches the requirement to lowercase tokens.\\n  - Token definition: Correctly treats tokens as ASCII [a-z0-9]+ sequences and treats all other characters (including non-ASCII) as separators. This aligns with the specified tokenization semantics.\\n  - However, the instruction explicitly says to \\\"use a regex\\\" for tokenization. The solution uses a manual scanner, not a regex. Functionally correct, but does not follow the specific method requested.\\n- Inputs and globals:\\n  - Uses the provided globals `text` and `k` without reassigning them.\\n  - Wraps access in try/except NameError to ensure `top_k` is defined if globals are missing; this is acceptable and does not violate the requirements.\\n- Requirements compliance:\\n  1) Sorting: Uses sorted with key (-count, token), exactly as required.\\n  2) Output structure: Produces a list of (token, count) tuples, length min(k, unique tokens) via slicing; correct.\\n  3) Edge case k <= 0: Returns [] early; correct.\\n  4) No input/file/network I/O: Satisfied; the script runs as-is.\\n- Output contract: Ensures `top_k` is defined by the end in all cases. No extraneous printing (printing is optional and not used).\\n- Tie handling: Does not rely on Counter.most_common; explicitly implements the specified sort; correct.\\n- Summary: All functional requirements are met. The only deviation is not using a regex for tokenization as explicitly instructed.\",\n    \"code_quality\": \"- Clarity and readability: Well-structured with clear helper names and comments describing tokenization.\\n- Correctness: Tokenization logic correctly handles ASCII letters and digits, lowercases A-Z, and treats all else as separators. Sorting and counting are correct.\\n- Efficiency: Streaming tokenization with a small buffer; uses defaultdict for counting. Sorting once with specified key is fine. Micro-optimizations (local append binding, buf.clear) are appropriate.\\n- Maintainability: Functions are small and focused. Type hints on parameters present; return types could be added but are not critical.\\n- Best practices: Avoids reliance on Counter.most_common tie behavior as requested. No unnecessary I/O. The try/except for missing globals makes the script robust.\\n- Minor note: The instruction asked for a regex-based tokenizer; while the manual approach is efficient and clear, it diverges from the prescribed method (this affects adherence more than code quality).\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 4,\n    \"code_quality_score\": 5,\n    \"comments\": \"Functionally excellent and meets all output and sorting requirements, including edge cases. The only shortcoming is not using a regex for tokenization as explicitly requested.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "- Reads and implements the core task: computes Top-K most frequent tokens from given text.\n- Tokenization rules:\n  - Lowercasing: Achieved by manually lowercasing ASCII A-Z during tokenization. Although it doesn't lowercase the entire text up front, the outcome matches the requirement to lowercase tokens.\n  - Token definition: Correctly treats tokens as ASCII [a-z0-9]+ sequences and treats all other characters (including non-ASCII) as separators. This aligns with the specified tokenization semantics.\n  - However, the instruction explicitly says to \"use a regex\" for tokenization. The solution uses a manual scanner, not a regex. Functionally correct, but does not follow the specific method requested.\n- Inputs and globals:\n  - Uses the provided globals `text` and `k` without reassigning them.\n  - Wraps access in try/except NameError to ensure `top_k` is defined if globals are missing; this is acceptable and does not violate the requirements.\n- Requirements compliance:\n  1) Sorting: Uses sorted with key (-count, token), exactly as required.\n  2) Output structure: Produces a list of (token, count) tuples, length min(k, unique tokens) via slicing; correct.\n  3) Edge case k <= 0: Returns [] early; correct.\n  4) No input/file/network I/O: Satisfied; the script runs as-is.\n- Output contract: Ensures `top_k` is defined by the end in all cases. No extraneous printing (printing is optional and not used).\n- Tie handling: Does not rely on Counter.most_common; explicitly implements the specified sort; correct.\n- Summary: All functional requirements are met. The only deviation is not using a regex for tokenization as explicitly instructed.",
+      "code_quality": "- Clarity and readability: Well-structured with clear helper names and comments describing tokenization.\n- Correctness: Tokenization logic correctly handles ASCII letters and digits, lowercases A-Z, and treats all else as separators. Sorting and counting are correct.\n- Efficiency: Streaming tokenization with a small buffer; uses defaultdict for counting. Sorting once with specified key is fine. Micro-optimizations (local append binding, buf.clear) are appropriate.\n- Maintainability: Functions are small and focused. Type hints on parameters present; return types could be added but are not critical.\n- Best practices: Avoids reliance on Counter.most_common tie behavior as requested. No unnecessary I/O. The try/except for missing globals makes the script robust.\n- Minor note: The instruction asked for a regex-based tokenizer; while the manual approach is efficient and clear, it diverges from the prescribed method (this affects adherence more than code quality)."
+    },
+    "final_judgement": {
+      "adherence_score": 4,
+      "code_quality_score": 5,
+      "comments": "Functionally excellent and meets all output and sorting requirements, including edge cases. The only shortcoming is not using a regex for tokenization as explicitly requested."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_06.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_06.json
new file mode 100644
index 0000000000..caa155101d
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_06.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_06.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"- Tokenization requirements:\\n  - Lowercasing: The implementation lowercases ASCII A-Z to a-z during tokenization, so all produced tokens are lowercase. This satisfies the effective requirement that tokens be lowercase.\\n  - Token definition: It treats only ASCII [a-z0-9] as part of tokens and all other characters as separators. This matches the specified tokenization.\\n  - Note: The instructions explicitly say to \\\"use a regex\\\". The solution uses a manual scanner instead of a regex. While the behavior matches the spec, this deviates from the stated method.\\n\\n- Inputs/globals:\\n  - It does not reassign the provided globals text and k. It reads them into _text and _k via try/except, which is acceptable. The fallback to defaults if globals are missing goes beyond the spec (since the task states they are provided) but does not violate any requirement.\\n\\n- Requirements:\\n  1) Sorting by count desc, then token asc: Achieved via heapq.nsmallest with key = (-count, token). The returned list is in ascending key order, which corresponds to the desired order. Correct.\\n  2) Set top_k to list of (token, count) tuples of length min(k, unique tokens): compute_top_k returns exactly that, and top_k is assigned accordingly. Correct.\\n  3) Handle k <= 0 => []: Explicitly handled at the start of compute_top_k. Correct.\\n  4) No input/file/network: None used. Correct.\\n\\n- Output contract:\\n  - top_k is defined at the end as specified. No extraneous printing; printing is optional, so this is fine.\\n\\n- Tie-ordering disclaimer: Does not rely on Counter.most_common; it implements the order directly. Correct.\\n\\n- Summary: Functionally adheres to all core requirements and edge cases. The only deviation is not using a regex for tokenization as explicitly requested.\",\n    \"code_quality\": \"- Correctness: The tokenizer correctly extracts ASCII [a-z0-9]+ tokens with lowercase output. Counting and Top-K selection are correct, including tie-breaks.\\n- Efficiency: Single-pass tokenization (O(n)) and heapq.nsmallest for Top-K (O(m log k)) are efficient choices. Avoids full sort when k << m.\\n- Readability/Maintainability: Code is organized with clear function boundaries and type hints. The manual ord-based tokenizer is slightly less readable than a regex, but comments clarify intent. Micro-optimizations (append alias) are fine but not strictly necessary.\\n- Structure/Best practices: Clean separation of concerns, no side effects, handles edge cases gracefully, and avoids reliance on unspecified tie ordering. Typing annotations improve clarity. No I/O or network usage.\\n\\nOverall, the code quality is high; the only minor note is that a regex would be simpler and align with the instruction, but the current implementation is clear and well-documented.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 4,\n    \"code_quality_score\": 5,\n    \"comments\": \"Functionally correct and efficient; produces the exact required Top-K with proper sorting and edge-case handling. Minor deviation: does not use a regex as explicitly requested for tokenization.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "- Tokenization requirements:\n  - Lowercasing: The implementation lowercases ASCII A-Z to a-z during tokenization, so all produced tokens are lowercase. This satisfies the effective requirement that tokens be lowercase.\n  - Token definition: It treats only ASCII [a-z0-9] as part of tokens and all other characters as separators. This matches the specified tokenization.\n  - Note: The instructions explicitly say to \"use a regex\". The solution uses a manual scanner instead of a regex. While the behavior matches the spec, this deviates from the stated method.\n\n- Inputs/globals:\n  - It does not reassign the provided globals text and k. It reads them into _text and _k via try/except, which is acceptable. The fallback to defaults if globals are missing goes beyond the spec (since the task states they are provided) but does not violate any requirement.\n\n- Requirements:\n  1) Sorting by count desc, then token asc: Achieved via heapq.nsmallest with key = (-count, token). The returned list is in ascending key order, which corresponds to the desired order. Correct.\n  2) Set top_k to list of (token, count) tuples of length min(k, unique tokens): compute_top_k returns exactly that, and top_k is assigned accordingly. Correct.\n  3) Handle k <= 0 => []: Explicitly handled at the start of compute_top_k. Correct.\n  4) No input/file/network: None used. Correct.\n\n- Output contract:\n  - top_k is defined at the end as specified. No extraneous printing; printing is optional, so this is fine.\n\n- Tie-ordering disclaimer: Does not rely on Counter.most_common; it implements the order directly. Correct.\n\n- Summary: Functionally adheres to all core requirements and edge cases. The only deviation is not using a regex for tokenization as explicitly requested.",
+      "code_quality": "- Correctness: The tokenizer correctly extracts ASCII [a-z0-9]+ tokens with lowercase output. Counting and Top-K selection are correct, including tie-breaks.\n- Efficiency: Single-pass tokenization (O(n)) and heapq.nsmallest for Top-K (O(m log k)) are efficient choices. Avoids full sort when k << m.\n- Readability/Maintainability: Code is organized with clear function boundaries and type hints. The manual ord-based tokenizer is slightly less readable than a regex, but comments clarify intent. Micro-optimizations (append alias) are fine but not strictly necessary.\n- Structure/Best practices: Clean separation of concerns, no side effects, handles edge cases gracefully, and avoids reliance on unspecified tie ordering. Typing annotations improve clarity. No I/O or network usage.\n\nOverall, the code quality is high; the only minor note is that a regex would be simpler and align with the instruction, but the current implementation is clear and well-documented."
+    },
+    "final_judgement": {
+      "adherence_score": 4,
+      "code_quality_score": 5,
+      "comments": "Functionally correct and efficient; produces the exact required Top-K with proper sorting and edge-case handling. Minor deviation: does not use a regex as explicitly requested for tokenization."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_07.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_07.json
new file mode 100644
index 0000000000..61b2b4db7f
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_07.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_07.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"Step-by-step check against instructions:\\n- Tokenization spec: Must lowercase and define tokens as ASCII [a-z0-9]+ with all others as separators, and it says to use a regex. The implementation uses a custom one-pass tokenizer that lowercases only A-Z and accepts only 'a'-'z' and '0'-'9', treating everything else as a separator. Functionally this matches the specified tokenization semantics for ASCII, including lowercasing and separator handling. However, it does not use a regex as explicitly requested. This is a minor deviation from the stated method, though the results should be equivalent.\\n- Inputs: Uses provided globals text and k without reassigning them. The final line sets top_k = compute_top_k(text, k), adhering to the constraint not to reassign text or k.\\n- Requirement 1 (sorting): Returns Top-K using heapq.nsmallest with key = (-count, token), which yields count descending, token ascending. This satisfies the exact sorting specification.\\n- Requirement 2 (top_k structure and length): top_k is set to a list of (token, count) tuples, and heapq.nsmallest(k, ...) ensures length = min(k, number of unique tokens). Correct.\\n- Requirement 3 (edge case k <= 0): compute_top_k returns [] if k <= 0, so top_k becomes []. Correct.\\n- Requirement 4 (no I/O or network): No input(), file I/O, or network usage. The script runs as-is given the globals.\\n- Output contract: top_k is defined at the end as required. No extra printing is performed, which is acceptable since printing is optional and constrained if used.\\n- Tie-order caution: Does not rely on Counter.most_common; implements explicit key as specified.\\nOverall, all functional requirements are met. The only deviation is not using a regex for tokenization, which the instructions explicitly mention.\",\n    \"code_quality\": \"Assessment:\\n- Correctness: The tokenization logic correctly captures ASCII [a-z0-9]+, lowercases A-Z, and treats all other characters as separators. Counting and Top-K selection are correct with the specified tie-breaker.\\n- Efficiency: Single pass tokenization O(n), counting O(n), Top-K via heapq.nsmallest O(U log k) where U is unique token count. Efficient for large inputs.\\n- Clarity and readability: Clear function decomposition, descriptive names, inline comments, and type hints. The custom tokenizer is straightforward and well-commented.\\n- Maintainability: Structured and easy to modify. The only potential stylistic concern is not following the \\\"use a regex\\\" directive, but the implementation itself is clean.\\n- Best practices: Avoids reliance on unspecified tie-ordering; no side effects; guards edge cases (k <= 0, empty text). Minor micro-optimizations (local append, counts.get) are fine.\\nNo bugs or inefficiencies detected. The choice not to use regex impacts task adherence rather than intrinsic code quality.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 4,\n    \"code_quality_score\": 5,\n    \"comments\": \"Functionally excellent and meets all output, sorting, and edge-case requirements. Minor deviation: tokenization did not use a regex as explicitly requested, though behavior matches the spec. Code is clean, efficient, and maintainable.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "Step-by-step check against instructions:\n- Tokenization spec: Must lowercase and define tokens as ASCII [a-z0-9]+ with all others as separators, and it says to use a regex. The implementation uses a custom one-pass tokenizer that lowercases only A-Z and accepts only 'a'-'z' and '0'-'9', treating everything else as a separator. Functionally this matches the specified tokenization semantics for ASCII, including lowercasing and separator handling. However, it does not use a regex as explicitly requested. This is a minor deviation from the stated method, though the results should be equivalent.\n- Inputs: Uses provided globals text and k without reassigning them. The final line sets top_k = compute_top_k(text, k), adhering to the constraint not to reassign text or k.\n- Requirement 1 (sorting): Returns Top-K using heapq.nsmallest with key = (-count, token), which yields count descending, token ascending. This satisfies the exact sorting specification.\n- Requirement 2 (top_k structure and length): top_k is set to a list of (token, count) tuples, and heapq.nsmallest(k, ...) ensures length = min(k, number of unique tokens). Correct.\n- Requirement 3 (edge case k <= 0): compute_top_k returns [] if k <= 0, so top_k becomes []. Correct.\n- Requirement 4 (no I/O or network): No input(), file I/O, or network usage. The script runs as-is given the globals.\n- Output contract: top_k is defined at the end as required. No extra printing is performed, which is acceptable since printing is optional and constrained if used.\n- Tie-order caution: Does not rely on Counter.most_common; implements explicit key as specified.\nOverall, all functional requirements are met. The only deviation is not using a regex for tokenization, which the instructions explicitly mention.",
+      "code_quality": "Assessment:\n- Correctness: The tokenization logic correctly captures ASCII [a-z0-9]+, lowercases A-Z, and treats all other characters as separators. Counting and Top-K selection are correct with the specified tie-breaker.\n- Efficiency: Single pass tokenization O(n), counting O(n), Top-K via heapq.nsmallest O(U log k) where U is unique token count. Efficient for large inputs.\n- Clarity and readability: Clear function decomposition, descriptive names, inline comments, and type hints. The custom tokenizer is straightforward and well-commented.\n- Maintainability: Structured and easy to modify. The only potential stylistic concern is not following the \"use a regex\" directive, but the implementation itself is clean.\n- Best practices: Avoids reliance on unspecified tie-ordering; no side effects; guards edge cases (k <= 0, empty text). Minor micro-optimizations (local append, counts.get) are fine.\nNo bugs or inefficiencies detected. The choice not to use regex impacts task adherence rather than intrinsic code quality."
+    },
+    "final_judgement": {
+      "adherence_score": 4,
+      "code_quality_score": 5,
+      "comments": "Functionally excellent and meets all output, sorting, and edge-case requirements. Minor deviation: tokenization did not use a regex as explicitly requested, though behavior matches the spec. Code is clean, efficient, and maintainable."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_08.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_08.json
new file mode 100644
index 0000000000..9b3870f247
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_08.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_08.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"Step-by-step check against the instructions:\\n- Tokenization: The code lowercases the input once (src.lower()) and uses a regex _token_re = re.compile(r'[a-z0-9]+') with finditer to extract tokens. This matches the spec: lowercase first, tokens are ASCII [a-z0-9]+ sequences, and all other characters act as separators.\\n- Inputs: It expects globals text (str) and k (int) and does not reassign them. It uses these to compute top_k at the end.\\n- Requirement 1 (sorting): It computes the top K using heapq.nsmallest with key=lambda kv: (-kv[1], kv[0]), which orders by count descending and token ascending, exactly as specified.\\n- Requirement 2 (top_k content and length): It returns a list of (token, count) tuples taken from counts.items(). The length is constrained with n = min(n, len(counts)), ensuring length equals min(k, unique tokens).\\n- Requirement 3 (edge cases): It handles k <= 0 by returning [] (n coerced via int conversion and explicit check if n <= 0). It also returns [] when there are no tokens (if not counts).\\n- Requirement 4 (no I/O/network): There is no input(), file I/O, or network access. The script runs as-is using the provided globals.\\n- Output contract: The global top_k is defined at the end as compute_top_k(text, k), producing the required list of (token, count) tuples. No extraneous printing occurs, which is allowed.\\n- Note on tie ordering: It does not rely on Counter.most_common; it explicitly implements the required sort ordering. \\nOverall, the code fully adheres to all specified instructions, including edge cases and ordering.\",\n    \"code_quality\": \"This is not only correct but also well-written:\\n- Clarity/Readability: Clear function name, type hints, and concise comments. Precompiled regex is a nice touch.\\n- Correctness: Tokenization, counting, sorting, and edge-case handling are implemented correctly. Using heapq.nsmallest with key (-count, token) yields the exact ordering required.\\n- Efficiency: Streaming tokenization via finditer avoids building an intermediate token list. Using nsmallest is efficient for large vocabularies when k is small (O(U log K)).\\n- Maintainability/Structure: Encapsulating logic in compute_top_k and assigning top_k at the end is clean and modular.\\n- Best practices: No unnecessary I/O, avoids reliance on unspecified tie ordering. Robustly coerces k to int (though the task guarantees int, this does no harm).\\nPotential minor nitpicks: None that affect correctness. One optional micro-clarity improvement could be to specify re.ASCII (not necessary here since [a-z0-9] is already ASCII-specific), or to avoid int conversion since k is guaranteed int, but this is harmless and can improve robustness.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 5,\n    \"code_quality_score\": 5,\n    \"comments\": \"Fully meets all requirements, including exact tokenization, ordering, edge cases, and output contract. Code is clear, efficient, and well-structured. No issues found.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "Step-by-step check against the instructions:\n- Tokenization: The code lowercases the input once (src.lower()) and uses a regex _token_re = re.compile(r'[a-z0-9]+') with finditer to extract tokens. This matches the spec: lowercase first, tokens are ASCII [a-z0-9]+ sequences, and all other characters act as separators.\n- Inputs: It expects globals text (str) and k (int) and does not reassign them. It uses these to compute top_k at the end.\n- Requirement 1 (sorting): It computes the top K using heapq.nsmallest with key=lambda kv: (-kv[1], kv[0]), which orders by count descending and token ascending, exactly as specified.\n- Requirement 2 (top_k content and length): It returns a list of (token, count) tuples taken from counts.items(). The length is constrained with n = min(n, len(counts)), ensuring length equals min(k, unique tokens).\n- Requirement 3 (edge cases): It handles k <= 0 by returning [] (n coerced via int conversion and explicit check if n <= 0). It also returns [] when there are no tokens (if not counts).\n- Requirement 4 (no I/O/network): There is no input(), file I/O, or network access. The script runs as-is using the provided globals.\n- Output contract: The global top_k is defined at the end as compute_top_k(text, k), producing the required list of (token, count) tuples. No extraneous printing occurs, which is allowed.\n- Note on tie ordering: It does not rely on Counter.most_common; it explicitly implements the required sort ordering. \nOverall, the code fully adheres to all specified instructions, including edge cases and ordering.",
+      "code_quality": "This is not only correct but also well-written:\n- Clarity/Readability: Clear function name, type hints, and concise comments. Precompiled regex is a nice touch.\n- Correctness: Tokenization, counting, sorting, and edge-case handling are implemented correctly. Using heapq.nsmallest with key (-count, token) yields the exact ordering required.\n- Efficiency: Streaming tokenization via finditer avoids building an intermediate token list. Using nsmallest is efficient for large vocabularies when k is small (O(U log K)).\n- Maintainability/Structure: Encapsulating logic in compute_top_k and assigning top_k at the end is clean and modular.\n- Best practices: No unnecessary I/O, avoids reliance on unspecified tie ordering. Robustly coerces k to int (though the task guarantees int, this does no harm).\nPotential minor nitpicks: None that affect correctness. One optional micro-clarity improvement could be to specify re.ASCII (not necessary here since [a-z0-9] is already ASCII-specific), or to avoid int conversion since k is guaranteed int, but this is harmless and can improve robustness."
+    },
+    "final_judgement": {
+      "adherence_score": 5,
+      "code_quality_score": 5,
+      "comments": "Fully meets all requirements, including exact tokenization, ordering, edge cases, and output contract. Code is clear, efficient, and well-structured. No issues found."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_09.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_09.json
new file mode 100644
index 0000000000..ea8bc2f50d
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_09.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_09.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"- Reads task: compute Top-K most frequent tokens from globals text and k, with specified tokenization and ordering; set top_k accordingly; handle k<=0; avoid I/O; don't rely on Counter tie rules.\\n- Tokenization requirements:\\n  - Lowercase the text: The code lowercases only ASCII A-Z by converting each uppercase letter via chr(o + 32) during scanning. This is equivalent to lowercasing for the specified token alphabet [a-z0-9].\\n  - Tokens are ASCII [a-z0-9]+; others are separators: The scanner accepts digits (48-57), lowercase letters (97-122), and converts uppercase letters (65-90) to lowercase before appending; anything else triggers a token flush, matching the separator rule. Behavior aligns with the spec for ASCII-only tokens.\\n  - \\\"Use a regex\\\": The implementation does not use a regex; instead it manually scans. While the functional outcome matches the spec, this deviates from the explicit instruction to use a regex. Minor adherence issue.\\n- Inputs: Uses globals text and k without reassigning them. It passes int(k) to the selection function but does not reassign k, which is acceptable.\\n- Requirements:\\n  1) Sort by count desc, then token asc: _select_top_k uses heapq.nsmallest with key (-count, token). Since nsmallest returns items ordered ascending by the key, this yields count descending then token ascending. Correct.\\n  2) Set top_k to list of (token, count) tuples, length = min(k, unique): _select_top_k computes n = min(k, len(counts)) and returns that many (token, count) pairs; top-level assigns top_k accordingly. Correct.\\n  3) Handle k <= 0 -> []: _select_top_k returns [] if not counts or k <= 0; thus top_k becomes []. Correct.\\n  4) No input/file/network: None used. Correct.\\n- Output contract: top_k is defined at end as list of (token, count) with correct ordering; no extra printing. Correct.\\n- Tie-ordering note: Does not rely on Counter; implements explicit ordering. Correct.\\n- Edge cases and ambiguity:\\n  - Non-ASCII letters/digits are treated as separators, consistent with ASCII-only token spec.\\n  - The manual lowercasing is limited to ASCII, which is appropriate given the token definition.\\n  - The only notable deviation is not using a regex as requested; however, the functional behavior matches the regex-defined tokenization.\\n\",\n    \"code_quality\": \"- Clarity and readability: Functions are small and well-named with helpful comments. Manual ASCII scanning with ord ranges and micro-optimizations (local variable bindings, buf list and clear) slightly reduce readability compared to a regex approach but are still understandable.\\n- Correctness: Tokenization matches the specified ASCII [a-z0-9]+ rule and lowercasing. Sorting uses a robust key (-count, token) and nsmallest, yielding the correct order. Edge cases (k <= 0, empty input) are handled.\\n- Efficiency: Single pass scan O(n) for counting; nsmallest for top-k selection is O(U log k) which is efficient for large U and small k. Avoids full sort when unnecessary.\\n- Structure and maintainability: Separation into _count_tokens and _select_top_k is good. No side effects beyond defining top_k. No reliance on undefined behavior (e.g., Counter tie-breaking). Variable names and comments are appropriate.\\n- Best practices: No I/O. Avoids reassigning globals. Uses heapq appropriately. Minor nit: micro-optimizations (binding methods to locals) trade clarity for speed; acceptable but could be simplified for readability if performance is not critical. Also, the instruction suggested using regex; while not required for correctness, adopting re would improve alignment with the spec and likely readability.\\n\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 4,\n    \"code_quality_score\": 4,\n    \"comments\": \"Functionally correct and efficient implementation that meets ordering, edge cases, and output contract. The only notable deviation is not using a regex for tokenization as specified, though behavior matches the rule. Code is clean and performant, with minor readability trade-offs due to manual ASCII scanning and micro-optimizations.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "- Reads task: compute Top-K most frequent tokens from globals text and k, with specified tokenization and ordering; set top_k accordingly; handle k<=0; avoid I/O; don't rely on Counter tie rules.\n- Tokenization requirements:\n  - Lowercase the text: The code lowercases only ASCII A-Z by converting each uppercase letter via chr(o + 32) during scanning. This is equivalent to lowercasing for the specified token alphabet [a-z0-9].\n  - Tokens are ASCII [a-z0-9]+; others are separators: The scanner accepts digits (48-57), lowercase letters (97-122), and converts uppercase letters (65-90) to lowercase before appending; anything else triggers a token flush, matching the separator rule. Behavior aligns with the spec for ASCII-only tokens.\n  - \"Use a regex\": The implementation does not use a regex; instead it manually scans. While the functional outcome matches the spec, this deviates from the explicit instruction to use a regex. Minor adherence issue.\n- Inputs: Uses globals text and k without reassigning them. It passes int(k) to the selection function but does not reassign k, which is acceptable.\n- Requirements:\n  1) Sort by count desc, then token asc: _select_top_k uses heapq.nsmallest with key (-count, token). Since nsmallest returns items ordered ascending by the key, this yields count descending then token ascending. Correct.\n  2) Set top_k to list of (token, count) tuples, length = min(k, unique): _select_top_k computes n = min(k, len(counts)) and returns that many (token, count) pairs; top-level assigns top_k accordingly. Correct.\n  3) Handle k <= 0 -> []: _select_top_k returns [] if not counts or k <= 0; thus top_k becomes []. Correct.\n  4) No input/file/network: None used. Correct.\n- Output contract: top_k is defined at end as list of (token, count) with correct ordering; no extra printing. Correct.\n- Tie-ordering note: Does not rely on Counter; implements explicit ordering. Correct.\n- Edge cases and ambiguity:\n  - Non-ASCII letters/digits are treated as separators, consistent with ASCII-only token spec.\n  - The manual lowercasing is limited to ASCII, which is appropriate given the token definition.\n  - The only notable deviation is not using a regex as requested; however, the functional behavior matches the regex-defined tokenization.\n",
+      "code_quality": "- Clarity and readability: Functions are small and well-named with helpful comments. Manual ASCII scanning with ord ranges and micro-optimizations (local variable bindings, buf list and clear) slightly reduce readability compared to a regex approach but are still understandable.\n- Correctness: Tokenization matches the specified ASCII [a-z0-9]+ rule and lowercasing. Sorting uses a robust key (-count, token) and nsmallest, yielding the correct order. Edge cases (k <= 0, empty input) are handled.\n- Efficiency: Single pass scan O(n) for counting; nsmallest for top-k selection is O(U log k) which is efficient for large U and small k. Avoids full sort when unnecessary.\n- Structure and maintainability: Separation into _count_tokens and _select_top_k is good. No side effects beyond defining top_k. No reliance on undefined behavior (e.g., Counter tie-breaking). Variable names and comments are appropriate.\n- Best practices: No I/O. Avoids reassigning globals. Uses heapq appropriately. Minor nit: micro-optimizations (binding methods to locals) trade clarity for speed; acceptable but could be simplified for readability if performance is not critical. Also, the instruction suggested using regex; while not required for correctness, adopting re would improve alignment with the spec and likely readability.\n"
+    },
+    "final_judgement": {
+      "adherence_score": 4,
+      "code_quality_score": 4,
+      "comments": "Functionally correct and efficient implementation that meets ordering, edge cases, and output contract. The only notable deviation is not using a regex for tokenization as specified, though behavior matches the rule. Code is clean and performant, with minor readability trade-offs due to manual ASCII scanning and micro-optimizations."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_10.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_10.json
new file mode 100644
index 0000000000..70b74be0f6
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_10.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_10.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"Step-by-step:\\n- Overall task: Computes Top-K most frequent tokens from the given text and assigns to top_k. Yes, via _compute_top_k and final assignment.\\n- Tokenization: Lowercasing is applied per character (c = ch.lower()). Tokens restricted to ASCII [a-z0-9]+ and others act as separators. This matches the semantics. However, the instruction explicitly says to use a regex; the implementation uses manual scanning instead. Functionally correct but does not follow the \\\"use a regex\\\" directive.\\n- Inputs: Uses globals text and k without reassigning them. Reads them into local variables _text and _k with fallbacks if missing, which does not violate the instruction and is harmless given that globals are provided.\\n- Requirement 1 (sort by count desc, then token asc): Satisfied. Uses heapq.nsmallest with key = (-count, token) over counts.items(). The returned list is in the required order.\\n- Requirement 2 (top_k is list of (token, count) tuples, length = min(k, unique)): Satisfied. counts.items() yields tuples; nsmallest(k, ...) returns at most k items; if k exceeds unique tokens, returns all, hence length is min(k, unique).\\n- Requirement 3 (k <= 0 -> []): Satisfied. Returns [] when k <= 0. Also handles non-int k by returning [], which is acceptable though not required.\\n- Requirement 4 (no input/file/network; run as-is): Satisfied. No prohibited I/O; script runs as-is.\\n- Output contract: top_k is defined at end exactly as specified. No extra printing. Does not rely on Counter.most_common tie ordering.\\n- Ambiguities/choices: Handling non-int k by returning [] is a reasonable defensive choice and does not conflict with requirements.\",\n    \"code_quality\": \"This is not user-facing code generation but evaluable code is present, so assessing code quality:\\n- Correctness: Tokenization logic matches the specified [a-z0-9]+ after lowercasing; sorting and tie-breaking are correct; edge cases for k handled.\\n- Clarity/Readability: Clear helper function names, concise comments, straightforward structure. Using aliases (append) and buf.clear() is fine and readable.\\n- Efficiency: Single pass tokenization; Counter accumulation; heapq.nsmallest gives O(U log K) top-K selection which is efficient. No unnecessary overhead.\\n- Maintainability: Modularized into tokenization and computation functions; easy to test and modify.\\n- Best practices: Avoids reliance on Counter.most_common tie ordering as required. Minor deviation: does not use regex as instructed (style/requirement rather than correctness). Otherwise solid.\\n- No apparent bugs or edge-case failures discovered.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 4,\n    \"code_quality_score\": 5,\n    \"comments\": \"Functionally correct with proper sorting, edge-case handling, and correct top_k output. The only notable miss is not using a regex for tokenization as explicitly requested; otherwise, the implementation is clean and efficient.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "Step-by-step:\n- Overall task: Computes Top-K most frequent tokens from the given text and assigns to top_k. Yes, via _compute_top_k and final assignment.\n- Tokenization: Lowercasing is applied per character (c = ch.lower()). Tokens restricted to ASCII [a-z0-9]+ and others act as separators. This matches the semantics. However, the instruction explicitly says to use a regex; the implementation uses manual scanning instead. Functionally correct but does not follow the \"use a regex\" directive.\n- Inputs: Uses globals text and k without reassigning them. Reads them into local variables _text and _k with fallbacks if missing, which does not violate the instruction and is harmless given that globals are provided.\n- Requirement 1 (sort by count desc, then token asc): Satisfied. Uses heapq.nsmallest with key = (-count, token) over counts.items(). The returned list is in the required order.\n- Requirement 2 (top_k is list of (token, count) tuples, length = min(k, unique)): Satisfied. counts.items() yields tuples; nsmallest(k, ...) returns at most k items; if k exceeds unique tokens, returns all, hence length is min(k, unique).\n- Requirement 3 (k <= 0 -> []): Satisfied. Returns [] when k <= 0. Also handles non-int k by returning [], which is acceptable though not required.\n- Requirement 4 (no input/file/network; run as-is): Satisfied. No prohibited I/O; script runs as-is.\n- Output contract: top_k is defined at end exactly as specified. No extra printing. Does not rely on Counter.most_common tie ordering.\n- Ambiguities/choices: Handling non-int k by returning [] is a reasonable defensive choice and does not conflict with requirements.",
+      "code_quality": "This is not user-facing code generation but evaluable code is present, so assessing code quality:\n- Correctness: Tokenization logic matches the specified [a-z0-9]+ after lowercasing; sorting and tie-breaking are correct; edge cases for k handled.\n- Clarity/Readability: Clear helper function names, concise comments, straightforward structure. Using aliases (append) and buf.clear() is fine and readable.\n- Efficiency: Single pass tokenization; Counter accumulation; heapq.nsmallest gives O(U log K) top-K selection which is efficient. No unnecessary overhead.\n- Maintainability: Modularized into tokenization and computation functions; easy to test and modify.\n- Best practices: Avoids reliance on Counter.most_common tie ordering as required. Minor deviation: does not use regex as instructed (style/requirement rather than correctness). Otherwise solid.\n- No apparent bugs or edge-case failures discovered."
+    },
+    "final_judgement": {
+      "adherence_score": 4,
+      "code_quality_score": 5,
+      "comments": "Functionally correct with proper sorting, edge-case handling, and correct top_k output. The only notable miss is not using a regex for tokenization as explicitly requested; otherwise, the implementation is clean and efficient."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_11.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_11.json
new file mode 100644
index 0000000000..298ad3c19c
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_11.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_11.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"- Inputs/globals: The code reads globals text and k without reassigning them, passing them into a helper function. It does not modify the globals, satisfying the constraint.\\n- Tokenization: Uses regex r'[A-Za-z0-9]+' with re.ASCII to capture ASCII alphanumeric sequences, and lowercases each matched token (tok = m.group(0).lower()), which functionally matches \\\"Lowercase the text\\\" and the specified tokenization rule.\\n- Counting: Accumulates counts in a dict, as required.\\n- Sorting/Top-K: Uses heapq.nsmallest with key (-count, token) over counts.items(), which produces a list sorted by count descending then token ascending, matching the exact specified sort key and ensuring deterministic tie-breaking without relying on Counter.most_common.\\n- Output shape: Returns a list of (token, count) tuples (from counts.items()) and assigns it to top_k at module scope. The length is min(k, number of unique tokens) via kk = min(k, n_unique).\\n- Edge cases: If k cannot be converted to int, it treats as 0; if k <= 0, returns []. If text is empty, returns [], which matches min(k, 0). All required edge cases are handled.\\n- No prohibited operations: No input(), file I/O, or network access; optional printing is not used.\\n- Ambiguities: The instruction states \\\"Lowercase the text\\\"; the implementation lowercases tokens on-the-fly, which yields identical tokens per the regex spec and is reasonable.\\nOverall, the implementation meets all specified requirements and contracts.\",\n    \"code_quality\": \"- Correctness: Logic is sound; key=(-count, token) ensures correct ordering. Returns proper list of (token, count) tuples.\\n- Efficiency: Uses heapq.nsmallest to avoid full sort when k << unique tokens; iterates regex matches without lowercasing the whole text, saving memory.\\n- Readability: Clear structure with explanatory comments. Variable names are mostly clear; kk could be more descriptive (e.g., k_eff), but this is minor.\\n- Robustness: Safely handles non-string text by coercing to str and handles non-int k by converting to int with fallback to 0.\\n- Maintainability/Style: Simple, modular via helper function; no unnecessary dependencies. Avoids reliance on unstable tie-breaking.\\nNo bugs or inefficiencies evident; minor naming nit only.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 5,\n    \"code_quality_score\": 5,\n    \"comments\": \"Meets all task requirements precisely, including tokenization, sorting, edge cases, and output contract. Clean, efficient implementation with clear comments.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "- Inputs/globals: The code reads globals text and k without reassigning them, passing them into a helper function. It does not modify the globals, satisfying the constraint.\n- Tokenization: Uses regex r'[A-Za-z0-9]+' with re.ASCII to capture ASCII alphanumeric sequences, and lowercases each matched token (tok = m.group(0).lower()), which functionally matches \"Lowercase the text\" and the specified tokenization rule.\n- Counting: Accumulates counts in a dict, as required.\n- Sorting/Top-K: Uses heapq.nsmallest with key (-count, token) over counts.items(), which produces a list sorted by count descending then token ascending, matching the exact specified sort key and ensuring deterministic tie-breaking without relying on Counter.most_common.\n- Output shape: Returns a list of (token, count) tuples (from counts.items()) and assigns it to top_k at module scope. The length is min(k, number of unique tokens) via kk = min(k, n_unique).\n- Edge cases: If k cannot be converted to int, it treats as 0; if k <= 0, returns []. If text is empty, returns [], which matches min(k, 0). All required edge cases are handled.\n- No prohibited operations: No input(), file I/O, or network access; optional printing is not used.\n- Ambiguities: The instruction states \"Lowercase the text\"; the implementation lowercases tokens on-the-fly, which yields identical tokens per the regex spec and is reasonable.\nOverall, the implementation meets all specified requirements and contracts.",
+      "code_quality": "- Correctness: Logic is sound; key=(-count, token) ensures correct ordering. Returns proper list of (token, count) tuples.\n- Efficiency: Uses heapq.nsmallest to avoid full sort when k << unique tokens; iterates regex matches without lowercasing the whole text, saving memory.\n- Readability: Clear structure with explanatory comments. Variable names are mostly clear; kk could be more descriptive (e.g., k_eff), but this is minor.\n- Robustness: Safely handles non-string text by coercing to str and handles non-int k by converting to int with fallback to 0.\n- Maintainability/Style: Simple, modular via helper function; no unnecessary dependencies. Avoids reliance on unstable tie-breaking.\nNo bugs or inefficiencies evident; minor naming nit only."
+    },
+    "final_judgement": {
+      "adherence_score": 5,
+      "code_quality_score": 5,
+      "comments": "Meets all task requirements precisely, including tokenization, sorting, edge cases, and output contract. Clean, efficient implementation with clear comments."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_12.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_12.json
new file mode 100644
index 0000000000..7724e10c70
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_12.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_12.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"- Tokenization: Uses regex [A-Za-z0-9]+ with re.ASCII and lowercases each match, which matches the spec of ASCII [a-z0-9]+ tokens with other chars as separators. Lowercasing is correctly applied post-match.\\n- Sorting: Constructs a key function key = lambda it: (-it[1], it[0]) and uses it for ordering, satisfying the requirement to sort by count descending then token ascending. It avoids Counter.most_common as requested.\\n- Top-K selection and length: Computes t = max(0, min(int(k), len(items))) and returns either nsmallest(t, items, key=key) or sorted(items, key=key), ensuring the result length is min(k, number of unique tokens). For t == 0 or no tokens, returns []. This meets the length contract and edge case of k <= 0.\\n- Edge cases: If no tokens (items empty) \u2192 [], correct. If k <= 0 \u2192 [], correct. If k > unique tokens \u2192 returns all sorted items, correct.\\n- Inputs handling: Does not reassign the provided globals text or k. Wraps the call in a try/except NameError to set top_k = [] if globals are missing; while unnecessary given the spec, it does not violate any requirement and still ensures top_k is defined.\\n- Output contract: Defines top_k at the end as a list of (token, count) tuples. No extra printing, which is allowed (printing is optional and constrained if used).\\n- No disallowed operations: No input(), file I/O, or network access present.\\n- Minor note: Using nsmallest ensures both correct Top-K selection and returns them in sorted order by the provided key, so the output order is correct.\\nOverall, the code satisfies all specified requirements.\",\n    \"code_quality\": \"- Correctness: Implements counting, tokenization, sorting, and Top-K selection correctly. Does not rely on Counter.most_common tie ordering.\\n- Efficiency: Uses heapq.nsmallest for the Top-K path, which is efficient when k << number of unique tokens. Precompiles the regex. Overall time/space usage is reasonable.\\n- Readability/Structure: Clear function structure with type hints. Variable names are mostly clear; 't' could be more descriptive (e.g., n or k_eff), but this is minor. Inline comment summarizes the tokenization rule.\\n- Maintainability: Simple, self-contained, and adheres to best practices. No unnecessary complexity.\\n- Error handling: The try/except NameError around the call is a gentle safeguard; it doesn\u2019t mask other errors and keeps behavior predictable.\\nNo bugs or significant stylistic issues identified.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 5,\n    \"code_quality_score\": 5,\n    \"comments\": \"Meets all task requirements precisely, including tokenization, sorting, edge cases, and output contract. Code is clean, efficient, and readable. Minor nit: rename variable 't' for clarity if desired.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "- Tokenization: Uses regex [A-Za-z0-9]+ with re.ASCII and lowercases each match, which matches the spec of ASCII [a-z0-9]+ tokens with other chars as separators. Lowercasing is correctly applied post-match.\n- Sorting: Constructs a key function key = lambda it: (-it[1], it[0]) and uses it for ordering, satisfying the requirement to sort by count descending then token ascending. It avoids Counter.most_common as requested.\n- Top-K selection and length: Computes t = max(0, min(int(k), len(items))) and returns either nsmallest(t, items, key=key) or sorted(items, key=key), ensuring the result length is min(k, number of unique tokens). For t == 0 or no tokens, returns []. This meets the length contract and edge case of k <= 0.\n- Edge cases: If no tokens (items empty) \u2192 [], correct. If k <= 0 \u2192 [], correct. If k > unique tokens \u2192 returns all sorted items, correct.\n- Inputs handling: Does not reassign the provided globals text or k. Wraps the call in a try/except NameError to set top_k = [] if globals are missing; while unnecessary given the spec, it does not violate any requirement and still ensures top_k is defined.\n- Output contract: Defines top_k at the end as a list of (token, count) tuples. No extra printing, which is allowed (printing is optional and constrained if used).\n- No disallowed operations: No input(), file I/O, or network access present.\n- Minor note: Using nsmallest ensures both correct Top-K selection and returns them in sorted order by the provided key, so the output order is correct.\nOverall, the code satisfies all specified requirements.",
+      "code_quality": "- Correctness: Implements counting, tokenization, sorting, and Top-K selection correctly. Does not rely on Counter.most_common tie ordering.\n- Efficiency: Uses heapq.nsmallest for the Top-K path, which is efficient when k << number of unique tokens. Precompiles the regex. Overall time/space usage is reasonable.\n- Readability/Structure: Clear function structure with type hints. Variable names are mostly clear; 't' could be more descriptive (e.g., n or k_eff), but this is minor. Inline comment summarizes the tokenization rule.\n- Maintainability: Simple, self-contained, and adheres to best practices. No unnecessary complexity.\n- Error handling: The try/except NameError around the call is a gentle safeguard; it doesn\u2019t mask other errors and keeps behavior predictable.\nNo bugs or significant stylistic issues identified."
+    },
+    "final_judgement": {
+      "adherence_score": 5,
+      "code_quality_score": 5,
+      "comments": "Meets all task requirements precisely, including tokenization, sorting, edge cases, and output contract. Code is clean, efficient, and readable. Minor nit: rename variable 't' for clarity if desired."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_13.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_13.json
new file mode 100644
index 0000000000..11925ee206
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_13.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_13.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"Step-by-step check against instructions:\\n- Tokenization rules: The code tokenizes ASCII [a-z0-9]+ sequences, lowercasing letters and treating all other characters as separators via a manual ASCII scan. This behavior matches the specified tokenization semantics. However, the instruction explicitly says \\\"use a regex\\\". The implementation does not use a regex; while functionally equivalent, this deviates from the stated method.\\n- Lowercasing: Uppercase ASCII letters are converted to lowercase during scanning. This satisfies the lowercase requirement for tokens within the ASCII range.\\n- Inputs (globals text, k; do not reassign): The code references text and k via compute_top_k(text, k) and does not reassign these globals. Inside the function, it casts the local k to int, which does not modify the global k. Compliant.\\n- Requirement 1 (sort by count desc, token asc): Achieved via heapq.nsmallest with key = (-count, token), which returns results sorted by that key. This meets the ordering requirement and does not rely on Counter.most_common.\\n- Requirement 2 (top_k list of (token, count) tuples, length = min(k, unique tokens)): The function computes counts, computes n = min(k, len(counts)), and returns a list of (token, count) tuples of length n. Compliant.\\n- Requirement 3 (k <= 0 -> []): If k <= 0 or counts empty, returns []. Compliant.\\n- Requirement 4 (no input/file/network; script runs as-is): No I/O is used. The code guards top_k assignment in a try/except NameError to ensure top_k is defined if globals are missing; with provided globals, it sets top_k accordingly. Compliant.\\n- Output contract (top_k defined as described; optional print only top_k): top_k is defined as required; no printing is performed. Compliant.\\n\\nSummary: All functional requirements are met, but the explicit \\\"use a regex\\\" directive for tokenization is not followed.\",\n    \"code_quality\": \"Code quality assessment:\\n- Correctness: Tokenization, counting, and sorting are correctly implemented for the specified ASCII token definition. Tie-breaking and k handling are correct.\\n- Clarity/Readability: The tokenizer uses ord-based character range checks and a micro-optimized buffer (append alias). This is efficient but less readable than a straightforward regex approach and typical Python style. Comments help, but readability could be improved by simpler constructs.\\n- Efficiency: Single-pass tokenization is O(n). Top-K extraction via heapq.nsmallest is efficient, especially when k << number of unique tokens. For k close to the number of unique tokens, performance remains acceptable.\\n- Structure/Maintainability: Separation into _count_tokens and compute_top_k is clean. The NameError guard ensures top_k is always defined but is arguably unnecessary given the stated inputs; still harmless.\\n- Best practices: Avoiding unnecessary micro-optimizations (like caching append) could improve readability. Using regex would align with the instruction and typical Python practices, but the current approach is still solid.\\n\\nNo bugs or correctness issues identified; primary nit is readability and deviation from the requested regex approach.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 4,\n    \"code_quality_score\": 4,\n    \"comments\": \"Functionally excellent and meets sorting and output requirements, but it does not follow the explicit 'use a regex' instruction for tokenization. Minor readability concerns due to micro-optimizations and low-level ASCII handling.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "Step-by-step check against instructions:\n- Tokenization rules: The code tokenizes ASCII [a-z0-9]+ sequences, lowercasing letters and treating all other characters as separators via a manual ASCII scan. This behavior matches the specified tokenization semantics. However, the instruction explicitly says \"use a regex\". The implementation does not use a regex; while functionally equivalent, this deviates from the stated method.\n- Lowercasing: Uppercase ASCII letters are converted to lowercase during scanning. This satisfies the lowercase requirement for tokens within the ASCII range.\n- Inputs (globals text, k; do not reassign): The code references text and k via compute_top_k(text, k) and does not reassign these globals. Inside the function, it casts the local k to int, which does not modify the global k. Compliant.\n- Requirement 1 (sort by count desc, token asc): Achieved via heapq.nsmallest with key = (-count, token), which returns results sorted by that key. This meets the ordering requirement and does not rely on Counter.most_common.\n- Requirement 2 (top_k list of (token, count) tuples, length = min(k, unique tokens)): The function computes counts, computes n = min(k, len(counts)), and returns a list of (token, count) tuples of length n. Compliant.\n- Requirement 3 (k <= 0 -> []): If k <= 0 or counts empty, returns []. Compliant.\n- Requirement 4 (no input/file/network; script runs as-is): No I/O is used. The code guards top_k assignment in a try/except NameError to ensure top_k is defined if globals are missing; with provided globals, it sets top_k accordingly. Compliant.\n- Output contract (top_k defined as described; optional print only top_k): top_k is defined as required; no printing is performed. Compliant.\n\nSummary: All functional requirements are met, but the explicit \"use a regex\" directive for tokenization is not followed.",
+      "code_quality": "Code quality assessment:\n- Correctness: Tokenization, counting, and sorting are correctly implemented for the specified ASCII token definition. Tie-breaking and k handling are correct.\n- Clarity/Readability: The tokenizer uses ord-based character range checks and a micro-optimized buffer (append alias). This is efficient but less readable than a straightforward regex approach and typical Python style. Comments help, but readability could be improved by simpler constructs.\n- Efficiency: Single-pass tokenization is O(n). Top-K extraction via heapq.nsmallest is efficient, especially when k << number of unique tokens. For k close to the number of unique tokens, performance remains acceptable.\n- Structure/Maintainability: Separation into _count_tokens and compute_top_k is clean. The NameError guard ensures top_k is always defined but is arguably unnecessary given the stated inputs; still harmless.\n- Best practices: Avoiding unnecessary micro-optimizations (like caching append) could improve readability. Using regex would align with the instruction and typical Python practices, but the current approach is still solid.\n\nNo bugs or correctness issues identified; primary nit is readability and deviation from the requested regex approach."
+    },
+    "final_judgement": {
+      "adherence_score": 4,
+      "code_quality_score": 4,
+      "comments": "Functionally excellent and meets sorting and output requirements, but it does not follow the explicit 'use a regex' instruction for tokenization. Minor readability concerns due to micro-optimizations and low-level ASCII handling."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_14.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_14.json
new file mode 100644
index 0000000000..7add319969
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_14.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_14.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"Step-by-step adherence check:\\n- Inputs/globals: The code reads from globals `text` and `k` and does not reassign them. It wraps the access in a try/except NameError and sets `top_k = []` if globals are missing. With provided globals (as per task), it uses them directly. This adheres to the input constraints.\\n- Tokenization: The tokenizer `_iter_ascii_tokens` lowercases ASCII A-Z by bitwise OR 32 and accepts only ASCII letters/digits [a-z0-9], treating all other characters (including non-ASCII) as separators. This matches the specified token definition and lowercasing behavior. The instruction suggests using a regex, but the implemented manual tokenizer produces equivalent behavior. This is a minor deviation from the suggested implementation style but not from the functional spec.\\n- Sorting: Uses `heapq.nsmallest(kk, counts.items(), key=lambda it: (-it[1], it[0]))`, which effectively returns items sorted by count descending (via negative count) and token ascending, matching requirement (1). Since `nsmallest` returns a sorted list by the key, the resulting order satisfies the contract.\\n- Top-K and length: It computes `kk = min(int(k), len(counts))` and returns exactly `kk` items, fulfilling requirement (2).\\n- Edge cases: If `k` cannot be cast to int or `k <= 0`, it returns `[]`, satisfying requirement (3). If the text yields no tokens, it also returns `[]`, which is consistent with `min(k, 0) = 0`.\\n- No I/O: There is no input(), file I/O, or network access. Satisfies requirement (4).\\n- Output contract: At the end, `top_k` is defined as a list of `(token, count)` tuples. No extraneous printing. Meets the contract.\\n- Tie-ordering and Counter: Does not rely on Counter.most_common; uses explicit key ordering as required.\\nAmbiguity consideration: The parenthetical \\\"use a regex\\\" could be read as a strict requirement or a suggestion. The code does not use a regex but achieves the exact specified tokenization, which is a reasonable and correct choice; thus, at most a minor stylistic deviation.\",\n    \"code_quality\": \"Code quality assessment:\\n- Correctness: Tokenization correctly handles ASCII rules, lowercases A-Z, treats all other chars as separators, and flushes buffers at boundaries and at end. Counting and Top-K selection are correct, and sorting by (-count, token) is implemented via `heapq.nsmallest` with an appropriate key.\\n- Clarity/Readability: Functions are small, well-named, and commented. The use of `ord` and bitwise OR (o | 32) is efficient but slightly less readable than `ch.lower()` or a regex; comments mitigate this. Overall readable.\\n- Efficiency: Single pass tokenization and counting O(n). Selection via `heapq.nsmallest` is O(n log k) and returns sorted output, which is efficient for large n and small k. For k near n, complexity is similar to sorting, which is acceptable.\\n- Structure/Maintainability: Helpers are modular. Minimal global interaction. No reliance on unspecified tie-breaking. Edge cases handled cleanly.\\n- Best practices: Avoids unnecessary I/O. Does not mutate provided globals. Uses local variable caching (`get = counts.get`) for micro-optimization. The fallback `try/except NameError` to define `top_k` is harmless and ensures `top_k` is always defined.\\nNo bugs or inefficiencies identified; only a minor readability note regarding bitwise lowercase and the choice not to use regex.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 4,\n    \"code_quality_score\": 5,\n    \"comments\": \"Functionally excellent and meets all requirements, including sorting, edge cases, and output format. Minor deviation: does not use a regex for tokenization as suggested, though behavior matches the spec exactly. Code is clean, efficient, and maintainable.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "Step-by-step adherence check:\n- Inputs/globals: The code reads from globals `text` and `k` and does not reassign them. It wraps the access in a try/except NameError and sets `top_k = []` if globals are missing. With provided globals (as per task), it uses them directly. This adheres to the input constraints.\n- Tokenization: The tokenizer `_iter_ascii_tokens` lowercases ASCII A-Z by bitwise OR 32 and accepts only ASCII letters/digits [a-z0-9], treating all other characters (including non-ASCII) as separators. This matches the specified token definition and lowercasing behavior. The instruction suggests using a regex, but the implemented manual tokenizer produces equivalent behavior. This is a minor deviation from the suggested implementation style but not from the functional spec.\n- Sorting: Uses `heapq.nsmallest(kk, counts.items(), key=lambda it: (-it[1], it[0]))`, which effectively returns items sorted by count descending (via negative count) and token ascending, matching requirement (1). Since `nsmallest` returns a sorted list by the key, the resulting order satisfies the contract.\n- Top-K and length: It computes `kk = min(int(k), len(counts))` and returns exactly `kk` items, fulfilling requirement (2).\n- Edge cases: If `k` cannot be cast to int or `k <= 0`, it returns `[]`, satisfying requirement (3). If the text yields no tokens, it also returns `[]`, which is consistent with `min(k, 0) = 0`.\n- No I/O: There is no input(), file I/O, or network access. Satisfies requirement (4).\n- Output contract: At the end, `top_k` is defined as a list of `(token, count)` tuples. No extraneous printing. Meets the contract.\n- Tie-ordering and Counter: Does not rely on Counter.most_common; uses explicit key ordering as required.\nAmbiguity consideration: The parenthetical \"use a regex\" could be read as a strict requirement or a suggestion. The code does not use a regex but achieves the exact specified tokenization, which is a reasonable and correct choice; thus, at most a minor stylistic deviation.",
+      "code_quality": "Code quality assessment:\n- Correctness: Tokenization correctly handles ASCII rules, lowercases A-Z, treats all other chars as separators, and flushes buffers at boundaries and at end. Counting and Top-K selection are correct, and sorting by (-count, token) is implemented via `heapq.nsmallest` with an appropriate key.\n- Clarity/Readability: Functions are small, well-named, and commented. The use of `ord` and bitwise OR (o | 32) is efficient but slightly less readable than `ch.lower()` or a regex; comments mitigate this. Overall readable.\n- Efficiency: Single pass tokenization and counting O(n). Selection via `heapq.nsmallest` is O(n log k) and returns sorted output, which is efficient for large n and small k. For k near n, complexity is similar to sorting, which is acceptable.\n- Structure/Maintainability: Helpers are modular. Minimal global interaction. No reliance on unspecified tie-breaking. Edge cases handled cleanly.\n- Best practices: Avoids unnecessary I/O. Does not mutate provided globals. Uses local variable caching (`get = counts.get`) for micro-optimization. The fallback `try/except NameError` to define `top_k` is harmless and ensures `top_k` is always defined.\nNo bugs or inefficiencies identified; only a minor readability note regarding bitwise lowercase and the choice not to use regex."
+    },
+    "final_judgement": {
+      "adherence_score": 4,
+      "code_quality_score": 5,
+      "comments": "Functionally excellent and meets all requirements, including sorting, edge cases, and output format. Minor deviation: does not use a regex for tokenization as suggested, though behavior matches the spec exactly. Code is clean, efficient, and maintainable."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_15.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_15.json
new file mode 100644
index 0000000000..40137aeab1
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_15.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_15.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"Step-by-step assessment against the task:\\n- Tokenization requirements:\\n  - Lowercasing: Achieved via on-the-fly conversion of 'A'-'Z' to lowercase when building tokens. Functionally equivalent to lowercasing the text first.\\n  - ASCII [a-z0-9]+ tokens; others are separators: Implemented by scanning characters with ord ranges for digits and letters, treating everything else as a separator. This matches the specified token set and separator behavior.\\n  - Use a regex: Not followed. The implementation uses a manual streaming tokenizer instead of a regex, which deviates from the explicit instruction.\\n- Inputs: Uses provided globals 'text' and 'k' without reassigning them. Correct.\\n- Requirement 1 (sort by count desc, then token asc): Implemented via sorted(counts.items(), key=lambda it: (-it[1], it[0])). Correct.\\n- Requirement 2 (top_k is list of (token, count) tuples, length = min(k, unique)): The function computes counts, sorts, and slices to k if needed. Returns [] when no tokens. The final 'top_k' is assigned the returned list. Correct.\\n- Requirement 3 (k <= 0 -> top_k = []): Handled at the start of _compute_top_k; returns [], so top_k becomes []. Correct.\\n- Requirement 4 (no I/O or network; runs as-is): No I/O or network usage. Relies only on provided globals. Correct.\\n- Output contract: Ends with 'top_k' defined exactly as specified; no extra printing. Correct.\\n- Note (do not rely on Counter.most_common tie ordering): Not using Counter at all; uses explicit sorting key. Correct.\\nOverall, all functional requirements are met except the explicit \\\"use a regex\\\" directive for tokenization.\",\n    \"code_quality\": \"The output is code; assessment follows:\\n- Correctness: Tokenization logic correctly yields lowercase ASCII alphanumeric tokens, treating other chars as separators. Counting and sorting logic match the spec, including tie-breaking. Edge cases (k <= 0, no tokens) handled properly.\\n- Clarity/Readability: Code is reasonably clear with explanatory comments. Variable names are meaningful. Minor nit: _iter_ascii_tokens lacks a return type hint (Iterator[str]). The ord-based branching is a bit low-level versus a regex but still understandable with comments.\\n- Efficiency: Single-pass tokenization with buffered yields; dictionary counting; O(U log U) sort where U is number of unique tokens. Local variable bindings (append, get) are micro-optimizations and fine.\\n- Maintainability/Structure: Helper functions are well-scoped; no side effects beyond final assignment. Type hints used for top_k and return of _compute_top_k.\\n- Best practices: Avoids reliance on Counter.most_common tie-order. No unnecessary I/O. The only deviation from the spec is not using a regex for tokenization; from a code-quality perspective, the manual tokenizer is acceptable and efficient.\\nNo bugs or inefficiencies detected that would affect correctness or performance in typical use.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 4,\n    \"code_quality_score\": 5,\n    \"comments\": \"Functionally excellent and meets all sorting, edge-case, and output requirements. The only miss is not using a regex for tokenization as explicitly requested. Otherwise, clean, efficient, and correct.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "Step-by-step assessment against the task:\n- Tokenization requirements:\n  - Lowercasing: Achieved via on-the-fly conversion of 'A'-'Z' to lowercase when building tokens. Functionally equivalent to lowercasing the text first.\n  - ASCII [a-z0-9]+ tokens; others are separators: Implemented by scanning characters with ord ranges for digits and letters, treating everything else as a separator. This matches the specified token set and separator behavior.\n  - Use a regex: Not followed. The implementation uses a manual streaming tokenizer instead of a regex, which deviates from the explicit instruction.\n- Inputs: Uses provided globals 'text' and 'k' without reassigning them. Correct.\n- Requirement 1 (sort by count desc, then token asc): Implemented via sorted(counts.items(), key=lambda it: (-it[1], it[0])). Correct.\n- Requirement 2 (top_k is list of (token, count) tuples, length = min(k, unique)): The function computes counts, sorts, and slices to k if needed. Returns [] when no tokens. The final 'top_k' is assigned the returned list. Correct.\n- Requirement 3 (k <= 0 -> top_k = []): Handled at the start of _compute_top_k; returns [], so top_k becomes []. Correct.\n- Requirement 4 (no I/O or network; runs as-is): No I/O or network usage. Relies only on provided globals. Correct.\n- Output contract: Ends with 'top_k' defined exactly as specified; no extra printing. Correct.\n- Note (do not rely on Counter.most_common tie ordering): Not using Counter at all; uses explicit sorting key. Correct.\nOverall, all functional requirements are met except the explicit \"use a regex\" directive for tokenization.",
+      "code_quality": "The output is code; assessment follows:\n- Correctness: Tokenization logic correctly yields lowercase ASCII alphanumeric tokens, treating other chars as separators. Counting and sorting logic match the spec, including tie-breaking. Edge cases (k <= 0, no tokens) handled properly.\n- Clarity/Readability: Code is reasonably clear with explanatory comments. Variable names are meaningful. Minor nit: _iter_ascii_tokens lacks a return type hint (Iterator[str]). The ord-based branching is a bit low-level versus a regex but still understandable with comments.\n- Efficiency: Single-pass tokenization with buffered yields; dictionary counting; O(U log U) sort where U is number of unique tokens. Local variable bindings (append, get) are micro-optimizations and fine.\n- Maintainability/Structure: Helper functions are well-scoped; no side effects beyond final assignment. Type hints used for top_k and return of _compute_top_k.\n- Best practices: Avoids reliance on Counter.most_common tie-order. No unnecessary I/O. The only deviation from the spec is not using a regex for tokenization; from a code-quality perspective, the manual tokenizer is acceptable and efficient.\nNo bugs or inefficiencies detected that would affect correctness or performance in typical use."
+    },
+    "final_judgement": {
+      "adherence_score": 4,
+      "code_quality_score": 5,
+      "comments": "Functionally excellent and meets all sorting, edge-case, and output requirements. The only miss is not using a regex for tokenization as explicitly requested. Otherwise, clean, efficient, and correct."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_16.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_16.json
new file mode 100644
index 0000000000..48734ddeaf
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_16.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_16.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"Step-by-step adherence assessment:\\n- Tokenization rules: The code lowercases characters and treats ASCII letters a\u2013z and digits 0\u20139 as token characters; everything else is a separator. This matches the functional definition of tokens. However, the instruction explicitly says to \\\"use a regex\\\" for tokenization. The implementation uses a manual state machine instead of a regex, so this part of the instruction is not followed, even though the behavior appears correct.\\n- Inputs: It reads the provided globals `text` and `k` and does not reassign them. It accesses them via `globals().get`, which still adheres to the constraint of not reassigning.\\n- Sorting requirement: It computes counts, then selects Top-K using `heapq.nsmallest` with key `(-count, token)`. This yields items in order of count descending, then token ascending, satisfying the specified sort key.\\n- Output shape and length: The result is a list of `(token, count)` tuples with length `min(k, number of unique tokens)` by applying `kk = min(kk, len(counts))`. If there are fewer unique tokens than `k`, it limits accordingly.\\n- Edge cases: If `k` is non-integer, it coerces to int inside a try/except; if the coercion fails or `kk <= 0`, it returns `[]`, satisfying the requirement that `k <= 0` yields an empty list. If there are no tokens, it also returns `[]`, which aligns with `min(k, 0) = 0`.\\n- No disallowed operations: It does not use input(), file I/O, or network access. It does not print anything, which is allowed as printing is optional and restricted to only printing `top_k` if done.\\n- Output contract: At the end, `top_k` is defined exactly as a list of `(token, count)` tuples, ordered correctly.\\n\\nSummary: All functional requirements are met, but the specific instruction to use a regex for tokenization is not followed.\",\n    \"code_quality\": \"Code quality assessment:\\n- Correctness: The tokenization logic correctly forms tokens from ASCII letters and digits after lowercasing. Counting and Top-K selection are correct and stable under the specified tie-breaker. No reliance on Counter.tie-ordering.\\n- Efficiency: Single pass counting is O(n). Using `heapq.nsmallest` provides O(m log k) selection, efficient for large m with small k. It also returns results sorted by the key, meeting order requirements.\\n- Readability and structure: Clear helper functions with type hints, descriptive comments, and straightforward logic. The use of `_iter_tokens` as a generator is clean. Variable names are clear. Minimal, focused code.\\n- Maintainability and best practices: Sensible separation of concerns, no side effects, and proper handling of edge cases. Using `globals().get` is slightly unconventional but harmless in this context. Lack of regex conflicts with the explicit instruction but does not harm code quality per se.\\n\\nNo bugs or inefficiencies identified beyond not using regex as specified by the task.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 4,\n    \"code_quality_score\": 5,\n    \"comments\": \"Functionally correct, efficient, and clean implementation that meets all requirements except the explicit instruction to use a regex for tokenization. Consider switching tokenization to a regex to fully comply with the task specification.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "Step-by-step adherence assessment:\n- Tokenization rules: The code lowercases characters and treats ASCII letters a\u2013z and digits 0\u20139 as token characters; everything else is a separator. This matches the functional definition of tokens. However, the instruction explicitly says to \"use a regex\" for tokenization. The implementation uses a manual state machine instead of a regex, so this part of the instruction is not followed, even though the behavior appears correct.\n- Inputs: It reads the provided globals `text` and `k` and does not reassign them. It accesses them via `globals().get`, which still adheres to the constraint of not reassigning.\n- Sorting requirement: It computes counts, then selects Top-K using `heapq.nsmallest` with key `(-count, token)`. This yields items in order of count descending, then token ascending, satisfying the specified sort key.\n- Output shape and length: The result is a list of `(token, count)` tuples with length `min(k, number of unique tokens)` by applying `kk = min(kk, len(counts))`. If there are fewer unique tokens than `k`, it limits accordingly.\n- Edge cases: If `k` is non-integer, it coerces to int inside a try/except; if the coercion fails or `kk <= 0`, it returns `[]`, satisfying the requirement that `k <= 0` yields an empty list. If there are no tokens, it also returns `[]`, which aligns with `min(k, 0) = 0`.\n- No disallowed operations: It does not use input(), file I/O, or network access. It does not print anything, which is allowed as printing is optional and restricted to only printing `top_k` if done.\n- Output contract: At the end, `top_k` is defined exactly as a list of `(token, count)` tuples, ordered correctly.\n\nSummary: All functional requirements are met, but the specific instruction to use a regex for tokenization is not followed.",
+      "code_quality": "Code quality assessment:\n- Correctness: The tokenization logic correctly forms tokens from ASCII letters and digits after lowercasing. Counting and Top-K selection are correct and stable under the specified tie-breaker. No reliance on Counter.tie-ordering.\n- Efficiency: Single pass counting is O(n). Using `heapq.nsmallest` provides O(m log k) selection, efficient for large m with small k. It also returns results sorted by the key, meeting order requirements.\n- Readability and structure: Clear helper functions with type hints, descriptive comments, and straightforward logic. The use of `_iter_tokens` as a generator is clean. Variable names are clear. Minimal, focused code.\n- Maintainability and best practices: Sensible separation of concerns, no side effects, and proper handling of edge cases. Using `globals().get` is slightly unconventional but harmless in this context. Lack of regex conflicts with the explicit instruction but does not harm code quality per se.\n\nNo bugs or inefficiencies identified beyond not using regex as specified by the task."
+    },
+    "final_judgement": {
+      "adherence_score": 4,
+      "code_quality_score": 5,
+      "comments": "Functionally correct, efficient, and clean implementation that meets all requirements except the explicit instruction to use a regex for tokenization. Consider switching tokenization to a regex to fully comply with the task specification."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_17.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_17.json
new file mode 100644
index 0000000000..7076ff6811
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_17.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_17.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"Step-by-step check against instructions:\\n- Tokenization: Uses a compiled regex [A-Za-z0-9]+ to extract ASCII alphanumeric sequences and lowercases each token via tok = m.group(0).lower(). This matches the requirement to lowercase and use ASCII [a-z0-9]+ with other characters as separators.\\n- Inputs: Reads from the provided globals text and k without reassigning them. Passes them into a helper function; does not modify the globals.\\n- Requirement 1 (sorting): Uses heapq.nsmallest with key=lambda kv: (-kv[1], kv[0]). Since nsmallest returns results in ascending key order, negating the count achieves count-desc, and kv[0] (token) provides ascending token tiebreak. This exactly matches the specified sort key (-count, token).\\n- Requirement 2 (top_k shape/length): Returns a list of (token, count) tuples from counts.items(). Computes top_n = min(k, len(counts)), so the length is min(k, number of unique tokens). Assigns top_k to this list at the end.\\n- Requirement 3 (edge case k <= 0): Early return [] if k <= 0 (also if k is not int, which is stricter than required but not harmful since the task promises int).\\n- Requirement 4 (no I/O/network): No input(), file I/O, or network usage. Script relies only on provided globals and standard library.\\n- Output contract: Defines top_k at the end as specified. Does not print anything else (printing is optional). Does not rely on Counter.most_common.\\nNo ambiguities appear to be mishandled. All parts of the task are met precisely.\",\n    \"code_quality\": \"Assessment:\\n- Correctness: Logic is sound; counting via a dict and selecting top-k with the correct sort key yields the exact required ordering. Handles empty input and k <= 0 correctly.\\n- Efficiency: Single pass tokenization with finditer avoids building intermediate lists. heapq.nsmallest provides O(n log k) behavior for small k, which is efficient. top_n is set to min(k, unique), avoiding over-selection.\\n- Readability/Clarity: Clear variable names, concise comments, and a small helper function improve structure. The compiled regex at module scope is good for performance. Type hints are present for parameters; adding a return type annotation would be a minor improvement.\\n- Maintainability/Style: Pythonic and straightforward. The isinstance(k, int) guard is extra relative to the spec but harmless and may prevent misuse. No unnecessary dependencies or side effects.\\n- No bugs or stylistic issues of concern. Using heapq.nsmallest returns a sorted list according to the key, satisfying the required output order.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 5,\n    \"code_quality_score\": 5,\n    \"comments\": \"Meets all requirements precisely: correct tokenization, ordering by (-count, token), correct length and edge cases, and proper top_k assignment. Code is clean, efficient, and maintainable. Minor optional improvement: add a return type annotation for the helper function.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "Step-by-step check against instructions:\n- Tokenization: Uses a compiled regex [A-Za-z0-9]+ to extract ASCII alphanumeric sequences and lowercases each token via tok = m.group(0).lower(). This matches the requirement to lowercase and use ASCII [a-z0-9]+ with other characters as separators.\n- Inputs: Reads from the provided globals text and k without reassigning them. Passes them into a helper function; does not modify the globals.\n- Requirement 1 (sorting): Uses heapq.nsmallest with key=lambda kv: (-kv[1], kv[0]). Since nsmallest returns results in ascending key order, negating the count achieves count-desc, and kv[0] (token) provides ascending token tiebreak. This exactly matches the specified sort key (-count, token).\n- Requirement 2 (top_k shape/length): Returns a list of (token, count) tuples from counts.items(). Computes top_n = min(k, len(counts)), so the length is min(k, number of unique tokens). Assigns top_k to this list at the end.\n- Requirement 3 (edge case k <= 0): Early return [] if k <= 0 (also if k is not int, which is stricter than required but not harmful since the task promises int).\n- Requirement 4 (no I/O/network): No input(), file I/O, or network usage. Script relies only on provided globals and standard library.\n- Output contract: Defines top_k at the end as specified. Does not print anything else (printing is optional). Does not rely on Counter.most_common.\nNo ambiguities appear to be mishandled. All parts of the task are met precisely.",
+      "code_quality": "Assessment:\n- Correctness: Logic is sound; counting via a dict and selecting top-k with the correct sort key yields the exact required ordering. Handles empty input and k <= 0 correctly.\n- Efficiency: Single pass tokenization with finditer avoids building intermediate lists. heapq.nsmallest provides O(n log k) behavior for small k, which is efficient. top_n is set to min(k, unique), avoiding over-selection.\n- Readability/Clarity: Clear variable names, concise comments, and a small helper function improve structure. The compiled regex at module scope is good for performance. Type hints are present for parameters; adding a return type annotation would be a minor improvement.\n- Maintainability/Style: Pythonic and straightforward. The isinstance(k, int) guard is extra relative to the spec but harmless and may prevent misuse. No unnecessary dependencies or side effects.\n- No bugs or stylistic issues of concern. Using heapq.nsmallest returns a sorted list according to the key, satisfying the required output order."
+    },
+    "final_judgement": {
+      "adherence_score": 5,
+      "code_quality_score": 5,
+      "comments": "Meets all requirements precisely: correct tokenization, ordering by (-count, token), correct length and edge cases, and proper top_k assignment. Code is clean, efficient, and maintainable. Minor optional improvement: add a return type annotation for the helper function."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_18.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_18.json
new file mode 100644
index 0000000000..075b175776
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_18.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_18.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"Step-by-step check against the instructions:\\n- Tokenization: The generator _iter_tokens_ascii_lower uses re.finditer(r'[A-Za-z0-9]+', s) and lower() on each match, which exactly matches the requirement: lowercase tokens; tokens are ASCII [a-z0-9]+ sequences; all other characters are separators.\\n- Inputs: The code consumes the provided globals text and k only at the final assignment top_k = _compute_top_k(text, k) and does not reassign them.\\n- Requirement 1 (sorting): In _compute_top_k, it selects the top k using heapq.nsmallest with key=lambda it: (-it[1], it[0]). Because the key sorts by negative count first (thus count descending) and then by token ascending, and nsmallest returns results in sorted order, the resulting list is correctly sorted by count desc, then token asc.\\n- Requirement 2 (shape and length): It builds a list of (token, count) tuples from counts and computes kk as min(k, number of unique tokens) via kk = k if k < len(counts) else len(counts). The returned list length is kk, satisfying the length requirement. The elements are 2-tuples (token, count).\\n- Requirement 3 (edge case k <= 0): Early return [] if k <= 0 satisfies this. Empty or no-token input also returns [] via the early checks.\\n- Requirement 4 (no I/O): The code performs no input(), file I/O, or network access; it runs purely on provided globals.\\n- Output contract: At the end, top_k is defined as the computed list with the exact specified ordering and length. It does not print, which is allowed (printing is optional). \\n- Tie-ordering note: It does not rely on Counter.most_common; it implements the specified sort explicitly.\\nOverall, the code fully adheres to all specified instructions and edge cases.\",\n    \"code_quality\": \"Clarity and correctness: Functions are clearly named and commented; logic is correct. The regex tokenization and counting are straightforward and correct.\\nEfficiency: Using heapq.nsmallest with key=(-count, token) is efficient (O(n log k)) and appropriate for Top-K selection. Streaming tokenization avoids holding intermediate lists.\\nReadability and style: Generally good. Minor nitpicks:\\n- kk could be named more descriptively (e.g., limit = min(k, len(counts))). Also, using min(k, len(counts)) would be clearer than the conditional expression.\\n- The list comprehension [(t, c) for t, c in nsmallest(...)] is redundant since nsmallest already returns tuples of (token, count); it can be returned directly.\\n- Optional micro-optimization: precompile the regex pattern if called frequently.\\nNo bugs or maintainability issues identified beyond these small style points.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 5,\n    \"code_quality_score\": 4,\n    \"comments\": \"Excellent adherence: correct tokenization, sorting, edge-case handling, and output contract. Code is clean and efficient. Minor style improvements possible (use min(), avoid redundant list comprehension, clearer variable name).\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "Step-by-step check against the instructions:\n- Tokenization: The generator _iter_tokens_ascii_lower uses re.finditer(r'[A-Za-z0-9]+', s) and lower() on each match, which exactly matches the requirement: lowercase tokens; tokens are ASCII [a-z0-9]+ sequences; all other characters are separators.\n- Inputs: The code consumes the provided globals text and k only at the final assignment top_k = _compute_top_k(text, k) and does not reassign them.\n- Requirement 1 (sorting): In _compute_top_k, it selects the top k using heapq.nsmallest with key=lambda it: (-it[1], it[0]). Because the key sorts by negative count first (thus count descending) and then by token ascending, and nsmallest returns results in sorted order, the resulting list is correctly sorted by count desc, then token asc.\n- Requirement 2 (shape and length): It builds a list of (token, count) tuples from counts and computes kk as min(k, number of unique tokens) via kk = k if k < len(counts) else len(counts). The returned list length is kk, satisfying the length requirement. The elements are 2-tuples (token, count).\n- Requirement 3 (edge case k <= 0): Early return [] if k <= 0 satisfies this. Empty or no-token input also returns [] via the early checks.\n- Requirement 4 (no I/O): The code performs no input(), file I/O, or network access; it runs purely on provided globals.\n- Output contract: At the end, top_k is defined as the computed list with the exact specified ordering and length. It does not print, which is allowed (printing is optional). \n- Tie-ordering note: It does not rely on Counter.most_common; it implements the specified sort explicitly.\nOverall, the code fully adheres to all specified instructions and edge cases.",
+      "code_quality": "Clarity and correctness: Functions are clearly named and commented; logic is correct. The regex tokenization and counting are straightforward and correct.\nEfficiency: Using heapq.nsmallest with key=(-count, token) is efficient (O(n log k)) and appropriate for Top-K selection. Streaming tokenization avoids holding intermediate lists.\nReadability and style: Generally good. Minor nitpicks:\n- kk could be named more descriptively (e.g., limit = min(k, len(counts))). Also, using min(k, len(counts)) would be clearer than the conditional expression.\n- The list comprehension [(t, c) for t, c in nsmallest(...)] is redundant since nsmallest already returns tuples of (token, count); it can be returned directly.\n- Optional micro-optimization: precompile the regex pattern if called frequently.\nNo bugs or maintainability issues identified beyond these small style points."
+    },
+    "final_judgement": {
+      "adherence_score": 5,
+      "code_quality_score": 4,
+      "comments": "Excellent adherence: correct tokenization, sorting, edge-case handling, and output contract. Code is clean and efficient. Minor style improvements possible (use min(), avoid redundant list comprehension, clearer variable name)."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_19.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_19.json
new file mode 100644
index 0000000000..765c001aae
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_19.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_19.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"- Tokenization: The helper _iter_tokens lowercases the input and uses a regex [a-z0-9]+ to extract ASCII alphanumeric sequences, treating all other characters as separators. This matches the specification.\\n- Inputs: The code uses the provided globals text and k without reassigning them. Access is via top_k = top_k_tokens(text, k) inside a try block. No I/O or network is used.\\n- Requirements:\\n  1) Sorting by count desc, then token asc is implemented by using heapq.nsmallest with key lambda item: (-item[1], item[0]). This produces the required order (largest counts first; alphabetical ties).\\n  2) The function returns a list of (token, count) tuples. Using nsmallest(k, ...) ensures the length is min(k, number of unique tokens). counts.items() yields (token, count) pairs, fulfilling the tuple structure.\\n  3) Edge case k <= 0: top_k_tokens returns [], satisfying the requirement.\\n  4) The script runs as-is given globals text (str) and k (int). It does not use input(), file I/O, or network.\\n- Output contract: top_k is defined at the end. With valid inputs, top_k will be exactly the computed Top-K as described. The broad try/except sets top_k = [] on any exception; while unnecessary given the guaranteed inputs, it does not affect correctness under the stated conditions.\\n- Additional notes: The code does not rely on Counter.most_common and explicitly implements the specified sort key.\\n- Minor nit: The early return if not counts is redundant because nsmallest would already return []. This does not affect adherence.\",\n    \"code_quality\": \"- Correctness: Logic is correct for counting, tokenization, and ordering. Tie-breaking is implemented correctly.\\n- Clarity/Readability: Clear function and variable names; annotations provided; concise comments explain intent. Helper _iter_tokens isolates tokenization.\\n- Efficiency: Uses a single pass to count tokens and heapq.nsmallest for top-k selection (O(U log k)), which is efficient. Compiled regex is reused via default parameter to avoid recompilation overhead.\\n- Maintainability/Structure: Separation of concerns (_iter_tokens vs. top_k_tokens). Minimal, clean imports. No unnecessary dependencies.\\n- Robustness: Type checks guard against incorrect input types. The broad try/except around the top_k assignment could mask unexpected errors; while harmless here, narrowing the exception or omitting the try in trusted environments would be cleaner.\\n- Minor style note: The explicit if not counts: return [] is unnecessary but harmless.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 5,\n    \"code_quality_score\": 5,\n    \"comments\": \"Meets all task requirements with correct tokenization, ordering, and edge-case handling. Code is clear and efficient. The broad try/except and a redundant empty-check are minor nits but do not impact correctness.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "- Tokenization: The helper _iter_tokens lowercases the input and uses a regex [a-z0-9]+ to extract ASCII alphanumeric sequences, treating all other characters as separators. This matches the specification.\n- Inputs: The code uses the provided globals text and k without reassigning them. Access is via top_k = top_k_tokens(text, k) inside a try block. No I/O or network is used.\n- Requirements:\n  1) Sorting by count desc, then token asc is implemented by using heapq.nsmallest with key lambda item: (-item[1], item[0]). This produces the required order (largest counts first; alphabetical ties).\n  2) The function returns a list of (token, count) tuples. Using nsmallest(k, ...) ensures the length is min(k, number of unique tokens). counts.items() yields (token, count) pairs, fulfilling the tuple structure.\n  3) Edge case k <= 0: top_k_tokens returns [], satisfying the requirement.\n  4) The script runs as-is given globals text (str) and k (int). It does not use input(), file I/O, or network.\n- Output contract: top_k is defined at the end. With valid inputs, top_k will be exactly the computed Top-K as described. The broad try/except sets top_k = [] on any exception; while unnecessary given the guaranteed inputs, it does not affect correctness under the stated conditions.\n- Additional notes: The code does not rely on Counter.most_common and explicitly implements the specified sort key.\n- Minor nit: The early return if not counts is redundant because nsmallest would already return []. This does not affect adherence.",
+      "code_quality": "- Correctness: Logic is correct for counting, tokenization, and ordering. Tie-breaking is implemented correctly.\n- Clarity/Readability: Clear function and variable names; annotations provided; concise comments explain intent. Helper _iter_tokens isolates tokenization.\n- Efficiency: Uses a single pass to count tokens and heapq.nsmallest for top-k selection (O(U log k)), which is efficient. Compiled regex is reused via default parameter to avoid recompilation overhead.\n- Maintainability/Structure: Separation of concerns (_iter_tokens vs. top_k_tokens). Minimal, clean imports. No unnecessary dependencies.\n- Robustness: Type checks guard against incorrect input types. The broad try/except around the top_k assignment could mask unexpected errors; while harmless here, narrowing the exception or omitting the try in trusted environments would be cleaner.\n- Minor style note: The explicit if not counts: return [] is unnecessary but harmless."
+    },
+    "final_judgement": {
+      "adherence_score": 5,
+      "code_quality_score": 5,
+      "comments": "Meets all task requirements with correct tokenization, ordering, and edge-case handling. Code is clear and efficient. The broad try/except and a redundant empty-check are minor nits but do not impact correctness."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_20.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_20.json
new file mode 100644
index 0000000000..bff31a7026
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_20.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_20.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"- Overall goal: The code computes the Top-K most frequent tokens from the given text and assigns the result to the global top_k. This is achieved via _count_tokens_ascii and _top_k_from_counts, and the final line sets top_k appropriately.\\n- Tokenization requirements:\\n  - Lowercasing: Implemented by mapping 'A'-'Z' to lowercase during scanning.\\n  - Tokens are ASCII [a-z0-9]+; others are separators: Implemented via an explicit character-class check (ord ranges) and committing on non-matching chars. Behavior matches the spec.\\n  - \\\"Use a regex\\\": Not followed. The implementation is manual and does not use a regex as explicitly instructed. Functionally correct but deviates from the stated method.\\n- Inputs: text (str) and k (int) are assumed to be provided and are not reassigned. Compliance met.\\n- Requirements:\\n  1) Sorting by count desc, then token asc: Implemented using heapq.nsmallest with key=(-count, token), which yields the correct order.\\n  2) top_k is a list of (token, count) tuples of length min(k, unique tokens): _top_k_from_counts returns such a list; nsmallest ensures length <= k; when k exceeds unique tokens, it returns all items.\\n  3) Edge case k <= 0: Returns [] explicitly; compliant.\\n  4) No I/O or network: No input(), file I/O, or network calls present.\\n- Output contract: top_k is defined at the end as required; no extraneous prints. Does not rely on Counter.most_common tie ordering.\\n\\nSummary: All functional requirements are met and edge cases handled. The sole deviation is not using a regex for tokenization, which was explicitly requested.\",\n    \"code_quality\": \"- Clarity and correctness: Functions are well-named and correctly implement the required behavior. The tokenization logic is accurate for ASCII [a-z0-9]+.\\n- Efficiency: Single-pass tokenizer; heapq.nsmallest yields O(n log k) selection, which is efficient for large inputs.\\n- Readability/Maintainability: Use of ord-range checks and micro-optimizations (local variable bindings like append/get) slightly reduce readability compared to a straightforward regex approach, which the spec suggested. Still, code is concise and understandable.\\n- Best practices: Avoids reliance on Counter.most_common tie-breaking, uses deterministic sorting criteria. Type hints are minimal but acceptable. No obvious bugs or edge-case omissions.\\n\\nNote: While not using regex violates the instruction, from a code-quality perspective the implementation is robust and efficient.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 4,\n    \"code_quality_score\": 4,\n    \"comments\": \"Functionally correct and efficient with proper sorting, edge-case handling, and output structure. The main shortcoming is not using a regex for tokenization as explicitly instructed; minor readability trade-offs due to manual ASCII handling and micro-optimizations.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "- Overall goal: The code computes the Top-K most frequent tokens from the given text and assigns the result to the global top_k. This is achieved via _count_tokens_ascii and _top_k_from_counts, and the final line sets top_k appropriately.\n- Tokenization requirements:\n  - Lowercasing: Implemented by mapping 'A'-'Z' to lowercase during scanning.\n  - Tokens are ASCII [a-z0-9]+; others are separators: Implemented via an explicit character-class check (ord ranges) and committing on non-matching chars. Behavior matches the spec.\n  - \"Use a regex\": Not followed. The implementation is manual and does not use a regex as explicitly instructed. Functionally correct but deviates from the stated method.\n- Inputs: text (str) and k (int) are assumed to be provided and are not reassigned. Compliance met.\n- Requirements:\n  1) Sorting by count desc, then token asc: Implemented using heapq.nsmallest with key=(-count, token), which yields the correct order.\n  2) top_k is a list of (token, count) tuples of length min(k, unique tokens): _top_k_from_counts returns such a list; nsmallest ensures length <= k; when k exceeds unique tokens, it returns all items.\n  3) Edge case k <= 0: Returns [] explicitly; compliant.\n  4) No I/O or network: No input(), file I/O, or network calls present.\n- Output contract: top_k is defined at the end as required; no extraneous prints. Does not rely on Counter.most_common tie ordering.\n\nSummary: All functional requirements are met and edge cases handled. The sole deviation is not using a regex for tokenization, which was explicitly requested.",
+      "code_quality": "- Clarity and correctness: Functions are well-named and correctly implement the required behavior. The tokenization logic is accurate for ASCII [a-z0-9]+.\n- Efficiency: Single-pass tokenizer; heapq.nsmallest yields O(n log k) selection, which is efficient for large inputs.\n- Readability/Maintainability: Use of ord-range checks and micro-optimizations (local variable bindings like append/get) slightly reduce readability compared to a straightforward regex approach, which the spec suggested. Still, code is concise and understandable.\n- Best practices: Avoids reliance on Counter.most_common tie-breaking, uses deterministic sorting criteria. Type hints are minimal but acceptable. No obvious bugs or edge-case omissions.\n\nNote: While not using regex violates the instruction, from a code-quality perspective the implementation is robust and efficient."
+    },
+    "final_judgement": {
+      "adherence_score": 4,
+      "code_quality_score": 4,
+      "comments": "Functionally correct and efficient with proper sorting, edge-case handling, and output structure. The main shortcoming is not using a regex for tokenization as explicitly instructed; minor readability trade-offs due to manual ASCII handling and micro-optimizations."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_21.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_21.json
new file mode 100644
index 0000000000..29f7e1e5e8
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_21.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_21.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"- Tokenization requirements:\\n  - Lowercasing: Tokens are converted to lowercase via m.group(0).lower(). Satisfied.\\n  - Regex with ASCII [a-z0-9]+ and non-matching chars as separators: Uses re.compile(r\\\"[a-z0-9]+\\\", flags=re.ASCII | re.IGNORECASE) and iterates over matches. Satisfied.\\n- Inputs and globals:\\n  - Uses provided globals text and k only to compute top_k at the end; does not reassign them. Satisfied.\\n- Sorting and Top-K:\\n  - Sort key specified as (-count, token): Achieved via heapq.nsmallest with key=lambda t: (-t[1], t[0]). This returns items sorted by count desc, token asc. Satisfied.\\n  - Returns list of (token, count) tuples with length min(k, unique tokens): nsmallest(k_int, counts.items(), ...) ensures length behavior. Satisfied.\\n- Edge cases:\\n  - k <= 0 returns []: Explicitly handled. Satisfied.\\n  - No tokens in text returns []: Explicitly handled via if not counts. Satisfied.\\n- Constraints:\\n  - No input(), file I/O, or network access. Satisfied.\\n  - Does not rely on Counter.most_common tie ordering. Satisfied.\\n- Output contract:\\n  - Defines top_k at module end as compute_top_k(text, k). Satisfied.\\n- Optional printing: Not used, which is allowed.\\nOverall, the code fully complies with all specified requirements.\",\n    \"code_quality\": \"- Correctness: Logic matches the spec exactly; tie-breaking and ordering are correct. No reliance on Counter.most_common.\\n- Clarity/Readability: Clear function and variable names; concise code; helpful comment on sorting intent.\\n- Efficiency: Uses Counter for counting and heapq.nsmallest for O(n log k) selection, which is efficient for large vocabularies and small k. Avoids full sort when unnecessary.\\n- Maintainability/Structure: Modularized with _iter_tokens and compute_top_k. Straightforward flow and minimal branching.\\n- Best practices: Regex uses re.ASCII to enforce ASCII semantics; tokens are explicitly lowercased. No side effects beyond defining top_k.\\n- Minor nitpicks (non-blocking):\\n  - The regex could be compiled once at module scope to avoid recompilation per call to _iter_tokens, though impact is minor.\\n  - The early return if not counts is redundant because nsmallest would return [] anyway, but it is explicit and fine.\\nOverall, code quality is high: clear, correct, and efficient.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 5,\n    \"code_quality_score\": 5,\n    \"comments\": \"Fully meets all task requirements with clean, efficient, and readable code. Minor micro-optimizations are possible but unnecessary.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "- Tokenization requirements:\n  - Lowercasing: Tokens are converted to lowercase via m.group(0).lower(). Satisfied.\n  - Regex with ASCII [a-z0-9]+ and non-matching chars as separators: Uses re.compile(r\"[a-z0-9]+\", flags=re.ASCII | re.IGNORECASE) and iterates over matches. Satisfied.\n- Inputs and globals:\n  - Uses provided globals text and k only to compute top_k at the end; does not reassign them. Satisfied.\n- Sorting and Top-K:\n  - Sort key specified as (-count, token): Achieved via heapq.nsmallest with key=lambda t: (-t[1], t[0]). This returns items sorted by count desc, token asc. Satisfied.\n  - Returns list of (token, count) tuples with length min(k, unique tokens): nsmallest(k_int, counts.items(), ...) ensures length behavior. Satisfied.\n- Edge cases:\n  - k <= 0 returns []: Explicitly handled. Satisfied.\n  - No tokens in text returns []: Explicitly handled via if not counts. Satisfied.\n- Constraints:\n  - No input(), file I/O, or network access. Satisfied.\n  - Does not rely on Counter.most_common tie ordering. Satisfied.\n- Output contract:\n  - Defines top_k at module end as compute_top_k(text, k). Satisfied.\n- Optional printing: Not used, which is allowed.\nOverall, the code fully complies with all specified requirements.",
+      "code_quality": "- Correctness: Logic matches the spec exactly; tie-breaking and ordering are correct. No reliance on Counter.most_common.\n- Clarity/Readability: Clear function and variable names; concise code; helpful comment on sorting intent.\n- Efficiency: Uses Counter for counting and heapq.nsmallest for O(n log k) selection, which is efficient for large vocabularies and small k. Avoids full sort when unnecessary.\n- Maintainability/Structure: Modularized with _iter_tokens and compute_top_k. Straightforward flow and minimal branching.\n- Best practices: Regex uses re.ASCII to enforce ASCII semantics; tokens are explicitly lowercased. No side effects beyond defining top_k.\n- Minor nitpicks (non-blocking):\n  - The regex could be compiled once at module scope to avoid recompilation per call to _iter_tokens, though impact is minor.\n  - The early return if not counts is redundant because nsmallest would return [] anyway, but it is explicit and fine.\nOverall, code quality is high: clear, correct, and efficient."
+    },
+    "final_judgement": {
+      "adherence_score": 5,
+      "code_quality_score": 5,
+      "comments": "Fully meets all task requirements with clean, efficient, and readable code. Minor micro-optimizations are possible but unnecessary."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_22.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_22.json
new file mode 100644
index 0000000000..8a3f088726
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_22.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_22.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"Step-by-step assessment:\\n- Tokenization requirements:\\n  - Lowercasing: The tokenizer lowercases each character (c = ch.lower()). \u2714\ufe0f\\n  - ASCII [a-z0-9]+ sequences with other chars as separators: Implemented via explicit character checks ('a' <= c <= 'z' or '0' <= c <= '9') and flushing the buffer on any other character. This matches the specified token definition. \u2714\ufe0f\\n  - Note: The instruction suggested using a regex; the solution does not use regex but achieves identical behavior. This is a minor deviation in method, not in result. \u26a0\ufe0f (minor)\\n- Inputs: The code reads the provided globals text and k without reassigning them. It copies them to local variables _text and _k (with int(k) coercion). It does not mutate the globals. \u2714\ufe0f\\n- Requirement 1 (sorting): Sorts by count descending and token ascending using key=lambda kv: (-kv[1], kv[0]). \u2714\ufe0f\\n- Requirement 2 (output structure and length): Returns a list of (token, count) tuples and slices to min(k, len(items)). \u2714\ufe0f\\n- Requirement 3 (k <= 0): _top_k_tokens returns [] when k <= 0, leading to top_k = []. \u2714\ufe0f\\n- Requirement 4 (no I/O/network): No input(), file I/O, or network access used. \u2714\ufe0f\\n- Output contract: top_k is always defined at the end. If globals are missing/invalid, it safely sets top_k = []. When provided, it computes as specified. No extraneous printing. \u2714\ufe0f\\n- Note on tie-ordering: Does not rely on Counter; explicitly sorts with the specified key. \u2714\ufe0f\\nOverall: Functional adherence is excellent; the only minor deviation is not using a regex as hinted by the instructions.\",\n    \"code_quality\": \"This is code; assessment follows:\\n- Correctness: The counting and sorting logic is correct and adheres to the spec, including edge cases and tie-breaking. \u2714\ufe0f\\n- Clarity/Readability: Functions are small and well-named with brief comments. Type hints are used for parameters. The micro-optimizations (binding get = counts.get and join = ''.join) are acceptable but slightly reduce readability. Minor. \u26a0\ufe0f\\n- Efficiency: Streaming tokenizer with a buffer is efficient. Counting is O(n); sorting unique tokens is O(m log m). \u2714\ufe0f\\n- Structure/Maintainability: Separation into _iter_tokens and _top_k_tokens is clean. Top-level try/except ensures top_k is always defined. \u2714\ufe0f\\n- Best practices: Avoids reliance on Counter.most_common ordering as requested. Does not perform I/O. Minor issue: Unused import (import sys). \u26a0\ufe0f\\n- Robustness: Gracefully handles missing globals by setting top_k = []. Casting k via int(k) is fine given the spec says k is int; it doesn\u2019t reassign the global. \u2714\ufe0f\\nNo bugs detected; only minor stylistic issues (unused import, micro-optimizations affecting readability) and not following the suggested regex approach.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 4,\n    \"code_quality_score\": 4,\n    \"comments\": \"Meets all functional requirements with correct sorting, tokenization behavior, and edge-case handling. Minor deviation: did not use regex as suggested. Code quality is strong; small issues include an unused import and slight readability trade-offs from micro-optimizations.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "Step-by-step assessment:\n- Tokenization requirements:\n  - Lowercasing: The tokenizer lowercases each character (c = ch.lower()). \u2714\ufe0f\n  - ASCII [a-z0-9]+ sequences with other chars as separators: Implemented via explicit character checks ('a' <= c <= 'z' or '0' <= c <= '9') and flushing the buffer on any other character. This matches the specified token definition. \u2714\ufe0f\n  - Note: The instruction suggested using a regex; the solution does not use regex but achieves identical behavior. This is a minor deviation in method, not in result. \u26a0\ufe0f (minor)\n- Inputs: The code reads the provided globals text and k without reassigning them. It copies them to local variables _text and _k (with int(k) coercion). It does not mutate the globals. \u2714\ufe0f\n- Requirement 1 (sorting): Sorts by count descending and token ascending using key=lambda kv: (-kv[1], kv[0]). \u2714\ufe0f\n- Requirement 2 (output structure and length): Returns a list of (token, count) tuples and slices to min(k, len(items)). \u2714\ufe0f\n- Requirement 3 (k <= 0): _top_k_tokens returns [] when k <= 0, leading to top_k = []. \u2714\ufe0f\n- Requirement 4 (no I/O/network): No input(), file I/O, or network access used. \u2714\ufe0f\n- Output contract: top_k is always defined at the end. If globals are missing/invalid, it safely sets top_k = []. When provided, it computes as specified. No extraneous printing. \u2714\ufe0f\n- Note on tie-ordering: Does not rely on Counter; explicitly sorts with the specified key. \u2714\ufe0f\nOverall: Functional adherence is excellent; the only minor deviation is not using a regex as hinted by the instructions.",
+      "code_quality": "This is code; assessment follows:\n- Correctness: The counting and sorting logic is correct and adheres to the spec, including edge cases and tie-breaking. \u2714\ufe0f\n- Clarity/Readability: Functions are small and well-named with brief comments. Type hints are used for parameters. The micro-optimizations (binding get = counts.get and join = ''.join) are acceptable but slightly reduce readability. Minor. \u26a0\ufe0f\n- Efficiency: Streaming tokenizer with a buffer is efficient. Counting is O(n); sorting unique tokens is O(m log m). \u2714\ufe0f\n- Structure/Maintainability: Separation into _iter_tokens and _top_k_tokens is clean. Top-level try/except ensures top_k is always defined. \u2714\ufe0f\n- Best practices: Avoids reliance on Counter.most_common ordering as requested. Does not perform I/O. Minor issue: Unused import (import sys). \u26a0\ufe0f\n- Robustness: Gracefully handles missing globals by setting top_k = []. Casting k via int(k) is fine given the spec says k is int; it doesn\u2019t reassign the global. \u2714\ufe0f\nNo bugs detected; only minor stylistic issues (unused import, micro-optimizations affecting readability) and not following the suggested regex approach."
+    },
+    "final_judgement": {
+      "adherence_score": 4,
+      "code_quality_score": 4,
+      "comments": "Meets all functional requirements with correct sorting, tokenization behavior, and edge-case handling. Minor deviation: did not use regex as suggested. Code quality is strong; small issues include an unused import and slight readability trade-offs from micro-optimizations."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_23.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_23.json
new file mode 100644
index 0000000000..4991443ea9
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_23.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_23.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"- Reads the task carefully: compute Top-K most frequent tokens with specific tokenization and sorting, using provided globals and setting top_k accordingly.\\n- Tokenization: The code implements ASCII [a-z0-9]+ tokenization and lowercasing by streaming through characters. Uppercase A-Z are lowered by adding 32, digits are kept, and all other characters act as separators. This produces exactly the [a-z0-9]+ tokens required and lowercases them. However, the instructions explicitly say to use a regex for tokenization; this code does not use regex. Functionally correct but deviates from the specified method.\\n- Sorting: Uses heapq.nsmallest with key lambda (-count, token) to obtain items sorted by count descending then token ascending. This matches the required sort order and avoids relying on Counter.most_common tie behavior.\\n- Output format: top_k is set to a list of (token, count) tuples of length min(k, unique tokens). This is satisfied: m = min(k, len(counts)) and the returned list contains (token, count) pairs from counts.items().\\n- Edge cases: If k <= 0, _top_k_tokens returns []. Also handles empty text (counts empty -> []). Both align with the requirements.\\n- Inputs: Does not reassign globals text or k. It copies them into _text and _k with fallbacks if not defined and safely coerces _k to int. This respects the constraint not to reassign provided globals and allows the script to run as-is.\\n- No I/O: No input(), file I/O, or network access. No printing except none, which is allowed.\\n- Output contract: top_k is defined at the end as specified, no extra output.\\n- Ambiguities: None significant; the only deviation is not using a regex despite the instruction to do so.\",\n    \"code_quality\": \"- Clarity/structure: Code is modular with helper functions (_iter_tokens_ascii_lower and _top_k_tokens). Comments explain key steps. Variable names are clear. The underscore prefixes indicate internal helpers.\\n- Correctness: Tokenization correctly yields lowercase ASCII alnum tokens and uses separators for all other characters. Counting and Top-K selection are correct. Sorting key enforces count desc then token asc.\\n- Efficiency: Streaming tokenizer avoids building full lowercased strings; using a buffer with method binding is efficient. heapq.nsmallest is appropriate for Top-K and returns results in the correct order.\\n- Readability: While using ord/chr and adding 32 is slightly lower-level than using .lower(), it is documented and constrained to ASCII as required. The logic is readable with comments.\\n- Maintainability: Functions are cohesive and small. No global side-effects besides defining top_k. Edge cases are handled explicitly.\\n- Best practices: Avoids reliance on Counter.most_common tie ordering per instruction. One stylistic note: the task asked to use a regex; while not a code quality fault per se, aligning with that would make intent explicit and simpler to verify. Minor micro-optimizations (append binding, manual lowercasing) slightly trade readability for performance but are acceptable and commented.\\n- No apparent bugs or inefficiencies affecting correctness were found.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 4,\n    \"code_quality_score\": 5,\n    \"comments\": \"Functionally meets all requirements, including correct tokenization behavior, sorting, and edge cases, and defines top_k properly without I/O or reassigning globals. The only notable miss is not using a regex as explicitly requested for tokenization.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "- Reads the task carefully: compute Top-K most frequent tokens with specific tokenization and sorting, using provided globals and setting top_k accordingly.\n- Tokenization: The code implements ASCII [a-z0-9]+ tokenization and lowercasing by streaming through characters. Uppercase A-Z are lowered by adding 32, digits are kept, and all other characters act as separators. This produces exactly the [a-z0-9]+ tokens required and lowercases them. However, the instructions explicitly say to use a regex for tokenization; this code does not use regex. Functionally correct but deviates from the specified method.\n- Sorting: Uses heapq.nsmallest with key lambda (-count, token) to obtain items sorted by count descending then token ascending. This matches the required sort order and avoids relying on Counter.most_common tie behavior.\n- Output format: top_k is set to a list of (token, count) tuples of length min(k, unique tokens). This is satisfied: m = min(k, len(counts)) and the returned list contains (token, count) pairs from counts.items().\n- Edge cases: If k <= 0, _top_k_tokens returns []. Also handles empty text (counts empty -> []). Both align with the requirements.\n- Inputs: Does not reassign globals text or k. It copies them into _text and _k with fallbacks if not defined and safely coerces _k to int. This respects the constraint not to reassign provided globals and allows the script to run as-is.\n- No I/O: No input(), file I/O, or network access. No printing except none, which is allowed.\n- Output contract: top_k is defined at the end as specified, no extra output.\n- Ambiguities: None significant; the only deviation is not using a regex despite the instruction to do so.",
+      "code_quality": "- Clarity/structure: Code is modular with helper functions (_iter_tokens_ascii_lower and _top_k_tokens). Comments explain key steps. Variable names are clear. The underscore prefixes indicate internal helpers.\n- Correctness: Tokenization correctly yields lowercase ASCII alnum tokens and uses separators for all other characters. Counting and Top-K selection are correct. Sorting key enforces count desc then token asc.\n- Efficiency: Streaming tokenizer avoids building full lowercased strings; using a buffer with method binding is efficient. heapq.nsmallest is appropriate for Top-K and returns results in the correct order.\n- Readability: While using ord/chr and adding 32 is slightly lower-level than using .lower(), it is documented and constrained to ASCII as required. The logic is readable with comments.\n- Maintainability: Functions are cohesive and small. No global side-effects besides defining top_k. Edge cases are handled explicitly.\n- Best practices: Avoids reliance on Counter.most_common tie ordering per instruction. One stylistic note: the task asked to use a regex; while not a code quality fault per se, aligning with that would make intent explicit and simpler to verify. Minor micro-optimizations (append binding, manual lowercasing) slightly trade readability for performance but are acceptable and commented.\n- No apparent bugs or inefficiencies affecting correctness were found."
+    },
+    "final_judgement": {
+      "adherence_score": 4,
+      "code_quality_score": 5,
+      "comments": "Functionally meets all requirements, including correct tokenization behavior, sorting, and edge cases, and defines top_k properly without I/O or reassigning globals. The only notable miss is not using a regex as explicitly requested for tokenization."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_24.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_24.json
new file mode 100644
index 0000000000..969564867e
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_24.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_24.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"Step-by-step adherence analysis:\\n- Core task: Computes the Top-K most frequent tokens from a given text. The function compute_top_k counts token frequencies and returns the top K after sorting. This matches the main requirement.\\n- Tokenization: Implements ASCII [a-z0-9]+ tokenization with lowercase by manually scanning characters, converting 'A'-'Z' to lowercase, accepting '0'-'9' and 'a'-'z', and treating all other characters as separators. This behavior matches the specified token set and separators. However, the instruction explicitly says to use a regex; the implementation does not use regex, which is a minor deviation from the instruction method, though the output semantics are correct.\\n- Inputs: Uses provided globals text and k without reassigning them. It copies them to _text and _k and never reassigns text or k, complying with the instruction.\\n- Requirement 1 (sorting): Sorts by (-count, token) via key=lambda it: (-it[1], it[0]). This exactly implements count descending then token ascending.\\n- Requirement 2 (top_k list and length): Returns a list of (token, count) tuples, and slices to min(k, number of unique tokens). Satisfied.\\n- Requirement 3 (k <= 0): compute_top_k returns [] when k <= 0, and top_k is set accordingly. Satisfied.\\n- Requirement 4 (no I/O/network): No input(), file I/O, or network calls. Satisfied.\\n- Output contract: Ensures top_k is defined at the end. If text/k are not defined, it sets top_k to an empty list; otherwise computes from compute_top_k. No extraneous prints. Satisfied.\\n- Note about tie ordering: Does not rely on Counter.most_common and explicitly implements the specified sort. Satisfied.\\n- Ambiguities/choices: The try/except handling for missing globals is conservative; the task states globals are provided, but this fallback does not violate any requirement and still leaves top_k defined. The only notable deviation is not using regex for tokenization as suggested.\",\n    \"code_quality\": \"Code quality assessment:\\n- Correctness: The tokenization logic correctly identifies ASCII letters/digits, lowercases uppercase ASCII, and splits on non-matching characters. Counting and sorting are correctly implemented. Edge cases (k <= 0, empty or no-token text, trailing buffered token) are handled.\\n- Clarity/readability: Overall structure is clear with a dedicated function and top-level glue. Micro-optimizations (binding append and get, using ord ranges) slightly reduce readability compared to a straightforward approach, especially since the task suggested using a regex. A regex like re.findall(r'[a-z0-9]+', text.lower()) would be more concise and maintainable.\\n- Efficiency: Single pass tokenization O(n) and sorting O(m log m), where m is the number of unique tokens; acceptable for typical use. For very large m, a heap-based top-k could be more efficient, but not required.\\n- Structure/maintainability: Good use of type hints and separation of concerns. No reliance on unspecified behavior. The try/except for globals is robust though arguably unnecessary per spec.\\n- Best practices: Avoids I/O as required, uses explicit sort key instead of Counter.most_common. Minor stylistic nit: could inline counts.items() into sorted. Using ord arithmetic is correct but less idiomatic than regex given the instruction.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 4,\n    \"code_quality_score\": 4,\n    \"comments\": \"Meets the task requirements accurately, including correct tokenization semantics, sorting, and edge-case handling. The main shortcoming is not using a regex as instructed for tokenization and some micro-optimizations that reduce readability. Otherwise, the code is correct, efficient, and defines top_k as specified.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "Step-by-step adherence analysis:\n- Core task: Computes the Top-K most frequent tokens from a given text. The function compute_top_k counts token frequencies and returns the top K after sorting. This matches the main requirement.\n- Tokenization: Implements ASCII [a-z0-9]+ tokenization with lowercase by manually scanning characters, converting 'A'-'Z' to lowercase, accepting '0'-'9' and 'a'-'z', and treating all other characters as separators. This behavior matches the specified token set and separators. However, the instruction explicitly says to use a regex; the implementation does not use regex, which is a minor deviation from the instruction method, though the output semantics are correct.\n- Inputs: Uses provided globals text and k without reassigning them. It copies them to _text and _k and never reassigns text or k, complying with the instruction.\n- Requirement 1 (sorting): Sorts by (-count, token) via key=lambda it: (-it[1], it[0]). This exactly implements count descending then token ascending.\n- Requirement 2 (top_k list and length): Returns a list of (token, count) tuples, and slices to min(k, number of unique tokens). Satisfied.\n- Requirement 3 (k <= 0): compute_top_k returns [] when k <= 0, and top_k is set accordingly. Satisfied.\n- Requirement 4 (no I/O/network): No input(), file I/O, or network calls. Satisfied.\n- Output contract: Ensures top_k is defined at the end. If text/k are not defined, it sets top_k to an empty list; otherwise computes from compute_top_k. No extraneous prints. Satisfied.\n- Note about tie ordering: Does not rely on Counter.most_common and explicitly implements the specified sort. Satisfied.\n- Ambiguities/choices: The try/except handling for missing globals is conservative; the task states globals are provided, but this fallback does not violate any requirement and still leaves top_k defined. The only notable deviation is not using regex for tokenization as suggested.",
+      "code_quality": "Code quality assessment:\n- Correctness: The tokenization logic correctly identifies ASCII letters/digits, lowercases uppercase ASCII, and splits on non-matching characters. Counting and sorting are correctly implemented. Edge cases (k <= 0, empty or no-token text, trailing buffered token) are handled.\n- Clarity/readability: Overall structure is clear with a dedicated function and top-level glue. Micro-optimizations (binding append and get, using ord ranges) slightly reduce readability compared to a straightforward approach, especially since the task suggested using a regex. A regex like re.findall(r'[a-z0-9]+', text.lower()) would be more concise and maintainable.\n- Efficiency: Single pass tokenization O(n) and sorting O(m log m), where m is the number of unique tokens; acceptable for typical use. For very large m, a heap-based top-k could be more efficient, but not required.\n- Structure/maintainability: Good use of type hints and separation of concerns. No reliance on unspecified behavior. The try/except for globals is robust though arguably unnecessary per spec.\n- Best practices: Avoids I/O as required, uses explicit sort key instead of Counter.most_common. Minor stylistic nit: could inline counts.items() into sorted. Using ord arithmetic is correct but less idiomatic than regex given the instruction."
+    },
+    "final_judgement": {
+      "adherence_score": 4,
+      "code_quality_score": 4,
+      "comments": "Meets the task requirements accurately, including correct tokenization semantics, sorting, and edge-case handling. The main shortcoming is not using a regex as instructed for tokenization and some micro-optimizations that reduce readability. Otherwise, the code is correct, efficient, and defines top_k as specified."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_25.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_25.json
new file mode 100644
index 0000000000..de32fa8108
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_25.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_25.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"Step-by-step check against instructions:\\n- Inputs and globals: The code reads the provided globals text and k and does not reassign them. Compliant.\\n- Tokenization: It lowercases ASCII letters on-the-fly and extracts tokens consisting of ASCII [a-z0-9]+ by treating any other character as a separator. This matches the specified token definition semantically. However, the instruction explicitly said to use a regex; the implementation uses a manual scanner instead. Functionally correct but deviates from the stated method.\\n- Requirement 1 (sorting): Uses heapq.nsmallest with key=(-count, token), which yields results sorted by count descending, then token ascending. Compliant and does not rely on Counter.most_common tie ordering.\\n- Requirement 2 (top_k structure and length): Produces a list of (token, count) tuples and clamps k to the number of unique tokens, ensuring length = min(k, unique). Compliant.\\n- Requirement 3 (k <= 0): If _k == 0 (including k <= 0), sets top_k = []. Compliant.\\n- Requirement 4 (no I/O/network): No input(), file I/O, or network access used. Compliant.\\n- Output contract: At the end, top_k is defined exactly as specified; no extra printing is performed, which is allowed. Compliant.\\n- Note on tie ordering: Does not use Counter.most_common; implements the specified sort. Compliant.\\nOverall, all functional requirements are met; the only notable deviation is not using a regex for tokenization as instructed.\",\n    \"code_quality\": \"The output is code; assessment follows:\\n- Correctness: The tokenizer correctly builds ASCII [a-z0-9]+ tokens with lowercase ASCII letters, handles separators, and flushes the buffer at boundaries and end-of-input. Sorting logic is correct and deterministic. Edge cases for k (<=0, > unique) are handled.\\n- Efficiency: Single pass tokenization O(n). Top-K selection via heapq.nsmallest is O(m log k), appropriate for large m. Efficient overall.\\n- Clarity/Readability: The manual ASCII lowercase via ord/chr and isascii() is more low-level than necessary; a regex-based approach would be clearer and matches the instruction. Magic numbers (65, 90, 32, etc.) reduce readability despite comments.\\n- Maintainability: The k parsing logic is overengineered given the spec guarantees k is int; excluding bool and accepting numeric strings adds complexity without clear benefit. Function and variables are reasonably named; comments help.\\n- Best practices: Avoids relying on Counter.most_common tie ordering as requested. Type annotation for Counter lacks type parameters but is acceptable. isascii() requires Python 3.7+, which is generally fine but slightly reduces portability.\\nNo functional bugs found; primary nits are stylistic/clarity and unnecessary k coercion.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 4,\n    \"code_quality_score\": 4,\n    \"comments\": \"Functionally correct and efficient; meets sorting, edge cases, and output requirements. Main deviation: did not use regex for tokenization as instructed. Minor readability issues and unnecessary k coercion complexity.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "Step-by-step check against instructions:\n- Inputs and globals: The code reads the provided globals text and k and does not reassign them. Compliant.\n- Tokenization: It lowercases ASCII letters on-the-fly and extracts tokens consisting of ASCII [a-z0-9]+ by treating any other character as a separator. This matches the specified token definition semantically. However, the instruction explicitly said to use a regex; the implementation uses a manual scanner instead. Functionally correct but deviates from the stated method.\n- Requirement 1 (sorting): Uses heapq.nsmallest with key=(-count, token), which yields results sorted by count descending, then token ascending. Compliant and does not rely on Counter.most_common tie ordering.\n- Requirement 2 (top_k structure and length): Produces a list of (token, count) tuples and clamps k to the number of unique tokens, ensuring length = min(k, unique). Compliant.\n- Requirement 3 (k <= 0): If _k == 0 (including k <= 0), sets top_k = []. Compliant.\n- Requirement 4 (no I/O/network): No input(), file I/O, or network access used. Compliant.\n- Output contract: At the end, top_k is defined exactly as specified; no extra printing is performed, which is allowed. Compliant.\n- Note on tie ordering: Does not use Counter.most_common; implements the specified sort. Compliant.\nOverall, all functional requirements are met; the only notable deviation is not using a regex for tokenization as instructed.",
+      "code_quality": "The output is code; assessment follows:\n- Correctness: The tokenizer correctly builds ASCII [a-z0-9]+ tokens with lowercase ASCII letters, handles separators, and flushes the buffer at boundaries and end-of-input. Sorting logic is correct and deterministic. Edge cases for k (<=0, > unique) are handled.\n- Efficiency: Single pass tokenization O(n). Top-K selection via heapq.nsmallest is O(m log k), appropriate for large m. Efficient overall.\n- Clarity/Readability: The manual ASCII lowercase via ord/chr and isascii() is more low-level than necessary; a regex-based approach would be clearer and matches the instruction. Magic numbers (65, 90, 32, etc.) reduce readability despite comments.\n- Maintainability: The k parsing logic is overengineered given the spec guarantees k is int; excluding bool and accepting numeric strings adds complexity without clear benefit. Function and variables are reasonably named; comments help.\n- Best practices: Avoids relying on Counter.most_common tie ordering as requested. Type annotation for Counter lacks type parameters but is acceptable. isascii() requires Python 3.7+, which is generally fine but slightly reduces portability.\nNo functional bugs found; primary nits are stylistic/clarity and unnecessary k coercion."
+    },
+    "final_judgement": {
+      "adherence_score": 4,
+      "code_quality_score": 4,
+      "comments": "Functionally correct and efficient; meets sorting, edge cases, and output requirements. Main deviation: did not use regex for tokenization as instructed. Minor readability issues and unnecessary k coercion complexity."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_26.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_26.json
new file mode 100644
index 0000000000..c86f544060
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_26.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_26.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"- Reads and follows the core task: computes Top-K most frequent tokens from provided globals text and k, and assigns the result to top_k.\\n- Tokenization: Implements ASCII tokenization for [a-z0-9]+ by treating all non [A-Z a-z 0-9] chars as separators, and lowercasing only A-Z while scanning. This yields exactly the specified token set and casing. However, the instruction explicitly says to use a regex; the solution does not use a regex and instead implements manual scanning. While the result is equivalent, this deviates from the stated method.\\n- Sorting: Uses heapq.nsmallest with key (-count, token) which correctly produces items sorted by count descending then token ascending, as required, and avoids full sort (acceptable and efficient).\\n- Output format: Sets top_k to a list of (token, count) tuples. Length is min(k, number of unique tokens) due to nsmallest behavior. Correct.\\n- Edge cases: If k <= 0, _top_k_from_counts returns []; negative k is clamped to 0. If counts empty, returns []. All match requirement 3.\\n- Inputs handling: Does not reassign text or k. Copies them into _text and _k safely, attempts int conversion of k, and clamps negatives. This is compatible with the contract. The fallback to defaults if globals are missing is harmless given the problem states they are provided.\\n- No I/O or network: No input(), file, or network usage. No printing (which is optional).\\n- Tie ordering: Does not rely on Counter.most_common; implements explicit sort key. Satisfies the note.\\n- Summary: All functional requirements are met; only deviation is not using a regex for tokenization as explicitly requested.\",\n    \"code_quality\": \"- Correctness: The tokenization logic matches the ASCII [a-z0-9]+ spec and lowercases A-Z. Counting and Top-K selection are correct. Edge cases handled.\\n- Efficiency: Single pass tokenization; Top-K via heapq.nsmallest gives O(n log k). Efficient.\\n- Readability/Maintainability: The manual ord/chr checks and micro-optimizations (caching append/clear/get) trade clarity for speed. A regex-based tokenizer would be shorter and clearer per the instruction. Nonetheless, the function has a clear comment describing behavior.\\n- Structure: Well-factored into two helper functions. Minimal global interaction. Reasonable variable naming and scoping.\\n- Best practices: Avoids unnecessary full sort; avoids reliance on unspecified tie ordering. Broad exception while casting k is acceptable in this context but could be narrowed. Partial type hints are provided; return types not annotated.\\n- No apparent bugs or edge-case failures identified.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 4,\n    \"code_quality_score\": 4,\n    \"comments\": \"Functionally correct and efficient implementation that meets sorting, output, and edge-case requirements. The main miss is not using a regex for tokenization as explicitly requested, and the manual ASCII scanning reduces readability compared to a regex-based approach. Otherwise, solid solution.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "- Reads and follows the core task: computes Top-K most frequent tokens from provided globals text and k, and assigns the result to top_k.\n- Tokenization: Implements ASCII tokenization for [a-z0-9]+ by treating all non [A-Z a-z 0-9] chars as separators, and lowercasing only A-Z while scanning. This yields exactly the specified token set and casing. However, the instruction explicitly says to use a regex; the solution does not use a regex and instead implements manual scanning. While the result is equivalent, this deviates from the stated method.\n- Sorting: Uses heapq.nsmallest with key (-count, token) which correctly produces items sorted by count descending then token ascending, as required, and avoids full sort (acceptable and efficient).\n- Output format: Sets top_k to a list of (token, count) tuples. Length is min(k, number of unique tokens) due to nsmallest behavior. Correct.\n- Edge cases: If k <= 0, _top_k_from_counts returns []; negative k is clamped to 0. If counts empty, returns []. All match requirement 3.\n- Inputs handling: Does not reassign text or k. Copies them into _text and _k safely, attempts int conversion of k, and clamps negatives. This is compatible with the contract. The fallback to defaults if globals are missing is harmless given the problem states they are provided.\n- No I/O or network: No input(), file, or network usage. No printing (which is optional).\n- Tie ordering: Does not rely on Counter.most_common; implements explicit sort key. Satisfies the note.\n- Summary: All functional requirements are met; only deviation is not using a regex for tokenization as explicitly requested.",
+      "code_quality": "- Correctness: The tokenization logic matches the ASCII [a-z0-9]+ spec and lowercases A-Z. Counting and Top-K selection are correct. Edge cases handled.\n- Efficiency: Single pass tokenization; Top-K via heapq.nsmallest gives O(n log k). Efficient.\n- Readability/Maintainability: The manual ord/chr checks and micro-optimizations (caching append/clear/get) trade clarity for speed. A regex-based tokenizer would be shorter and clearer per the instruction. Nonetheless, the function has a clear comment describing behavior.\n- Structure: Well-factored into two helper functions. Minimal global interaction. Reasonable variable naming and scoping.\n- Best practices: Avoids unnecessary full sort; avoids reliance on unspecified tie ordering. Broad exception while casting k is acceptable in this context but could be narrowed. Partial type hints are provided; return types not annotated.\n- No apparent bugs or edge-case failures identified."
+    },
+    "final_judgement": {
+      "adherence_score": 4,
+      "code_quality_score": 4,
+      "comments": "Functionally correct and efficient implementation that meets sorting, output, and edge-case requirements. The main miss is not using a regex for tokenization as explicitly requested, and the manual ASCII scanning reduces readability compared to a regex-based approach. Otherwise, solid solution."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_27.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_27.json
new file mode 100644
index 0000000000..59f49fb401
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_27.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_27.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"- Interprets task correctly: computes Top-K most frequent tokens from the provided text.\\n- Tokenization:\\n  - Produces tokens limited to ASCII [a-z0-9]+ and treats all other chars as separators \u2014 matches the spec behaviorally.\\n  - Lowercasing is handled on-the-fly for ASCII uppercase letters; functionally equivalent to lowercasing the text first.\\n  - However, the instruction explicitly says to use a regex; the implementation uses a manual scanner, not a regex. This is a deviation from the stated method, even though results match.\\n- Inputs: Does not reassign globals 'text' or 'k'; reads them into _text and _k. Complies.\\n- Requirements:\\n  1) Sorting by count desc, then token asc: Implemented via heapq.nsmallest with key=(-count, token). Correct and does not rely on Counter.most_common.\\n  2) Sets top_k to list of (token, count) tuples with length min(k, unique tokens): heapq.nsmallest returns min(k, n) items. Complies.\\n  3) k <= 0 -> top_k = []: Achieved by coercing invalid/negative k to 0 and using conditional \\\"if _counts and _k\\\". Complies.\\n  4) No input(), file I/O, or network: None used. Complies.\\n- Output contract: Defines top_k exactly as specified; no extraneous output. Complies.\\n- Tie-order note: Does not rely on most_common; uses defined sort key. Complies.\\n\\nSummary: All behavioral requirements met; only notable deviation is not using a regex for tokenization as instructed.\",\n    \"code_quality\": \"- Clarity/Readability: Clear structure with a dedicated tokenizer function and comments. The ord()-based ASCII checks are explicit but slightly less readable than a regex; still understandable.\\n- Correctness: Tokenization correctly extracts [a-z0-9]+, lowercases ASCII letters, and treats all else as separators. Sorting is correct for the required order.\\n- Efficiency: Single-pass tokenizer O(n). Top-K via heapq.nsmallest is O(n log k) \u2014 efficient.\\n- Maintainability/Structure: Helper function encapsulates tokenization; avoids side effects on globals by copying into local vars. Variable naming is consistent; comments explain behavior.\\n- Best practices: Avoids reliance on Counter.most_common tie behavior. Handles edge cases for k robustly. Minor nit: type hint could specify Counter[str].\\n\\nNo bugs identified; implementation is robust and efficient. The only stylistic divergence is not using regex (impacts adherence more than code quality).\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 4,\n    \"code_quality_score\": 5,\n    \"comments\": \"Behavior fully meets the requirements, including correct sorting and edge cases. The only shortfall is not using a regex for tokenization as explicitly requested. Code is otherwise clean, efficient, and correct.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "- Interprets task correctly: computes Top-K most frequent tokens from the provided text.\n- Tokenization:\n  - Produces tokens limited to ASCII [a-z0-9]+ and treats all other chars as separators \u2014 matches the spec behaviorally.\n  - Lowercasing is handled on-the-fly for ASCII uppercase letters; functionally equivalent to lowercasing the text first.\n  - However, the instruction explicitly says to use a regex; the implementation uses a manual scanner, not a regex. This is a deviation from the stated method, even though results match.\n- Inputs: Does not reassign globals 'text' or 'k'; reads them into _text and _k. Complies.\n- Requirements:\n  1) Sorting by count desc, then token asc: Implemented via heapq.nsmallest with key=(-count, token). Correct and does not rely on Counter.most_common.\n  2) Sets top_k to list of (token, count) tuples with length min(k, unique tokens): heapq.nsmallest returns min(k, n) items. Complies.\n  3) k <= 0 -> top_k = []: Achieved by coercing invalid/negative k to 0 and using conditional \"if _counts and _k\". Complies.\n  4) No input(), file I/O, or network: None used. Complies.\n- Output contract: Defines top_k exactly as specified; no extraneous output. Complies.\n- Tie-order note: Does not rely on most_common; uses defined sort key. Complies.\n\nSummary: All behavioral requirements met; only notable deviation is not using a regex for tokenization as instructed.",
+      "code_quality": "- Clarity/Readability: Clear structure with a dedicated tokenizer function and comments. The ord()-based ASCII checks are explicit but slightly less readable than a regex; still understandable.\n- Correctness: Tokenization correctly extracts [a-z0-9]+, lowercases ASCII letters, and treats all else as separators. Sorting is correct for the required order.\n- Efficiency: Single-pass tokenizer O(n). Top-K via heapq.nsmallest is O(n log k) \u2014 efficient.\n- Maintainability/Structure: Helper function encapsulates tokenization; avoids side effects on globals by copying into local vars. Variable naming is consistent; comments explain behavior.\n- Best practices: Avoids reliance on Counter.most_common tie behavior. Handles edge cases for k robustly. Minor nit: type hint could specify Counter[str].\n\nNo bugs identified; implementation is robust and efficient. The only stylistic divergence is not using regex (impacts adherence more than code quality)."
+    },
+    "final_judgement": {
+      "adherence_score": 4,
+      "code_quality_score": 5,
+      "comments": "Behavior fully meets the requirements, including correct sorting and edge cases. The only shortfall is not using a regex for tokenization as explicitly requested. Code is otherwise clean, efficient, and correct."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_28.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_28.json
new file mode 100644
index 0000000000..05ee39936c
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_28.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_28.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"Step-by-step check against the task:\\n- Tokenization: Uses regex r'[a-z0-9]+' with flags re.ASCII | re.IGNORECASE to find ASCII alphanumeric runs and lowercases each token via m.group(0).lower(). This satisfies \\\"Lowercase the text\\\" (lowercasing per token is equivalent for ASCII) and \\\"Tokens are ASCII [a-z0-9]+ sequences; all other characters are separators (use a regex).\\\"\\n- Inputs/globals: Reads provided globals text and k without reassigning them. Wraps access in try/except NameError to provide a safe fallback; this is extra but does not violate requirements.\\n- Requirement 1 (sorting): Returns heapq.nsmallest(kk, counts.items(), key=lambda item: (-item[1], item[0])). Sorting by the key (-count, token) and taking the n smallest produces a list ordered by count descending, then token ascending, exactly as specified.\\n- Requirement 2 (output shape): Returns a list of (token, count) tuples from counts.items(), with length kk = min(k, number of unique tokens). This matches the contract.\\n- Requirement 3 (edge case k <= 0): Explicitly returns [] when k <= 0; also returns [] if no tokens are found. Correct.\\n- Requirement 4 (no I/O/network): No input(), file I/O, or network calls are used. Script runs as-is with provided globals.\\n- Output contract: top_k is defined at end of execution as specified. No extra prints (printing was optional). Does not rely on Counter.most_common tie ordering.\\nAmbiguities/notes: The initial isinstance(text, str) guard is stricter than required but harmless given the task guarantees. The try/except for missing globals is extra robustness not required by the spec, but it still ensures top_k is defined.\",\n    \"code_quality\": \"No code generation issues; assessment of quality:\\n- Clarity/readability: Clear helper functions (_iter_tokens, _top_k_tokens), descriptive names, concise comments explaining intent.\\n- Correctness: Implements the specified tokenization and sorting criteria accurately. Handles edge cases correctly.\\n- Efficiency: Single pass to count tokens (O(n)); uses heapq.nsmallest for Top-K selection (O(U log K), U=unique tokens). Efficient and scalable.\\n- Maintainability/structure: Modular design with small focused functions; no reliance on unspecified behaviors (e.g., not using Counter.most_common). Reasonable fallback for missing globals.\\n- Style/best practices: Uses regex flags appropriately; avoids unnecessary global reassignment; returns immutable tuples for results. Minor nit: could use heapq.nlargest with key on count instead of nsmallest with negative counts for readability, but current approach is fine.\\nNo bugs or inefficiencies identified relevant to the task.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 5,\n    \"code_quality_score\": 5,\n    \"comments\": \"Meets all requirements precisely with clean, efficient, and readable code. Minor extras (type check and NameError fallback) are harmless and do not detract from adherence.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "Step-by-step check against the task:\n- Tokenization: Uses regex r'[a-z0-9]+' with flags re.ASCII | re.IGNORECASE to find ASCII alphanumeric runs and lowercases each token via m.group(0).lower(). This satisfies \"Lowercase the text\" (lowercasing per token is equivalent for ASCII) and \"Tokens are ASCII [a-z0-9]+ sequences; all other characters are separators (use a regex).\"\n- Inputs/globals: Reads provided globals text and k without reassigning them. Wraps access in try/except NameError to provide a safe fallback; this is extra but does not violate requirements.\n- Requirement 1 (sorting): Returns heapq.nsmallest(kk, counts.items(), key=lambda item: (-item[1], item[0])). Sorting by the key (-count, token) and taking the n smallest produces a list ordered by count descending, then token ascending, exactly as specified.\n- Requirement 2 (output shape): Returns a list of (token, count) tuples from counts.items(), with length kk = min(k, number of unique tokens). This matches the contract.\n- Requirement 3 (edge case k <= 0): Explicitly returns [] when k <= 0; also returns [] if no tokens are found. Correct.\n- Requirement 4 (no I/O/network): No input(), file I/O, or network calls are used. Script runs as-is with provided globals.\n- Output contract: top_k is defined at end of execution as specified. No extra prints (printing was optional). Does not rely on Counter.most_common tie ordering.\nAmbiguities/notes: The initial isinstance(text, str) guard is stricter than required but harmless given the task guarantees. The try/except for missing globals is extra robustness not required by the spec, but it still ensures top_k is defined.",
+      "code_quality": "No code generation issues; assessment of quality:\n- Clarity/readability: Clear helper functions (_iter_tokens, _top_k_tokens), descriptive names, concise comments explaining intent.\n- Correctness: Implements the specified tokenization and sorting criteria accurately. Handles edge cases correctly.\n- Efficiency: Single pass to count tokens (O(n)); uses heapq.nsmallest for Top-K selection (O(U log K), U=unique tokens). Efficient and scalable.\n- Maintainability/structure: Modular design with small focused functions; no reliance on unspecified behaviors (e.g., not using Counter.most_common). Reasonable fallback for missing globals.\n- Style/best practices: Uses regex flags appropriately; avoids unnecessary global reassignment; returns immutable tuples for results. Minor nit: could use heapq.nlargest with key on count instead of nsmallest with negative counts for readability, but current approach is fine.\nNo bugs or inefficiencies identified relevant to the task."
+    },
+    "final_judgement": {
+      "adherence_score": 5,
+      "code_quality_score": 5,
+      "comments": "Meets all requirements precisely with clean, efficient, and readable code. Minor extras (type check and NameError fallback) are harmless and do not detract from adherence."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_29.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_29.json
new file mode 100644
index 0000000000..7ae301a3b5
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_29.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_29.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"- Interpreting the task: compute Top-K most frequent tokens from provided globals text (string) and k (int); tokenize as lowercase ASCII [a-z0-9]+ with all other chars as separators (explicitly says use a regex); output top_k as a list of (token, count) sorted by count desc then token asc; handle k <= 0 -> []; no I/O; don't reassign text or k.\\n- Tokenization:\\n  - Lowercasing: Achieved. Uppercase A-Z are converted to lowercase on-the-fly in _iter_tokens.\\n  - Token definition: Achieved. Only ASCII digits 0-9 and letters a-z are accumulated; anything else (including non-ASCII) is treated as a separator, producing tokens that match [a-z0-9]+.\\n  - Use a regex: Not followed. Tokenization is implemented via manual character inspection (ord checks), not using a regex as the instruction explicitly requests. While functionally correct, this misses the stated method requirement.\\n- Inputs/globals:\\n  - Does not reassign text or k. It reads them into _text and _k safely and handles NameError by providing defaults. This respects the \\\"do not reassign\\\" requirement.\\n- Requirements:\\n  1) Sorting by count desc, token asc: Followed. Uses key = lambda kv: (-kv[1], kv[0]) and applies either full sort or heapq.nsmallest + sort, yielding the correct ordering.\\n  2) top_k is a list of (token, count) tuples with length = min(k, unique tokens): Followed. When unique <= k it returns all sorted pairs; otherwise it returns exactly k items; tuples are (token, count).\\n  3) Edge case k <= 0 -> []: Followed. Early return [].\\n  4) No input(), file I/O, or network: Followed. None used.\\n- Output contract:\\n  - top_k is defined at the end as specified. No extra printing is performed, which is allowed (printing was optional and restricted if used).\\n- Additional notes:\\n  - The function gracefully handles empty or non-string text by casting to str, which is acceptable and does not violate any constraints.\\n  - Does not rely on Counter.most_common; implements explicit sorting as requested.\\n- Summary: All functional requirements are met, but the explicit \\\"use a regex\\\" instruction for tokenization is not followed.\",\n    \"code_quality\": \"- Clarity/readability: Good. Functions are small and focused; comments explain token rules and sorting. Minor micro-optimizations (append alias) and numeric ord ranges slightly reduce readability compared to a regex approach but are still understandable.\\n- Correctness: Correct tokenization (per spec), counting, and Top-K selection/sorting. Proper handling of ties and ordering via (-count, token). Edge cases handled.\\n- Efficiency: Good. Single-pass tokenizer; counting with dict; for large unique token sets uses heapq.nsmallest with a key for O(m log k); when k >= m, falls back to O(m log m) full sort. Reasonable memory/time complexity.\\n- Structure/maintainability: Reasonable. Clear separation of concerns (_iter_tokens, _compute_top_k). Avoids global mutation; exposes a single top_k result. The use of raw ASCII code ranges could be replaced with regex for maintainability (and to meet the instruction), but functionally it's fine.\\n- Best practices: Avoids reliance on unspecified tie-breaking; no I/O side effects; handles invalid k robustly. Names and comments are descriptive. No apparent bugs.\\n- Overall: High-quality, efficient implementation. The only notable deviation is not using a regex for tokenization (a task adherence issue more than code quality).\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 4,\n    \"code_quality_score\": 5,\n    \"comments\": \"Functionally excellent: correct tokenization behavior, counting, Top-K selection, order, and edge-case handling with no I/O. The sole miss is not using a regex for tokenization as explicitly requested.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "- Interpreting the task: compute Top-K most frequent tokens from provided globals text (string) and k (int); tokenize as lowercase ASCII [a-z0-9]+ with all other chars as separators (explicitly says use a regex); output top_k as a list of (token, count) sorted by count desc then token asc; handle k <= 0 -> []; no I/O; don't reassign text or k.\n- Tokenization:\n  - Lowercasing: Achieved. Uppercase A-Z are converted to lowercase on-the-fly in _iter_tokens.\n  - Token definition: Achieved. Only ASCII digits 0-9 and letters a-z are accumulated; anything else (including non-ASCII) is treated as a separator, producing tokens that match [a-z0-9]+.\n  - Use a regex: Not followed. Tokenization is implemented via manual character inspection (ord checks), not using a regex as the instruction explicitly requests. While functionally correct, this misses the stated method requirement.\n- Inputs/globals:\n  - Does not reassign text or k. It reads them into _text and _k safely and handles NameError by providing defaults. This respects the \"do not reassign\" requirement.\n- Requirements:\n  1) Sorting by count desc, token asc: Followed. Uses key = lambda kv: (-kv[1], kv[0]) and applies either full sort or heapq.nsmallest + sort, yielding the correct ordering.\n  2) top_k is a list of (token, count) tuples with length = min(k, unique tokens): Followed. When unique <= k it returns all sorted pairs; otherwise it returns exactly k items; tuples are (token, count).\n  3) Edge case k <= 0 -> []: Followed. Early return [].\n  4) No input(), file I/O, or network: Followed. None used.\n- Output contract:\n  - top_k is defined at the end as specified. No extra printing is performed, which is allowed (printing was optional and restricted if used).\n- Additional notes:\n  - The function gracefully handles empty or non-string text by casting to str, which is acceptable and does not violate any constraints.\n  - Does not rely on Counter.most_common; implements explicit sorting as requested.\n- Summary: All functional requirements are met, but the explicit \"use a regex\" instruction for tokenization is not followed.",
+      "code_quality": "- Clarity/readability: Good. Functions are small and focused; comments explain token rules and sorting. Minor micro-optimizations (append alias) and numeric ord ranges slightly reduce readability compared to a regex approach but are still understandable.\n- Correctness: Correct tokenization (per spec), counting, and Top-K selection/sorting. Proper handling of ties and ordering via (-count, token). Edge cases handled.\n- Efficiency: Good. Single-pass tokenizer; counting with dict; for large unique token sets uses heapq.nsmallest with a key for O(m log k); when k >= m, falls back to O(m log m) full sort. Reasonable memory/time complexity.\n- Structure/maintainability: Reasonable. Clear separation of concerns (_iter_tokens, _compute_top_k). Avoids global mutation; exposes a single top_k result. The use of raw ASCII code ranges could be replaced with regex for maintainability (and to meet the instruction), but functionally it's fine.\n- Best practices: Avoids reliance on unspecified tie-breaking; no I/O side effects; handles invalid k robustly. Names and comments are descriptive. No apparent bugs.\n- Overall: High-quality, efficient implementation. The only notable deviation is not using a regex for tokenization (a task adherence issue more than code quality)."
+    },
+    "final_judgement": {
+      "adherence_score": 4,
+      "code_quality_score": 5,
+      "comments": "Functionally excellent: correct tokenization behavior, counting, Top-K selection, order, and edge-case handling with no I/O. The sole miss is not using a regex for tokenization as explicitly requested."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_30.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_30.json
new file mode 100644
index 0000000000..38f511483b
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_baseline/run_30.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_30.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"Step-by-step:\\n- Tokenization: Uses a regex pattern r'[A-Za-z0-9]+' and lowercases tokens when counting. This matches the requirement: tokens are ASCII [a-z0-9]+ sequences with other chars as separators, and text is effectively lowercased before counting by lowercasing each token.\\n- Inputs: Uses provided globals text and k by passing them to compute_top_k and does not reassign them. Compliant.\\n- Sorting: Sorts with key lambda kv: (-kv[1], kv[0]), i.e., by count descending then token ascending. Matches the specified sort key (-count, token). Does not rely on Counter.most_common.\\n- Output structure: Returns a list of (token, count) tuples and assigns to top_k. Length is items[:min(k, len(items))], satisfying the min(k, unique) requirement.\\n- Edge cases: If k <= 0, returns [] (and thus top_k = []). Also safely returns [] if no tokens are found. Additional type checks for text and k are extra but do not violate the spec.\\n- No disallowed operations: No input(), file I/O, or network access. The script will run as-is with provided globals. No printing beyond optional requirement.\\nOverall, all requirements are fully met; the minor choice of matching [A-Za-z0-9]+ and then lowercasing tokens is equivalent to lowercasing first and matching [a-z0-9]+.\",\n    \"code_quality\": \"Clarity: The function is concise, with clear variable names and a direct flow. Correctness: Implements required tokenization, counting, sorting, and edge cases correctly. Efficiency: Uses a compiled regex and Counter; operations are linear in text length plus sorting cost. Readability and structure: Good use of a helper function and type hints; no unnecessary complexity. Maintainability: Straightforward, with standard library usage. Best practices: Avoids relying on Counter.most_common ordering; sorts explicitly. Minor note: The early return if not counter is redundant but harmless. Overall, high-quality code with no identified bugs or inefficiencies.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 5,\n    \"code_quality_score\": 5,\n    \"comments\": \"Fully meets the task requirements with clear, correct, and efficient code. Sorting and edge cases are handled as specified; output contract is satisfied.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "Step-by-step:\n- Tokenization: Uses a regex pattern r'[A-Za-z0-9]+' and lowercases tokens when counting. This matches the requirement: tokens are ASCII [a-z0-9]+ sequences with other chars as separators, and text is effectively lowercased before counting by lowercasing each token.\n- Inputs: Uses provided globals text and k by passing them to compute_top_k and does not reassign them. Compliant.\n- Sorting: Sorts with key lambda kv: (-kv[1], kv[0]), i.e., by count descending then token ascending. Matches the specified sort key (-count, token). Does not rely on Counter.most_common.\n- Output structure: Returns a list of (token, count) tuples and assigns to top_k. Length is items[:min(k, len(items))], satisfying the min(k, unique) requirement.\n- Edge cases: If k <= 0, returns [] (and thus top_k = []). Also safely returns [] if no tokens are found. Additional type checks for text and k are extra but do not violate the spec.\n- No disallowed operations: No input(), file I/O, or network access. The script will run as-is with provided globals. No printing beyond optional requirement.\nOverall, all requirements are fully met; the minor choice of matching [A-Za-z0-9]+ and then lowercasing tokens is equivalent to lowercasing first and matching [a-z0-9]+.",
+      "code_quality": "Clarity: The function is concise, with clear variable names and a direct flow. Correctness: Implements required tokenization, counting, sorting, and edge cases correctly. Efficiency: Uses a compiled regex and Counter; operations are linear in text length plus sorting cost. Readability and structure: Good use of a helper function and type hints; no unnecessary complexity. Maintainability: Straightforward, with standard library usage. Best practices: Avoids relying on Counter.most_common ordering; sorts explicitly. Minor note: The early return if not counter is redundant but harmless. Overall, high-quality code with no identified bugs or inefficiencies."
+    },
+    "final_judgement": {
+      "adherence_score": 5,
+      "code_quality_score": 5,
+      "comments": "Fully meets the task requirements with clear, correct, and efficient code. Sorting and edge cases are handled as specified; output contract is satisfied."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/judgement_summary.csv b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/judgement_summary.csv
new file mode 100644
index 0000000000..9632d704e0
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/judgement_summary.csv
@@ -0,0 +1,31 @@
+File,adherence_score,code_quality_score,parse_error,error
+run_01.py,5,5,,
+run_02.py,5,5,,
+run_03.py,5,5,,
+run_04.py,5,5,,
+run_05.py,5,5,,
+run_06.py,5,5,,
+run_07.py,5,5,,
+run_08.py,5,5,,
+run_09.py,5,5,,
+run_10.py,5,5,,
+run_11.py,5,5,,
+run_12.py,5,5,,
+run_13.py,5,4,,
+run_14.py,,,"Expecting ',' delimiter: line 10 column 2 (char 3422)",
+run_15.py,5,5,,
+run_16.py,5,5,,
+run_17.py,5,5,,
+run_18.py,5,5,,
+run_19.py,5,5,,
+run_20.py,5,5,,
+run_21.py,5,5,,
+run_22.py,2,3,,
+run_23.py,5,5,,
+run_24.py,5,5,,
+run_25.py,5,5,,
+run_26.py,5,5,,
+run_27.py,5,5,,
+run_28.py,5,5,,
+run_29.py,5,5,,
+run_30.py,5,5,,
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_01.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_01.json
new file mode 100644
index 0000000000..7b7eba905e
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_01.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_01.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"- Tokenization requirements: The code lowercases tokens and uses a regex [a-z0-9]+ with re.ASCII and re.IGNORECASE, then explicitly lowercases tokens via .lower(). This matches the requirement to treat ASCII letters/digits as tokens and all other chars as separators.\\n- Sorting by (-count, token): Implemented via key = lambda kv: (-kv[1], kv[0]). When k >= number of unique tokens (u), it returns sorted(cnt.items(), key=key). When k < u, it returns heapq.nsmallest(k, cnt.items(), key=key). Since nsmallest returns results sorted by the given key, both paths produce a list sorted by count descending, token ascending. This satisfies requirement (1).\\n- Setting top_k: For provided globals text and k, the code sets top_k = top_k_tokens(text, k). The result is a list of (token, count) tuples, length min(k, unique tokens), satisfying requirement (2).\\n- Edge cases: If k <= 0, top_k_tokens returns [], and thus top_k is set to []. If there are zero tokens (u == 0), the function also returns []. This covers requirement (3).\\n- I/O/network restrictions: No input(), file I/O, or network access used. Optional printing only occurs in demo mode and prints only top_k on the last line, complying with the optional output rule.\\n- Not relying on Counter.most_common: The implementation does not use most_common and defines its own sort key, meeting the note.\\n- Output contract: With provided globals, top_k is defined at the end of execution exactly as specified. In the fallback demo path (when globals are missing and running as __main__), top_k is also defined and printed as a Python literal on the last line.\\n- Minor ambiguity: If globals are missing and the code is not run as __main__, top_k would not be defined. However, the task specifies that globals are provided; under the specified conditions the code adheres fully.\",\n    \"code_quality\": \"- Clarity/readability: Good separation of concerns: tokenization helper, main function, and module-level wiring. Descriptive names and concise implementation. Type hints are provided.\\n- Correctness: Tokenization and ordering logic are correct. Tie-breaking on token ascending is implemented. Handles k <= 0 and empty input.\\n- Efficiency: Counting is O(N tokens). Selection uses heapq.nsmallest for O(U log k) when k < U and full sort when k >= U, which is appropriate. Space usage is O(U + k). A helpful complexity comment is included.\\n- Maintainability: Uses a compiled regex constant and a small, well-structured function. Minimal dependencies.\\n- Best practices: Avoids relying on Counter.most_common. The try/except NameError to detect globals is slightly unconventional; using 'if \\\"text\\\" in globals() and \\\"k\\\" in globals()' would avoid raising/handling exceptions, but this is a minor stylistic point. The '# type: ignore[name-defined]' comments are acceptable for linters/type checkers.\\n- No bugs or inefficiencies identified that would affect correctness or performance under the task constraints.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 5,\n    \"code_quality_score\": 5,\n    \"comments\": \"Excellent adherence: correct tokenization, ordering, edge-case handling, and top_k assignment. Code is clear, efficient, and avoids disallowed features. Minor stylistic nit on detecting provided globals, but overall high quality.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "- Tokenization requirements: The code lowercases tokens and uses a regex [a-z0-9]+ with re.ASCII and re.IGNORECASE, then explicitly lowercases tokens via .lower(). This matches the requirement to treat ASCII letters/digits as tokens and all other chars as separators.\n- Sorting by (-count, token): Implemented via key = lambda kv: (-kv[1], kv[0]). When k >= number of unique tokens (u), it returns sorted(cnt.items(), key=key). When k < u, it returns heapq.nsmallest(k, cnt.items(), key=key). Since nsmallest returns results sorted by the given key, both paths produce a list sorted by count descending, token ascending. This satisfies requirement (1).\n- Setting top_k: For provided globals text and k, the code sets top_k = top_k_tokens(text, k). The result is a list of (token, count) tuples, length min(k, unique tokens), satisfying requirement (2).\n- Edge cases: If k <= 0, top_k_tokens returns [], and thus top_k is set to []. If there are zero tokens (u == 0), the function also returns []. This covers requirement (3).\n- I/O/network restrictions: No input(), file I/O, or network access used. Optional printing only occurs in demo mode and prints only top_k on the last line, complying with the optional output rule.\n- Not relying on Counter.most_common: The implementation does not use most_common and defines its own sort key, meeting the note.\n- Output contract: With provided globals, top_k is defined at the end of execution exactly as specified. In the fallback demo path (when globals are missing and running as __main__), top_k is also defined and printed as a Python literal on the last line.\n- Minor ambiguity: If globals are missing and the code is not run as __main__, top_k would not be defined. However, the task specifies that globals are provided; under the specified conditions the code adheres fully.",
+      "code_quality": "- Clarity/readability: Good separation of concerns: tokenization helper, main function, and module-level wiring. Descriptive names and concise implementation. Type hints are provided.\n- Correctness: Tokenization and ordering logic are correct. Tie-breaking on token ascending is implemented. Handles k <= 0 and empty input.\n- Efficiency: Counting is O(N tokens). Selection uses heapq.nsmallest for O(U log k) when k < U and full sort when k >= U, which is appropriate. Space usage is O(U + k). A helpful complexity comment is included.\n- Maintainability: Uses a compiled regex constant and a small, well-structured function. Minimal dependencies.\n- Best practices: Avoids relying on Counter.most_common. The try/except NameError to detect globals is slightly unconventional; using 'if \"text\" in globals() and \"k\" in globals()' would avoid raising/handling exceptions, but this is a minor stylistic point. The '# type: ignore[name-defined]' comments are acceptable for linters/type checkers.\n- No bugs or inefficiencies identified that would affect correctness or performance under the task constraints."
+    },
+    "final_judgement": {
+      "adherence_score": 5,
+      "code_quality_score": 5,
+      "comments": "Excellent adherence: correct tokenization, ordering, edge-case handling, and top_k assignment. Code is clear, efficient, and avoids disallowed features. Minor stylistic nit on detecting provided globals, but overall high quality."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_02.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_02.json
new file mode 100644
index 0000000000..59522ab55a
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_02.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_02.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"- Tokenization: Correct. Uses regex r\\\"[a-z0-9]+\\\" with re.ASCII and re.IGNORECASE, then lowercases tokens in _tokens(). This matches the requirement to lowercase and treat non-[a-z0-9] ASCII as separators.\\n- Inputs: Correct. Reads provided globals text and k without reassigning them. The detection via try: text; k avoids assignment.\\n- Sorting/key: Correct. The key lambda (-count, token) implements the required ordering: count descending, then token ascending. No reliance on Counter.most_common.\\n- Top-K computation: Correct and exact. For k >= number of unique tokens (u), returns full sorted list; otherwise returns exactly k items, preserving the specified order. Uses heapq.nsmallest with the same key, which returns elements sorted by the key, ensuring correct order.\\n- Edge cases: Correct. If k <= 0, top_k_tokens returns [], and thus top_k is set to []. If the text contains no tokens (u == 0), returns [].\\n- Output contract: Satisfied when globals are provided. At module end, if text and k exist, top_k is defined as required. Optional printing is only performed in demo mode and prints exactly top_k as a Python literal on the last line. No input(), file I/O, or network access is used.\\n- Ambiguity note: If globals were not provided and the module was imported (not __main__), top_k would not be defined. However, the task states the two globals are provided, so this scenario is outside the intended use and does not violate requirements.\",\n    \"code_quality\": \"- Clarity/readability: Good. Clear function and helper names; concise logic. Type hints for function signatures are provided.\\n- Correctness: High. Implements the specified sort key and handles all edge cases. Does not rely on Counter.most_common tie behavior.\\n- Efficiency: Good. Counts in O(N tokens). Chooses between full sort and heap selection to avoid unnecessary full sorts when k is small (O(U log U) vs. O(U log k)).\\n- Maintainability/structure: Good. Separation of tokenization and ranking; local key function improves readability. Inline comments document strategy and complexity.\\n- Style/best practices: Generally solid. Minor nit: the availability check using try: text; k is a bit unconventional but functional and type-checked with ignores. Using a named function instead of a lambda for the key could slightly improve readability, but not necessary.\\n- No bugs or inefficiencies identified that affect correctness.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 5,\n    \"code_quality_score\": 5,\n    \"comments\": \"Meets all task requirements precisely, including tokenization, ordering, edge cases, and output contract. Code is clear, efficient, and avoids prohibited patterns. Minor nit about globals detection is acceptable under the stated assumptions.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "- Tokenization: Correct. Uses regex r\"[a-z0-9]+\" with re.ASCII and re.IGNORECASE, then lowercases tokens in _tokens(). This matches the requirement to lowercase and treat non-[a-z0-9] ASCII as separators.\n- Inputs: Correct. Reads provided globals text and k without reassigning them. The detection via try: text; k avoids assignment.\n- Sorting/key: Correct. The key lambda (-count, token) implements the required ordering: count descending, then token ascending. No reliance on Counter.most_common.\n- Top-K computation: Correct and exact. For k >= number of unique tokens (u), returns full sorted list; otherwise returns exactly k items, preserving the specified order. Uses heapq.nsmallest with the same key, which returns elements sorted by the key, ensuring correct order.\n- Edge cases: Correct. If k <= 0, top_k_tokens returns [], and thus top_k is set to []. If the text contains no tokens (u == 0), returns [].\n- Output contract: Satisfied when globals are provided. At module end, if text and k exist, top_k is defined as required. Optional printing is only performed in demo mode and prints exactly top_k as a Python literal on the last line. No input(), file I/O, or network access is used.\n- Ambiguity note: If globals were not provided and the module was imported (not __main__), top_k would not be defined. However, the task states the two globals are provided, so this scenario is outside the intended use and does not violate requirements.",
+      "code_quality": "- Clarity/readability: Good. Clear function and helper names; concise logic. Type hints for function signatures are provided.\n- Correctness: High. Implements the specified sort key and handles all edge cases. Does not rely on Counter.most_common tie behavior.\n- Efficiency: Good. Counts in O(N tokens). Chooses between full sort and heap selection to avoid unnecessary full sorts when k is small (O(U log U) vs. O(U log k)).\n- Maintainability/structure: Good. Separation of tokenization and ranking; local key function improves readability. Inline comments document strategy and complexity.\n- Style/best practices: Generally solid. Minor nit: the availability check using try: text; k is a bit unconventional but functional and type-checked with ignores. Using a named function instead of a lambda for the key could slightly improve readability, but not necessary.\n- No bugs or inefficiencies identified that affect correctness."
+    },
+    "final_judgement": {
+      "adherence_score": 5,
+      "code_quality_score": 5,
+      "comments": "Meets all task requirements precisely, including tokenization, ordering, edge cases, and output contract. Code is clear, efficient, and avoids prohibited patterns. Minor nit about globals detection is acceptable under the stated assumptions."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_03.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_03.json
new file mode 100644
index 0000000000..b08bc9c89e
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_03.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_03.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"Step-by-step check against the instructions:\\n- Tokenization: Uses regex r\\\"[a-z0-9]+\\\" with flags re.ASCII | re.IGNORECASE, and yields tokens lowercased via m.group(0).lower(). This satisfies: lowercase tokens; ASCII [a-z0-9]+ sequences; non-matching chars treated as separators; uses a regex.\\n- Inputs/globals: The code reads provided globals text and k without reassigning them. It uses a try/except NameError guard to detect their presence. If they exist, it computes top_k = top_k_tokens(text, k). It does not modify text or k.\\n- Requirement 1 (sorting): It defines key = lambda kv: (-kv[1], kv[0]) corresponding to (-count, token). For k >= unique tokens, it returns sorted(cnt.items(), key=key). For k < unique tokens, it uses heapq.nsmallest(k, cnt.items(), key=key), which returns the k elements in ascending order of the key, i.e., descending by count then ascending by token. This matches the specified order and avoids relying on Counter.most_common.\\n- Requirement 2 (top_k value/length): top_k is set to a list of (token, count) tuples via the function call. For k >= u, it returns all u items; for k < u, returns exactly k items; for no tokens, returns []. Thus length is min(k, number of unique tokens).\\n- Requirement 3 (edge cases): If k <= 0, top_k_tokens returns [], so top_k = [] in that case. If there are zero tokens (u == 0), returns [].\\n- Requirement 4 (no I/O, runs as-is with provided globals): No input(), file I/O, or network is used. With provided globals, it computes top_k and does not print. The demo branch only triggers if globals are absent and __name__ == \\\"__main__\\\".\\n- Output contract: At end of execution, top_k is defined exactly as required when text and k are provided. Optional printing is only in the demo path and prints top_k alone on the last line. The implementation does not use Counter.most_common and defines its own sort key.\\nMinor note: The code lowercases tokens rather than the entire text, but due to IGNORECASE in the regex, the extracted tokens cover upper/lowercase correctly and are normalized to lowercase, which is equivalent for the specified tokenization.\\nConclusion: All instructions are fully met.\",\n    \"code_quality\": \"The output is code; assessment:\\n- Correctness: Logic for tokenization, counting, sorting, and top-k selection is correct. heapq.nsmallest with key=(-count, token) yields the desired ordering for the returned list.\\n- Efficiency: Counting is O(N tokens). Selection is O(U log k) when k < U via heapq, and O(U log U) for full sort when k >= U. Extra space O(U + k). This is efficient and appropriate.\\n- Readability/Structure: Clear separation of concerns with _tokens and top_k_tokens. Type hints for function return types aid readability. Variable names are concise but understandable (cnt, u). Inline comment for complexity is helpful.\\n- Maintainability/Best practices: Avoids relying on Counter.most_common tie behavior. Uses a well-defined sort key. No side effects except optional demo in __main__. Does not reassign provided globals. No unnecessary I/O.\\n- Minor nits: Using both re.IGNORECASE and lowercasing tokens is redundant (either alone would suffice if text were lowercased first or pattern remained case-insensitive). The try/except NameError guard is slightly unconventional versus checking 'text' and 'k' in globals(), but functional and clear with the comment. Neither issue impacts correctness.\\nOverall: High-quality, clean, and efficient code.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 5,\n    \"code_quality_score\": 5,\n    \"comments\": \"Fully meets all task requirements, including exact sorting, edge cases, and output contract. Code is correct, efficient, and readable. Minor redundancies (IGNORECASE plus lowercasing) do not affect correctness.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "Step-by-step check against the instructions:\n- Tokenization: Uses regex r\"[a-z0-9]+\" with flags re.ASCII | re.IGNORECASE, and yields tokens lowercased via m.group(0).lower(). This satisfies: lowercase tokens; ASCII [a-z0-9]+ sequences; non-matching chars treated as separators; uses a regex.\n- Inputs/globals: The code reads provided globals text and k without reassigning them. It uses a try/except NameError guard to detect their presence. If they exist, it computes top_k = top_k_tokens(text, k). It does not modify text or k.\n- Requirement 1 (sorting): It defines key = lambda kv: (-kv[1], kv[0]) corresponding to (-count, token). For k >= unique tokens, it returns sorted(cnt.items(), key=key). For k < unique tokens, it uses heapq.nsmallest(k, cnt.items(), key=key), which returns the k elements in ascending order of the key, i.e., descending by count then ascending by token. This matches the specified order and avoids relying on Counter.most_common.\n- Requirement 2 (top_k value/length): top_k is set to a list of (token, count) tuples via the function call. For k >= u, it returns all u items; for k < u, returns exactly k items; for no tokens, returns []. Thus length is min(k, number of unique tokens).\n- Requirement 3 (edge cases): If k <= 0, top_k_tokens returns [], so top_k = [] in that case. If there are zero tokens (u == 0), returns [].\n- Requirement 4 (no I/O, runs as-is with provided globals): No input(), file I/O, or network is used. With provided globals, it computes top_k and does not print. The demo branch only triggers if globals are absent and __name__ == \"__main__\".\n- Output contract: At end of execution, top_k is defined exactly as required when text and k are provided. Optional printing is only in the demo path and prints top_k alone on the last line. The implementation does not use Counter.most_common and defines its own sort key.\nMinor note: The code lowercases tokens rather than the entire text, but due to IGNORECASE in the regex, the extracted tokens cover upper/lowercase correctly and are normalized to lowercase, which is equivalent for the specified tokenization.\nConclusion: All instructions are fully met.",
+      "code_quality": "The output is code; assessment:\n- Correctness: Logic for tokenization, counting, sorting, and top-k selection is correct. heapq.nsmallest with key=(-count, token) yields the desired ordering for the returned list.\n- Efficiency: Counting is O(N tokens). Selection is O(U log k) when k < U via heapq, and O(U log U) for full sort when k >= U. Extra space O(U + k). This is efficient and appropriate.\n- Readability/Structure: Clear separation of concerns with _tokens and top_k_tokens. Type hints for function return types aid readability. Variable names are concise but understandable (cnt, u). Inline comment for complexity is helpful.\n- Maintainability/Best practices: Avoids relying on Counter.most_common tie behavior. Uses a well-defined sort key. No side effects except optional demo in __main__. Does not reassign provided globals. No unnecessary I/O.\n- Minor nits: Using both re.IGNORECASE and lowercasing tokens is redundant (either alone would suffice if text were lowercased first or pattern remained case-insensitive). The try/except NameError guard is slightly unconventional versus checking 'text' and 'k' in globals(), but functional and clear with the comment. Neither issue impacts correctness.\nOverall: High-quality, clean, and efficient code."
+    },
+    "final_judgement": {
+      "adherence_score": 5,
+      "code_quality_score": 5,
+      "comments": "Fully meets all task requirements, including exact sorting, edge cases, and output contract. Code is correct, efficient, and readable. Minor redundancies (IGNORECASE plus lowercasing) do not affect correctness."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_04.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_04.json
new file mode 100644
index 0000000000..4f0bbb4fe8
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_04.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_04.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"- Tokenization: Uses regex r\\\"[a-z0-9]+\\\" with re.ASCII | re.IGNORECASE and lowercases tokens in _tokens(), matching the requirement to lowercase and treat non [a-z0-9] ASCII chars as separators.\\n- Inputs: Accesses globals text and k without reassigning them. Presence is checked via try/except; when provided, it computes top_k = top_k_tokens(text, k) as required.\\n- Requirement 1 (sorting): Defines key = lambda kv: (-kv[1], kv[0]) and applies it consistently. For k >= u, returns sorted(cnt.items(), key=key). For 0 < k < u, either sorts and slices or uses heapq.nsmallest with the same key, which returns the k items in ascending order by the key (i.e., count desc, token asc). Does not rely on Counter.most_common tie ordering.\\n- Requirement 2 (top_k list of tuples with correct length): The function returns a list of (token, count) tuples. Length is min(k, number of unique tokens) due to branches (k <= 0 -> [], k >= u -> all, else -> exactly k via slice or nsmallest). Tokens are lowercased.\\n- Requirement 3 (edge cases): If k <= 0, returns []. If there are zero unique tokens (u == 0), returns []. Both cases are handled.\\n- Requirement 4 (no I/O): No input(), file I/O, or network access. Printing occurs only in a demo path when globals are absent and __name__ == \\\"__main__\\\"; with provided globals (per task), it performs no printing.\\n- Output contract: Ensures top_k is defined at the end when globals exist. Optional printing is limited to the demo path and prints only top_k as a Python literal on the last line.\\n- Other notes: Does not reassign text or k. Implements specified sort key directly.\",\n    \"code_quality\": \"- Clarity and structure: Clean separation via helper _tokens() and top_k_tokens(); meaningful names; type hints provided; inline comments and complexity note included.\\n- Correctness: Tokenization and sorting logic meet specs. Uses Counter for counting; avoids most_common tie behavior by explicit sort key. heapq.nsmallest with the composite key preserves the required ordering of the returned k items.\\n- Efficiency: Counts in O(N tokens). Selects top-k via either full sort (when k relatively large) or heap-based selection (when k small), which is a sensible optimization. Regex precompiled globally.\\n- Readability/Maintainability: Concise, readable, and follows Python best practices. No obvious bugs or edge-case gaps given the stated inputs. No unnecessary side effects when globals are present.\\n- Minor nitpicks: The threshold 0.3 is heuristic (acceptable). Type ignore comments are unnecessary but harmless.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 5,\n    \"code_quality_score\": 5,\n    \"comments\": \"Meets all task requirements precisely, including tokenization, sorting, edge cases, global handling, and output contract. Code is clear, efficient, and well-structured.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "- Tokenization: Uses regex r\"[a-z0-9]+\" with re.ASCII | re.IGNORECASE and lowercases tokens in _tokens(), matching the requirement to lowercase and treat non [a-z0-9] ASCII chars as separators.\n- Inputs: Accesses globals text and k without reassigning them. Presence is checked via try/except; when provided, it computes top_k = top_k_tokens(text, k) as required.\n- Requirement 1 (sorting): Defines key = lambda kv: (-kv[1], kv[0]) and applies it consistently. For k >= u, returns sorted(cnt.items(), key=key). For 0 < k < u, either sorts and slices or uses heapq.nsmallest with the same key, which returns the k items in ascending order by the key (i.e., count desc, token asc). Does not rely on Counter.most_common tie ordering.\n- Requirement 2 (top_k list of tuples with correct length): The function returns a list of (token, count) tuples. Length is min(k, number of unique tokens) due to branches (k <= 0 -> [], k >= u -> all, else -> exactly k via slice or nsmallest). Tokens are lowercased.\n- Requirement 3 (edge cases): If k <= 0, returns []. If there are zero unique tokens (u == 0), returns []. Both cases are handled.\n- Requirement 4 (no I/O): No input(), file I/O, or network access. Printing occurs only in a demo path when globals are absent and __name__ == \"__main__\"; with provided globals (per task), it performs no printing.\n- Output contract: Ensures top_k is defined at the end when globals exist. Optional printing is limited to the demo path and prints only top_k as a Python literal on the last line.\n- Other notes: Does not reassign text or k. Implements specified sort key directly.",
+      "code_quality": "- Clarity and structure: Clean separation via helper _tokens() and top_k_tokens(); meaningful names; type hints provided; inline comments and complexity note included.\n- Correctness: Tokenization and sorting logic meet specs. Uses Counter for counting; avoids most_common tie behavior by explicit sort key. heapq.nsmallest with the composite key preserves the required ordering of the returned k items.\n- Efficiency: Counts in O(N tokens). Selects top-k via either full sort (when k relatively large) or heap-based selection (when k small), which is a sensible optimization. Regex precompiled globally.\n- Readability/Maintainability: Concise, readable, and follows Python best practices. No obvious bugs or edge-case gaps given the stated inputs. No unnecessary side effects when globals are present.\n- Minor nitpicks: The threshold 0.3 is heuristic (acceptable). Type ignore comments are unnecessary but harmless."
+    },
+    "final_judgement": {
+      "adherence_score": 5,
+      "code_quality_score": 5,
+      "comments": "Meets all task requirements precisely, including tokenization, sorting, edge cases, global handling, and output contract. Code is clear, efficient, and well-structured."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_05.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_05.json
new file mode 100644
index 0000000000..6719df859e
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_05.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_05.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"- Tokenization: Uses a compiled regex r\\\"[a-z0-9]+\\\" with re.ASCII and re.IGNORECASE, and explicitly lowercases tokens in _tokens(). This matches the requirement to lowercase and to treat tokens as ASCII [a-z0-9]+ with other chars as separators.\\n- Sorting spec: Defines key = lambda kv: (-kv[1], kv[0]), which enforces sort by count descending then token ascending. Both sorted(...) and heapq.nsmallest(..., key=key) use this key, satisfying the specified ordering and avoiding Counter.most_common tie behavior.\\n- Exact Top-K: Returns exact results. When k >= number of unique tokens (u), it returns the fully sorted list; otherwise it either sorts then slices or uses heapq.nsmallest with the specified key. heapq.nsmallest returns items in ascending key order, so the resulting list is already sorted as required.\\n- Output variable: With provided globals, the code assigns top_k = top_k_tokens(text, k) at the end, satisfying \\\"top_k must be defined exactly as described.\\\" It does not reassign text or k.\\n- Edge cases: If k <= 0, top_k_tokens returns [], and therefore top_k becomes []. If there are zero unique tokens, it returns []. Both meet the requirements.\\n- Inputs and environment: No input(), file I/O, or network access. The code runs as-is given the globals. It also includes an optional __main__ demo (only prints top_k) when globals are missing, which is allowed by the \\\"Optional printing\\\" clause.\\n- Tie handling: Does not rely on Counter.most_common; implements explicit sort key as required.\\n- Minor note: It treats non-int k as invalid and returns [], which is slightly beyond the spec (k is stated to be int) but harmless and not contrary to requirements.\\nOverall, the code fully adheres to the task instructions.\",\n    \"code_quality\": \"- Correctness: Logic is sound; tokenization and ordering are correctly implemented. Top-K selection is exact in all branches.\\n- Efficiency: Uses an adaptive strategy: full sort when k is large relative to u (k >= 0.3u) and heap-based selection otherwise, achieving O(U log k) or O(U log U) as appropriate. Counter is used efficiently.\\n- Readability/Clarity: Functions are small and focused. The key for sorting is clearly documented via a comment. The regex is compiled once at module scope. Type hints are provided. Complexity comment is helpful.\\n- Maintainability/Style: Clean structure with a helper _tokens(). Uses try/except to detect provided globals without reassigning them, plus type: ignore comments for static checkers; acceptable here. Minor stylistic nits could be: building Counter directly from the generator (Counter(_tokens(text))) and possibly omitting re.IGNORECASE since tokens are lowercased anyway, but these do not affect correctness or clarity.\\n- No bugs or evident edge-case failures found.\\nOverall, code quality is high.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 5,\n    \"code_quality_score\": 5,\n    \"comments\": \"Meets all task requirements precisely, including tokenization, ordering, edge cases, and output contract. Code is clean, efficient, and well-structured. Minor stylistic tweaks are optional.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "- Tokenization: Uses a compiled regex r\"[a-z0-9]+\" with re.ASCII and re.IGNORECASE, and explicitly lowercases tokens in _tokens(). This matches the requirement to lowercase and to treat tokens as ASCII [a-z0-9]+ with other chars as separators.\n- Sorting spec: Defines key = lambda kv: (-kv[1], kv[0]), which enforces sort by count descending then token ascending. Both sorted(...) and heapq.nsmallest(..., key=key) use this key, satisfying the specified ordering and avoiding Counter.most_common tie behavior.\n- Exact Top-K: Returns exact results. When k >= number of unique tokens (u), it returns the fully sorted list; otherwise it either sorts then slices or uses heapq.nsmallest with the specified key. heapq.nsmallest returns items in ascending key order, so the resulting list is already sorted as required.\n- Output variable: With provided globals, the code assigns top_k = top_k_tokens(text, k) at the end, satisfying \"top_k must be defined exactly as described.\" It does not reassign text or k.\n- Edge cases: If k <= 0, top_k_tokens returns [], and therefore top_k becomes []. If there are zero unique tokens, it returns []. Both meet the requirements.\n- Inputs and environment: No input(), file I/O, or network access. The code runs as-is given the globals. It also includes an optional __main__ demo (only prints top_k) when globals are missing, which is allowed by the \"Optional printing\" clause.\n- Tie handling: Does not rely on Counter.most_common; implements explicit sort key as required.\n- Minor note: It treats non-int k as invalid and returns [], which is slightly beyond the spec (k is stated to be int) but harmless and not contrary to requirements.\nOverall, the code fully adheres to the task instructions.",
+      "code_quality": "- Correctness: Logic is sound; tokenization and ordering are correctly implemented. Top-K selection is exact in all branches.\n- Efficiency: Uses an adaptive strategy: full sort when k is large relative to u (k >= 0.3u) and heap-based selection otherwise, achieving O(U log k) or O(U log U) as appropriate. Counter is used efficiently.\n- Readability/Clarity: Functions are small and focused. The key for sorting is clearly documented via a comment. The regex is compiled once at module scope. Type hints are provided. Complexity comment is helpful.\n- Maintainability/Style: Clean structure with a helper _tokens(). Uses try/except to detect provided globals without reassigning them, plus type: ignore comments for static checkers; acceptable here. Minor stylistic nits could be: building Counter directly from the generator (Counter(_tokens(text))) and possibly omitting re.IGNORECASE since tokens are lowercased anyway, but these do not affect correctness or clarity.\n- No bugs or evident edge-case failures found.\nOverall, code quality is high."
+    },
+    "final_judgement": {
+      "adherence_score": 5,
+      "code_quality_score": 5,
+      "comments": "Meets all task requirements precisely, including tokenization, ordering, edge cases, and output contract. Code is clean, efficient, and well-structured. Minor stylistic tweaks are optional."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_06.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_06.json
new file mode 100644
index 0000000000..4c9833ed61
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_06.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_06.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"- Tokenization requirements: The code compiles a regex r\\\"[a-z0-9]+\\\" with re.ASCII and re.IGNORECASE, then lowercases each match in _tokens(). This matches the spec: lowercase tokens and ASCII [a-z0-9]+ sequences with all other chars as separators.\\n- Inputs/globals: The code reads text and k without reassigning them. It wraps access in a try/except NameError to allow a demo when globals are absent. Under the task's stated scenario (globals are provided), it uses them directly and does not reassign them.\\n- Requirement 1 (sorting): It defines key = lambda kv: (-kv[1], kv[0]) on (token, count) pairs, which corresponds to sorting by count descending, then token ascending. When k*10 >= 3*u, it uses sorted(cnt.items(), key=key)[:eff_k]; otherwise it uses heapq.nsmallest(eff_k, cnt.items(), key=key). Since nsmallest returns items in ascending order of the key (equivalent to sorted(... )[:n]), and the key uses -count, both branches produce the correct final ordering: highest count first, then lexicographically smallest token on ties.\\n- Requirement 2 (top_k value and length): eff_k = min(k, number of unique tokens) is enforced via eff_k = k if k < u else u. The result in both branches is a list of (token, count) tuples of length eff_k. The final assignment top_k = top_k_tokens(text, k) sets top_k accordingly.\\n- Requirement 3 (edge cases): If k <= 0, top_k_tokens returns []. If there are zero unique tokens (u == 0), it returns []. Both satisfy the edge case handling.\\n- Requirement 4 (I/O/network): No input(), file I/O, or network access is used. With provided globals, the script does not print anything. A demo print occurs only when globals are missing and the script is run as __main__, which does not violate the requirement.\\n- Output contract: With provided globals, top_k is defined at the end as specified. Optional printing is respected; when printing in demo mode, it prints only top_k on the last line as a Python literal. It does not rely on Counter.most_common; sorting/tie-breaking is implemented via a custom key.\\n- Minor note: If the script is imported as a module without text/k provided (and not __main__), top_k would not be defined. However, the task states the globals are provided, so this does not affect adherence under the specified conditions.\",\n    \"code_quality\": \"- Correctness: The algorithm correctly tokenizes, counts, and selects Top-K with the required ordering. It does not rely on Counter.most_common tie behavior.\\n- Efficiency: Uses an adaptive approach: sorts all when k is a significant fraction of U; otherwise uses heapq.nsmallest with a key, which is O(U log k). Counting is O(N tokens). This is efficient and appropriate.\\n- Readability and maintainability: Clear structure with small, well-named helpers (_tokens, top_k_tokens). Type hints are provided. Comments document the selection strategy and complexity. Variable names (u, eff_k) are concise and understandable. The key function is simple and accurate.\\n- Style/robustness: No unnecessary reassignment of globals. The try/except NameError pattern for optional demo is reasonable and guarded by __main__. Minor nit: In general library usage, if imported without globals, top_k may remain undefined; this is acceptable given the task context. Overall, the code is clean, idiomatic, and maintainable.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 5,\n    \"code_quality_score\": 5,\n    \"comments\": \"Excellent adherence: correct tokenization, ordering, edge-case handling, and output variable. Efficient and clean implementation with appropriate tie-breaking and no reliance on most_common. Minor non-issue: top_k undefined if imported without globals, but within task constraints this is fine.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "- Tokenization requirements: The code compiles a regex r\"[a-z0-9]+\" with re.ASCII and re.IGNORECASE, then lowercases each match in _tokens(). This matches the spec: lowercase tokens and ASCII [a-z0-9]+ sequences with all other chars as separators.\n- Inputs/globals: The code reads text and k without reassigning them. It wraps access in a try/except NameError to allow a demo when globals are absent. Under the task's stated scenario (globals are provided), it uses them directly and does not reassign them.\n- Requirement 1 (sorting): It defines key = lambda kv: (-kv[1], kv[0]) on (token, count) pairs, which corresponds to sorting by count descending, then token ascending. When k*10 >= 3*u, it uses sorted(cnt.items(), key=key)[:eff_k]; otherwise it uses heapq.nsmallest(eff_k, cnt.items(), key=key). Since nsmallest returns items in ascending order of the key (equivalent to sorted(... )[:n]), and the key uses -count, both branches produce the correct final ordering: highest count first, then lexicographically smallest token on ties.\n- Requirement 2 (top_k value and length): eff_k = min(k, number of unique tokens) is enforced via eff_k = k if k < u else u. The result in both branches is a list of (token, count) tuples of length eff_k. The final assignment top_k = top_k_tokens(text, k) sets top_k accordingly.\n- Requirement 3 (edge cases): If k <= 0, top_k_tokens returns []. If there are zero unique tokens (u == 0), it returns []. Both satisfy the edge case handling.\n- Requirement 4 (I/O/network): No input(), file I/O, or network access is used. With provided globals, the script does not print anything. A demo print occurs only when globals are missing and the script is run as __main__, which does not violate the requirement.\n- Output contract: With provided globals, top_k is defined at the end as specified. Optional printing is respected; when printing in demo mode, it prints only top_k on the last line as a Python literal. It does not rely on Counter.most_common; sorting/tie-breaking is implemented via a custom key.\n- Minor note: If the script is imported as a module without text/k provided (and not __main__), top_k would not be defined. However, the task states the globals are provided, so this does not affect adherence under the specified conditions.",
+      "code_quality": "- Correctness: The algorithm correctly tokenizes, counts, and selects Top-K with the required ordering. It does not rely on Counter.most_common tie behavior.\n- Efficiency: Uses an adaptive approach: sorts all when k is a significant fraction of U; otherwise uses heapq.nsmallest with a key, which is O(U log k). Counting is O(N tokens). This is efficient and appropriate.\n- Readability and maintainability: Clear structure with small, well-named helpers (_tokens, top_k_tokens). Type hints are provided. Comments document the selection strategy and complexity. Variable names (u, eff_k) are concise and understandable. The key function is simple and accurate.\n- Style/robustness: No unnecessary reassignment of globals. The try/except NameError pattern for optional demo is reasonable and guarded by __main__. Minor nit: In general library usage, if imported without globals, top_k may remain undefined; this is acceptable given the task context. Overall, the code is clean, idiomatic, and maintainable."
+    },
+    "final_judgement": {
+      "adherence_score": 5,
+      "code_quality_score": 5,
+      "comments": "Excellent adherence: correct tokenization, ordering, edge-case handling, and output variable. Efficient and clean implementation with appropriate tie-breaking and no reliance on most_common. Minor non-issue: top_k undefined if imported without globals, but within task constraints this is fine."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_07.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_07.json
new file mode 100644
index 0000000000..5a97b7366e
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_07.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_07.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"- Tokenization: Uses regex [a-z0-9]+ with re.ASCII and re.IGNORECASE, and explicitly lowercases each matched token via .lower(). This fulfills the requirement of ASCII tokenization with lowercase tokens, and per-token lowercasing is acceptable.\\n- Inputs: The script accesses globals text and k without reassigning them. It uses a try/except NameError to detect their presence and only falls back to a demo when they are absent and __name__ == \\\"__main__\\\", which is acceptable.\\n- Sorting/Ranking: Defines key = lambda kv: (-kv[1], kv[0]) and uses either sorted(..., key=key) or heapq.nsmallest(k, ..., key=key). This correctly implements sort by count descending, then token ascending, without relying on Counter.most_common.\\n- Top-K result: The function top_k_tokens returns exactly the top k items in the correct order, with length min(k, number of unique tokens). For k >= u, it returns the fully sorted list; for small k it returns the k smallest by the key (which corresponds to highest counts and lexicographically smallest tokens in ties) in sorted order.\\n- Edge cases: If k <= 0, returns []. If there are no tokens (u == 0), returns []. Both match the requirements.\\n- Output contract: When globals are provided, top_k is set at the end via top_k = top_k_tokens(text, k). No extra output is produced unless running the demo; printing is optional and the demo prints only top_k.\\n- Constraints: No input(), file I/O, or network access. Does not rely on Counter.most_common tie ordering.\\n- Ambiguities: None materially affecting compliance. The demo printing is limited to one line and only when globals are absent, which is allowed.\",\n    \"code_quality\": \"- Clarity/Structure: Clear separation of concerns with a tokenizer helper, a top_k_tokens function, and top-level glue code. Readable variable names and a concise sort key.\\n- Correctness: The key function and use of sorted/heapq.nsmallest ensure exact ordering by (-count, token). Tie-breaking is handled correctly.\\n- Efficiency: Uses Counter for O(N) counting. Chooses between heap-based selection O(U log k) and full sort O(U log U) with a reasonable threshold heuristic. This is efficient and scalable.\\n- Readability/Maintainability: Type hints provided; code is straightforward and commented where relevant (complexity note). The try/except pattern for globals is clean and safe.\\n- Best practices: Avoids Counter.most_common to ensure explicit ordering. No side effects except optional demo printing.\\n- Minor nits: re.IGNORECASE is redundant since tokens are lowercased; harmless. Could add a short docstring, but not necessary.\\n\\nOverall, code quality is high with only trivial, non-impactful redundancies.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 5,\n    \"code_quality_score\": 5,\n    \"comments\": \"Fully meets the task: correct tokenization, ordering, edge-case handling, and top_k definition with no forbidden I/O. Code is clean, efficient, and well-structured. Minor redundancy in regex flags is harmless.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "- Tokenization: Uses regex [a-z0-9]+ with re.ASCII and re.IGNORECASE, and explicitly lowercases each matched token via .lower(). This fulfills the requirement of ASCII tokenization with lowercase tokens, and per-token lowercasing is acceptable.\n- Inputs: The script accesses globals text and k without reassigning them. It uses a try/except NameError to detect their presence and only falls back to a demo when they are absent and __name__ == \"__main__\", which is acceptable.\n- Sorting/Ranking: Defines key = lambda kv: (-kv[1], kv[0]) and uses either sorted(..., key=key) or heapq.nsmallest(k, ..., key=key). This correctly implements sort by count descending, then token ascending, without relying on Counter.most_common.\n- Top-K result: The function top_k_tokens returns exactly the top k items in the correct order, with length min(k, number of unique tokens). For k >= u, it returns the fully sorted list; for small k it returns the k smallest by the key (which corresponds to highest counts and lexicographically smallest tokens in ties) in sorted order.\n- Edge cases: If k <= 0, returns []. If there are no tokens (u == 0), returns []. Both match the requirements.\n- Output contract: When globals are provided, top_k is set at the end via top_k = top_k_tokens(text, k). No extra output is produced unless running the demo; printing is optional and the demo prints only top_k.\n- Constraints: No input(), file I/O, or network access. Does not rely on Counter.most_common tie ordering.\n- Ambiguities: None materially affecting compliance. The demo printing is limited to one line and only when globals are absent, which is allowed.",
+      "code_quality": "- Clarity/Structure: Clear separation of concerns with a tokenizer helper, a top_k_tokens function, and top-level glue code. Readable variable names and a concise sort key.\n- Correctness: The key function and use of sorted/heapq.nsmallest ensure exact ordering by (-count, token). Tie-breaking is handled correctly.\n- Efficiency: Uses Counter for O(N) counting. Chooses between heap-based selection O(U log k) and full sort O(U log U) with a reasonable threshold heuristic. This is efficient and scalable.\n- Readability/Maintainability: Type hints provided; code is straightforward and commented where relevant (complexity note). The try/except pattern for globals is clean and safe.\n- Best practices: Avoids Counter.most_common to ensure explicit ordering. No side effects except optional demo printing.\n- Minor nits: re.IGNORECASE is redundant since tokens are lowercased; harmless. Could add a short docstring, but not necessary.\n\nOverall, code quality is high with only trivial, non-impactful redundancies."
+    },
+    "final_judgement": {
+      "adherence_score": 5,
+      "code_quality_score": 5,
+      "comments": "Fully meets the task: correct tokenization, ordering, edge-case handling, and top_k definition with no forbidden I/O. Code is clean, efficient, and well-structured. Minor redundancy in regex flags is harmless."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_08.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_08.json
new file mode 100644
index 0000000000..37492dbe4b
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_08.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_08.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"- Tokenization: Uses a compiled regex r\\\"[a-z0-9]+\\\" with flags re.ASCII | re.IGNORECASE and lowercases each match in _tokens(). This exactly matches the requirement: ASCII [a-z0-9]+ sequences, all other characters as separators, and tokens lowercased.\\n- Inputs/Globals: The script expects globals text (str) and k (int) and does not reassign them. It accesses them in a try block; if present, it computes top_k = top_k_tokens(text, k). This respects the constraint not to modify the provided globals.\\n- Sorting requirement: Implements ordering with key = lambda kv: (-kv[1], kv[0]) applied to (token, count) items, which sorts by count descending then token ascending. For k >= u or when sorting-all-and-slicing, it uses sorted(..., key=key). For the heap path, it uses heapq.nsmallest(k, ..., key=key), which returns the k smallest by the key in sorted order, i.e., highest counts first with correct tiebreaker. It does not rely on Counter.most_common.\\n- Top-K length and content: Returns a list of (token, count) tuples of length min(k, number of unique tokens) in all code paths. If k >= u, returns the full sorted list; else returns exactly k items.\\n- Edge cases: If k <= 0, top_k_tokens returns [] (requirement 3). If there are zero unique tokens (u == 0), returns [], which is consistent with requirement 2.\\n- Output contract: When globals are provided, top_k is defined at module end as required. Optional printing is only done in a demo branch when globals are missing and __name__ == \\\"__main__\\\"; it prints only top_k on the last line, complying with the optional printing rule. With provided globals, it does not print, which is allowed.\\n- Prohibited actions: No input(), file I/O, or network access is used.\\n- Minor note: If the file is imported as a module without text/k and not run as __main__, top_k wouldn't be defined. However, the task states the globals are provided, so under the intended conditions, the contract is met.\",\n    \"code_quality\": \"- Correctness: The implementation correctly counts tokens and selects/sorts Top-K per the specified key without relying on Counter.most_common.\\n- Efficiency: Uses Counter for O(N tokens) counting and an optimization to choose between sorting all (O(U log U)) or heap selection (O(U log k)), which is efficient and well-considered.\\n- Readability/Structure: Clear function decomposition (_tokens and top_k_tokens), descriptive names, type hints for clarity and maintainability, and concise comments on complexity and selection strategy.\\n- Robustness: Handles edge cases (k <= 0, no tokens) gracefully. Tokenization is explicit and correct for ASCII alphanumerics.\\n- Style/Best practices: Uses a compiled regex, avoids unnecessary global mutation, and adheres to the output contract. The try/except to detect provided globals is acceptable and simple.\\n- No bugs or inefficiencies apparent. The heapq.nsmallest result is in sorted order by the given key, so the returned top_k has the required ordering.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 5,\n    \"code_quality_score\": 5,\n    \"comments\": \"Meets all task requirements precisely, including tokenization, sorting, edge-case handling, and output contract. Code is clear, efficient, and well-structured. No issues found.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "- Tokenization: Uses a compiled regex r\"[a-z0-9]+\" with flags re.ASCII | re.IGNORECASE and lowercases each match in _tokens(). This exactly matches the requirement: ASCII [a-z0-9]+ sequences, all other characters as separators, and tokens lowercased.\n- Inputs/Globals: The script expects globals text (str) and k (int) and does not reassign them. It accesses them in a try block; if present, it computes top_k = top_k_tokens(text, k). This respects the constraint not to modify the provided globals.\n- Sorting requirement: Implements ordering with key = lambda kv: (-kv[1], kv[0]) applied to (token, count) items, which sorts by count descending then token ascending. For k >= u or when sorting-all-and-slicing, it uses sorted(..., key=key). For the heap path, it uses heapq.nsmallest(k, ..., key=key), which returns the k smallest by the key in sorted order, i.e., highest counts first with correct tiebreaker. It does not rely on Counter.most_common.\n- Top-K length and content: Returns a list of (token, count) tuples of length min(k, number of unique tokens) in all code paths. If k >= u, returns the full sorted list; else returns exactly k items.\n- Edge cases: If k <= 0, top_k_tokens returns [] (requirement 3). If there are zero unique tokens (u == 0), returns [], which is consistent with requirement 2.\n- Output contract: When globals are provided, top_k is defined at module end as required. Optional printing is only done in a demo branch when globals are missing and __name__ == \"__main__\"; it prints only top_k on the last line, complying with the optional printing rule. With provided globals, it does not print, which is allowed.\n- Prohibited actions: No input(), file I/O, or network access is used.\n- Minor note: If the file is imported as a module without text/k and not run as __main__, top_k wouldn't be defined. However, the task states the globals are provided, so under the intended conditions, the contract is met.",
+      "code_quality": "- Correctness: The implementation correctly counts tokens and selects/sorts Top-K per the specified key without relying on Counter.most_common.\n- Efficiency: Uses Counter for O(N tokens) counting and an optimization to choose between sorting all (O(U log U)) or heap selection (O(U log k)), which is efficient and well-considered.\n- Readability/Structure: Clear function decomposition (_tokens and top_k_tokens), descriptive names, type hints for clarity and maintainability, and concise comments on complexity and selection strategy.\n- Robustness: Handles edge cases (k <= 0, no tokens) gracefully. Tokenization is explicit and correct for ASCII alphanumerics.\n- Style/Best practices: Uses a compiled regex, avoids unnecessary global mutation, and adheres to the output contract. The try/except to detect provided globals is acceptable and simple.\n- No bugs or inefficiencies apparent. The heapq.nsmallest result is in sorted order by the given key, so the returned top_k has the required ordering."
+    },
+    "final_judgement": {
+      "adherence_score": 5,
+      "code_quality_score": 5,
+      "comments": "Meets all task requirements precisely, including tokenization, sorting, edge-case handling, and output contract. Code is clear, efficient, and well-structured. No issues found."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_09.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_09.json
new file mode 100644
index 0000000000..5f4dea6d91
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_09.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_09.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"Step-by-step adherence check:\\n- Tokenization rules: The code compiles a regex r\\\"[a-z0-9]+\\\" with flags re.ASCII | re.IGNORECASE and the _tokens generator yields matches lowercased. This matches the requirement to lowercase and to treat ASCII [a-z0-9]+ as tokens with other chars as separators.\\n- Inputs/globals: It uses provided globals text and k without reassigning them. Access is guarded via a try/except NameError; when globals exist, it computes top_k from them.\\n- Requirements:\\n  1) Sort key (-count, token): Implemented via key = lambda kv: (-kv[1], kv[0]) and used both in sorted(...) and in heapq.nsmallest(...), ensuring count desc then token asc.\\n  2) Set top_k to the list of (token, count) of length min(k, unique tokens): m is computed as min(k, u) (with early return [] if k <= 0). Returns exactly m items from either full sort slice [:m] or nsmallest(m, ...), maintaining the required ordering.\\n  3) Edge case k <= 0: top_k_tokens returns [], so top_k becomes [].\\n  4) No input(), file I/O, or network used. Script runs with provided globals and does not modify them.\\n- Output contract: With provided globals, the else branch sets top_k = top_k_tokens(text, k). In the demo (when globals missing and __name__ == \\\"__main__\\\"), it defines top_k and prints only top_k on the last line. It does not rely on Counter.most_common for tie ordering. Therefore, all specified behaviors are satisfied.\\n- Minor note: If globals are missing and not running as __main__, top_k would remain undefined; however, the task states globals are provided, so this path is out of scope. Overall, adherence is complete.\",\n    \"code_quality\": \"Code quality assessment:\\n- Correctness: Algorithm correctly counts tokens, handles lowercasing, and produces the exact Top-K with the specified ordering. It avoids Counter.most_common tie ordering.\\n- Efficiency: Uses Counter for O(N tokens), and switches between full sort and heapq.nsmallest for selection based on m relative to u, which is a good optimization. Key function with negative counts is appropriate for nsmallest.\\n- Readability/Structure: Clear helper _tokens with type hints. Well-named variables, concise logic, and explanatory comments for complexity and selection strategy. Regex is compiled once at module level.\\n- Maintainability/Best practices: Uses typing annotations, avoids side effects on inputs, and isolates logic in a function. The try/except to detect globals is reasonable; type: ignore comments are minimally intrusive. Optional print is constrained to demo path and prints only the required artifact. No obvious bugs or stylistic issues.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 5,\n    \"code_quality_score\": 5,\n    \"comments\": \"Meets all task requirements precisely, including tokenization, ordering, edge cases, and output contract. Code is clear, efficient, and well-structured. Minor non-issue: in non-main context without globals, top_k isn\u2019t set, but task guarantees globals, so this is acceptable.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "Step-by-step adherence check:\n- Tokenization rules: The code compiles a regex r\"[a-z0-9]+\" with flags re.ASCII | re.IGNORECASE and the _tokens generator yields matches lowercased. This matches the requirement to lowercase and to treat ASCII [a-z0-9]+ as tokens with other chars as separators.\n- Inputs/globals: It uses provided globals text and k without reassigning them. Access is guarded via a try/except NameError; when globals exist, it computes top_k from them.\n- Requirements:\n  1) Sort key (-count, token): Implemented via key = lambda kv: (-kv[1], kv[0]) and used both in sorted(...) and in heapq.nsmallest(...), ensuring count desc then token asc.\n  2) Set top_k to the list of (token, count) of length min(k, unique tokens): m is computed as min(k, u) (with early return [] if k <= 0). Returns exactly m items from either full sort slice [:m] or nsmallest(m, ...), maintaining the required ordering.\n  3) Edge case k <= 0: top_k_tokens returns [], so top_k becomes [].\n  4) No input(), file I/O, or network used. Script runs with provided globals and does not modify them.\n- Output contract: With provided globals, the else branch sets top_k = top_k_tokens(text, k). In the demo (when globals missing and __name__ == \"__main__\"), it defines top_k and prints only top_k on the last line. It does not rely on Counter.most_common for tie ordering. Therefore, all specified behaviors are satisfied.\n- Minor note: If globals are missing and not running as __main__, top_k would remain undefined; however, the task states globals are provided, so this path is out of scope. Overall, adherence is complete.",
+      "code_quality": "Code quality assessment:\n- Correctness: Algorithm correctly counts tokens, handles lowercasing, and produces the exact Top-K with the specified ordering. It avoids Counter.most_common tie ordering.\n- Efficiency: Uses Counter for O(N tokens), and switches between full sort and heapq.nsmallest for selection based on m relative to u, which is a good optimization. Key function with negative counts is appropriate for nsmallest.\n- Readability/Structure: Clear helper _tokens with type hints. Well-named variables, concise logic, and explanatory comments for complexity and selection strategy. Regex is compiled once at module level.\n- Maintainability/Best practices: Uses typing annotations, avoids side effects on inputs, and isolates logic in a function. The try/except to detect globals is reasonable; type: ignore comments are minimally intrusive. Optional print is constrained to demo path and prints only the required artifact. No obvious bugs or stylistic issues."
+    },
+    "final_judgement": {
+      "adherence_score": 5,
+      "code_quality_score": 5,
+      "comments": "Meets all task requirements precisely, including tokenization, ordering, edge cases, and output contract. Code is clear, efficient, and well-structured. Minor non-issue: in non-main context without globals, top_k isn\u2019t set, but task guarantees globals, so this is acceptable."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_10.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_10.json
new file mode 100644
index 0000000000..c2ca4a50c4
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_10.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_10.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"- Tokenization requirements: The code lowercases tokens and uses a regex r\\\"[a-z0-9]+\\\" with re.ASCII and re.IGNORECASE, then explicitly lowercases matches in _tokens(). This matches the spec: ASCII [a-z0-9]+ sequences, lowercase output, non-matching chars are separators.\\n- Inputs: It treats text and k as provided globals and does not reassign them. It accesses them via a presence check and then calls top_k_tokens(text, k). No input(), file I/O, or network access used.\\n- Requirement 1 (sorting key): Uses key = lambda kv: (-kv[1], kv[0]) both for sorted(...) and heapq.nsmallest(...), which implements sorting by count desc, then token asc. heapq.nsmallest returns results in increasing order of the key, which matches the required order.\\n- Requirement 2 (top_k content and length): top_k_tokens returns a list of (token, count) tuples. It computes k_eff = min(k, number of unique tokens) and slices to that length. The top-level assigns top_k = top_k_tokens(text, k), so top_k has the correct type and length.\\n- Requirement 3 (edge case k <= 0): top_k_tokens returns [] for k <= 0. That is propagated to top_k.\\n- Requirement 4 (script runs as-is): When globals text and k exist, top_k is defined at the end of execution via the else branch of the try/except. No prohibited I/O is used. If globals are missing, it only runs a demo when __main__, which is acceptable and does not violate the contract in the intended environment where globals are provided.\\n- Output contract: At the end, top_k is defined as specified when text and k are provided. Optional printing is only done in the demo path and prints just top_k on the last line.\\n- Note about Counter.most_common: The code does not use most_common; it implements the specified sort explicitly.\\nOverall, all instructions are satisfied without reliance on unspecified behavior. The minor demo branch does not interfere with the required behavior.\",\n    \"code_quality\": \"- Correctness: The counting and selection logic is correct and adheres to the specified ordering, including tie-breaking.\\n- Efficiency: Uses Counter for O(N tokens) counting. Selects top-k via full sort when k is a substantial fraction of U, otherwise uses heapq.nsmallest for O(U log k). This is efficient and documented in a complexity comment.\\n- Readability and structure: Clear separation of concerns (_tokens, top_k_tokens). Type hints for inputs/outputs improve clarity. Variable names are concise but understandable (cnt, u, k_eff). Inline comments explain decisions.\\n- Maintainability: Modular with small, focused functions; easy to adapt. Avoids relying on Counter.most_common tie behavior as required.\\n- Style/best practices: Uses a compiled regex and a generator. Handles edge cases early. The try/except check for globals is slightly unconventional but effective and harmless. Using re.IGNORECASE plus lower() is slightly redundant but not problematic.\\nNo bugs or meaningful inefficiencies identified.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 5,\n    \"code_quality_score\": 5,\n    \"comments\": \"Excellent adherence and implementation. Correct tokenization, ordering, edge-case handling, and output variable set as required. Clean, efficient code with thoughtful selection strategy. Only negligible nits (redundant IGNORECASE given lowercasing).\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "- Tokenization requirements: The code lowercases tokens and uses a regex r\"[a-z0-9]+\" with re.ASCII and re.IGNORECASE, then explicitly lowercases matches in _tokens(). This matches the spec: ASCII [a-z0-9]+ sequences, lowercase output, non-matching chars are separators.\n- Inputs: It treats text and k as provided globals and does not reassign them. It accesses them via a presence check and then calls top_k_tokens(text, k). No input(), file I/O, or network access used.\n- Requirement 1 (sorting key): Uses key = lambda kv: (-kv[1], kv[0]) both for sorted(...) and heapq.nsmallest(...), which implements sorting by count desc, then token asc. heapq.nsmallest returns results in increasing order of the key, which matches the required order.\n- Requirement 2 (top_k content and length): top_k_tokens returns a list of (token, count) tuples. It computes k_eff = min(k, number of unique tokens) and slices to that length. The top-level assigns top_k = top_k_tokens(text, k), so top_k has the correct type and length.\n- Requirement 3 (edge case k <= 0): top_k_tokens returns [] for k <= 0. That is propagated to top_k.\n- Requirement 4 (script runs as-is): When globals text and k exist, top_k is defined at the end of execution via the else branch of the try/except. No prohibited I/O is used. If globals are missing, it only runs a demo when __main__, which is acceptable and does not violate the contract in the intended environment where globals are provided.\n- Output contract: At the end, top_k is defined as specified when text and k are provided. Optional printing is only done in the demo path and prints just top_k on the last line.\n- Note about Counter.most_common: The code does not use most_common; it implements the specified sort explicitly.\nOverall, all instructions are satisfied without reliance on unspecified behavior. The minor demo branch does not interfere with the required behavior.",
+      "code_quality": "- Correctness: The counting and selection logic is correct and adheres to the specified ordering, including tie-breaking.\n- Efficiency: Uses Counter for O(N tokens) counting. Selects top-k via full sort when k is a substantial fraction of U, otherwise uses heapq.nsmallest for O(U log k). This is efficient and documented in a complexity comment.\n- Readability and structure: Clear separation of concerns (_tokens, top_k_tokens). Type hints for inputs/outputs improve clarity. Variable names are concise but understandable (cnt, u, k_eff). Inline comments explain decisions.\n- Maintainability: Modular with small, focused functions; easy to adapt. Avoids relying on Counter.most_common tie behavior as required.\n- Style/best practices: Uses a compiled regex and a generator. Handles edge cases early. The try/except check for globals is slightly unconventional but effective and harmless. Using re.IGNORECASE plus lower() is slightly redundant but not problematic.\nNo bugs or meaningful inefficiencies identified."
+    },
+    "final_judgement": {
+      "adherence_score": 5,
+      "code_quality_score": 5,
+      "comments": "Excellent adherence and implementation. Correct tokenization, ordering, edge-case handling, and output variable set as required. Clean, efficient code with thoughtful selection strategy. Only negligible nits (redundant IGNORECASE given lowercasing)."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_11.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_11.json
new file mode 100644
index 0000000000..225bc65398
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_11.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_11.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"- Tokenization: Uses regex r\\\"[a-z0-9]+\\\" with flags re.ASCII | re.IGNORECASE and lowercases each match via m.group(0).lower(). This meets the requirement: lowercase tokens and treat non [a-z0-9] ASCII as separators.\\n- Inputs: Reads globals text and k without reassigning them. Presence is checked via try/except; no mutation occurs.\\n- Requirement 1 (sorting): Implements key = (-count, token) and uses sorted(...) when k >= unique_count and heapq.nsmallest(...) otherwise. Since nsmallest returns results in ascending key order, this yields count desc then token asc. No reliance on Counter.most_common.\\n- Requirement 2 (top_k content/length): top_k_tokens returns a list of (token, count) pairs. Length is min(k, number of unique tokens) when k > 0; otherwise empty. The outer code assigns this list to the global variable top_k.\\n- Requirement 3 (k <= 0): Explicitly returns [] for k <= 0; thus top_k becomes [].\\n- Requirement 4 (no I/O): No input(), file, or network usage. Optional demo only prints top_k when globals are absent and __name__ == \\\"__main__\\\".\\n- Output contract: With provided globals, top_k is defined at the end as specified. Optional printing is suppressed in that case; in demo mode, it prints only top_k on the last line as a Python literal. Does not rely on Counter.most_common tie ordering.\\n- Edge considerations: Sorting tie-breaker by token asc is correctly handled. ASCII/lexicographic assumptions hold since tokens are lowercase ASCII strings.\",\n    \"code_quality\": \"- Clarity/Structure: Clean separation of concerns with a token generator and a top_k_tokens function. Names are descriptive; type hints provided.\\n- Correctness: Algorithm correctly counts tokens and selects/sorts by the specified key. Handles k <= 0 and k >= unique_count cases correctly.\\n- Efficiency: Counting is O(N tokens). Selection uses heapq.nsmallest for O(U log k) when k < U, and full sort O(U log U) otherwise. Space usage matches the comment.\\n- Readability/Maintainability: Readable, concise, and well-commented. The complexity note is helpful.\\n- Best practices: Avoids Counter.most_common. Uses regex with ASCII and proper lowercasing. No side effects on inputs.\\n- Minor nits: re.IGNORECASE is redundant given explicit .lower() (either alone would suffice), but harmless. In environments without provided globals and not running as __main__, top_k won't be defined, though this is outside the stated execution context (globals are provided).\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 5,\n    \"code_quality_score\": 5,\n    \"comments\": \"Excellent adherence and implementation. Correct tokenization, ordering, edge-case handling, and output variable contract. Code is clear, efficient, and robust. Minor redundancy in IGNORECASE with lowercasing, but not impactful.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "- Tokenization: Uses regex r\"[a-z0-9]+\" with flags re.ASCII | re.IGNORECASE and lowercases each match via m.group(0).lower(). This meets the requirement: lowercase tokens and treat non [a-z0-9] ASCII as separators.\n- Inputs: Reads globals text and k without reassigning them. Presence is checked via try/except; no mutation occurs.\n- Requirement 1 (sorting): Implements key = (-count, token) and uses sorted(...) when k >= unique_count and heapq.nsmallest(...) otherwise. Since nsmallest returns results in ascending key order, this yields count desc then token asc. No reliance on Counter.most_common.\n- Requirement 2 (top_k content/length): top_k_tokens returns a list of (token, count) pairs. Length is min(k, number of unique tokens) when k > 0; otherwise empty. The outer code assigns this list to the global variable top_k.\n- Requirement 3 (k <= 0): Explicitly returns [] for k <= 0; thus top_k becomes [].\n- Requirement 4 (no I/O): No input(), file, or network usage. Optional demo only prints top_k when globals are absent and __name__ == \"__main__\".\n- Output contract: With provided globals, top_k is defined at the end as specified. Optional printing is suppressed in that case; in demo mode, it prints only top_k on the last line as a Python literal. Does not rely on Counter.most_common tie ordering.\n- Edge considerations: Sorting tie-breaker by token asc is correctly handled. ASCII/lexicographic assumptions hold since tokens are lowercase ASCII strings.",
+      "code_quality": "- Clarity/Structure: Clean separation of concerns with a token generator and a top_k_tokens function. Names are descriptive; type hints provided.\n- Correctness: Algorithm correctly counts tokens and selects/sorts by the specified key. Handles k <= 0 and k >= unique_count cases correctly.\n- Efficiency: Counting is O(N tokens). Selection uses heapq.nsmallest for O(U log k) when k < U, and full sort O(U log U) otherwise. Space usage matches the comment.\n- Readability/Maintainability: Readable, concise, and well-commented. The complexity note is helpful.\n- Best practices: Avoids Counter.most_common. Uses regex with ASCII and proper lowercasing. No side effects on inputs.\n- Minor nits: re.IGNORECASE is redundant given explicit .lower() (either alone would suffice), but harmless. In environments without provided globals and not running as __main__, top_k won't be defined, though this is outside the stated execution context (globals are provided)."
+    },
+    "final_judgement": {
+      "adherence_score": 5,
+      "code_quality_score": 5,
+      "comments": "Excellent adherence and implementation. Correct tokenization, ordering, edge-case handling, and output variable contract. Code is clear, efficient, and robust. Minor redundancy in IGNORECASE with lowercasing, but not impactful."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_12.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_12.json
new file mode 100644
index 0000000000..3680320b0d
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_12.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_12.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"- Tokenization: Uses regex r\\\"[a-z0-9]+\\\" with re.ASCII and re.IGNORECASE, then lowercases matches in _tokens(), yielding lowercase ASCII alnum sequences. This matches the requirement precisely (lowercase; tokens are ASCII [a-z0-9]+; non-matching chars act as separators).\\n- Inputs: Accesses globals text and k without reassigning them. Uses a try/except NameError to detect their presence and only runs a demo if they are missing and the script is __main__, which does not violate any requirement.\\n- Requirement 1 (ordering): Implements the exact sort key (-count, token). For k >= number of unique tokens, returns sorted(cnt.items(), key=key). For k < unique, uses heapq.nsmallest(k, cnt.items(), key=key). Since nsmallest returns items sorted ascending by the key, and the key is (-count, token), the output is correctly ordered by count desc then token asc.\\n- Requirement 2 (top_k value and length): top_k is set to the return of top_k_tokens(text, k), which returns a list of (token, count) tuples with length min(k, unique), or all if k >= unique. Satisfied.\\n- Requirement 3 (k <= 0): top_k_tokens returns [] when k <= 0; thus top_k becomes []. Satisfied.\\n- Requirement 4 (no I/O/network): No input(), file I/O, or network usage. The optional print occurs only in demo mode when globals are not provided and __name__ == \\\"__main__\\\".\\n- Output contract: With provided globals, top_k is defined exactly as required at the end of execution. Optional printing is not performed in that path; in demo mode, only top_k is printed on the last line. The code does not rely on Counter.most_common for tie handling.\\n- Edge considerations: If globals are not provided and not running as __main__, top_k would remain undefined, but the task specifies that text and k are provided, so this does not violate the contract for the intended usage.\",\n    \"code_quality\": \"- Correctness: Logic for tokenization, counting, and top-k selection is correct and matches the specified sort order, including tie-breaking.\\n- Efficiency: O(T) counting, O(U log k) selection using heapq for k < U, and full sort only when needed. Space usage as documented in the comment. Efficient and appropriate.\\n- Readability/Structure: Clear separation of concerns (_tokens helper, top_k_tokens core function). Meaningful names, type hints, and a compiled regex constant. Inline key function is clear.\\n- Maintainability: Minimal, clean code with clear complexity comment. Does not depend on unspecified behaviors (avoids Counter.most_common ordering).\\n- Minor nits:\\n  - re.IGNORECASE is redundant since matches are explicitly lowered; it can be removed without changing behavior.\\n  - _tokens could be annotated as Iterator[str] instead of Iterable[str] for precision, but this is minor.\\n  - The demo branch is guarded to avoid interfering with normal usage; good practice.\\nOverall code quality is high with only trivial improvements possible.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 5,\n    \"code_quality_score\": 5,\n    \"comments\": \"Excellent adherence to all requirements, including exact tokenization and specified ordering. Efficient and clean implementation. Minor, non-impactful redundancy in regex flags.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "- Tokenization: Uses regex r\"[a-z0-9]+\" with re.ASCII and re.IGNORECASE, then lowercases matches in _tokens(), yielding lowercase ASCII alnum sequences. This matches the requirement precisely (lowercase; tokens are ASCII [a-z0-9]+; non-matching chars act as separators).\n- Inputs: Accesses globals text and k without reassigning them. Uses a try/except NameError to detect their presence and only runs a demo if they are missing and the script is __main__, which does not violate any requirement.\n- Requirement 1 (ordering): Implements the exact sort key (-count, token). For k >= number of unique tokens, returns sorted(cnt.items(), key=key). For k < unique, uses heapq.nsmallest(k, cnt.items(), key=key). Since nsmallest returns items sorted ascending by the key, and the key is (-count, token), the output is correctly ordered by count desc then token asc.\n- Requirement 2 (top_k value and length): top_k is set to the return of top_k_tokens(text, k), which returns a list of (token, count) tuples with length min(k, unique), or all if k >= unique. Satisfied.\n- Requirement 3 (k <= 0): top_k_tokens returns [] when k <= 0; thus top_k becomes []. Satisfied.\n- Requirement 4 (no I/O/network): No input(), file I/O, or network usage. The optional print occurs only in demo mode when globals are not provided and __name__ == \"__main__\".\n- Output contract: With provided globals, top_k is defined exactly as required at the end of execution. Optional printing is not performed in that path; in demo mode, only top_k is printed on the last line. The code does not rely on Counter.most_common for tie handling.\n- Edge considerations: If globals are not provided and not running as __main__, top_k would remain undefined, but the task specifies that text and k are provided, so this does not violate the contract for the intended usage.",
+      "code_quality": "- Correctness: Logic for tokenization, counting, and top-k selection is correct and matches the specified sort order, including tie-breaking.\n- Efficiency: O(T) counting, O(U log k) selection using heapq for k < U, and full sort only when needed. Space usage as documented in the comment. Efficient and appropriate.\n- Readability/Structure: Clear separation of concerns (_tokens helper, top_k_tokens core function). Meaningful names, type hints, and a compiled regex constant. Inline key function is clear.\n- Maintainability: Minimal, clean code with clear complexity comment. Does not depend on unspecified behaviors (avoids Counter.most_common ordering).\n- Minor nits:\n  - re.IGNORECASE is redundant since matches are explicitly lowered; it can be removed without changing behavior.\n  - _tokens could be annotated as Iterator[str] instead of Iterable[str] for precision, but this is minor.\n  - The demo branch is guarded to avoid interfering with normal usage; good practice.\nOverall code quality is high with only trivial improvements possible."
+    },
+    "final_judgement": {
+      "adherence_score": 5,
+      "code_quality_score": 5,
+      "comments": "Excellent adherence to all requirements, including exact tokenization and specified ordering. Efficient and clean implementation. Minor, non-impactful redundancy in regex flags."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_13.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_13.json
new file mode 100644
index 0000000000..f10a4bd795
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_13.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_13.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"- Tokenization: Uses compiled regex r\\\"[a-z0-9]+\\\" with flags re.ASCII | re.IGNORECASE and lowers tokens via .lower(). This matches the requirement to tokenize ASCII [a-z0-9]+ sequences and lowercase the text.\\n- Inputs: The code reads globals text and k without reassigning them. It conditionally uses them if present; otherwise it runs a demo only under __main__. This respects the \\\"do not reassign\\\" constraint.\\n- Requirement 1 (sorting): Implements sorting by count desc, then token asc via key = lambda kv: (-kv[1], kv[0]). For k >= unique tokens, it uses sorted(..., key=key). For k < unique tokens, it uses heapq.nsmallest(k, ..., key=key). nsmallest returns items in sorted order by the given key, thus producing the exact required ordering.\\n- Requirement 2 (set top_k, correct length): Assigns top_k to the return value of top_k_tokens(text, k), which returns a list of (token, count) tuples. Length is min(k, number of unique tokens) due to either full sort when k >= U or nsmallest(k, ...).\\n- Requirement 3 (edge k <= 0): top_k_tokens returns [] when k <= 0, so top_k is set to [].\\n- Requirement 4 (no input/file/network; runs with provided globals): No input(), file I/O, or network used. With provided globals, the script sets top_k directly without printing. The optional demo path only runs when globals are missing and __name__ == \\\"__main__\\\".\\n- Output contract: With provided globals, top_k is defined at end as specified. Optional printing is only in the demo case and prints only top_k as a Python literal on the last line. The solution does not rely on Counter.most_common tie ordering.\\n- Minor note: If globals are missing and the script is not __main__, top_k would not be defined, but the task specifies that globals are provided, so this does not violate the requirements in the intended execution context.\",\n    \"code_quality\": \"- Clarity/Structure: Clean separation via helper _tokens and top_k_tokens function; type hints provided; compiled regex improves readability and performance.\\n- Correctness: Sorting key correctly implements (-count, token). Uses heapq.nsmallest to achieve Top-K with correct ordering for k < U. Handles empty input and k <= 0.\\n- Efficiency: O(N) counting and O(U log k) selection for k < U; falls back to O(U log U) when k >= U. This is efficient and appropriate. The included complexity comment is accurate.\\n- Readability: Generally good. Minor nit: variable name u could be more descriptive (e.g., uniq). Lambda could destructure for readability, but current form is fine.\\n- Best practices: Avoids relying on Counter.most_common tie behavior; no unnecessary I/O; main guard used properly. The try/except for checking globals is functional but could be clearer using 'if \\\"text\\\" in globals() and \\\"k\\\" in globals()'.\\n- Minor nit: Using re.IGNORECASE and then lower() is redundant; lowercasing alone with ASCII regex would suffice. This does not affect correctness.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 5,\n    \"code_quality_score\": 4,\n    \"comments\": \"Meets all task requirements precisely, including tokenization, ordering, edge cases, and output contract. Code is clean and efficient. Minor nits: redundant IGNORECASE + lower(), and globals detection via try/except could be clearer.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "- Tokenization: Uses compiled regex r\"[a-z0-9]+\" with flags re.ASCII | re.IGNORECASE and lowers tokens via .lower(). This matches the requirement to tokenize ASCII [a-z0-9]+ sequences and lowercase the text.\n- Inputs: The code reads globals text and k without reassigning them. It conditionally uses them if present; otherwise it runs a demo only under __main__. This respects the \"do not reassign\" constraint.\n- Requirement 1 (sorting): Implements sorting by count desc, then token asc via key = lambda kv: (-kv[1], kv[0]). For k >= unique tokens, it uses sorted(..., key=key). For k < unique tokens, it uses heapq.nsmallest(k, ..., key=key). nsmallest returns items in sorted order by the given key, thus producing the exact required ordering.\n- Requirement 2 (set top_k, correct length): Assigns top_k to the return value of top_k_tokens(text, k), which returns a list of (token, count) tuples. Length is min(k, number of unique tokens) due to either full sort when k >= U or nsmallest(k, ...).\n- Requirement 3 (edge k <= 0): top_k_tokens returns [] when k <= 0, so top_k is set to [].\n- Requirement 4 (no input/file/network; runs with provided globals): No input(), file I/O, or network used. With provided globals, the script sets top_k directly without printing. The optional demo path only runs when globals are missing and __name__ == \"__main__\".\n- Output contract: With provided globals, top_k is defined at end as specified. Optional printing is only in the demo case and prints only top_k as a Python literal on the last line. The solution does not rely on Counter.most_common tie ordering.\n- Minor note: If globals are missing and the script is not __main__, top_k would not be defined, but the task specifies that globals are provided, so this does not violate the requirements in the intended execution context.",
+      "code_quality": "- Clarity/Structure: Clean separation via helper _tokens and top_k_tokens function; type hints provided; compiled regex improves readability and performance.\n- Correctness: Sorting key correctly implements (-count, token). Uses heapq.nsmallest to achieve Top-K with correct ordering for k < U. Handles empty input and k <= 0.\n- Efficiency: O(N) counting and O(U log k) selection for k < U; falls back to O(U log U) when k >= U. This is efficient and appropriate. The included complexity comment is accurate.\n- Readability: Generally good. Minor nit: variable name u could be more descriptive (e.g., uniq). Lambda could destructure for readability, but current form is fine.\n- Best practices: Avoids relying on Counter.most_common tie behavior; no unnecessary I/O; main guard used properly. The try/except for checking globals is functional but could be clearer using 'if \"text\" in globals() and \"k\" in globals()'.\n- Minor nit: Using re.IGNORECASE and then lower() is redundant; lowercasing alone with ASCII regex would suffice. This does not affect correctness."
+    },
+    "final_judgement": {
+      "adherence_score": 5,
+      "code_quality_score": 4,
+      "comments": "Meets all task requirements precisely, including tokenization, ordering, edge cases, and output contract. Code is clean and efficient. Minor nits: redundant IGNORECASE + lower(), and globals detection via try/except could be clearer."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_14.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_14.json
new file mode 100644
index 0000000000..af7fd2d1bc
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_14.json
@@ -0,0 +1,6 @@
+{
+  "file": "run_14.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"- Tokenization: Uses a compiled regex r\\\"[a-z0-9]+\\\" with flags re.ASCII and re.IGNORECASE, and explicitly lowercases each token via .lower(). This satisfies the requirement to lowercase and to treat non-[a-z0-9] ASCII as separators using a regex.\\n- Inputs/Globals: The code reads globals text and k without reassigning them. It guards with a try/except to detect their presence. When provided, it sets top_k = top_k_tokens(text, k) as required. It does not use input(), file I/O, or networking.\\n- Requirement 1 (Sorting key): Sorting is implemented with key=lambda kv: (-kv[1], kv[0]) on (token, count) pairs. For k >= u or for the full-sort path, it uses sorted(..., key=key), which orders by count desc then token asc. For the selection path, it uses heapq.nsmallest(k, cnt.items(), key=key), which returns the k smallest by (-count, token) and in sorted order, equivalent to the specified ordering. It does not rely on Counter.most_common.\\n- Requirement 2 (Set top_k list and length): top_k_tokens returns a list of (token, count) tuples. Branches ensure the length is min(k, number of unique tokens):\\n  - If k >= u: returns all u items sorted.\\n  - Else: returns first k items either via sorted(... )[:k] or nsmallest(k, ...), both giving exactly k items.\\n- Requirement 3 (Edge case k <= 0): top_k_tokens returns [] when k <= 0. If there are zero unique tokens (u == 0), it also returns [].\\n- Requirement 4 (Script behavior): With provided globals, it computes and assigns top_k accordingly. No forbidden I/O is used. Optional printing is only performed in a demo block when globals are absent and __name__ == \\\"__main__\\\"; it prints only top_k on the last line, complying with the optional print rule.\\n- Output contract: At end of execution with provided globals, top_k is defined exactly as described. In demo mode, top_k is still defined and printed. No reliance on Counter.most_common tie behavior.\\n- Minor note: If executed without globals and not as __main__ (e.g., imported), top_k would not be defined; however, the task specifies that globals are provided for the execution context, so this does not violate the stated contract.\",\n    \"code_quality\": \"- Correctness: Logic matches the specification precisely; ordering key is correct; selection via heapq.nsmallest yields exact Top-K in the required order.\\n- Efficiency: Uses Counter for O(N) counting. Selects between full sort O(U log U) when k is a large fraction of U and heap-based selection O(U log k) otherwise; includes a clear complexity comment.\\n- Readability/Maintainability: Code is clear and well-structured. Helper function _tokens and compiled regex improve clarity and performance. Type hints are used appropriately. Inline comment explains the selection heuristic.\\n- Best practices: Avoids Counter.most_common ties. Does not mutate globals. Demo guarded by if __name__ == \\\"__main__\\\". Uses key functions instead of relying on unspecified tie ordering.\\n- Minor nit: re.IGNORECASE is redundant since tokens are lowercased afterward, but it does not harm correctness.\",\n  \"final_judgement\": {\n    \"adherence_score\": 5,\n    \"code_quality_score\": 5,\n    \"comments\": \"Meets all task requirements exactly, including tokenization, ordering, edge cases, and output contract. Code is clean, efficient, and well-structured. Only minor nit is redundant IGNORECASE given explicit lowercasing.\"\n  }\n}",
+  "parsed": null,
+  "parse_error": "Expecting ',' delimiter: line 10 column 2 (char 3422)"
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_15.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_15.json
new file mode 100644
index 0000000000..fd0c549a45
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_15.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_15.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"- Tokenization: Uses regex r\\\"[a-z0-9]+\\\" with flags re.ASCII | re.IGNORECASE and lowercases matches in _tokens(). This matches the requirement to lowercase and treat ASCII [a-z0-9]+ as tokens with other chars as separators.\\n- Inputs: Reads provided globals text and k without reassigning them. Presence is checked via try/except; if present, computes result from those globals.\\n- Requirement 1 (sorting): Implements key = lambda kv: (-kv[1], kv[0]) and uses it both in sorted(...) and heapq.nsmallest(...). This produces exact ordering by count desc then token asc. Does not rely on Counter.most_common.\\n- Requirement 2 (top_k contents/length): top_k is set to a list of (token, count) tuples with length min(k, number of unique tokens). Both branches slice or request min(k, u) items.\\n- Requirement 3 (edge k <= 0): top_k_tokens returns [] when k <= 0; thus top_k becomes [].\\n- Requirement 4 (no I/O/network): No input(), file, or network usage. Script runs with provided globals; optional demo only executes under __main__ when globals are absent.\\n- Output contract: When globals text and k are present, top_k is defined exactly as specified. Optional printing occurs only in the demo fallback and prints only top_k on the last line. No extraneous output in the primary (globals-present) path.\\n- Ambiguities/choices: The code chooses between full sort and heap selection for efficiency (0.3 threshold). Both paths yield exact ordering and correct results, so this is reasonable and consistent with requirements.\",\n    \"code_quality\": \"- Clarity/readability: Clear structure with helper tokenizer function, type hints, and meaningful variable names. Comments explain complexity and selection strategy.\\n- Correctness: Tokenization and ordering strictly follow the spec. Heap-based selection uses key=(-count, token) ensuring exact tie-breaking and final order (heapq.nsmallest returns items sorted by key).\\n- Efficiency: Uses Counter for O(N) counting and adapts between O(U log U) full sort and O(U log k) selection; good optimization.\\n- Maintainability: Modular function top_k_tokens, compiled regex, and straightforward control flow. No reliance on unspecified tie behavior.\\n- Style/best practices: Avoids mutating provided globals; uses typing; avoids unnecessary I/O. Minor nit: variables like 'cnt'/'u' are concise but still readable.\\n- No bugs or inefficiencies detected relevant to the task. The fallback demo doesn't interfere with primary behavior.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 5,\n    \"code_quality_score\": 5,\n    \"comments\": \"Excellent adherence: correct tokenization, ordering, edge handling, and output variable. Code is clean, efficient, and robust. The optional demo is safely isolated under __main__.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "- Tokenization: Uses regex r\"[a-z0-9]+\" with flags re.ASCII | re.IGNORECASE and lowercases matches in _tokens(). This matches the requirement to lowercase and treat ASCII [a-z0-9]+ as tokens with other chars as separators.\n- Inputs: Reads provided globals text and k without reassigning them. Presence is checked via try/except; if present, computes result from those globals.\n- Requirement 1 (sorting): Implements key = lambda kv: (-kv[1], kv[0]) and uses it both in sorted(...) and heapq.nsmallest(...). This produces exact ordering by count desc then token asc. Does not rely on Counter.most_common.\n- Requirement 2 (top_k contents/length): top_k is set to a list of (token, count) tuples with length min(k, number of unique tokens). Both branches slice or request min(k, u) items.\n- Requirement 3 (edge k <= 0): top_k_tokens returns [] when k <= 0; thus top_k becomes [].\n- Requirement 4 (no I/O/network): No input(), file, or network usage. Script runs with provided globals; optional demo only executes under __main__ when globals are absent.\n- Output contract: When globals text and k are present, top_k is defined exactly as specified. Optional printing occurs only in the demo fallback and prints only top_k on the last line. No extraneous output in the primary (globals-present) path.\n- Ambiguities/choices: The code chooses between full sort and heap selection for efficiency (0.3 threshold). Both paths yield exact ordering and correct results, so this is reasonable and consistent with requirements.",
+      "code_quality": "- Clarity/readability: Clear structure with helper tokenizer function, type hints, and meaningful variable names. Comments explain complexity and selection strategy.\n- Correctness: Tokenization and ordering strictly follow the spec. Heap-based selection uses key=(-count, token) ensuring exact tie-breaking and final order (heapq.nsmallest returns items sorted by key).\n- Efficiency: Uses Counter for O(N) counting and adapts between O(U log U) full sort and O(U log k) selection; good optimization.\n- Maintainability: Modular function top_k_tokens, compiled regex, and straightforward control flow. No reliance on unspecified tie behavior.\n- Style/best practices: Avoids mutating provided globals; uses typing; avoids unnecessary I/O. Minor nit: variables like 'cnt'/'u' are concise but still readable.\n- No bugs or inefficiencies detected relevant to the task. The fallback demo doesn't interfere with primary behavior."
+    },
+    "final_judgement": {
+      "adherence_score": 5,
+      "code_quality_score": 5,
+      "comments": "Excellent adherence: correct tokenization, ordering, edge handling, and output variable. Code is clean, efficient, and robust. The optional demo is safely isolated under __main__."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_16.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_16.json
new file mode 100644
index 0000000000..d2b86edde1
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_16.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_16.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"Step-by-step check against the instructions:\\n- Tokenization: Uses regex r\\\"[a-z0-9]+\\\" with re.ASCII and re.IGNORECASE, then lowercases tokens via m.group(0).lower(). This matches the requirement to lowercase and treat ASCII [a-z0-9]+ as tokens with others as separators.\\n- Inputs: The code expects globals text and k without reassigning them. It references them in a try/except NameError block and only uses demo variables if they are missing and the script is run as __main__. This respects the \\\"do not reassign\\\" rule.\\n- Requirement 1 (sorting): Sorting key is defined as (-count, token) via key=lambda kv: (-kv[1], kv[0]) applied to cnt.items() where kv=(token, count). For k >= u it uses sorted(..., key=key). For k < u it uses heapq.nsmallest(k, ..., key=key), which returns the k smallest elements sorted according to the key. Given the negative count in the key, this yields exact Top-K by count desc, token asc with correct tie-breaking. It does not rely on Counter.most_common.\\n- Requirement 2 (set top_k): In the presence of provided globals, it sets top_k = top_k_tokens(text, k). The function returns a list of (token, count) tuples of length min(k, number of unique tokens), or [] for edge cases, as required.\\n- Requirement 3 (edge cases): If k <= 0, top_k_tokens returns [], so top_k becomes []. If there are 0 unique tokens (u == 0), it returns []. Both cases handled.\\n- Requirement 4 (no input/file/network; runs as-is): No input(), file I/O, or network use. With provided globals, the script runs and defines top_k accordingly.\\n- Output contract: At end of execution (with provided globals), top_k is defined exactly as specified. Optional printing: In the demo-only fallback, it prints only top_k on the last line as a Python literal; with provided globals it does not print, which is allowed.\\n- Minor note: If globals are missing and the script is not __main__, top_k would not be defined, but the task states globals are provided, so this is acceptable.\\nOverall, the code fully adheres to the task instructions.\",\n    \"code_quality\": \"Notable points:\\n- Correctness: Implements required tokenization and sorting with explicit key. Handles all specified edge cases.\\n- Efficiency: Counting is O(N tokens). Selection is O(U log k) via heapq.nsmallest, and falls back to full sort when k >= U. Space is O(U + k). This aligns with best practices for Top-K.\\n- Readability/Maintainability: Clear structure with a dedicated tokenizer, compiled regex, type hints for function signatures, and explanatory comments. The key function is explicit about tie-breaking.\\n- Robustness: Avoids relying on Counter.most_common ordering. Uses try/except for presence of globals without reassigning them. The 'type: ignore' comments are harmless and improve static typing compatibility.\\n- Style: Clean imports, sensible names, no unnecessary globals modified. Optional demo is properly gated under __main__ and does not interfere with required behavior.\\nNo bugs or inefficiencies detected; overall code quality is high.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 5,\n    \"code_quality_score\": 5,\n    \"comments\": \"Fully meets the spec with correct tokenization, sorting, edge-case handling, and output contract. Efficient and readable implementation; optional demo is properly isolated. Minor non-issue: top_k is not defined if globals are absent and not __main__, but this is outside the stated operating conditions.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "Step-by-step check against the instructions:\n- Tokenization: Uses regex r\"[a-z0-9]+\" with re.ASCII and re.IGNORECASE, then lowercases tokens via m.group(0).lower(). This matches the requirement to lowercase and treat ASCII [a-z0-9]+ as tokens with others as separators.\n- Inputs: The code expects globals text and k without reassigning them. It references them in a try/except NameError block and only uses demo variables if they are missing and the script is run as __main__. This respects the \"do not reassign\" rule.\n- Requirement 1 (sorting): Sorting key is defined as (-count, token) via key=lambda kv: (-kv[1], kv[0]) applied to cnt.items() where kv=(token, count). For k >= u it uses sorted(..., key=key). For k < u it uses heapq.nsmallest(k, ..., key=key), which returns the k smallest elements sorted according to the key. Given the negative count in the key, this yields exact Top-K by count desc, token asc with correct tie-breaking. It does not rely on Counter.most_common.\n- Requirement 2 (set top_k): In the presence of provided globals, it sets top_k = top_k_tokens(text, k). The function returns a list of (token, count) tuples of length min(k, number of unique tokens), or [] for edge cases, as required.\n- Requirement 3 (edge cases): If k <= 0, top_k_tokens returns [], so top_k becomes []. If there are 0 unique tokens (u == 0), it returns []. Both cases handled.\n- Requirement 4 (no input/file/network; runs as-is): No input(), file I/O, or network use. With provided globals, the script runs and defines top_k accordingly.\n- Output contract: At end of execution (with provided globals), top_k is defined exactly as specified. Optional printing: In the demo-only fallback, it prints only top_k on the last line as a Python literal; with provided globals it does not print, which is allowed.\n- Minor note: If globals are missing and the script is not __main__, top_k would not be defined, but the task states globals are provided, so this is acceptable.\nOverall, the code fully adheres to the task instructions.",
+      "code_quality": "Notable points:\n- Correctness: Implements required tokenization and sorting with explicit key. Handles all specified edge cases.\n- Efficiency: Counting is O(N tokens). Selection is O(U log k) via heapq.nsmallest, and falls back to full sort when k >= U. Space is O(U + k). This aligns with best practices for Top-K.\n- Readability/Maintainability: Clear structure with a dedicated tokenizer, compiled regex, type hints for function signatures, and explanatory comments. The key function is explicit about tie-breaking.\n- Robustness: Avoids relying on Counter.most_common ordering. Uses try/except for presence of globals without reassigning them. The 'type: ignore' comments are harmless and improve static typing compatibility.\n- Style: Clean imports, sensible names, no unnecessary globals modified. Optional demo is properly gated under __main__ and does not interfere with required behavior.\nNo bugs or inefficiencies detected; overall code quality is high."
+    },
+    "final_judgement": {
+      "adherence_score": 5,
+      "code_quality_score": 5,
+      "comments": "Fully meets the spec with correct tokenization, sorting, edge-case handling, and output contract. Efficient and readable implementation; optional demo is properly isolated. Minor non-issue: top_k is not defined if globals are absent and not __main__, but this is outside the stated operating conditions."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_17.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_17.json
new file mode 100644
index 0000000000..22a4a87070
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_17.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_17.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"- Tokenization: Uses regex [a-z0-9]+ with re.ASCII and re.IGNORECASE, and lowercases tokens in _tokens(). This matches the spec (ASCII alnum sequences; others are separators; lowercase).\\n- Sorting: Sort key implemented as key = lambda kv: (-kv[1], kv[0]) over Counter items (kv = (token, count)). For k >= unique count, uses sorted(..., key=key); for k < unique, uses heapq.nsmallest(k, ..., key=key), which returns results sorted by the same key. This satisfies count desc then token asc.\\n- Output top_k: When globals text and k exist, assigns top_k = top_k_tokens(text, k). Length is min(k, unique) due to branching; when k <= 0, function returns [] (requirement 3).\\n- Edge cases: k <= 0 handled; empty text (u == 0) returns [] as well.\\n- Inputs handling: Does not reassign text or k. Uses them if present; otherwise, under __main__, runs a self-contained demo without touching globals (allowed optional behavior).\\n- I/O/network: No input(), file I/O, or network access. Optional print only in demo path, printing exactly top_k on one line.\\n- Avoids Counter.most_common tie ordering: Yes, does not use most_common.\\n- End-of-execution contract: With provided globals, top_k is defined as required. Demo path also defines and prints top_k. All requirements are met.\",\n    \"code_quality\": \"- Clarity/structure: Clean separation of concerns (_tokens, top_k_tokens). Clear variable names and brief comments. Type hints provided.\\n- Correctness: Regex and lowering implement the specified tokenization. Sorting/tie-breaking is correct. Handles edge cases.\\n- Efficiency: Counting O(N tokens); selection O(U log k) via heap for k < U; otherwise full sort. Appropriate for Top-K.\\n- Readability/maintainability: Concise, readable, and idiomatic. Minimal, well-placed comments. No unnecessary complexity.\\n- Minor nit: re.IGNORECASE is redundant since tokens are lowercased, but harmless. Overall excellent quality.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 5,\n    \"code_quality_score\": 5,\n    \"comments\": \"Meets all instructions precisely, including tokenization, sorting, edge cases, and output contract. Code is clean, efficient, and well-structured. Minor optional refinement: remove redundant IGNORECASE.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "- Tokenization: Uses regex [a-z0-9]+ with re.ASCII and re.IGNORECASE, and lowercases tokens in _tokens(). This matches the spec (ASCII alnum sequences; others are separators; lowercase).\n- Sorting: Sort key implemented as key = lambda kv: (-kv[1], kv[0]) over Counter items (kv = (token, count)). For k >= unique count, uses sorted(..., key=key); for k < unique, uses heapq.nsmallest(k, ..., key=key), which returns results sorted by the same key. This satisfies count desc then token asc.\n- Output top_k: When globals text and k exist, assigns top_k = top_k_tokens(text, k). Length is min(k, unique) due to branching; when k <= 0, function returns [] (requirement 3).\n- Edge cases: k <= 0 handled; empty text (u == 0) returns [] as well.\n- Inputs handling: Does not reassign text or k. Uses them if present; otherwise, under __main__, runs a self-contained demo without touching globals (allowed optional behavior).\n- I/O/network: No input(), file I/O, or network access. Optional print only in demo path, printing exactly top_k on one line.\n- Avoids Counter.most_common tie ordering: Yes, does not use most_common.\n- End-of-execution contract: With provided globals, top_k is defined as required. Demo path also defines and prints top_k. All requirements are met.",
+      "code_quality": "- Clarity/structure: Clean separation of concerns (_tokens, top_k_tokens). Clear variable names and brief comments. Type hints provided.\n- Correctness: Regex and lowering implement the specified tokenization. Sorting/tie-breaking is correct. Handles edge cases.\n- Efficiency: Counting O(N tokens); selection O(U log k) via heap for k < U; otherwise full sort. Appropriate for Top-K.\n- Readability/maintainability: Concise, readable, and idiomatic. Minimal, well-placed comments. No unnecessary complexity.\n- Minor nit: re.IGNORECASE is redundant since tokens are lowercased, but harmless. Overall excellent quality."
+    },
+    "final_judgement": {
+      "adherence_score": 5,
+      "code_quality_score": 5,
+      "comments": "Meets all instructions precisely, including tokenization, sorting, edge cases, and output contract. Code is clean, efficient, and well-structured. Minor optional refinement: remove redundant IGNORECASE."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_18.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_18.json
new file mode 100644
index 0000000000..0f0b9c07c3
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_18.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_18.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"- Tokenization: The code lowercases tokens in _tokens() and uses a regex compiled with re.ASCII and re.IGNORECASE to match [a-z0-9]+, treating non-matching characters as separators. This exactly matches the tokenization requirements.\\n- Inputs: It reads the provided globals text and k without reassigning them. The try/except NameError guard only checks for their existence; it does not modify them.\\n- Requirement 1 (sorting): Implements the specified ordering via key = lambda kv: (-kv[1], kv[0]) and uses either sorted(...) or heapq.nsmallest(..., key=key). This yields sorting by count descending, then token ascending. nsmallest returns results in ascending order by the provided key, which corresponds to the desired order when using -count.\\n- Requirement 2 (top_k content/length): top_k is set to the list returned by top_k_tokens(text, k). If k >= number of unique tokens, it returns all items sorted correctly; if 0 < k < unique tokens, it returns k items; if k <= 0, it returns []. Length is thus min(k, unique) with the k <= 0 edge handled explicitly.\\n- Requirement 3 (k <= 0): top_k_tokens returns [] for k <= 0, so top_k becomes [] as required.\\n- Requirement 4 (no I/O): No input(), file I/O, or network access is used. Optional demo printing occurs only when globals are absent and __name__ == \\\"__main__\\\"; with provided globals, nothing is printed.\\n- Output contract: With provided globals, top_k is defined at the end as required. Optional printing is compliant (only prints top_k on the last line in demo mode). It does not rely on Counter.most_common tie ordering.\\n- Ambiguities: If globals are not provided and not running as __main__, top_k would not be defined; however, the task states the globals are provided, so this is acceptable. The approach is reasonable and does not violate any constraints.\",\n    \"code_quality\": \"- Correctness: Logic is correct for counting, tokenization, ordering, and edge cases. Does not use Counter.most_common.\\n- Efficiency: Counting is O(T) over tokens. Selection is O(U log k) via heapq.nsmallest when k < U and O(U log U) via sorted when k >= U. Space O(U + k). This is efficient and appropriate.\\n- Readability and structure: Clear helper tokenizer, descriptive names, type hints, and helpful comments (including complexity). The key function is simple and correct.\\n- Maintainability: Modularized via top_k_tokens; tokenization encapsulated; easy to adapt. No unnecessary globals mutated.\\n- Minor nit: Forcing the heap path by passing an iterator to nsmallest is a micro-optimization tied to CPython behavior; not harmful, but slightly over-engineered. The try/except to probe globals is fine, though using 'if \\\"text\\\" in globals()' could be clearer. These are minor style points and do not affect correctness.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 5,\n    \"code_quality_score\": 5,\n    \"comments\": \"Excellent adherence and implementation: correct tokenization, ordering, edge-case handling, and output contract. Code is clean, efficient, and well-structured. Only minor stylistic nits.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "- Tokenization: The code lowercases tokens in _tokens() and uses a regex compiled with re.ASCII and re.IGNORECASE to match [a-z0-9]+, treating non-matching characters as separators. This exactly matches the tokenization requirements.\n- Inputs: It reads the provided globals text and k without reassigning them. The try/except NameError guard only checks for their existence; it does not modify them.\n- Requirement 1 (sorting): Implements the specified ordering via key = lambda kv: (-kv[1], kv[0]) and uses either sorted(...) or heapq.nsmallest(..., key=key). This yields sorting by count descending, then token ascending. nsmallest returns results in ascending order by the provided key, which corresponds to the desired order when using -count.\n- Requirement 2 (top_k content/length): top_k is set to the list returned by top_k_tokens(text, k). If k >= number of unique tokens, it returns all items sorted correctly; if 0 < k < unique tokens, it returns k items; if k <= 0, it returns []. Length is thus min(k, unique) with the k <= 0 edge handled explicitly.\n- Requirement 3 (k <= 0): top_k_tokens returns [] for k <= 0, so top_k becomes [] as required.\n- Requirement 4 (no I/O): No input(), file I/O, or network access is used. Optional demo printing occurs only when globals are absent and __name__ == \"__main__\"; with provided globals, nothing is printed.\n- Output contract: With provided globals, top_k is defined at the end as required. Optional printing is compliant (only prints top_k on the last line in demo mode). It does not rely on Counter.most_common tie ordering.\n- Ambiguities: If globals are not provided and not running as __main__, top_k would not be defined; however, the task states the globals are provided, so this is acceptable. The approach is reasonable and does not violate any constraints.",
+      "code_quality": "- Correctness: Logic is correct for counting, tokenization, ordering, and edge cases. Does not use Counter.most_common.\n- Efficiency: Counting is O(T) over tokens. Selection is O(U log k) via heapq.nsmallest when k < U and O(U log U) via sorted when k >= U. Space O(U + k). This is efficient and appropriate.\n- Readability and structure: Clear helper tokenizer, descriptive names, type hints, and helpful comments (including complexity). The key function is simple and correct.\n- Maintainability: Modularized via top_k_tokens; tokenization encapsulated; easy to adapt. No unnecessary globals mutated.\n- Minor nit: Forcing the heap path by passing an iterator to nsmallest is a micro-optimization tied to CPython behavior; not harmful, but slightly over-engineered. The try/except to probe globals is fine, though using 'if \"text\" in globals()' could be clearer. These are minor style points and do not affect correctness."
+    },
+    "final_judgement": {
+      "adherence_score": 5,
+      "code_quality_score": 5,
+      "comments": "Excellent adherence and implementation: correct tokenization, ordering, edge-case handling, and output contract. Code is clean, efficient, and well-structured. Only minor stylistic nits."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_19.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_19.json
new file mode 100644
index 0000000000..250d93654b
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_19.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_19.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"Step-by-step check against instructions:\\n- Tokenization: Uses a compiled regex r\\\"[a-z0-9]+\\\" with flags re.ASCII | re.IGNORECASE and lowercases each match in _tokens(). This satisfies \\\"Lowercase the text\\\" and \\\"Tokens are ASCII [a-z0-9]+ sequences; all other characters are separators (use a regex).\\\"\\n- Inputs: The script expects two globals, text and k, and does not reassign them. It accesses them read-only and assigns the result to a new variable top_k. Compliant.\\n- Requirement 1 (sorting): Sorting key defined as key = lambda kv: (-kv[1], kv[0]), which implements count desc then token asc. For k < u, it either slices a fully sorted list or uses heapq.nsmallest with the same key, which returns items sorted by the key. No reliance on Counter.most_common. Compliant.\\n- Requirement 2 (top_k list of tuples, length min(k, unique)): top_k_tokens returns a list of (token, count) pairs; branches ensure the length is min(k, u) when k > 0, and full list when k >= u. Compliant.\\n- Requirement 3 (k <= 0 -> []): top_k_tokens returns [] for non-int k or k <= 0. This covers k <= 0 explicitly. Compliant.\\n- Requirement 4 (no input/file/network; run with provided globals): No input(), file I/O, or network. When globals exist, it computes top_k directly. If globals are missing and __name__ == \\\"__main__\\\", it runs a demo and prints; otherwise does nothing. With provided globals (as per task), it runs as-is. Compliant.\\n- Output contract: At end, top_k is defined via top_k = top_k_tokens(text, k) when globals are provided, matching the contract. Optional printing is only in the demo branch and prints only top_k on the last line. Compliant.\\n- Tie ordering: Explicitly implemented via sort key; does not use most_common. Compliant.\\nMinor note: If imported as a module without provided globals and not run as __main__, top_k will not be defined; however, the task guarantees the globals are provided, so this is not a violation.\",\n    \"code_quality\": \"The code is clear, correct, and efficient:\\n- Correctness: Tokenization, counting, sorting key, and selection logic all match the specification. Edge cases (k <= 0, no tokens) are handled.\\n- Efficiency: Uses Counter for counting and conditionally chooses between full sort and heapq.nsmallest based on k relative to unique count, reducing unnecessary O(U log U) sorting for small k. Results remain correctly sorted.\\n- Readability/Maintainability: Good names, type hints, modularization (_tokens, top_k_tokens), and concise logic. Compiled regex is reused. No reliance on unspecified tie-ordering. Comments are minimal and helpful.\\n- Best practices: No side effects except optional demo printing; no I/O beyond that; does not mutate provided globals; avoids most_common tie pitfalls.\\nNo bugs or style issues that impact the task. The only benign nit is the demo/__main__ branch leaving top_k undefined when globals are absent and not __main__, which is outside the task's operational context.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 5,\n    \"code_quality_score\": 5,\n    \"comments\": \"Meets all requirements precisely: correct tokenization, sorting, edge-case handling, and final top_k definition. Code is clean, efficient, and avoids most_common tie-ordering. Optional demo printing is appropriate.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "Step-by-step check against instructions:\n- Tokenization: Uses a compiled regex r\"[a-z0-9]+\" with flags re.ASCII | re.IGNORECASE and lowercases each match in _tokens(). This satisfies \"Lowercase the text\" and \"Tokens are ASCII [a-z0-9]+ sequences; all other characters are separators (use a regex).\"\n- Inputs: The script expects two globals, text and k, and does not reassign them. It accesses them read-only and assigns the result to a new variable top_k. Compliant.\n- Requirement 1 (sorting): Sorting key defined as key = lambda kv: (-kv[1], kv[0]), which implements count desc then token asc. For k < u, it either slices a fully sorted list or uses heapq.nsmallest with the same key, which returns items sorted by the key. No reliance on Counter.most_common. Compliant.\n- Requirement 2 (top_k list of tuples, length min(k, unique)): top_k_tokens returns a list of (token, count) pairs; branches ensure the length is min(k, u) when k > 0, and full list when k >= u. Compliant.\n- Requirement 3 (k <= 0 -> []): top_k_tokens returns [] for non-int k or k <= 0. This covers k <= 0 explicitly. Compliant.\n- Requirement 4 (no input/file/network; run with provided globals): No input(), file I/O, or network. When globals exist, it computes top_k directly. If globals are missing and __name__ == \"__main__\", it runs a demo and prints; otherwise does nothing. With provided globals (as per task), it runs as-is. Compliant.\n- Output contract: At end, top_k is defined via top_k = top_k_tokens(text, k) when globals are provided, matching the contract. Optional printing is only in the demo branch and prints only top_k on the last line. Compliant.\n- Tie ordering: Explicitly implemented via sort key; does not use most_common. Compliant.\nMinor note: If imported as a module without provided globals and not run as __main__, top_k will not be defined; however, the task guarantees the globals are provided, so this is not a violation.",
+      "code_quality": "The code is clear, correct, and efficient:\n- Correctness: Tokenization, counting, sorting key, and selection logic all match the specification. Edge cases (k <= 0, no tokens) are handled.\n- Efficiency: Uses Counter for counting and conditionally chooses between full sort and heapq.nsmallest based on k relative to unique count, reducing unnecessary O(U log U) sorting for small k. Results remain correctly sorted.\n- Readability/Maintainability: Good names, type hints, modularization (_tokens, top_k_tokens), and concise logic. Compiled regex is reused. No reliance on unspecified tie-ordering. Comments are minimal and helpful.\n- Best practices: No side effects except optional demo printing; no I/O beyond that; does not mutate provided globals; avoids most_common tie pitfalls.\nNo bugs or style issues that impact the task. The only benign nit is the demo/__main__ branch leaving top_k undefined when globals are absent and not __main__, which is outside the task's operational context."
+    },
+    "final_judgement": {
+      "adherence_score": 5,
+      "code_quality_score": 5,
+      "comments": "Meets all requirements precisely: correct tokenization, sorting, edge-case handling, and final top_k definition. Code is clean, efficient, and avoids most_common tie-ordering. Optional demo printing is appropriate."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_20.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_20.json
new file mode 100644
index 0000000000..d689ff1a80
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_20.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_20.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"- Tokenization requirements: The code uses a compiled regex r\\\"[a-z0-9]+\\\" with flags re.ASCII | re.IGNORECASE, and each match is lowercased in _tokens(). This satisfies \\\"Lowercase the text\\\" and \\\"Tokens are ASCII [a-z0-9]+ sequences; all other characters are separators (use a regex).\\\"\\n- Sorting and Top-K requirements: The key function key = lambda kv: (-kv[1], kv[0]) correctly implements sort by count descending, then token ascending. All selection paths (full sort, heapq.nsmallest, partial slice after sort) produce results ordered by that key.\\n- Output variable: The script sets top_k to a list of (token, count) tuples via top_k = top_k_tokens(text, k) when globals text and k are present, matching the requirement that top_k length equals min(k, number of unique tokens).\\n- Edge case k <= 0: top_k_tokens returns [] when k <= 0, so top_k will be [] in that case.\\n- Inputs handling: It does not reassign text or k; it only reads them. No input(), file I/O, or network access are used.\\n- Output contract: At end of execution (with provided globals), top_k is defined exactly as specified. Optional printing is only done in the demo path (when globals are missing and running as __main__), and it prints only top_k on the last line, which is acceptable.\\n- Tie handling and Counter.most_common: The code does not use most_common and explicitly implements the specified sort.\\n- Minor note: If the globals are missing and the code is imported (not __main__), top_k would not be defined. However, the task states the globals are provided; under that scenario, the script meets all requirements.\",\n    \"code_quality\": \"- Correctness: The algorithm correctly counts tokens and selects/sorts Top-K with the specified key. heapq.nsmallest is used appropriately with a key that encodes both count and token to ensure correct tie-breaking and ordering of the returned list.\\n- Efficiency: Uses O(N) counting and selects between O(U log k) via nsmallest for small k and O(U log U) sorting otherwise. This is efficient and well-considered. The heuristic threshold (0.3 * U) is reasonable.\\n- Clarity and readability: Clear function decomposition (_tokens, top_k_tokens), meaningful variable names, and a concise key function. Type hints and a complexity comment improve maintainability.\\n- Maintainability/structure: Regex compiled once at module level. No reliance on undefined tie behavior. Edge cases are handled explicitly.\\n- Minor nits: Using both re.IGNORECASE and lowercasing tokens is slightly redundant (either lower the input first or keep IGNORECASE), but harmless and clear. The demo/import fallback path is fine; if imported without globals, top_k is not defined, but this is outside the stated execution context.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 5,\n    \"code_quality_score\": 5,\n    \"comments\": \"Meets all task requirements precisely, including tokenization, ordering, edge cases, and output contract. Code is clear, efficient, and robust. Minor redundancy in case handling (IGNORECASE plus lowercasing) is negligible.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "- Tokenization requirements: The code uses a compiled regex r\"[a-z0-9]+\" with flags re.ASCII | re.IGNORECASE, and each match is lowercased in _tokens(). This satisfies \"Lowercase the text\" and \"Tokens are ASCII [a-z0-9]+ sequences; all other characters are separators (use a regex).\"\n- Sorting and Top-K requirements: The key function key = lambda kv: (-kv[1], kv[0]) correctly implements sort by count descending, then token ascending. All selection paths (full sort, heapq.nsmallest, partial slice after sort) produce results ordered by that key.\n- Output variable: The script sets top_k to a list of (token, count) tuples via top_k = top_k_tokens(text, k) when globals text and k are present, matching the requirement that top_k length equals min(k, number of unique tokens).\n- Edge case k <= 0: top_k_tokens returns [] when k <= 0, so top_k will be [] in that case.\n- Inputs handling: It does not reassign text or k; it only reads them. No input(), file I/O, or network access are used.\n- Output contract: At end of execution (with provided globals), top_k is defined exactly as specified. Optional printing is only done in the demo path (when globals are missing and running as __main__), and it prints only top_k on the last line, which is acceptable.\n- Tie handling and Counter.most_common: The code does not use most_common and explicitly implements the specified sort.\n- Minor note: If the globals are missing and the code is imported (not __main__), top_k would not be defined. However, the task states the globals are provided; under that scenario, the script meets all requirements.",
+      "code_quality": "- Correctness: The algorithm correctly counts tokens and selects/sorts Top-K with the specified key. heapq.nsmallest is used appropriately with a key that encodes both count and token to ensure correct tie-breaking and ordering of the returned list.\n- Efficiency: Uses O(N) counting and selects between O(U log k) via nsmallest for small k and O(U log U) sorting otherwise. This is efficient and well-considered. The heuristic threshold (0.3 * U) is reasonable.\n- Clarity and readability: Clear function decomposition (_tokens, top_k_tokens), meaningful variable names, and a concise key function. Type hints and a complexity comment improve maintainability.\n- Maintainability/structure: Regex compiled once at module level. No reliance on undefined tie behavior. Edge cases are handled explicitly.\n- Minor nits: Using both re.IGNORECASE and lowercasing tokens is slightly redundant (either lower the input first or keep IGNORECASE), but harmless and clear. The demo/import fallback path is fine; if imported without globals, top_k is not defined, but this is outside the stated execution context."
+    },
+    "final_judgement": {
+      "adherence_score": 5,
+      "code_quality_score": 5,
+      "comments": "Meets all task requirements precisely, including tokenization, ordering, edge cases, and output contract. Code is clear, efficient, and robust. Minor redundancy in case handling (IGNORECASE plus lowercasing) is negligible."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_21.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_21.json
new file mode 100644
index 0000000000..98f83d60e5
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_21.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_21.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"- Tokenization: Uses regex [a-z0-9]+ with re.IGNORECASE and lowercases tokens via _tokens(), satisfying 'ASCII [a-z0-9]+ sequences; lowercase; others are separators'.\\n- Inputs/globals: Accesses provided globals text and k without reassigning them. The try/except only detects presence and does not modify them.\\n- Requirement 1 (ordering): Sorting key is key = lambda kv: (-kv[1], kv[0]), which enforces count descending then token ascending. For k < U, heapq.nsmallest with this key returns the top-k items sorted by that key; for k >= U, it uses sorted(..., key=key). No reliance on Counter.most_common tie ordering.\\n- Requirement 2 (output shape/length): Returns a list of (token, count) tuples. For k >= U, returns all U; for k < U, returns exactly k. Thus length is min(k, number of unique tokens).\\n- Requirement 3 (edge cases): If k <= 0, top_k_tokens returns []. If there are zero unique tokens (u == 0), it returns []. Both satisfy the edge-case requirement.\\n- Requirement 4 (I/O/network): No input(), file I/O, or network use. Script runs as-is, computing top_k from provided globals.\\n- Output contract: At end, top_k is defined as specified when globals text and k are present (else branch assigns top_k = top_k_tokens(text, k)). Optional printing: Only prints top_k in the __main__ demo path, and prints only top_k on the last line. With provided globals, it does not print, which is allowed.\\n- Ambiguities/notes: Includes a fallback demo only when globals are missing and __main__. This does not violate requirements and does not affect correctness when globals are provided.\",\n    \"code_quality\": \"- Correctness: Logic is sound and matches the required ordering. heapq.nsmallest with key produces a fully sorted top-k list per the key.\\n- Efficiency: O(N) tokenization/counting; O(U log min(k, U)) selection via nsmallest and O(U log U) when k >= U. Efficient for large U with small k. Space O(U + min(k, U)).\\n- Clarity/Readability: Clear structure with helper _tokens(), type hints, and explanatory comment. Variable 'u' could be more descriptive, but acceptable. Key function is concise and correct.\\n- Maintainability/Structure: Separation of concerns (tokenization, counting, selection). No unnecessary dependencies. Uses Counter appropriately without relying on most_common ordering.\\n- Best practices: Precompiled regex, lowercase normalization, type annotations, and avoiding side effects. Optional demo guarded by __main__.\\n- No bugs or stylistic issues apparent; no reliance on unspecified behaviors.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 5,\n    \"code_quality_score\": 5,\n    \"comments\": \"Meets all task requirements precisely, including ordering, edge cases, and output contract. Code is clean, efficient, and well-structured. Minor nit: variable naming (u) could be more descriptive, but overall excellent.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "- Tokenization: Uses regex [a-z0-9]+ with re.IGNORECASE and lowercases tokens via _tokens(), satisfying 'ASCII [a-z0-9]+ sequences; lowercase; others are separators'.\n- Inputs/globals: Accesses provided globals text and k without reassigning them. The try/except only detects presence and does not modify them.\n- Requirement 1 (ordering): Sorting key is key = lambda kv: (-kv[1], kv[0]), which enforces count descending then token ascending. For k < U, heapq.nsmallest with this key returns the top-k items sorted by that key; for k >= U, it uses sorted(..., key=key). No reliance on Counter.most_common tie ordering.\n- Requirement 2 (output shape/length): Returns a list of (token, count) tuples. For k >= U, returns all U; for k < U, returns exactly k. Thus length is min(k, number of unique tokens).\n- Requirement 3 (edge cases): If k <= 0, top_k_tokens returns []. If there are zero unique tokens (u == 0), it returns []. Both satisfy the edge-case requirement.\n- Requirement 4 (I/O/network): No input(), file I/O, or network use. Script runs as-is, computing top_k from provided globals.\n- Output contract: At end, top_k is defined as specified when globals text and k are present (else branch assigns top_k = top_k_tokens(text, k)). Optional printing: Only prints top_k in the __main__ demo path, and prints only top_k on the last line. With provided globals, it does not print, which is allowed.\n- Ambiguities/notes: Includes a fallback demo only when globals are missing and __main__. This does not violate requirements and does not affect correctness when globals are provided.",
+      "code_quality": "- Correctness: Logic is sound and matches the required ordering. heapq.nsmallest with key produces a fully sorted top-k list per the key.\n- Efficiency: O(N) tokenization/counting; O(U log min(k, U)) selection via nsmallest and O(U log U) when k >= U. Efficient for large U with small k. Space O(U + min(k, U)).\n- Clarity/Readability: Clear structure with helper _tokens(), type hints, and explanatory comment. Variable 'u' could be more descriptive, but acceptable. Key function is concise and correct.\n- Maintainability/Structure: Separation of concerns (tokenization, counting, selection). No unnecessary dependencies. Uses Counter appropriately without relying on most_common ordering.\n- Best practices: Precompiled regex, lowercase normalization, type annotations, and avoiding side effects. Optional demo guarded by __main__.\n- No bugs or stylistic issues apparent; no reliance on unspecified behaviors."
+    },
+    "final_judgement": {
+      "adherence_score": 5,
+      "code_quality_score": 5,
+      "comments": "Meets all task requirements precisely, including ordering, edge cases, and output contract. Code is clean, efficient, and well-structured. Minor nit: variable naming (u) could be more descriptive, but overall excellent."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_22.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_22.json
new file mode 100644
index 0000000000..1b4c374e55
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_22.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_22.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"- Tokenization: Correct. Uses regex [a-z0-9]+ with re.ASCII | re.IGNORECASE and lowercases tokens in _tokens, matching the specification.\\n- Sorting and tie-break: Correct. Sort key is (-count, token). Both sorted(...) and heapq.nsmallest(..., key=key) produce the required order (count desc, token asc) without relying on Counter.most_common.\\n- Top-K length requirement: Fails in a common case. In top_k_tokens, the branch `if k >= u or k >= 0.3 * u: return sorted(cnt.items(), key=key)` returns all U items even when `k < u` but `k >= 0.3*u`. This violates requirement 2: length must be exactly min(k, number of unique tokens). It is only correct when `k >= u`.\\n- Edge cases: Handles `k <= 0` by returning [] as required. Handles empty text (u == 0) by returning [].\\n- Globals and I/O: Does not reassign provided globals `text` and `k`. No input(), file I/O, or network access. Optional printing occurs only in demo mode when globals are missing and __name__ == \\\"__main__\\\"; otherwise nothing is printed, which is acceptable.\\n- Output contract: With provided globals, `top_k` is defined. However, due to the length bug above, `top_k` may not have the required length when `0.3*u <= k < u`. Also note: if globals are missing and not running as __main__, `top_k` is not defined, but the task states globals are provided, so this path is unlikely in the intended environment.\",\n    \"code_quality\": \"- Clarity/readability: Good. Clear function names, helpful comments, and type hints. Tokenization is factored out cleanly.\\n- Correctness: One significant logic error: returning the full sorted list in the `k >= 0.3*u` branch without slicing to k causes incorrect output length. Fix by slicing: `sorted(cnt.items(), key=key)[:k]` for that branch, or compute once and slice to `min(k, u)`.\\n- Efficiency: Sensible approach\u2014Counter for counting and heapq.nsmallest for partial selection. The 0.3*U heuristic to switch to full sort is reasonable, but must still respect k. Complexity comments are accurate.\\n- Maintainability: Generally good. Could simplify by unifying the return path to ensure length invariants, e.g., always slice to `min(k, u)`. The try/except NameError for globals is a bit unconventional; checking `'text' in globals()`/`'k' in globals()` may be clearer. The `# type: ignore` comments are not necessary at runtime and could be removed or replaced with safer existence checks.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 2,\n    \"code_quality_score\": 3,\n    \"comments\": \"Main issue: when 0.3*U <= k < U, the function returns all U items instead of exactly the top-k, violating the length requirement. Sorting and tokenization are correct. Fix by slicing the full-sort branch (or always slicing to min(k, u)). Otherwise, the code is clean and efficient.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "- Tokenization: Correct. Uses regex [a-z0-9]+ with re.ASCII | re.IGNORECASE and lowercases tokens in _tokens, matching the specification.\n- Sorting and tie-break: Correct. Sort key is (-count, token). Both sorted(...) and heapq.nsmallest(..., key=key) produce the required order (count desc, token asc) without relying on Counter.most_common.\n- Top-K length requirement: Fails in a common case. In top_k_tokens, the branch `if k >= u or k >= 0.3 * u: return sorted(cnt.items(), key=key)` returns all U items even when `k < u` but `k >= 0.3*u`. This violates requirement 2: length must be exactly min(k, number of unique tokens). It is only correct when `k >= u`.\n- Edge cases: Handles `k <= 0` by returning [] as required. Handles empty text (u == 0) by returning [].\n- Globals and I/O: Does not reassign provided globals `text` and `k`. No input(), file I/O, or network access. Optional printing occurs only in demo mode when globals are missing and __name__ == \"__main__\"; otherwise nothing is printed, which is acceptable.\n- Output contract: With provided globals, `top_k` is defined. However, due to the length bug above, `top_k` may not have the required length when `0.3*u <= k < u`. Also note: if globals are missing and not running as __main__, `top_k` is not defined, but the task states globals are provided, so this path is unlikely in the intended environment.",
+      "code_quality": "- Clarity/readability: Good. Clear function names, helpful comments, and type hints. Tokenization is factored out cleanly.\n- Correctness: One significant logic error: returning the full sorted list in the `k >= 0.3*u` branch without slicing to k causes incorrect output length. Fix by slicing: `sorted(cnt.items(), key=key)[:k]` for that branch, or compute once and slice to `min(k, u)`.\n- Efficiency: Sensible approach\u2014Counter for counting and heapq.nsmallest for partial selection. The 0.3*U heuristic to switch to full sort is reasonable, but must still respect k. Complexity comments are accurate.\n- Maintainability: Generally good. Could simplify by unifying the return path to ensure length invariants, e.g., always slice to `min(k, u)`. The try/except NameError for globals is a bit unconventional; checking `'text' in globals()`/`'k' in globals()` may be clearer. The `# type: ignore` comments are not necessary at runtime and could be removed or replaced with safer existence checks."
+    },
+    "final_judgement": {
+      "adherence_score": 2,
+      "code_quality_score": 3,
+      "comments": "Main issue: when 0.3*U <= k < U, the function returns all U items instead of exactly the top-k, violating the length requirement. Sorting and tokenization are correct. Fix by slicing the full-sort branch (or always slicing to min(k, u)). Otherwise, the code is clean and efficient."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_23.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_23.json
new file mode 100644
index 0000000000..b33b0faefc
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_23.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_23.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"- Tokenization: Uses a compiled regex r\\\"[a-z0-9]+\\\" with flags re.ASCII | re.IGNORECASE and lowercases each matched token via .lower(). This satisfies the requirement to lowercase and to use ASCII [a-z0-9]+ sequences with other characters as separators.\\n- Inputs/globals: Accesses the provided globals text and k without reassigning them. The presence check uses a NameError guard and only computes a demo when globals are absent and running as __main__, which is acceptable given the task context.\\n- Sorting/key: Implements sorting by count descending, then token ascending using a key function key = lambda kv: (-kv[1], kv[0]). Does not rely on Counter.most_common; meets the specified sort order.\\n- Top-K exactness: \\n  - If k >= number of unique tokens (u), returns sorted(cnt.items(), key=key) (length u), which equals min(k, u).\\n  - If 0 < k < u and k is a \\\"large\\\" fraction of u, sorts all and slices [:k], still exact and ordered correctly.\\n  - Otherwise uses heapq.nsmallest(k, cnt.items(), key=key), which returns items in ascending order of the key, i.e., desired (-count, token) ordering, yielding an exact and correctly ordered Top-K.\\n- Edge cases: If k <= 0, top_k_tokens returns [] and the top-level assigns this to top_k. If there are no tokens (u == 0), returns []. Both satisfy length = min(k, u) and the explicit k <= 0 requirement.\\n- Output contract: When globals are provided, the script sets top_k = top_k_tokens(text, k) at module level. Printing is optional; in the demo path it prints only top_k on the last line. In the intended environment (globals provided), it does not print anything extra, and top_k is defined exactly as required.\\n- Prohibited I/O: No input(), file I/O, or network access used.\\n- Ambiguities/notes: If the script is imported without globals and not run as __main__, top_k is not defined; however, the task specifies that globals are provided, so this is acceptable in context.\",\n    \"code_quality\": \"- Correctness: Logic for counting and selecting Top-K is sound. The composite key ensures correct tie-breaking. heapq.nsmallest produces a correctly ordered list for the selected K.\\n- Efficiency: Counting is O(N tokens). Selection is O(U log U) when sorting and O(U log k) with the heap path, which is efficient. The heuristic to switch to sorting when k is a large fraction of U is reasonable.\\n- Readability/structure: Clear separation of concerns with a tokenizer, a top_k_tokens function, and top-level orchestration. Type hints and concise comments improve clarity. Variable name 'u' is a bit terse but understandable.\\n- Maintainability: Precompiled regex, small functions, and type annotations aid maintainability. No reliance on unspecified ordering behavior (avoids most_common).\\n- Minor nits: Using both re.IGNORECASE and .lower() is slightly redundant (either alone would suffice given ASCII), but harmless. In a non-specified environment (imported, no globals, not __main__), top_k remains undefined, though this does not violate the task requirements.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 5,\n    \"code_quality_score\": 5,\n    \"comments\": \"Meets all task requirements exactly, including tokenization, sorting, edge cases, and output contract. Code is clear, efficient, and well-structured. Minor optional improvements: remove redundant case-handling or ensure top_k is always set in all import contexts.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "- Tokenization: Uses a compiled regex r\"[a-z0-9]+\" with flags re.ASCII | re.IGNORECASE and lowercases each matched token via .lower(). This satisfies the requirement to lowercase and to use ASCII [a-z0-9]+ sequences with other characters as separators.\n- Inputs/globals: Accesses the provided globals text and k without reassigning them. The presence check uses a NameError guard and only computes a demo when globals are absent and running as __main__, which is acceptable given the task context.\n- Sorting/key: Implements sorting by count descending, then token ascending using a key function key = lambda kv: (-kv[1], kv[0]). Does not rely on Counter.most_common; meets the specified sort order.\n- Top-K exactness: \n  - If k >= number of unique tokens (u), returns sorted(cnt.items(), key=key) (length u), which equals min(k, u).\n  - If 0 < k < u and k is a \"large\" fraction of u, sorts all and slices [:k], still exact and ordered correctly.\n  - Otherwise uses heapq.nsmallest(k, cnt.items(), key=key), which returns items in ascending order of the key, i.e., desired (-count, token) ordering, yielding an exact and correctly ordered Top-K.\n- Edge cases: If k <= 0, top_k_tokens returns [] and the top-level assigns this to top_k. If there are no tokens (u == 0), returns []. Both satisfy length = min(k, u) and the explicit k <= 0 requirement.\n- Output contract: When globals are provided, the script sets top_k = top_k_tokens(text, k) at module level. Printing is optional; in the demo path it prints only top_k on the last line. In the intended environment (globals provided), it does not print anything extra, and top_k is defined exactly as required.\n- Prohibited I/O: No input(), file I/O, or network access used.\n- Ambiguities/notes: If the script is imported without globals and not run as __main__, top_k is not defined; however, the task specifies that globals are provided, so this is acceptable in context.",
+      "code_quality": "- Correctness: Logic for counting and selecting Top-K is sound. The composite key ensures correct tie-breaking. heapq.nsmallest produces a correctly ordered list for the selected K.\n- Efficiency: Counting is O(N tokens). Selection is O(U log U) when sorting and O(U log k) with the heap path, which is efficient. The heuristic to switch to sorting when k is a large fraction of U is reasonable.\n- Readability/structure: Clear separation of concerns with a tokenizer, a top_k_tokens function, and top-level orchestration. Type hints and concise comments improve clarity. Variable name 'u' is a bit terse but understandable.\n- Maintainability: Precompiled regex, small functions, and type annotations aid maintainability. No reliance on unspecified ordering behavior (avoids most_common).\n- Minor nits: Using both re.IGNORECASE and .lower() is slightly redundant (either alone would suffice given ASCII), but harmless. In a non-specified environment (imported, no globals, not __main__), top_k remains undefined, though this does not violate the task requirements."
+    },
+    "final_judgement": {
+      "adherence_score": 5,
+      "code_quality_score": 5,
+      "comments": "Meets all task requirements exactly, including tokenization, sorting, edge cases, and output contract. Code is clear, efficient, and well-structured. Minor optional improvements: remove redundant case-handling or ensure top_k is always set in all import contexts."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_24.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_24.json
new file mode 100644
index 0000000000..502d3db632
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_24.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_24.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"Step-by-step check against instructions:\\n- Tokenization: Uses a compiled regex r\\\"[a-z0-9]+\\\" with flags re.ASCII | re.IGNORECASE, and explicitly lowercases each matched token in _tokens(). This matches the requirement: ASCII [a-z0-9]+ sequences, lowercase, other chars are separators.\\n- Sorting and Top-K: Builds a Counter from tokens. Defines key = lambda kv: (-kv[1], kv[0]) over cnt.items(), which corresponds to sorting by count descending, then token ascending. For k >= number of unique tokens, returns sorted(cnt.items(), key=key), which yields the full list in the required order. For k < unique, uses heapq.nsmallest(k, cnt.items(), key=key); nsmallest returns the k elements in sorted order according to the key, so the output is correctly ordered as required.\\n- Output shape and length: Returns lists of (token, count) tuples. For k >= U, returns all U tuples; for 0 < k < U, returns exactly k tuples; for k <= 0, returns [] (handled early). This satisfies \\\"length = min(k, number of unique tokens)\\\" and the edge case requirement.\\n- Globals usage: Does not reassign text or k. Detects presence of globals via try/except NameError and, if present, sets top_k = top_k_tokens(text, k). If not present and running as __main__, it runs a guarded demo using separate demo_* variables and still defines top_k.\\n- Prohibited I/O: No input(), file I/O, or network access. Only an optional print in the demo branch.\\n- Output contract: Ensures top_k is defined at end of execution in both code paths (with provided globals or in demo). Optional printing only prints top_k on the last line when in demo mode. Does not rely on Counter.most_common tie ordering.\\nOverall, the code fully adheres to all specified requirements, including edge cases and tie-breaking.\",\n    \"code_quality\": \"The code is clear, correct, and efficient:\\n- Clarity/structure: Clean separation of concerns (_tokens generator, top_k_tokens function). Type hints provided. Meaningful names, small and readable.\\n- Correctness: Implements the specified tokenization and ordering precisely. Uses heapq.nsmallest with a key that encodes the required ordering, yielding a sorted Top-K. Handles k <= 0 and k >= U correctly.\\n- Efficiency: Counting is O(N tokens). Selection is O(U log k) for k < U and O(U log U) when sorting all. Extra space O(U + k). This meets typical performance expectations.\\n- Maintainability/readability: Compact and idiomatic. Minor nit: variable name 'u' could be more descriptive (e.g., num_unique). The use of both re.IGNORECASE and explicit lowercasing is slightly redundant but harmless.\\n- Best practices: Avoids Counter.most_common tie semantics as requested. No side effects on globals. The guarded demo respects the output contract and avoids prohibited I/O.\\nNo bugs or inefficiencies of concern were found.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 5,\n    \"code_quality_score\": 5,\n    \"comments\": \"Excellent adherence: correct tokenization, ordering, edge case handling, and top_k assignment. Code is concise, efficient, and readable. Minor redundancy (IGNORECASE plus lower()) and a terse variable name are the only small nits.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "Step-by-step check against instructions:\n- Tokenization: Uses a compiled regex r\"[a-z0-9]+\" with flags re.ASCII | re.IGNORECASE, and explicitly lowercases each matched token in _tokens(). This matches the requirement: ASCII [a-z0-9]+ sequences, lowercase, other chars are separators.\n- Sorting and Top-K: Builds a Counter from tokens. Defines key = lambda kv: (-kv[1], kv[0]) over cnt.items(), which corresponds to sorting by count descending, then token ascending. For k >= number of unique tokens, returns sorted(cnt.items(), key=key), which yields the full list in the required order. For k < unique, uses heapq.nsmallest(k, cnt.items(), key=key); nsmallest returns the k elements in sorted order according to the key, so the output is correctly ordered as required.\n- Output shape and length: Returns lists of (token, count) tuples. For k >= U, returns all U tuples; for 0 < k < U, returns exactly k tuples; for k <= 0, returns [] (handled early). This satisfies \"length = min(k, number of unique tokens)\" and the edge case requirement.\n- Globals usage: Does not reassign text or k. Detects presence of globals via try/except NameError and, if present, sets top_k = top_k_tokens(text, k). If not present and running as __main__, it runs a guarded demo using separate demo_* variables and still defines top_k.\n- Prohibited I/O: No input(), file I/O, or network access. Only an optional print in the demo branch.\n- Output contract: Ensures top_k is defined at end of execution in both code paths (with provided globals or in demo). Optional printing only prints top_k on the last line when in demo mode. Does not rely on Counter.most_common tie ordering.\nOverall, the code fully adheres to all specified requirements, including edge cases and tie-breaking.",
+      "code_quality": "The code is clear, correct, and efficient:\n- Clarity/structure: Clean separation of concerns (_tokens generator, top_k_tokens function). Type hints provided. Meaningful names, small and readable.\n- Correctness: Implements the specified tokenization and ordering precisely. Uses heapq.nsmallest with a key that encodes the required ordering, yielding a sorted Top-K. Handles k <= 0 and k >= U correctly.\n- Efficiency: Counting is O(N tokens). Selection is O(U log k) for k < U and O(U log U) when sorting all. Extra space O(U + k). This meets typical performance expectations.\n- Maintainability/readability: Compact and idiomatic. Minor nit: variable name 'u' could be more descriptive (e.g., num_unique). The use of both re.IGNORECASE and explicit lowercasing is slightly redundant but harmless.\n- Best practices: Avoids Counter.most_common tie semantics as requested. No side effects on globals. The guarded demo respects the output contract and avoids prohibited I/O.\nNo bugs or inefficiencies of concern were found."
+    },
+    "final_judgement": {
+      "adherence_score": 5,
+      "code_quality_score": 5,
+      "comments": "Excellent adherence: correct tokenization, ordering, edge case handling, and top_k assignment. Code is concise, efficient, and readable. Minor redundancy (IGNORECASE plus lower()) and a terse variable name are the only small nits."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_25.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_25.json
new file mode 100644
index 0000000000..cf4cb7ef4a
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_25.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_25.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"Step-by-step:\\n- Tokenization: Uses regex r\\\"[a-z0-9]+\\\" with re.ASCII and re.IGNORECASE, and yields m.group(0).lower(). This matches the requirement to use ASCII [a-z0-9]+ as tokens with other chars as separators, and to lowercase tokens. Using IGNORECASE plus .lower() is redundant but compliant.\\n- Inputs: The code references provided globals text and k without reassigning them. It conditionally executes a demo only if those globals are absent and the script is run as __main__, which does not violate the instructions.\\n- Requirement 1 (sorting): Defines key = lambda kv: (-kv[1], kv[0]) and applies it to (token, count) pairs. For k >= number of unique tokens, returns sorted(cnt.items(), key=key). For k < unique tokens, returns heapq.nsmallest(k, cnt.items(), key=key). This achieves sort by count desc then token asc for the selected Top-K and avoids Counter.most_common.\\n- Requirement 2 (top_k value): Sets top_k to the list returned by top_k_tokens(text, k). The function returns a list of (token, count) tuples of length min(k, unique tokens). Correct.\\n- Requirement 3 (edge case k <= 0): top_k_tokens returns [], so top_k will be []. Correct.\\n- Requirement 4 (no input/I-O/net): No input(), no file I/O, no network access. Optional printing occurs only in the demo branch and prints only top_k on the last line.\\n- Output contract: When globals are provided (the intended scenario), top_k is defined exactly as specified. In demo mode, top_k is also defined at module level and printed as a Python literal. The code does not rely on Counter.most_common for tie ordering.\\n- Minor note: If globals were not provided and the module was imported (not __main__), top_k would not be defined; however, the task explicitly states globals are provided when running, so this is not a violation in the intended use.\\nOverall, all specified requirements are met, with correct tokenization, sorting, edge-case handling, and output placement.\",\n    \"code_quality\": \"Clarity and correctness: The code is clear, concise, and correct. The helper _tokens encapsulates tokenization cleanly. Type hints improve readability.\\nEfficiency: Counting is O(N tokens). Selecting Top-K uses heapq.nsmallest with key-based ordering, giving O(U log k) time and O(U + k) space as commented. For k >= U, it sensibly falls back to full sort.\\nBest practices and readability: Names are descriptive, structure is modular. No reliance on most_common tie semantics. The try/except NameError to detect globals is pragmatic. Optional demo prints only the required value. Minor nit: using re.IGNORECASE together with .lower() is redundant (either alone would suffice), but it doesn't harm correctness or performance materially. Docstrings are absent but not required here.\\nNo bugs or stylistic issues that affect behavior were found.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 5,\n    \"code_quality_score\": 5,\n    \"comments\": \"Excellent adherence: correct tokenization, sorting, edge-case handling, and output. Code is clean, efficient, and maintainable. Minor optional improvement: remove redundant IGNORECASE or .lower() redundancy.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "Step-by-step:\n- Tokenization: Uses regex r\"[a-z0-9]+\" with re.ASCII and re.IGNORECASE, and yields m.group(0).lower(). This matches the requirement to use ASCII [a-z0-9]+ as tokens with other chars as separators, and to lowercase tokens. Using IGNORECASE plus .lower() is redundant but compliant.\n- Inputs: The code references provided globals text and k without reassigning them. It conditionally executes a demo only if those globals are absent and the script is run as __main__, which does not violate the instructions.\n- Requirement 1 (sorting): Defines key = lambda kv: (-kv[1], kv[0]) and applies it to (token, count) pairs. For k >= number of unique tokens, returns sorted(cnt.items(), key=key). For k < unique tokens, returns heapq.nsmallest(k, cnt.items(), key=key). This achieves sort by count desc then token asc for the selected Top-K and avoids Counter.most_common.\n- Requirement 2 (top_k value): Sets top_k to the list returned by top_k_tokens(text, k). The function returns a list of (token, count) tuples of length min(k, unique tokens). Correct.\n- Requirement 3 (edge case k <= 0): top_k_tokens returns [], so top_k will be []. Correct.\n- Requirement 4 (no input/I-O/net): No input(), no file I/O, no network access. Optional printing occurs only in the demo branch and prints only top_k on the last line.\n- Output contract: When globals are provided (the intended scenario), top_k is defined exactly as specified. In demo mode, top_k is also defined at module level and printed as a Python literal. The code does not rely on Counter.most_common for tie ordering.\n- Minor note: If globals were not provided and the module was imported (not __main__), top_k would not be defined; however, the task explicitly states globals are provided when running, so this is not a violation in the intended use.\nOverall, all specified requirements are met, with correct tokenization, sorting, edge-case handling, and output placement.",
+      "code_quality": "Clarity and correctness: The code is clear, concise, and correct. The helper _tokens encapsulates tokenization cleanly. Type hints improve readability.\nEfficiency: Counting is O(N tokens). Selecting Top-K uses heapq.nsmallest with key-based ordering, giving O(U log k) time and O(U + k) space as commented. For k >= U, it sensibly falls back to full sort.\nBest practices and readability: Names are descriptive, structure is modular. No reliance on most_common tie semantics. The try/except NameError to detect globals is pragmatic. Optional demo prints only the required value. Minor nit: using re.IGNORECASE together with .lower() is redundant (either alone would suffice), but it doesn't harm correctness or performance materially. Docstrings are absent but not required here.\nNo bugs or stylistic issues that affect behavior were found."
+    },
+    "final_judgement": {
+      "adherence_score": 5,
+      "code_quality_score": 5,
+      "comments": "Excellent adherence: correct tokenization, sorting, edge-case handling, and output. Code is clean, efficient, and maintainable. Minor optional improvement: remove redundant IGNORECASE or .lower() redundancy."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_26.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_26.json
new file mode 100644
index 0000000000..53b973d0fb
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_26.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_26.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"Step-by-step against the instructions:\\n- Tokenization: Uses a regex r\\\"[a-z0-9]+\\\" with flags re.ASCII | re.IGNORECASE to extract alphanumeric ASCII sequences, and each token is lowercased in _tokens(). This matches the spec (lowercase and ASCII [a-z0-9]+ tokens; other chars are separators via regex).\\n- Inputs and globals: The code reads globals text and k without reassigning them. It computes top_k = top_k_tokens(text, k) when those globals exist. It never reassigns text or k.\\n- Requirement 1 (sorting): The final ordering is by (-count, token). In the sorting path, it does sorted(cnt.items(), key=lambda kv: (-kv[1], kv[0])). In the heap path, it sorts the final result with result.sort(key=lambda kv: (-kv[1], kv[0])). This exactly matches the required sort key.\\n- Requirement 2 (Top-K list and length): top_k_tokens returns a list of (token, count) tuples. It computes k_eff = min(k, number of unique tokens) and either slices the sorted list [:k_eff] or maintains a size-k heap, ensuring the returned list length is min(k, unique tokens). The module-level top_k is set to that list when globals are provided.\\n- Requirement 3 (k <= 0): Early return [] if k <= 0, so top_k will be an empty list in that case.\\n- Requirement 4 (no input/file/network; runs as-is): No input(), file I/O, or network usage. With the provided globals, the script computes top_k and does not print anything extra. If globals are absent and the script is executed as __main__, it runs a guarded demo and prints only top_k, which is allowed as optional behavior.\\n- Output contract: When text and k are provided, top_k is defined at the end as required. The code does not rely on Counter.most_common; it explicitly implements the sort order and a correct heap-based selection with proper tie-breaking.\\n- Minor note: If text and k are not provided and the module is imported (not run as __main__), top_k would remain undefined. Given the task guarantees those globals are provided, this is acceptable but worth noting as a minor edge consideration.\\nOverall, the solution adheres very well to the instructions, including edge cases and the specified sorting and output contract.\",\n    \"code_quality\": \"Notable points:\\n- Clarity/readability: Well-structured with clear helper functions (_tokens, _revlex_tuple, top_k_tokens). Comments explain the heap ordering rationale. Type hints improve readability.\\n- Correctness: Tokenization matches requirements. Sorting and tie-breaking are correct. The heap branch uses rk = (count, _revlex_tuple(token)) so the min-heap root represents the current worst item (lowest count, then lexicographically largest), and items replace the root when better (rk > root). Final sort ensures exact required order. Edge cases k <= 0 and no tokens are handled.\\n- Efficiency: Uses Counter for O(N tokens) counting. Chooses between full sort (O(U log U)) and a bounded heap (O(U log k)), which is efficient. _revlex_tuple enables correct tie behavior in the heap.\\n- Maintainability: Modular design, doc-style comments for complexity, and no reliance on unspecified Counter.most_common behavior. No unnecessary side effects; respects provided globals.\\n- Minor nits: re.IGNORECASE is redundant since matches are lowercased anyway; storing both c in rk and again as a separate field duplicates data slightly; the globals-existence check via 'try: text; k' is a bit unconventional but functional.\\nOverall, code quality is high with no correctness bugs identified.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 5,\n    \"code_quality_score\": 5,\n    \"comments\": \"Excellent adherence to requirements and robust implementation. Correct tokenization, sorting, edge-case handling, and output contract. Minor style nits only.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "Step-by-step against the instructions:\n- Tokenization: Uses a regex r\"[a-z0-9]+\" with flags re.ASCII | re.IGNORECASE to extract alphanumeric ASCII sequences, and each token is lowercased in _tokens(). This matches the spec (lowercase and ASCII [a-z0-9]+ tokens; other chars are separators via regex).\n- Inputs and globals: The code reads globals text and k without reassigning them. It computes top_k = top_k_tokens(text, k) when those globals exist. It never reassigns text or k.\n- Requirement 1 (sorting): The final ordering is by (-count, token). In the sorting path, it does sorted(cnt.items(), key=lambda kv: (-kv[1], kv[0])). In the heap path, it sorts the final result with result.sort(key=lambda kv: (-kv[1], kv[0])). This exactly matches the required sort key.\n- Requirement 2 (Top-K list and length): top_k_tokens returns a list of (token, count) tuples. It computes k_eff = min(k, number of unique tokens) and either slices the sorted list [:k_eff] or maintains a size-k heap, ensuring the returned list length is min(k, unique tokens). The module-level top_k is set to that list when globals are provided.\n- Requirement 3 (k <= 0): Early return [] if k <= 0, so top_k will be an empty list in that case.\n- Requirement 4 (no input/file/network; runs as-is): No input(), file I/O, or network usage. With the provided globals, the script computes top_k and does not print anything extra. If globals are absent and the script is executed as __main__, it runs a guarded demo and prints only top_k, which is allowed as optional behavior.\n- Output contract: When text and k are provided, top_k is defined at the end as required. The code does not rely on Counter.most_common; it explicitly implements the sort order and a correct heap-based selection with proper tie-breaking.\n- Minor note: If text and k are not provided and the module is imported (not run as __main__), top_k would remain undefined. Given the task guarantees those globals are provided, this is acceptable but worth noting as a minor edge consideration.\nOverall, the solution adheres very well to the instructions, including edge cases and the specified sorting and output contract.",
+      "code_quality": "Notable points:\n- Clarity/readability: Well-structured with clear helper functions (_tokens, _revlex_tuple, top_k_tokens). Comments explain the heap ordering rationale. Type hints improve readability.\n- Correctness: Tokenization matches requirements. Sorting and tie-breaking are correct. The heap branch uses rk = (count, _revlex_tuple(token)) so the min-heap root represents the current worst item (lowest count, then lexicographically largest), and items replace the root when better (rk > root). Final sort ensures exact required order. Edge cases k <= 0 and no tokens are handled.\n- Efficiency: Uses Counter for O(N tokens) counting. Chooses between full sort (O(U log U)) and a bounded heap (O(U log k)), which is efficient. _revlex_tuple enables correct tie behavior in the heap.\n- Maintainability: Modular design, doc-style comments for complexity, and no reliance on unspecified Counter.most_common behavior. No unnecessary side effects; respects provided globals.\n- Minor nits: re.IGNORECASE is redundant since matches are lowercased anyway; storing both c in rk and again as a separate field duplicates data slightly; the globals-existence check via 'try: text; k' is a bit unconventional but functional.\nOverall, code quality is high with no correctness bugs identified."
+    },
+    "final_judgement": {
+      "adherence_score": 5,
+      "code_quality_score": 5,
+      "comments": "Excellent adherence to requirements and robust implementation. Correct tokenization, sorting, edge-case handling, and output contract. Minor style nits only."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_27.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_27.json
new file mode 100644
index 0000000000..87cf11a0d9
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_27.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_27.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"- Tokenization: Uses regex r\\\"[a-z0-9]+\\\" with re.ASCII and re.IGNORECASE, then lowercases via m.group(0).lower(). This matches the instruction to lowercase and to tokenize as ASCII [a-z0-9]+ sequences with other characters as separators.\\n- Inputs (globals): Accesses provided globals text and k without reassigning them. It conditionally runs a demo only if globals are missing and __name__ == \\\"__main__\\\"; otherwise, it computes top_k from the provided globals. This respects the constraint not to reassign the globals.\\n- Requirement 1 (sorting by count desc, token asc): Defines key = lambda kv: (-kv[1], kv[0]) where kv is (token, count). Sorting with this key yields descending count then ascending token. For the heap path, heapq.nsmallest(k, ..., key=key) returns items in ascending order per the key, which is the desired order. No reliance on Counter.most_common.\\n- Requirement 2 (top_k list length): When k >= number of unique tokens (u), returns all items sorted. Otherwise, returns exactly k items, both in correct order. The final assignment top_k = top_k_tokens(text, k) ensures top_k is that list of (token, count) tuples.\\n- Requirement 3 (k <= 0): top_k_tokens returns [] when k <= 0, so top_k becomes [] in that case.\\n- Requirement 4 (no input/file/network): No input(), file I/O, or network access is used. The only print occurs in the demo branch when globals are absent and running as main.\\n- Output contract: At end, when globals are provided (as per task), top_k is defined exactly as specified. Optional printing is only in the demo branch and prints just top_k on the last line. No extraneous output when globals are provided.\\n- Ambiguities/choices: The implementation uses a heuristic to choose between sorting and heap selection; both paths produce exactly the required ordering and results. The presence of a demo path is acceptable given it doesn\u2019t interfere when globals are provided. The code avoids Counter.most_common as requested.\\n- Edge conditions: Handles empty text (u = 0) correctly yielding []. Handles k > number of unique tokens, k == 0, and negative k correctly.\",\n    \"code_quality\": \"- Clarity and structure: Clean separation of concerns: tokenization helper, main top_k_tokens function, and a guarded main/demo section. Type annotations improve readability.\\n- Correctness: Follows the specified tokenization and sorting rules precisely. Does not rely on Counter.most_common.\\n- Efficiency: Counts in O(N tokens). Chooses between full sort and heapq.nsmallest based on a threshold; both are efficient and correct. Heap path returns properly ordered results.\\n- Readability: Variable names are succinct though cnt/u could be more descriptive; still understandable. Key function is clear. Comment on complexity is helpful.\\n- Maintainability: Minimal dependencies, clear functions, and no hidden side effects. The try/except for globals is reasonable; uses type: ignore to satisfy type checkers.\\n- Minor nits: Using both re.IGNORECASE and .lower() is slightly redundant; either alone (with lowercase conversion) would suffice. Not harmful. If imported and globals are missing (and not __main__), top_k would not be defined, but the task assumes globals are provided, so this is acceptable.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 5,\n    \"code_quality_score\": 5,\n    \"comments\": \"Implements the exact tokenization, sorting, and Top-K requirements; handles edge cases; defines top_k as specified; avoids prohibited I/O. Code is clear, correct, and efficient. Only minor stylistic nits (redundant case handling).\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "- Tokenization: Uses regex r\"[a-z0-9]+\" with re.ASCII and re.IGNORECASE, then lowercases via m.group(0).lower(). This matches the instruction to lowercase and to tokenize as ASCII [a-z0-9]+ sequences with other characters as separators.\n- Inputs (globals): Accesses provided globals text and k without reassigning them. It conditionally runs a demo only if globals are missing and __name__ == \"__main__\"; otherwise, it computes top_k from the provided globals. This respects the constraint not to reassign the globals.\n- Requirement 1 (sorting by count desc, token asc): Defines key = lambda kv: (-kv[1], kv[0]) where kv is (token, count). Sorting with this key yields descending count then ascending token. For the heap path, heapq.nsmallest(k, ..., key=key) returns items in ascending order per the key, which is the desired order. No reliance on Counter.most_common.\n- Requirement 2 (top_k list length): When k >= number of unique tokens (u), returns all items sorted. Otherwise, returns exactly k items, both in correct order. The final assignment top_k = top_k_tokens(text, k) ensures top_k is that list of (token, count) tuples.\n- Requirement 3 (k <= 0): top_k_tokens returns [] when k <= 0, so top_k becomes [] in that case.\n- Requirement 4 (no input/file/network): No input(), file I/O, or network access is used. The only print occurs in the demo branch when globals are absent and running as main.\n- Output contract: At end, when globals are provided (as per task), top_k is defined exactly as specified. Optional printing is only in the demo branch and prints just top_k on the last line. No extraneous output when globals are provided.\n- Ambiguities/choices: The implementation uses a heuristic to choose between sorting and heap selection; both paths produce exactly the required ordering and results. The presence of a demo path is acceptable given it doesn\u2019t interfere when globals are provided. The code avoids Counter.most_common as requested.\n- Edge conditions: Handles empty text (u = 0) correctly yielding []. Handles k > number of unique tokens, k == 0, and negative k correctly.",
+      "code_quality": "- Clarity and structure: Clean separation of concerns: tokenization helper, main top_k_tokens function, and a guarded main/demo section. Type annotations improve readability.\n- Correctness: Follows the specified tokenization and sorting rules precisely. Does not rely on Counter.most_common.\n- Efficiency: Counts in O(N tokens). Chooses between full sort and heapq.nsmallest based on a threshold; both are efficient and correct. Heap path returns properly ordered results.\n- Readability: Variable names are succinct though cnt/u could be more descriptive; still understandable. Key function is clear. Comment on complexity is helpful.\n- Maintainability: Minimal dependencies, clear functions, and no hidden side effects. The try/except for globals is reasonable; uses type: ignore to satisfy type checkers.\n- Minor nits: Using both re.IGNORECASE and .lower() is slightly redundant; either alone (with lowercase conversion) would suffice. Not harmful. If imported and globals are missing (and not __main__), top_k would not be defined, but the task assumes globals are provided, so this is acceptable."
+    },
+    "final_judgement": {
+      "adherence_score": 5,
+      "code_quality_score": 5,
+      "comments": "Implements the exact tokenization, sorting, and Top-K requirements; handles edge cases; defines top_k as specified; avoids prohibited I/O. Code is clear, correct, and efficient. Only minor stylistic nits (redundant case handling)."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_28.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_28.json
new file mode 100644
index 0000000000..8ce2711b13
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_28.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_28.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"- Tokenization requirements:\\n  - Uses regex r\\\"[a-z0-9]+\\\" with re.ASCII to ensure ASCII-only tokens and re.IGNORECASE to capture uppercase. Then lowercases each token in _tokens(). This matches: lowercase tokens; tokens are ASCII [a-z0-9]+; non-matching chars act as separators.\\n- Inputs/globals:\\n  - Reads globals text and k without reassigning. The try/except NameError branch falls back to a demo only if globals are absent. When globals are present, it computes top_k = top_k_tokens(text, k) as required.\\n- Sorting and Top-K:\\n  - Defines key = lambda kv: (-kv[1], kv[0]) which implements count descending, then token ascending.\\n  - For k >= number of unique tokens (u), returns sorted(cnt.items(), key=key) which is fully sorted.\\n  - For k < u, either sorts-then-slices or uses heapq.nsmallest(k, cnt.items(), key=key). heapq.nsmallest with this key returns elements in ascending order of (-count, token), which corresponds exactly to descending count and ascending token. This does not rely on Counter.most_common.\\n- Edge cases:\\n  - If k <= 0, returns [] and subsequently sets top_k = [].\\n  - If there are zero unique tokens, returns [].\\n  - Length of result is exactly min(k, u) in all branches.\\n- No disallowed I/O:\\n  - No input(), file I/O, or network access. Optional print occurs only in demo mode and prints only top_k on the last line.\\n- Output contract:\\n  - With provided globals, top_k is defined at end as a list of (token, count) tuples ordered per spec. In the no-globals case, a demo under __main__ sets and prints top_k; otherwise no top_k is defined, which is acceptable given the task context that globals are provided.\\n- Ambiguities/notes:\\n  - The use of both re.IGNORECASE and lower() is slightly redundant but correct and safe. The selection heuristic (sort-all vs heap) is an internal optimization that preserves exact ordering.\",\n    \"code_quality\": \"- Correctness: Implements exact sorting key and Top-K selection; avoids Counter.most_common tie behavior; handles edge cases.\\n- Efficiency: Uses Counter for O(N) counting and selects either full sort O(U log U) or heap-based selection O(U log k) depending on k/U. Reasonable threshold and documented.\\n- Readability/Maintainability:\\n  - Clear structure with small, well-named helpers (_tokens, top_k_tokens).\\n  - Regex precompiled. Type hints provided. Comments explain key and complexity.\\n  - Minor nit: variable name 'u' could be more descriptive (e.g., num_unique). Also, using both IGNORECASE and .lower() is redundant, but harmless.\\n- Style/Best practices: No global reassignment; optional demo guarded by __main__; no extraneous prints. Overall clean and idiomatic Python.\\n- No bugs or inefficiencies evident that affect correctness or ordering.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 5,\n    \"code_quality_score\": 5,\n    \"comments\": \"Excellent adherence: correct tokenization, ordering, edge-case handling, and output variable. Efficient and clear implementation without relying on Counter.most_common. Minor nits only (redundant IGNORECASE + lower, terse variable name).\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "- Tokenization requirements:\n  - Uses regex r\"[a-z0-9]+\" with re.ASCII to ensure ASCII-only tokens and re.IGNORECASE to capture uppercase. Then lowercases each token in _tokens(). This matches: lowercase tokens; tokens are ASCII [a-z0-9]+; non-matching chars act as separators.\n- Inputs/globals:\n  - Reads globals text and k without reassigning. The try/except NameError branch falls back to a demo only if globals are absent. When globals are present, it computes top_k = top_k_tokens(text, k) as required.\n- Sorting and Top-K:\n  - Defines key = lambda kv: (-kv[1], kv[0]) which implements count descending, then token ascending.\n  - For k >= number of unique tokens (u), returns sorted(cnt.items(), key=key) which is fully sorted.\n  - For k < u, either sorts-then-slices or uses heapq.nsmallest(k, cnt.items(), key=key). heapq.nsmallest with this key returns elements in ascending order of (-count, token), which corresponds exactly to descending count and ascending token. This does not rely on Counter.most_common.\n- Edge cases:\n  - If k <= 0, returns [] and subsequently sets top_k = [].\n  - If there are zero unique tokens, returns [].\n  - Length of result is exactly min(k, u) in all branches.\n- No disallowed I/O:\n  - No input(), file I/O, or network access. Optional print occurs only in demo mode and prints only top_k on the last line.\n- Output contract:\n  - With provided globals, top_k is defined at end as a list of (token, count) tuples ordered per spec. In the no-globals case, a demo under __main__ sets and prints top_k; otherwise no top_k is defined, which is acceptable given the task context that globals are provided.\n- Ambiguities/notes:\n  - The use of both re.IGNORECASE and lower() is slightly redundant but correct and safe. The selection heuristic (sort-all vs heap) is an internal optimization that preserves exact ordering.",
+      "code_quality": "- Correctness: Implements exact sorting key and Top-K selection; avoids Counter.most_common tie behavior; handles edge cases.\n- Efficiency: Uses Counter for O(N) counting and selects either full sort O(U log U) or heap-based selection O(U log k) depending on k/U. Reasonable threshold and documented.\n- Readability/Maintainability:\n  - Clear structure with small, well-named helpers (_tokens, top_k_tokens).\n  - Regex precompiled. Type hints provided. Comments explain key and complexity.\n  - Minor nit: variable name 'u' could be more descriptive (e.g., num_unique). Also, using both IGNORECASE and .lower() is redundant, but harmless.\n- Style/Best practices: No global reassignment; optional demo guarded by __main__; no extraneous prints. Overall clean and idiomatic Python.\n- No bugs or inefficiencies evident that affect correctness or ordering."
+    },
+    "final_judgement": {
+      "adherence_score": 5,
+      "code_quality_score": 5,
+      "comments": "Excellent adherence: correct tokenization, ordering, edge-case handling, and output variable. Efficient and clear implementation without relying on Counter.most_common. Minor nits only (redundant IGNORECASE + lower, terse variable name)."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_29.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_29.json
new file mode 100644
index 0000000000..5889fe8175
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_29.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_29.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"Step-by-step adherence check:\\n- Tokenization rules: The code compiles a regex r\\\"[a-z0-9]+\\\" with re.ASCII | re.IGNORECASE and then lowercases each matched token in _tokens(). This satisfies: lowercase text and ASCII [a-z0-9]+ tokens; other chars as separators.\\n- Sorting requirement: The key lambda (-count, token) is used with sorted(...) or heapq.nsmallest(...), producing order by count desc then token asc. This matches the specified sort key; it also avoids relying on Counter.most_common.\\n- Top-K computation: The function returns min(k, U) items. Cases:\\n  - If k <= 0: returns []. Matches requirement 3.\\n  - If U == 0: returns []. Appropriate.\\n  - If k >= U: returns full sorted list of U items. Correct length and order.\\n  - Else: either sorts and slices or uses heapq.nsmallest(k, ...). Both yield exactly k items sorted by the given key (heapq.nsmallest returns results sorted by the key), so the order is correct.\\n- Globals handling: It does not reassign text or k. It assigns top_k = top_k_tokens(text, k) when those globals exist, satisfying the requirement that at the end of execution top_k is defined as specified (in the intended environment where globals are provided).\\n- No disallowed I/O: No input(), file, or network access. Optional printing only occurs in a demo branch when globals are missing and __name__ == \\\"__main__\\\"; it prints only top_k and nothing else, fulfilling the optional print constraint.\\n- Edge/ambiguity: If globals are absent and not running as __main__, top_k would not be set, but the task context states the globals are provided, so this is acceptable. The implementation does not use Counter.most_common and implements the specified sort explicitly.\\nOverall, the code fully meets the instructions.\",\n    \"code_quality\": \"Assessment:\\n- Correctness: Tokenization, counting, and ordering are correct. heapq.nsmallest with key=(-count, token) correctly returns the top-k in the required sorted order. Edge cases (k<=0, no tokens) handled.\\n- Efficiency: Uses Counter for O(N) counting. Chooses between full sort O(U log U) for large k and heap-based selection O(U log k) for small k. This is efficient and memory-conscious (extra O(k) beyond counts).\\n- Readability: Clear structure with helper _tokens and top_k_tokens function. Type hints provided. Inline comments clarify strategy and complexity.\\n- Maintainability: Logic is modular and well-documented. Regex is compiled once at module level. No reliance on unspecified tie-breaking behavior.\\n- Style: Minor nit: \\\"import re, heapq\\\" could be split into separate lines per PEP 8; variable name 'u' could be more descriptive. These are minor and do not affect quality.\\nNo bugs or significant issues identified.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 5,\n    \"code_quality_score\": 5,\n    \"comments\": \"Meets all task requirements precisely, including tokenization, sorting, edge cases, and global handling. Code is efficient, clean, and well-documented. Minor stylistic nits only.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "Step-by-step adherence check:\n- Tokenization rules: The code compiles a regex r\"[a-z0-9]+\" with re.ASCII | re.IGNORECASE and then lowercases each matched token in _tokens(). This satisfies: lowercase text and ASCII [a-z0-9]+ tokens; other chars as separators.\n- Sorting requirement: The key lambda (-count, token) is used with sorted(...) or heapq.nsmallest(...), producing order by count desc then token asc. This matches the specified sort key; it also avoids relying on Counter.most_common.\n- Top-K computation: The function returns min(k, U) items. Cases:\n  - If k <= 0: returns []. Matches requirement 3.\n  - If U == 0: returns []. Appropriate.\n  - If k >= U: returns full sorted list of U items. Correct length and order.\n  - Else: either sorts and slices or uses heapq.nsmallest(k, ...). Both yield exactly k items sorted by the given key (heapq.nsmallest returns results sorted by the key), so the order is correct.\n- Globals handling: It does not reassign text or k. It assigns top_k = top_k_tokens(text, k) when those globals exist, satisfying the requirement that at the end of execution top_k is defined as specified (in the intended environment where globals are provided).\n- No disallowed I/O: No input(), file, or network access. Optional printing only occurs in a demo branch when globals are missing and __name__ == \"__main__\"; it prints only top_k and nothing else, fulfilling the optional print constraint.\n- Edge/ambiguity: If globals are absent and not running as __main__, top_k would not be set, but the task context states the globals are provided, so this is acceptable. The implementation does not use Counter.most_common and implements the specified sort explicitly.\nOverall, the code fully meets the instructions.",
+      "code_quality": "Assessment:\n- Correctness: Tokenization, counting, and ordering are correct. heapq.nsmallest with key=(-count, token) correctly returns the top-k in the required sorted order. Edge cases (k<=0, no tokens) handled.\n- Efficiency: Uses Counter for O(N) counting. Chooses between full sort O(U log U) for large k and heap-based selection O(U log k) for small k. This is efficient and memory-conscious (extra O(k) beyond counts).\n- Readability: Clear structure with helper _tokens and top_k_tokens function. Type hints provided. Inline comments clarify strategy and complexity.\n- Maintainability: Logic is modular and well-documented. Regex is compiled once at module level. No reliance on unspecified tie-breaking behavior.\n- Style: Minor nit: \"import re, heapq\" could be split into separate lines per PEP 8; variable name 'u' could be more descriptive. These are minor and do not affect quality.\nNo bugs or significant issues identified."
+    },
+    "final_judgement": {
+      "adherence_score": 5,
+      "code_quality_score": 5,
+      "comments": "Meets all task requirements precisely, including tokenization, sorting, edge cases, and global handling. Code is efficient, clean, and well-documented. Minor stylistic nits only."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_30.json b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_30.json
new file mode 100644
index 0000000000..a859ccbcb5
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_llm_as_judge_optimized/run_30.json
@@ -0,0 +1,16 @@
+{
+  "file": "run_30.py",
+  "raw": "{\n  \"reasoning\": {\n    \"task_adherence\": \"- Tokenization: Uses regex r\\\"[a-z0-9]+\\\" with re.ASCII to ensure ASCII matching and lowercases tokens in _tokens(), satisfying the requirement to lowercase and use ASCII [a-z0-9]+ with other chars as separators.\\n- Inputs: Accesses provided globals text and k without reassigning them. Uses a try/except NameError to detect their presence and only computes from them when available, respecting the constraint.\\n- Requirement 1 (sorting): Constructs key = lambda kv: (-kv[1], kv[0]) over (token, count) pairs and uses heapq.nsmallest(m, cnt.items(), key=key). This produces items ordered by count descending, then token ascending, matching the specified sort key (-count, token). It does not rely on Counter.most_common tie ordering.\\n- Requirement 2 (top_k content and length): The function returns a list of (token, count) tuples and limits its length to m = min(k, number of unique tokens). The top-level assigns top_k = top_k_tokens(text, k), so top_k meets the spec when globals are provided.\\n- Requirement 3 (k <= 0): top_k_tokens returns [] when k <= 0; thus top_k is [] in that case.\\n- Requirement 4 (no I/O): No input(), file I/O, or network access is used. Optional printing occurs only in a demo path when globals are missing and __name__ == \\\"__main__\\\", printing only top_k.\\n- Output contract: With provided globals, top_k is defined at the end exactly as required. Optional printing is constrained to output only top_k as a Python literal. A minor note: if globals are missing and not running as __main__, top_k is not defined, but the task states globals are provided, so this path is outside the stated execution context.\\n- Note on tie ordering: Does not use Counter.most_common; ordering is implemented explicitly via key.\",\n    \"code_quality\": \"- Correctness: The logic correctly tokenizes, counts, and selects the top-k with the proper sort key and tie-breaker. Edge cases (k <= 0 and no tokens) return [].\\n- Efficiency: Counting is O(N tokens). Selection via heapq.nsmallest is O(U log k) with space O(U + k), which is efficient for large U and small k.\\n- Readability/clarity: Clear structure with helper functions and type hints. Minor nit: variable names u and m are terse; more descriptive names could improve readability. A small redundancy exists (using re.IGNORECASE plus lowercasing), but it\u2019s harmless.\\n- Maintainability: Modular design and clear top-level orchestration. Type hints aid maintainability. The try/except for globals is pragmatic and well-scoped. A very minor improvement would be to always define top_k even if globals are missing and not __main__, though this is outside the stated execution scenario.\\n- Best practices: Avoids reliance on Counter.most_common ordering, avoids unnecessary I/O, and handles edge cases explicitly. The complexity comment is accurate and helpful.\"\n  },\n  \"final_judgement\": {\n    \"adherence_score\": 5,\n    \"code_quality_score\": 5,\n    \"comments\": \"Meets all task requirements precisely with correct sorting, proper tokenization, edge-case handling, and no prohibited I/O. Code is clean, efficient, and maintainable. Minor nits (redundant IGNORECASE, terse variable names) do not affect correctness or quality.\"\n  }\n}",
+  "parsed": {
+    "reasoning": {
+      "task_adherence": "- Tokenization: Uses regex r\"[a-z0-9]+\" with re.ASCII to ensure ASCII matching and lowercases tokens in _tokens(), satisfying the requirement to lowercase and use ASCII [a-z0-9]+ with other chars as separators.\n- Inputs: Accesses provided globals text and k without reassigning them. Uses a try/except NameError to detect their presence and only computes from them when available, respecting the constraint.\n- Requirement 1 (sorting): Constructs key = lambda kv: (-kv[1], kv[0]) over (token, count) pairs and uses heapq.nsmallest(m, cnt.items(), key=key). This produces items ordered by count descending, then token ascending, matching the specified sort key (-count, token). It does not rely on Counter.most_common tie ordering.\n- Requirement 2 (top_k content and length): The function returns a list of (token, count) tuples and limits its length to m = min(k, number of unique tokens). The top-level assigns top_k = top_k_tokens(text, k), so top_k meets the spec when globals are provided.\n- Requirement 3 (k <= 0): top_k_tokens returns [] when k <= 0; thus top_k is [] in that case.\n- Requirement 4 (no I/O): No input(), file I/O, or network access is used. Optional printing occurs only in a demo path when globals are missing and __name__ == \"__main__\", printing only top_k.\n- Output contract: With provided globals, top_k is defined at the end exactly as required. Optional printing is constrained to output only top_k as a Python literal. A minor note: if globals are missing and not running as __main__, top_k is not defined, but the task states globals are provided, so this path is outside the stated execution context.\n- Note on tie ordering: Does not use Counter.most_common; ordering is implemented explicitly via key.",
+      "code_quality": "- Correctness: The logic correctly tokenizes, counts, and selects the top-k with the proper sort key and tie-breaker. Edge cases (k <= 0 and no tokens) return [].\n- Efficiency: Counting is O(N tokens). Selection via heapq.nsmallest is O(U log k) with space O(U + k), which is efficient for large U and small k.\n- Readability/clarity: Clear structure with helper functions and type hints. Minor nit: variable names u and m are terse; more descriptive names could improve readability. A small redundancy exists (using re.IGNORECASE plus lowercasing), but it\u2019s harmless.\n- Maintainability: Modular design and clear top-level orchestration. Type hints aid maintainability. The try/except for globals is pragmatic and well-scoped. A very minor improvement would be to always define top_k even if globals are missing and not __main__, though this is outside the stated execution scenario.\n- Best practices: Avoids reliance on Counter.most_common ordering, avoids unnecessary I/O, and handles edge cases explicitly. The complexity comment is accurate and helpful."
+    },
+    "final_judgement": {
+      "adherence_score": 5,
+      "code_quality_score": 5,
+      "comments": "Meets all task requirements precisely with correct sorting, proper tokenization, edge-case handling, and no prohibited I/O. Code is clean, efficient, and maintainable. Minor nits (redundant IGNORECASE, terse variable names) do not affect correctness or quality."
+    }
+  },
+  "parse_error": null
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_01.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_01.py
new file mode 100644
index 0000000000..d47439fd16
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_01.py
@@ -0,0 +1,34 @@
+import re
+import heapq
+
+def compute_top_k(text: str, k: int):
+    # Tokenize: lowercase, ASCII [a-z0-9]+; others are separators
+    if not text or k <= 0:
+        return []
+    s = text.lower()
+    pattern = re.compile(r'[a-z0-9]+', re.ASCII)
+
+    counts = {}
+    get = counts.get
+    for m in pattern.finditer(s):
+        t = m.group(0)
+        counts[t] = get(t, 0) + 1
+
+    n = min(k, len(counts))
+    if n <= 0:
+        return []
+    # Sort by count desc, then token asc
+    return heapq.nsmallest(n, counts.items(), key=lambda it: (-it[1], it[0]))
+
+def _to_int(v):
+    try:
+        return int(v)
+    except Exception:
+        return 0
+
+# Use provided globals; expose only top_k
+_text = globals().get('text', '')
+_k = _to_int(globals().get('k', 0))
+top_k = compute_top_k(_text, _k)
+
+__all__ = ['top_k']
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_02.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_02.py
new file mode 100644
index 0000000000..be0191fdde
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_02.py
@@ -0,0 +1,25 @@
+import re
+from typing import List, Tuple, Dict
+
+def compute_top_k(text: str, k: int) -> List[Tuple[str, int]]:
+    # Tokens are ASCII [a-z0-9]+; lowercase; others are separators.
+    if not isinstance(text, str) or not isinstance(k, int) or k <= 0:
+        return []
+
+    pattern = re.compile(r'[a-z0-9]+', re.ASCII | re.IGNORECASE)
+    counts: Dict[str, int] = {}
+    get = counts.get
+
+    for m in pattern.finditer(text):
+        tok = m.group(0).lower()
+        counts[tok] = (get(tok) or 0) + 1
+
+    if not counts:
+        return []
+
+    items = sorted(counts.items(), key=lambda kv: (-kv[1], kv[0]))
+    limit = min(k, len(items))
+    return items[:limit]
+
+# Expose the result as a convenient global.
+top_k: List[Tuple[str, int]] = compute_top_k(text, k)
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_03.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_03.py
new file mode 100644
index 0000000000..5e3275d55a
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_03.py
@@ -0,0 +1,45 @@
+import heapq
+
+def _count_tokens(s: str) -> dict:
+    # Count ASCII [a-z0-9]+ tokens, lowercasing letters during scan.
+    counts = {}
+    buf = []
+    append = buf.append
+    for ch in s:
+        o = ord(ch)
+        if 48 <= o <= 57:          # 0-9
+            append(ch)
+        elif 65 <= o <= 90:        # A-Z -> a-z
+            append(chr(o + 32))
+        elif 97 <= o <= 122:       # a-z
+            append(ch)
+        else:
+            if buf:
+                tok = ''.join(buf)
+                counts[tok] = counts.get(tok, 0) + 1
+                buf.clear()
+    if buf:
+        tok = ''.join(buf)
+        counts[tok] = counts.get(tok, 0) + 1
+    return counts
+
+def _top_k_from_counts(counts: dict, k: int):
+    if not counts or k <= 0:
+        return []
+    m = min(k, len(counts))
+    # Order: count desc, then token asc -> use nsmallest with key (-count, token)
+    return heapq.nsmallest(m, counts.items(), key=lambda it: (-it[1], it[0]))
+
+# Use provided globals text (str) and k (int); fall back safely if absent.
+try:
+    _text = text  # type: ignore[name-defined]
+except NameError:
+    _text = ""
+try:
+    _k = int(k)  # type: ignore[name-defined]
+except NameError:
+    _k = 0
+except Exception:
+    _k = 0
+
+top_k = _top_k_from_counts(_count_tokens(_text), _k)
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_04.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_04.py
new file mode 100644
index 0000000000..93986a0b8a
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_04.py
@@ -0,0 +1,23 @@
+import re
+import heapq
+
+def compute_top_k(s: str, k_value: int):
+    # Count tokens: ASCII [A-Za-z0-9]+, case-insensitive, stored lowercase
+    counts = {}
+    for m in re.finditer(r'[A-Za-z0-9]+', s):
+        tok = m.group(0).lower()
+        counts[tok] = counts.get(tok, 0) + 1
+
+    n = max(0, int(k_value))
+    if n == 0 or not counts:
+        return []
+
+    # Sort by count desc, then token asc using a key tuple
+    key = lambda item: (-item[1], item[0])
+    # Use nsmallest with the composite key to avoid sorting the whole list when k << unique
+    top_items = heapq.nsmallest(n, counts.items(), key=key)
+    # Ensure exact order (nsmallest returns sorted by key already)
+    return [(tok, cnt) for tok, cnt in top_items]
+
+# Expect globals: text (str), k (int)
+top_k = compute_top_k(text, k)
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_05.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_05.py
new file mode 100644
index 0000000000..3204cf7b35
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_05.py
@@ -0,0 +1,36 @@
+from collections import defaultdict
+
+def _iter_tokens_ascii_lower(s: str):
+    # Yield lowercase ASCII [a-z0-9]+ tokens, treating everything else as separators.
+    buf = []
+    append = buf.append
+    for ch in s:
+        # Fast ASCII classification with manual lowercasing for A-Z
+        if 'A' <= ch <= 'Z':
+            append(chr(ord(ch) + 32))  # to lowercase
+        elif 'a' <= ch <= 'z' or '0' <= ch <= '9':
+            append(ch)
+        else:
+            if buf:
+                yield ''.join(buf)
+                buf.clear()
+    if buf:
+        yield ''.join(buf)
+
+def _top_k_tokens(text: str, k: int):
+    if not isinstance(text, str) or not isinstance(k, int) or k <= 0:
+        return []
+    counts = defaultdict(int)
+    for tok in _iter_tokens_ascii_lower(text):
+        counts[tok] += 1
+    if not counts:
+        return []
+    # Sort by count desc, then token asc
+    items = sorted(counts.items(), key=lambda it: (-it[1], it[0]))
+    return items[:k]
+
+# Expect globals `text` and `k` to be provided by the environment.
+try:
+    top_k = _top_k_tokens(text, k)  # type: ignore[name-defined]
+except NameError:
+    top_k = []
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_06.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_06.py
new file mode 100644
index 0000000000..7e9eaf01f1
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_06.py
@@ -0,0 +1,48 @@
+import heapq
+from typing import Dict, List, Tuple
+
+def _compute_counts(s: str) -> Dict[str, int]:
+    # Single pass ASCII [a-z0-9]+ tokenizer with inline lowercasing
+    counts: Dict[str, int] = {}
+    buf: List[str] = []
+    append = buf.append
+    for ch in s:
+        o = ord(ch)
+        if 48 <= o <= 57:  # '0'-'9'
+            append(ch)
+        elif 65 <= o <= 90:  # 'A'-'Z' -> to lower
+            append(chr(o + 32))
+        elif 97 <= o <= 122:  # 'a'-'z'
+            append(ch)
+        else:
+            if buf:
+                tok = "".join(buf)
+                counts[tok] = counts.get(tok, 0) + 1
+                buf.clear()
+    if buf:
+        tok = "".join(buf)
+        counts[tok] = counts.get(tok, 0) + 1
+    return counts
+
+def compute_top_k(text: str, k: int) -> List[Tuple[str, int]]:
+    if not isinstance(text, str) or not isinstance(k, int) or k <= 0:
+        return []
+    counts = _compute_counts(text)
+    if not counts:
+        return []
+    n = min(k, len(counts))
+    # Top-K by count desc, then token asc
+    return heapq.nsmallest(n, counts.items(), key=lambda kv: (-kv[1], kv[0]))
+
+# Fetch provided globals; fall back to empty if absent
+try:
+    _text = text  # type: ignore[name-defined]
+except NameError:
+    _text = ""
+try:
+    _k = k  # type: ignore[name-defined]
+except NameError:
+    _k = 0
+
+# Expose result as requested
+top_k: List[Tuple[str, int]] = compute_top_k(_text, _k)
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_07.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_07.py
new file mode 100644
index 0000000000..226611e1a9
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_07.py
@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+import heapq
+from typing import Dict, Iterable, List, Tuple
+
+def _iter_tokens(s: str) -> Iterable[str]:
+    # One-pass ASCII tokenizer with inline lowercasing
+    buf: List[str] = []
+    append = buf.append
+    for ch in s:
+        o = ord(ch)
+        if 65 <= o <= 90:  # 'A'-'Z' -> lowercase
+            append(chr(o + 32))
+        elif 97 <= o <= 122 or 48 <= o <= 57:  # 'a'-'z' or '0'-'9'
+            append(ch)
+        else:
+            if buf:
+                yield "".join(buf)
+                buf.clear()
+    if buf:
+        yield "".join(buf)
+
+def compute_top_k(text: str, k: int) -> List[Tuple[str, int]]:
+    if not isinstance(k, int) or k <= 0:
+        return []
+    counts: Dict[str, int] = {}
+    get = counts.get
+    for tok in _iter_tokens(text):
+        counts[tok] = get(tok, 0) + 1
+    if not counts:
+        return []
+    # Sort by count desc, then token asc, using a size-k heap
+    items = counts.items()
+    result = heapq.nsmallest(k, items, key=lambda kv: (-kv[1], kv[0]))
+    return result
+
+# Expected globals: text (str) and k (int)
+top_k: List[Tuple[str, int]] = compute_top_k(text, k)
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_08.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_08.py
new file mode 100644
index 0000000000..8d60df4561
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_08.py
@@ -0,0 +1,31 @@
+import re
+import heapq
+from typing import List, Tuple, Dict
+
+# Expects globals: text (str) and k (int)
+
+_token_re = re.compile(r'[a-z0-9]+')
+
+def compute_top_k(src: str, top_n: int) -> List[Tuple[str, int]]:
+    # Lowercase once, stream tokens via finditer to avoid building a full token list
+    counts: Dict[str, int] = {}
+    for m in _token_re.finditer(src.lower()):
+        t = m.group(0)
+        counts[t] = counts.get(t, 0) + 1
+
+    if not counts:
+        return []
+
+    try:
+        n = int(top_n)
+    except Exception:
+        n = 0
+    if n <= 0:
+        return []
+
+    n = min(n, len(counts))
+    # Smallest by (-count, token) => count desc, token asc
+    return heapq.nsmallest(n, counts.items(), key=lambda kv: (-kv[1], kv[0]))
+
+# Produce the required global
+top_k = compute_top_k(text, k)
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_09.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_09.py
new file mode 100644
index 0000000000..53e9a715a0
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_09.py
@@ -0,0 +1,40 @@
+from heapq import nsmallest
+
+def _count_tokens(s):
+    # Scan once, building ASCII [a-z0-9]+ tokens in lowercase.
+    counts = {}
+    buf = []  # token buffer
+    append = buf.append  # local for speed
+    get = counts.get
+    for ch in s:
+        o = ord(ch)
+        if 48 <= o <= 57:          # '0'-'9'
+            append(ch)
+        elif 65 <= o <= 90:        # 'A'-'Z' -> lower
+            append(chr(o + 32))
+        elif 97 <= o <= 122:       # 'a'-'z'
+            append(ch)
+        else:
+            if buf:
+                tok = "".join(buf)
+                counts[tok] = get(tok, 0) + 1
+                buf.clear()
+    if buf:
+        tok = "".join(buf)
+        counts[tok] = get(tok, 0) + 1
+        buf.clear()
+    return counts
+
+def _select_top_k(counts, k):
+    # Sort by count desc, then token asc; pick up to k unique tokens.
+    if not counts or k <= 0:
+        return []
+    n = min(k, len(counts))
+    items = counts.items()
+    # nsmallest with key (-count, token) gives desired order
+    top = nsmallest(n, items, key=lambda kv: (-kv[1], kv[0]))
+    return list(top)
+
+# Expect globals: text (str), k (int)
+# Build top_k as required: list of (token, count) tuples.
+top_k = _select_top_k(_count_tokens(text), int(k))
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_10.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_10.py
new file mode 100644
index 0000000000..9f6df0b39e
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_10.py
@@ -0,0 +1,37 @@
+from collections import Counter
+import heapq
+
+def _iter_tokens(s):
+    # Stream tokens: lowercase ASCII [a-z0-9]+; others are separators
+    buf = []
+    append = buf.append
+    for ch in s:
+        c = ch.lower()
+        if ('a' <= c <= 'z') or ('0' <= c <= '9'):
+            append(c)
+        elif buf:
+            yield ''.join(buf)
+            buf.clear()
+    if buf:
+        yield ''.join(buf)
+
+def _compute_top_k(s, k):
+    if not isinstance(k, int) or k <= 0:
+        return []
+    counts = Counter()
+    for tok in _iter_tokens(s):
+        counts[tok] += 1
+    # Sort by count desc, then token asc
+    return heapq.nsmallest(k, counts.items(), key=lambda kv: (-kv[1], kv[0]))
+
+# Use provided globals; fall back to safe defaults if missing
+try:
+    _text = text
+except NameError:
+    _text = ""
+try:
+    _k = k
+except NameError:
+    _k = 0
+
+top_k = _compute_top_k(_text, _k)
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_11.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_11.py
new file mode 100644
index 0000000000..75d689a068
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_11.py
@@ -0,0 +1,36 @@
+import re
+import heapq
+
+def _compute_top_k(text, k):
+    # Tokens: ASCII [A-Za-z0-9]+, lowercased; others are separators.
+    if not isinstance(text, str):
+        text = "" if text is None else str(text)
+    try:
+        k = int(k)
+    except Exception:
+        k = 0
+    if k <= 0 or not text:
+        return []
+
+    counts = {}
+    # Iterate matches without lowercasing the entire text to keep memory low.
+    pattern = re.compile(r'[A-Za-z0-9]+', flags=re.ASCII)
+    for m in pattern.finditer(text):
+        tok = m.group(0).lower()
+        counts[tok] = counts.get(tok, 0) + 1
+
+    if not counts:
+        return []
+
+    n_unique = len(counts)
+    kk = k if k < n_unique else n_unique
+    if kk == 0:
+        return []
+
+    # Use a heap to avoid sorting the entire map when k << unique tokens.
+    # Key: (-count, token) gives count desc, then token asc.
+    top = heapq.nsmallest(kk, counts.items(), key=lambda it: (-it[1], it[0]))
+    return top
+
+# Expect globals 'text' and 'k'; define top_k for inspection.
+top_k = _compute_top_k(globals().get('text', ''), globals().get('k', 0))
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_12.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_12.py
new file mode 100644
index 0000000000..04914630b2
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_12.py
@@ -0,0 +1,29 @@
+import re
+from collections import Counter
+from heapq import nsmallest
+
+def _compute_top_k(text: str, k: int):
+    # Tokens: ASCII [a-z0-9]+ after lowercasing
+    pat = re.compile(r'[A-Za-z0-9]+', flags=re.ASCII)
+    freq = Counter()
+    for m in pat.finditer(text):
+        freq[m.group(0).lower()] += 1
+
+    items = list(freq.items())
+    if not items:
+        return []
+
+    t = max(0, min(int(k), len(items)))
+    if t == 0:
+        return []
+
+    key = lambda it: (-it[1], it[0])  # count desc, token asc
+    if t < len(items):
+        return nsmallest(t, items, key=key)
+    return sorted(items, key=key)
+
+try:
+    top_k = _compute_top_k(text, k)
+except NameError:
+    # If text or k are not defined, expose an empty result.
+    top_k = []
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_13.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_13.py
new file mode 100644
index 0000000000..ad966b1a23
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_13.py
@@ -0,0 +1,43 @@
+from heapq import nsmallest
+
+def _count_tokens(s: str):
+    # One-pass ASCII [a-z0-9]+ tokenizer; letters lowercased, others are separators.
+    counts = {}
+    buf = []
+    append = buf.append
+    for ch in s:
+        o = ord(ch)
+        if 48 <= o <= 57:  # '0'-'9'
+            append(ch)
+        elif 65 <= o <= 90:  # 'A'-'Z' -> lower
+            append(chr(o + 32))
+        elif 97 <= o <= 122:  # 'a'-'z'
+            append(ch)
+        else:
+            if buf:
+                tok = ''.join(buf)
+                counts[tok] = counts.get(tok, 0) + 1
+                buf.clear()
+    if buf:
+        tok = ''.join(buf)
+        counts[tok] = counts.get(tok, 0) + 1
+    return counts
+
+def compute_top_k(text, k):
+    s = text if isinstance(text, str) else str(text)
+    try:
+        k = int(k)
+    except Exception:
+        k = 0
+    counts = _count_tokens(s)
+    if k <= 0 or not counts:
+        return []
+    n = min(k, len(counts))
+    # Sort by count desc, then token asc using key (-count, token)
+    return nsmallest(n, counts.items(), key=lambda kv: (-kv[1], kv[0]))
+
+try:
+    top_k = compute_top_k(text, k)
+except NameError:
+    # If globals not provided, expose empty result.
+    top_k = []
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_14.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_14.py
new file mode 100644
index 0000000000..11b8abfe20
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_14.py
@@ -0,0 +1,48 @@
+import heapq
+
+# Produces top_k: list[(token, count)] from globals `text` (str) and `k` (int).
+# Tokenization: lowercase ASCII [a-z0-9]+, others are separators.
+# Sorting: count desc, then token asc. Length = min(k, unique tokens).
+
+def _iter_ascii_tokens(s):
+    buf = []
+    append = buf.append
+    for ch in s:
+        o = ord(ch)
+        if 65 <= o <= 90:        # 'A'-'Z' -> lowercase
+            append(chr(o | 32))
+        elif 97 <= o <= 122 or 48 <= o <= 57:  # 'a'-'z' or '0'-'9'
+            append(ch)
+        else:
+            if buf:
+                yield ''.join(buf)
+                buf.clear()
+    if buf:
+        yield ''.join(buf)
+
+def _top_k_tokens(s, k):
+    try:
+        kk = int(k)
+    except Exception:
+        kk = 0
+    if kk <= 0:
+        return []
+
+    counts = {}
+    get = counts.get
+    for tok in _iter_ascii_tokens(s):
+        counts[tok] = get(tok, 0) + 1
+
+    if not counts:
+        return []
+
+    kk = min(kk, len(counts))
+    # nsmallest with key (-count, token) gives count desc, token asc and returns sorted.
+    return heapq.nsmallest(kk, counts.items(), key=lambda it: (-it[1], it[0]))
+
+# Build top_k from provided globals `text` and `k`.
+try:
+    top_k = _top_k_tokens(text, k)
+except NameError:
+    # If globals are missing, expose an empty result.
+    top_k = []
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_15.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_15.py
new file mode 100644
index 0000000000..b65960930c
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_15.py
@@ -0,0 +1,41 @@
+# Computes top_k: the Top-K most frequent ASCII [a-z0-9]+ tokens from the global `text`
+# using lowercase tokenization and sorting by count desc, then token asc.
+
+from typing import List, Tuple
+
+def _iter_ascii_tokens(s: str):
+    # Stream through s once; yield lowercase ASCII [a-z0-9]+ tokens
+    buf = []
+    append = buf.append
+    for ch in s:
+        o = ord(ch)
+        if 48 <= o <= 57:         # '0'-'9'
+            append(ch)
+        elif 97 <= o <= 122:      # 'a'-'z'
+            append(ch)
+        elif 65 <= o <= 90:       # 'A'-'Z' -> lower
+            append(chr(o + 32))
+        else:
+            if buf:
+                yield ''.join(buf)
+                buf.clear()
+    if buf:
+        yield ''.join(buf)
+
+def _compute_top_k(txt: str, k: int) -> List[Tuple[str, int]]:
+    if k <= 0:
+        return []
+    counts = {}
+    get = counts.get
+    for tok in _iter_ascii_tokens(txt):
+        counts[tok] = get(tok, 0) + 1
+    if not counts:
+        return []
+    # Sort by count desc, then token asc; take first k
+    items = sorted(counts.items(), key=lambda it: (-it[1], it[0]))
+    if k < len(items):
+        items = items[:k]
+    return items
+
+# Expect globals `text` (str) and `k` (int) to be provided by the caller environment.
+top_k: List[Tuple[str, int]] = _compute_top_k(text, k)
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_16.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_16.py
new file mode 100644
index 0000000000..1da8b69cbd
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_16.py
@@ -0,0 +1,37 @@
+import heapq
+from typing import Iterator, List, Tuple
+
+def _iter_tokens(s: str) -> Iterator[str]:
+    # Stream tokens: lowercase ASCII [a-z0-9]+; others are separators
+    buf = []
+    append = buf.append
+    for ch in s:
+        lo = ch.lower()
+        if ('a' <= lo <= 'z') or ('0' <= ch <= '9'):
+            append(lo)
+        elif buf:
+            yield ''.join(buf)
+            buf.clear()
+    if buf:
+        yield ''.join(buf)
+
+def _top_k_tokens(text: str, k: int) -> List[Tuple[str, int]]:
+    # Count in one pass
+    counts = {}
+    for tok in _iter_tokens(text):
+        counts[tok] = counts.get(tok, 0) + 1
+
+    # Handle edge cases
+    try:
+        kk = int(k)
+    except Exception:
+        kk = 0
+    if kk <= 0 or not counts:
+        return []
+
+    # Select Top-K sorted by count desc, then token asc
+    kk = min(kk, len(counts))
+    return heapq.nsmallest(kk, counts.items(), key=lambda item: (-item[1], item[0]))
+
+# Compute using provided globals `text` and `k`
+top_k = _top_k_tokens(globals().get('text', ''), globals().get('k', 0))
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_17.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_17.py
new file mode 100644
index 0000000000..8f71c0ff33
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_17.py
@@ -0,0 +1,26 @@
+import re
+import heapq
+
+# Compile once for speed; ASCII-only tokens
+_TOKEN_RE = re.compile(r'[A-Za-z0-9]+')
+
+def _compute_top_k(src_text: str, k: int):
+    # k <= 0 yields empty result
+    if not isinstance(k, int) or k <= 0:
+        return []
+
+    counts = {}
+    # One pass: iterate matches without building an intermediate list
+    for m in _TOKEN_RE.finditer(src_text):
+        tok = m.group(0).lower()  # lowercase per token
+        counts[tok] = counts.get(tok, 0) + 1
+
+    if not counts:
+        return []
+
+    top_n = k if k < len(counts) else len(counts)
+    # Sort by count desc, then token asc using a key on (-count, token)
+    return heapq.nsmallest(top_n, counts.items(), key=lambda kv: (-kv[1], kv[0]))
+
+# Expose the requested global result
+top_k = _compute_top_k(text, k)
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_18.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_18.py
new file mode 100644
index 0000000000..728898dfa2
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_18.py
@@ -0,0 +1,22 @@
+import re
+from heapq import nsmallest
+
+# Token generator: ASCII [a-z0-9]+, lowercased, streaming via re.finditer
+def _iter_tokens_ascii_lower(s: str):
+    for m in re.finditer(r'[A-Za-z0-9]+', s):
+        yield m.group(0).lower()
+
+def _compute_top_k(s: str, k: int):
+    if not s or k <= 0:
+        return []
+    counts = {}
+    for tok in _iter_tokens_ascii_lower(s):
+        counts[tok] = counts.get(tok, 0) + 1
+    if not counts:
+        return []
+    kk = k if k < len(counts) else len(counts)
+    # Select and sort by count desc, then token asc
+    return [(t, c) for t, c in nsmallest(kk, counts.items(), key=lambda it: (-it[1], it[0]))]
+
+# Expose result as a convenient global
+top_k = _compute_top_k(text, k)
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_19.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_19.py
new file mode 100644
index 0000000000..e559661e95
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_19.py
@@ -0,0 +1,36 @@
+import re
+from heapq import nsmallest
+from typing import List, Tuple, Iterable, Dict
+
+
+def _iter_tokens(s: str, _pat=re.compile(r'[a-z0-9]+')) -> Iterable[str]:
+    # Lowercase, then yield ASCII [a-z0-9]+ sequences
+    for m in _pat.finditer(s.lower()):
+        yield m.group(0)
+
+
+def top_k_tokens(s: str, k: int) -> List[Tuple[str, int]]:
+    if not isinstance(s, str):
+        raise TypeError("text must be a str")
+    if not isinstance(k, int):
+        raise TypeError("k must be an int")
+    if k <= 0:
+        return []
+
+    counts: Dict[str, int] = {}
+    get = counts.get
+    for tok in _iter_tokens(s):
+        counts[tok] = get(tok, 0) + 1
+
+    if not counts:
+        return []
+
+    # Sort by count desc, then token asc using nsmallest with key (-count, token)
+    return nsmallest(k, counts.items(), key=lambda item: (-item[1], item[0]))
+
+
+# Expose the result as a convenient global: top_k
+try:
+    top_k = top_k_tokens(text, k)  # expects globals: text (str), k (int)
+except Exception:
+    top_k = []
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_20.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_20.py
new file mode 100644
index 0000000000..63c534fa49
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_20.py
@@ -0,0 +1,36 @@
+from heapq import nsmallest
+
+def _count_tokens_ascii(text: str):
+    # One-pass ASCII [a-z0-9]+ tokenizer (lowercasing A-Z); others are separators.
+    counts = {}
+    buf = []
+    append = buf.append
+    get = counts.get
+    def commit():
+        if buf:
+            tok = ''.join(buf)
+            counts[tok] = get(tok, 0) + 1
+            buf.clear()
+
+    for ch in text:
+        o = ord(ch)
+        if 65 <= o <= 90:          # 'A'-'Z' -> lower
+            append(chr(o + 32))
+        elif 97 <= o <= 122:       # 'a'-'z'
+            append(ch)
+        elif 48 <= o <= 57:        # '0'-'9'
+            append(ch)
+        else:
+            commit()
+    commit()
+    return counts
+
+def _top_k_from_counts(counts, k: int):
+    if k <= 0 or not counts:
+        return []
+    # Sort by count desc, then token asc using nsmallest with key (-count, token)
+    return nsmallest(k, counts.items(), key=lambda kv: (-kv[1], kv[0]))
+
+# Expect globals: text (str) and k (int) to be provided by the environment.
+# Produce the required global `top_k`.
+top_k = _top_k_from_counts(_count_tokens_ascii(text), k)
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_21.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_21.py
new file mode 100644
index 0000000000..2e83a7e8f3
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_21.py
@@ -0,0 +1,24 @@
+import re
+from collections import Counter
+from heapq import nsmallest
+
+def _iter_tokens(s):
+    # Yield lowercase ASCII [a-z0-9]+ tokens; non-matching chars are separators
+    pattern = re.compile(r"[a-z0-9]+", flags=re.ASCII | re.IGNORECASE)
+    for m in pattern.finditer(s):
+        yield m.group(0).lower()
+
+def compute_top_k(s, k_value):
+    k_int = int(k_value)
+    if k_int <= 0:
+        return []
+    counts = Counter()
+    for tok in _iter_tokens(s):
+        counts[tok] += 1
+    if not counts:
+        return []
+    # Sort by count desc, then token asc; take top k
+    return nsmallest(k_int, counts.items(), key=lambda t: (-t[1], t[0]))
+
+# Expose result as a convenient global
+top_k = compute_top_k(text, k)
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_22.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_22.py
new file mode 100644
index 0000000000..89cde196d6
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_22.py
@@ -0,0 +1,40 @@
+import sys
+
+def _iter_tokens(s: str):
+    # Stream tokenizer: ASCII [a-z0-9]+, lowercase; others are separators.
+    buf = []
+    append = buf.append
+    join = ''.join
+    for ch in s:
+        c = ch.lower()
+        if ('a' <= c <= 'z') or ('0' <= c <= '9'):
+            append(c)
+        else:
+            if buf:
+                yield join(buf)
+                buf.clear()
+    if buf:
+        yield join(buf)
+
+def _top_k_tokens(s: str, k: int):
+    if k <= 0:
+        return []
+    counts = {}
+    get = counts.get
+    for tok in _iter_tokens(s):
+        counts[tok] = get(tok, 0) + 1
+    if not counts:
+        return []
+    # Sort by count desc, then token asc
+    items = sorted(counts.items(), key=lambda kv: (-kv[1], kv[0]))
+    return items[: min(k, len(items))]
+
+# Expect globals: text (str) and k (int)
+try:
+    _text = text  # provided by caller
+    _k = int(k)
+except Exception:
+    # If globals not provided, expose empty result for safety.
+    top_k = []
+else:
+    top_k = _top_k_tokens(_text, _k)
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_23.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_23.py
new file mode 100644
index 0000000000..2984bf4188
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_23.py
@@ -0,0 +1,43 @@
+import heapq
+
+def _iter_tokens_ascii_lower(s):
+    # Stream tokens: ASCII [a-z0-9]+, lowercase letters; non-matching chars are separators.
+    buf = []
+    append = buf.append
+    for ch in s:
+        o = ord(ch)
+        if 65 <= o <= 90:           # 'A'-'Z' -> lower
+            append(chr(o + 32))
+        elif 97 <= o <= 122 or 48 <= o <= 57:  # 'a'-'z' or '0'-'9'
+            append(ch)
+        else:
+            if buf:
+                yield ''.join(buf)
+                buf.clear()
+    if buf:
+        yield ''.join(buf)
+
+def _top_k_tokens(s, k):
+    if not s or k <= 0:
+        return []
+    counts = {}
+    for tok in _iter_tokens_ascii_lower(s):
+        counts[tok] = counts.get(tok, 0) + 1
+    if not counts:
+        return []
+    m = k if k < len(counts) else len(counts)
+    # Sort by count desc, then token asc -> key (-count, token); nsmallest returns sorted ascending by key.
+    return heapq.nsmallest(m, counts.items(), key=lambda it: (-it[1], it[0]))
+
+# Use provided globals `text` and `k`; fall back to empty values if missing.
+try:
+    _text, _k = text, k
+except NameError:
+    _text, _k = "", 0
+
+try:
+    _k = int(_k)
+except Exception:
+    _k = 0
+
+top_k = _top_k_tokens(_text, _k)
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_24.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_24.py
new file mode 100644
index 0000000000..83f3d66b22
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_24.py
@@ -0,0 +1,42 @@
+from typing import List, Tuple, Dict
+
+def compute_top_k(s: str, k: int) -> List[Tuple[str, int]]:
+    # Tokenize: lowercase letters, digits; others are separators
+    counts: Dict[str, int] = {}
+    buf: List[str] = []
+
+    append = buf.append
+    get = counts.get
+
+    for c in s:
+        oc = ord(c)
+        if 48 <= oc <= 57:  # '0'-'9'
+            append(c)
+        elif 65 <= oc <= 90:  # 'A'-'Z' -> to lowercase
+            append(chr(oc + 32))
+        elif 97 <= oc <= 122:  # 'a'-'z'
+            append(c)
+        else:
+            if buf:
+                tok = ''.join(buf)
+                counts[tok] = (get(tok) or 0) + 1
+                buf.clear()
+    if buf:
+        tok = ''.join(buf)
+        counts[tok] = (get(tok) or 0) + 1
+
+    if k <= 0 or not counts:
+        return []
+
+    items = counts.items()
+    items_sorted = sorted(items, key=lambda it: (-it[1], it[0]))
+    return items_sorted[:min(k, len(items_sorted))]
+
+# Produce the required global `top_k` using provided globals `text` and `k`
+try:
+    _text = text  # provided externally
+    _k = k        # provided externally
+except NameError:
+    top_k: List[Tuple[str, int]] = []
+else:
+    top_k = compute_top_k(_text, _k)
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_25.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_25.py
new file mode 100644
index 0000000000..35a2469f5d
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_25.py
@@ -0,0 +1,52 @@
+import heapq
+from collections import Counter
+
+# Expects globals: text (str) and k (int)
+# Produces: top_k -> list[tuple[str, int]]
+
+def _count_tokens_ascii_lower(s: str) -> Counter:
+    # One-pass ASCII [a-z0-9]+ tokenizer with on-the-fly lowercasing
+    cnt = Counter()
+    buf = []  # current token buffer
+
+    for ch in s:
+        if ch.isascii():
+            o = ord(ch)
+            # Fast ASCII lowercase
+            if 65 <= o <= 90:  # 'A'-'Z'
+                o += 32
+                c = chr(o)
+            else:
+                c = ch
+
+            oc = ord(c)
+            if 97 <= oc <= 122 or 48 <= oc <= 57:  # 'a'-'z' or '0'-'9'
+                buf.append(c)
+                continue
+
+        if buf:
+            token = ''.join(buf)
+            cnt[token] += 1
+            buf.clear()
+
+    if buf:
+        token = ''.join(buf)
+        cnt[token] += 1
+
+    return cnt
+
+
+# Build frequency map
+_counts = _count_tokens_ascii_lower(text)
+
+# Determine k safely
+_unique = len(_counts)
+_k = int(k) if isinstance(k, int) or (isinstance(k, bool) is False and str(k).lstrip("-").isdigit()) else 0
+_k = max(0, min(_k, _unique))
+
+# Top-K sorted by count desc, then token asc
+if _k == 0:
+    top_k = []
+else:
+    # nsmallest on (-count, token) yields count desc, token asc
+    top_k = heapq.nsmallest(_k, _counts.items(), key=lambda it: (-it[1], it[0]))
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_26.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_26.py
new file mode 100644
index 0000000000..e7fca2bd11
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_26.py
@@ -0,0 +1,49 @@
+from heapq import nsmallest
+
+def _counts_from_text(s: str):
+    # One-pass ASCII tokenizer: [a-z0-9]+ after lowercasing A-Z only
+    counts = {}
+    buf = []
+    append = buf.append
+    clear = buf.clear
+    get = counts.get
+    for ch in s:
+        oc = ord(ch)
+        if 48 <= oc <= 57:          # 0-9
+            append(ch)
+        elif 65 <= oc <= 90:        # A-Z -> a-z
+            append(chr(oc + 32))
+        elif 97 <= oc <= 122:       # a-z
+            append(ch)
+        else:
+            if buf:
+                tok = ''.join(buf)
+                counts[tok] = get(tok, 0) + 1
+                clear()
+    if buf:
+        tok = ''.join(buf)
+        counts[tok] = get(tok, 0) + 1
+    return counts
+
+def _top_k_from_counts(counts, k: int):
+    if k <= 0 or not counts:
+        return []
+    # Sort by count desc, then token asc; do k-selection to avoid full sort
+    return list(nsmallest(k, counts.items(), key=lambda it: (-it[1], it[0])))
+
+# Use provided globals `text` (str) and `k` (int)
+try:
+    _text = text
+    _k = k
+except NameError:
+    _text = ""
+    _k = 0
+
+try:
+    _k = int(_k)
+except Exception:
+    _k = 0
+if _k < 0:
+    _k = 0
+
+top_k = _top_k_from_counts(_counts_from_text(_text), _k)
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_27.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_27.py
new file mode 100644
index 0000000000..0649f5401b
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_27.py
@@ -0,0 +1,47 @@
+from collections import Counter
+import heapq
+
+# Expects globals: text (str) and k (int). Produces: top_k = [(token, count), ...]
+
+def _count_tokens(s: str) -> Counter:
+    # Single-pass ASCII tokenizer: [a-z0-9]+, lowercased; others are separators
+    counts = Counter()
+    buf = []
+    for ch in s:
+        o = ord(ch)
+        if 48 <= o <= 57:          # '0'-'9'
+            buf.append(ch)
+        elif 65 <= o <= 90:        # 'A'-'Z' -> lower
+            buf.append(chr(o + 32))
+        elif 97 <= o <= 122:       # 'a'-'z'
+            buf.append(ch)
+        else:
+            if buf:
+                tok = ''.join(buf)
+                counts[tok] += 1
+                buf.clear()
+    if buf:
+        tok = ''.join(buf)
+        counts[tok] += 1
+    return counts
+
+# Read provided globals safely
+try:
+    _text = text
+except NameError:
+    _text = ""
+
+try:
+    _k = int(k)
+except Exception:
+    _k = 0
+if _k < 0:
+    _k = 0
+
+_counts = _count_tokens(_text)
+
+# Top-K by count desc, then token asc
+if _counts and _k:
+    top_k = heapq.nsmallest(_k, _counts.items(), key=lambda kv: (-kv[1], kv[0]))
+else:
+    top_k = []
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_28.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_28.py
new file mode 100644
index 0000000000..ebd8306332
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_28.py
@@ -0,0 +1,27 @@
+import re
+import heapq
+
+# Compute Top-K most frequent ASCII [a-z0-9]+ tokens (case-insensitive).
+def _iter_tokens(s):
+    # Stream tokens; match ASCII letters/digits, case-insensitive, then lowercase per token
+    for m in re.finditer(r'[a-z0-9]+', s, flags=re.ASCII | re.IGNORECASE):
+        yield m.group(0).lower()
+
+def _top_k_tokens(text, k):
+    if not isinstance(text, str) or not isinstance(k, int) or k <= 0:
+        return []
+    counts = {}
+    for tok in _iter_tokens(text):
+        counts[tok] = counts.get(tok, 0) + 1
+    if not counts:
+        return []
+    kk = min(k, len(counts))
+    # Get k items sorted by count desc, then token asc
+    return heapq.nsmallest(kk, counts.items(), key=lambda item: (-item[1], item[0]))
+
+# Produce the required global `top_k` using provided globals `text` and `k`.
+try:
+    top_k = _top_k_tokens(text, k)
+except NameError:
+    # If globals are missing, expose an empty result.
+    top_k = []
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_29.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_29.py
new file mode 100644
index 0000000000..cce861ba58
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_29.py
@@ -0,0 +1,58 @@
+import heapq
+
+def _iter_tokens(s):
+    # Stream tokens: ASCII [a-z0-9]+, lowercase; others are separators
+    buf = []
+    append = buf.append
+    for ch in s:
+        o = ord(ch)
+        if 48 <= o <= 57:          # '0'-'9'
+            append(ch)
+        elif 65 <= o <= 90:         # 'A'-'Z' -> to lowercase
+            append(chr(o + 32))
+        elif 97 <= o <= 122:        # 'a'-'z'
+            append(ch)
+        else:
+            if buf:
+                yield ''.join(buf)
+                buf.clear()
+    if buf:
+        yield ''.join(buf)
+
+def _compute_top_k(s, k):
+    try:
+        k = int(k)
+    except Exception:
+        k = 0
+    if k <= 0 or not s:
+        return []
+
+    counts = {}
+    for tok in _iter_tokens(s if isinstance(s, str) else str(s)):
+        counts[tok] = counts.get(tok, 0) + 1
+
+    if not counts:
+        return []
+
+    n_unique = len(counts)
+    key = lambda kv: (-kv[1], kv[0])  # sort by count desc, token asc
+
+    if n_unique <= k:
+        return sorted(counts.items(), key=key)
+
+    top = heapq.nsmallest(k, counts.items(), key=key)
+    top.sort(key=key)
+    return top
+
+# Use provided globals `text` and `k`; fall back safely if absent.
+try:
+    _text = text  # type: ignore[name-defined]
+except NameError:
+    _text = ""
+try:
+    _k = k  # type: ignore[name-defined]
+except NameError:
+    _k = 0
+
+# Exposed result: list of (token, count), sorted by count desc then token asc
+top_k = _compute_top_k(_text, _k)
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_30.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_30.py
new file mode 100644
index 0000000000..d47888c2c6
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_30.py
@@ -0,0 +1,18 @@
+import re
+from collections import Counter
+
+def compute_top_k(text: str, k: int):
+    # Tokens: ASCII [A-Za-z0-9]+, lowercased; other chars are separators
+    if not isinstance(text, str) or not isinstance(k, int) or k <= 0:
+        return []
+    counter = Counter()
+    pattern = re.compile(r'[A-Za-z0-9]+')
+    for m in pattern.finditer(text):
+        counter[m.group(0).lower()] += 1
+    if not counter:
+        return []
+    items = sorted(counter.items(), key=lambda kv: (-kv[1], kv[0]))
+    return items[:min(k, len(items))]
+
+# Exposed result
+top_k = compute_top_k(text, k)
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_results_topk_baseline.csv b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_results_topk_baseline.csv
new file mode 100644
index 0000000000..4ff5bffd5b
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_results_topk_baseline.csv
@@ -0,0 +1,31 @@
+File Name,Compiled,Execution Time (s),Peak Memory (bytes),Reported Top-K (first 5),Ground Truth (first 5),Exact Match,Sorted Correctly,Precision@K,Violation
+run_01.py,True,6.035606833000202,30571416,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_02.py,True,8.617520125000738,1255649,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_03.py,True,7.340578834002372,570753,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_04.py,True,6.27685929099971,571056,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_05.py,True,8.08934216700436,1256803,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_06.py,True,7.394314333003422,571723,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_07.py,True,7.231126874998154,570664,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_08.py,True,5.075305165999453,30571892,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_09.py,True,7.392094041002565,599538,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_10.py,True,14.158977334001975,580008,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_11.py,True,9.552443332999246,571013,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_12.py,True,7.1676780420020805,856089,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_13.py,True,7.361231750001025,570692,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_14.py,True,7.191091291999328,571750,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_15.py,True,6.4659761669972795,1144638,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_16.py,True,14.088706583999738,571492,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_17.py,True,7.104060042001947,570641,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_18.py,True,6.395613125001546,572554,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_19.py,True,5.3718107500026235,30540066,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_20.py,True,6.399601584002085,580142,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_21.py,True,7.4909848750030505,570245,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_22.py,True,14.278637458002777,1219947,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_23.py,True,7.079161000001477,571353,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_24.py,True,7.359142333996715,1255216,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_25.py,True,8.727166875003604,571887,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_26.py,True,7.575888125000347,571429,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_27.py,True,7.574360042002809,572071,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_28.py,True,7.103595166001469,598620,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_29.py,True,6.998820416003582,580173,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_30.py,True,8.294044041998859,1219045,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_results_topk_baseline_summary.json b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_results_topk_baseline_summary.json
new file mode 100644
index 0000000000..e077d08405
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_results_topk_baseline_summary.json
@@ -0,0 +1,13 @@
+{
+  "total_runs": 30,
+  "successes": 30,
+  "avg_exec_time_s": 7.906391266701151,
+  "avg_peak_mem_kb": 3626.25537109375,
+  "exact_matches": 30,
+  "sorted_correctly": 30,
+  "violations": 0,
+  "csv": "results_topk_baseline/run_results_topk_baseline.csv",
+  "folder": "results_topk_baseline",
+  "k": 500,
+  "scale_tokens": 5000000
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_results_topk_baseline_summary.txt b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_results_topk_baseline_summary.txt
new file mode 100644
index 0000000000..e26b1e560b
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_baseline/run_results_topk_baseline_summary.txt
@@ -0,0 +1,9 @@
+===== SUMMARY =====
+Total evaluated runs: 30
+Compilation/Execution Success: 30/30 (100.00%)
+Violations (static scan): 0
+Average Execution Time (successful): 7.906391 s
+Average Peak Memory (successful): 3626.26 KB
+Exact matches: 30/30
+Sorted correctly: 30/30
+CSV written to: results_topk_baseline/run_results_topk_baseline.csv
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_01.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_01.py
new file mode 100644
index 0000000000..65c3ddaac8
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_01.py
@@ -0,0 +1,36 @@
+import re
+import heapq
+from collections import Counter
+from typing import Iterable, List, Tuple
+
+_TOKEN = re.compile(r"[a-z0-9]+", flags=re.ASCII | re.IGNORECASE)
+
+def _tokens(s: str) -> Iterable[str]:
+    for m in _TOKEN.finditer(s):
+        yield m.group(0).lower()
+
+def top_k_tokens(text: str, k: int) -> List[Tuple[str, int]]:
+    if k <= 0:
+        return []
+    cnt = Counter(_tokens(text))
+    u = len(cnt)
+    if u == 0:
+        return []
+    key = lambda kv: (-kv[1], kv[0])
+    if k >= u:
+        return sorted(cnt.items(), key=key)
+    return heapq.nsmallest(k, cnt.items(), key=key)
+
+# Compute from provided globals when available; demo only if missing and running as main
+try:
+    text; k  # type: ignore[name-defined]
+except NameError:
+    if __name__ == "__main__":
+        demo_text = "A a b b b c1 C1 c1 -- d! d? e"
+        demo_k = 3
+        top_k = top_k_tokens(demo_text, demo_k)
+        print(top_k)
+else:
+    top_k = top_k_tokens(text, k)  # type: ignore[name-defined]
+
+# Complexity: counting O(N tokens), selection O(U log k) via heapq.nsmallest; extra space O(U + k)
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_02.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_02.py
new file mode 100644
index 0000000000..f992be30fc
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_02.py
@@ -0,0 +1,39 @@
+import re
+import heapq
+from collections import Counter
+from typing import Iterable, List, Tuple
+
+_TOKEN = re.compile(r"[a-z0-9]+", flags=re.ASCII | re.IGNORECASE)
+
+def _tokens(s: str) -> Iterable[str]:
+    for m in _TOKEN.finditer(s):
+        yield m.group(0).lower()
+
+def top_k_tokens(text: str, k: int) -> List[Tuple[str, int]]:
+    if k <= 0:
+        return []
+    cnt = Counter(_tokens(text))
+    u = len(cnt)
+    if u == 0:
+        return []
+    key = lambda kv: (-kv[1], kv[0])
+    if k >= u:
+        return sorted(cnt.items(), key=key)
+    # Choose strategy: avoid full sort unless k >= 0.3 * u
+    if k * 10 >= 3 * u:
+        return sorted(cnt.items(), key=key)[:k]
+    return heapq.nsmallest(k, cnt.items(), key=key)
+
+# Compute from provided globals when available; demo only if missing and running as main
+try:
+    text; k  # type: ignore[name-defined]
+except NameError:
+    if __name__ == "__main__":
+        demo_text = "A a b b b c1 C1 c1 -- d! d? e"
+        demo_k = 3
+        top_k = top_k_tokens(demo_text, demo_k)
+        print(top_k)
+else:
+    top_k = top_k_tokens(text, k)  # type: ignore[name-defined]
+
+# Complexity: counting O(N tokens); selection O(U log U) if k >= 0.3U else O(U log k); extra space O(U + k)
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_03.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_03.py
new file mode 100644
index 0000000000..d8b6d09e47
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_03.py
@@ -0,0 +1,35 @@
+import re, heapq
+from collections import Counter
+from typing import Iterable, List, Tuple
+
+_TOKEN = re.compile(r"[a-z0-9]+", flags=re.ASCII | re.IGNORECASE)
+
+def _tokens(s: str) -> Iterable[str]:
+    for m in _TOKEN.finditer(s):
+        yield m.group(0).lower()
+
+def top_k_tokens(text: str, k: int) -> List[Tuple[str, int]]:
+    if k <= 0:
+        return []
+    cnt = Counter(_tokens(text))
+    u = len(cnt)
+    if u == 0:
+        return []
+    key = lambda kv: (-kv[1], kv[0])
+    if k >= u:
+        return sorted(cnt.items(), key=key)
+    return heapq.nsmallest(k, cnt.items(), key=key)
+
+# Compute from provided globals when available; demo only if missing and running as main
+try:
+    text; k  # type: ignore[name-defined]
+except NameError:
+    if __name__ == "__main__":
+        demo_text = "A a b b b c1 C1 c1 -- d! d? e"
+        demo_k = 3
+        top_k = top_k_tokens(demo_text, demo_k)
+        print(top_k)
+else:
+    top_k = top_k_tokens(text, k)  # type: ignore[name-defined]
+
+# Complexity: counting O(N tokens); selection O(U log k) via heapq.nsmallest; extra space O(U + k)
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_04.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_04.py
new file mode 100644
index 0000000000..4e07fbffcc
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_04.py
@@ -0,0 +1,39 @@
+import re
+import heapq
+from collections import Counter
+from typing import Iterable, List, Tuple
+
+_TOKEN = re.compile(r"[a-z0-9]+", flags=re.ASCII | re.IGNORECASE)
+
+def _tokens(s: str) -> Iterable[str]:
+    for m in _TOKEN.finditer(s):
+        yield m.group(0).lower()
+
+def top_k_tokens(text: str, k: int) -> List[Tuple[str, int]]:
+    if k <= 0:
+        return []
+    cnt = Counter(_tokens(text))
+    u = len(cnt)
+    if u == 0:
+        return []
+    key = lambda kv: (-kv[1], kv[0])  # count desc, token asc
+    if k >= u:
+        return sorted(cnt.items(), key=key)
+    # If k is large relative to unique tokens, sort all and slice; otherwise exact selection via heap
+    if k / u >= 0.3:
+        return sorted(cnt.items(), key=key)[:k]
+    return heapq.nsmallest(k, cnt.items(), key=key)
+
+# Compute from provided globals when available; demo only if missing and running as main
+try:
+    text; k  # type: ignore[name-defined]
+except NameError:
+    if __name__ == "__main__":
+        demo_text = "A a b b b c1 C1 c1 -- d! d? e"
+        demo_k = 3
+        top_k = top_k_tokens(demo_text, demo_k)
+        print(top_k)
+else:
+    top_k = top_k_tokens(text, k)  # type: ignore[name-defined]
+
+# Complexity: counting O(N tokens), selection O(U log k) or O(U log U) when k is large; extra space O(U) for counts and O(k) additional.
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_05.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_05.py
new file mode 100644
index 0000000000..0b76cbc662
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_05.py
@@ -0,0 +1,43 @@
+import re
+import heapq
+from collections import Counter
+from typing import List, Tuple, Iterable
+
+_TOKEN = re.compile(r"[a-z0-9]+", flags=re.ASCII | re.IGNORECASE)
+
+def _tokens(s: str) -> Iterable[str]:
+    for m in _TOKEN.finditer(s):
+        yield m.group(0).lower()
+
+def top_k_tokens(text: str, k: int) -> List[Tuple[str, int]]:
+    if not isinstance(k, int) or k <= 0:
+        return []
+    cnt = Counter()
+    for t in _tokens(text):
+        cnt[t] += 1
+    u = len(cnt)
+    if u == 0:
+        return []
+    key = lambda kv: (-kv[1], kv[0])  # sort by count desc, then token asc
+
+    if k >= u:
+        return sorted(cnt.items(), key=key)
+    # Sort all only when k >= 0.3 * u
+    if 10 * k >= 3 * u:
+        return sorted(cnt.items(), key=key)[:k]
+    # Exact selection with bounded memory
+    return heapq.nsmallest(k, cnt.items(), key=key)
+
+# Use provided globals if available; optional demo otherwise
+try:
+    text; k  # type: ignore[name-defined]
+except NameError:
+    if __name__ == "__main__":
+        demo_text = "A a b b b c1 C1 c1 -- d! d? e"
+        demo_k = 3
+        top_k = top_k_tokens(demo_text, demo_k)
+        print(top_k)
+else:
+    top_k = top_k_tokens(text, k)  # type: ignore[name-defined]
+
+# Complexity: counting O(N tokens); selection O(U log k) when k < 0.3U, else O(U log U). Extra space O(U + k).
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_06.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_06.py
new file mode 100644
index 0000000000..9bfa3d82dc
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_06.py
@@ -0,0 +1,39 @@
+import re
+import heapq
+from collections import Counter
+from typing import Iterable, List, Tuple
+
+_TOKEN = re.compile(r"[a-z0-9]+", flags=re.ASCII | re.IGNORECASE)
+
+def _tokens(s: str) -> Iterable[str]:
+    for m in _TOKEN.finditer(s):
+        yield m.group(0).lower()
+
+def top_k_tokens(text: str, k: int) -> List[Tuple[str, int]]:
+    if k <= 0:
+        return []
+    cnt = Counter(_tokens(text))
+    u = len(cnt)
+    if u == 0:
+        return []
+    eff_k = k if k < u else u
+    key = lambda kv: (-kv[1], kv[0])
+    # Sort all only when k >= 0.3 * U; otherwise exact selection with bounded heap
+    if k * 10 >= 3 * u:
+        return sorted(cnt.items(), key=key)[:eff_k]
+    return heapq.nsmallest(eff_k, cnt.items(), key=key)
+
+# Use provided globals if present; otherwise run a small demo only when executed as main
+try:
+    text  # type: ignore[name-defined]
+    k     # type: ignore[name-defined]
+except NameError:
+    if __name__ == "__main__":
+        demo_text = "A a b b b c1 C1 c1 -- d! d? e"
+        demo_k = 3
+        top_k = top_k_tokens(demo_text, demo_k)
+        print(top_k)
+else:
+    top_k = top_k_tokens(text, k)  # type: ignore[name-defined]
+
+# Complexity: counting O(N tokens); selection O(U log U) when k >= 0.3U else O(U log k); extra space O(U) for counts and O(k) for selection.
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_07.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_07.py
new file mode 100644
index 0000000000..d49eedf563
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_07.py
@@ -0,0 +1,41 @@
+import re
+import heapq
+from collections import Counter
+from typing import Iterable, List, Tuple
+
+_TOKEN = re.compile(r"[a-z0-9]+", flags=re.ASCII | re.IGNORECASE)
+
+def _tokens(s: str) -> Iterable[str]:
+    for m in _TOKEN.finditer(s):
+        yield m.group(0).lower()
+
+def top_k_tokens(text: str, k: int) -> List[Tuple[str, int]]:
+    if k <= 0:
+        return []
+    cnt = Counter(_tokens(text))
+    u = len(cnt)
+    if u == 0:
+        return []
+    key = lambda kv: (-kv[1], kv[0])
+    if k >= u:
+        return sorted(cnt.items(), key=key)
+    # Avoid full sort unless k is a large fraction of unique tokens (>= 30%)
+    if 10 * k < 3 * u:
+        return heapq.nsmallest(k, cnt.items(), key=key)
+    # k is moderately large: sort all then slice
+    return sorted(cnt.items(), key=key)[:k]
+
+# Use provided globals when present; demo only if absent
+try:
+    text  # type: ignore[name-defined]
+    k     # type: ignore[name-defined]
+except NameError:
+    if __name__ == "__main__":
+        demo_text = "A a b b b c1 C1 c1 -- d! d? e"
+        demo_k = 3
+        top_k = top_k_tokens(demo_text, demo_k)
+        print(top_k)
+else:
+    top_k = top_k_tokens(text, k)  # type: ignore[name-defined]
+
+# Complexity: counting O(N tokens); selection O(U log k) with heap or O(U log U) when sorting; extra space O(U) + O(k)
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_08.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_08.py
new file mode 100644
index 0000000000..071af4d482
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_08.py
@@ -0,0 +1,39 @@
+import re
+import heapq
+from collections import Counter
+from typing import List, Tuple, Iterable
+
+_TOKEN = re.compile(r"[a-z0-9]+", flags=re.ASCII | re.IGNORECASE)
+
+def _tokens(s: str) -> Iterable[str]:
+    for m in _TOKEN.finditer(s):
+        yield m.group(0).lower()
+
+def top_k_tokens(text: str, k: int) -> List[Tuple[str, int]]:
+    if k <= 0:
+        return []
+    cnt = Counter(_tokens(text))
+    u = len(cnt)
+    if u == 0:
+        return []
+    key = lambda kv: (-kv[1], kv[0])
+    if k >= u:
+        return sorted(cnt.items(), key=key)
+    # If k is a large fraction of U (>= 30%), sort all then slice; else exact selection via heap
+    if 10 * k >= 3 * u:
+        return sorted(cnt.items(), key=key)[:k]
+    return heapq.nsmallest(k, cnt.items(), key=key)
+
+# Compute from provided globals when available; demo only if missing and running as main
+try:
+    text; k  # type: ignore[name-defined]
+except NameError:
+    if __name__ == "__main__":
+        demo_text = "A a b b b c1 C1 c1 -- d! d? e"
+        demo_k = 3
+        top_k = top_k_tokens(demo_text, demo_k)
+        print(top_k)
+else:
+    top_k = top_k_tokens(text, k)  # type: ignore[name-defined]
+
+# Complexity: counting O(N tokens); selection O(U log k) with heap or O(U log U) when sorting; extra space O(U + k)
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_09.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_09.py
new file mode 100644
index 0000000000..ac4b1f108b
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_09.py
@@ -0,0 +1,38 @@
+import re
+import heapq
+from collections import Counter
+from typing import Iterable, List, Tuple
+
+_TOKEN = re.compile(r"[a-z0-9]+", flags=re.ASCII | re.IGNORECASE)
+
+def _tokens(s: str) -> Iterable[str]:
+    for m in _TOKEN.finditer(s):
+        yield m.group(0).lower()
+
+def top_k_tokens(text: str, k: int) -> List[Tuple[str, int]]:
+    if k <= 0:
+        return []
+    cnt = Counter(_tokens(text))
+    u = len(cnt)
+    if u == 0:
+        return []
+    m = k if k < u else u
+    key = lambda kv: (-kv[1], kv[0])
+    # If requesting a large fraction, sort all; otherwise use bounded selection
+    if m >= u or (m * 10 >= 3 * u):
+        return sorted(cnt.items(), key=key)[:m]
+    return heapq.nsmallest(m, cnt.items(), key=key)
+
+# Compute from provided globals when available; demo only if missing and running as main
+try:
+    text; k  # type: ignore[name-defined]
+except NameError:
+    if __name__ == "__main__":
+        demo_text = "A a b b b c1 C1 c1 -- d! d? e"
+        demo_k = 3
+        top_k = top_k_tokens(demo_text, demo_k)
+        print(top_k)
+else:
+    top_k = top_k_tokens(text, k)  # type: ignore[name-defined]
+
+# Complexity: counting O(N tokens); selection O(U log min(k, 0.3U)) via heap/partial sort; extra space O(U + min(k, 0.3U))
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_10.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_10.py
new file mode 100644
index 0000000000..a830c9922b
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_10.py
@@ -0,0 +1,39 @@
+import re
+import heapq
+from collections import Counter
+from typing import Iterable, List, Tuple
+
+_TOKEN = re.compile(r"[a-z0-9]+", flags=re.ASCII | re.IGNORECASE)
+
+def _tokens(s: str) -> Iterable[str]:
+    for m in _TOKEN.finditer(s):
+        yield m.group(0).lower()
+
+def top_k_tokens(text: str, k: int) -> List[Tuple[str, int]]:
+    if k <= 0:
+        return []
+    cnt = Counter(_tokens(text))
+    u = len(cnt)
+    if u == 0:
+        return []
+    k_eff = k if k < u else u
+    key = lambda kv: (-kv[1], kv[0])
+    # Sort all only when k is a substantial fraction of unique tokens
+    if k_eff >= u or k_eff >= 0.3 * u:
+        return sorted(cnt.items(), key=key)[:k_eff]
+    # Exact selection with bounded memory
+    return heapq.nsmallest(k_eff, cnt.items(), key=key)
+
+# Compute from provided globals when available; demo only if missing and running as main
+try:
+    text; k  # type: ignore[name-defined]
+except NameError:
+    if __name__ == "__main__":
+        demo_text = "A a b b b c1 C1 c1 -- d! d? e"
+        demo_k = 3
+        top_k = top_k_tokens(demo_text, demo_k)
+        print(top_k)
+else:
+    top_k = top_k_tokens(text, k)  # type: ignore[name-defined]
+
+# Complexity: counting O(N tokens); selection O(U log min(k,U)) with extra space O(U + min(k,U))
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_11.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_11.py
new file mode 100644
index 0000000000..4447b05179
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_11.py
@@ -0,0 +1,34 @@
+import re
+import heapq
+from collections import Counter
+from typing import Iterable, List, Tuple
+
+_TOKEN = re.compile(r"[a-z0-9]+", flags=re.ASCII | re.IGNORECASE)
+
+def _tokens(s: str) -> Iterable[str]:
+    for m in _TOKEN.finditer(s):
+        yield m.group(0).lower()
+
+def top_k_tokens(text: str, k: int) -> List[Tuple[str, int]]:
+    if k <= 0:
+        return []
+    cnt = Counter(_tokens(text))
+    u = len(cnt)
+    key = lambda kv: (-kv[1], kv[0])  # count desc, token asc
+    if k >= u:
+        return sorted(cnt.items(), key=key)
+    return heapq.nsmallest(k, cnt.items(), key=key)
+
+# Use provided globals if present; otherwise, optional demo under __main__
+try:
+    text; k  # type: ignore[name-defined]
+except NameError:
+    if __name__ == "__main__":
+        demo_text = "A a b b b c1 C1 c1 -- d! d? e"
+        demo_k = 3
+        top_k = top_k_tokens(demo_text, demo_k)
+        print(top_k)
+else:
+    top_k = top_k_tokens(text, k)  # type: ignore[name-defined]
+
+# Complexity: counting O(N tokens), selection O(U log k) via heapq.nsmallest; extra space O(U + k)
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_12.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_12.py
new file mode 100644
index 0000000000..c0a982a60a
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_12.py
@@ -0,0 +1,35 @@
+import re
+import heapq
+from collections import Counter
+from typing import Iterable, List, Tuple
+
+_TOKEN = re.compile(r"[a-z0-9]+", flags=re.ASCII | re.IGNORECASE)
+
+def _tokens(s: str) -> Iterable[str]:
+    for m in _TOKEN.finditer(s):
+        yield m.group(0).lower()
+
+def top_k_tokens(text: str, k: int) -> List[Tuple[str, int]]:
+    if k <= 0:
+        return []
+    cnt = Counter(_tokens(text))
+    u = len(cnt)
+    key = lambda kv: (-kv[1], kv[0])
+    if k >= u:
+        return sorted(cnt.items(), key=key)
+    return heapq.nsmallest(k, cnt.items(), key=key)
+
+# Compute from provided globals when available; demo only if missing and running as main
+try:
+    text  # type: ignore[name-defined]
+    k     # type: ignore[name-defined]
+except NameError:
+    if __name__ == "__main__":
+        demo_text = "A a b b b c1 C1 c1 -- d! d? e"
+        demo_k = 3
+        top_k = top_k_tokens(demo_text, demo_k)
+        print(top_k)
+else:
+    top_k = top_k_tokens(text, k)  # type: ignore[name-defined]
+
+# Complexity: counting O(T) over tokens; selection O(U log k); extra space O(U) for counts and O(k) additional.
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_13.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_13.py
new file mode 100644
index 0000000000..9e2b6b1c97
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_13.py
@@ -0,0 +1,37 @@
+import re
+import heapq
+from collections import Counter
+from typing import List, Tuple, Iterable
+
+_TOKEN = re.compile(r"[a-z0-9]+", flags=re.ASCII | re.IGNORECASE)
+
+def _tokens(s: str) -> Iterable[str]:
+    for m in _TOKEN.finditer(s):
+        yield m.group(0).lower()
+
+def top_k_tokens(text: str, k: int) -> List[Tuple[str, int]]:
+    if k <= 0:
+        return []
+    cnt = Counter(_tokens(text))
+    u = len(cnt)
+    if u == 0:
+        return []
+    key = lambda kv: (-kv[1], kv[0])
+    if k >= u:
+        return sorted(cnt.items(), key=key)
+    return heapq.nsmallest(k, cnt.items(), key=key)
+
+# Set top_k from provided globals if present; otherwise optional demo under __main__
+try:
+    text  # type: ignore[name-defined]
+    k     # type: ignore[name-defined]
+except NameError:
+    if __name__ == "__main__":
+        demo_text = "A a b b b c1 C1 c1 -- d! d? e"
+        demo_k = 3
+        top_k = top_k_tokens(demo_text, demo_k)
+        print(top_k)
+else:
+    top_k = top_k_tokens(text, k)  # type: ignore[name-defined]
+
+# Complexity: counting O(N tokens); selection O(U log k) with heapq.nsmallest or O(U log U) when k >= U; extra space O(U + k).
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_14.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_14.py
new file mode 100644
index 0000000000..dcfa1d9e26
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_14.py
@@ -0,0 +1,41 @@
+import re
+import heapq
+from collections import Counter
+from typing import Iterable, List, Tuple
+
+_TOKEN = re.compile(r"[a-z0-9]+", flags=re.ASCII | re.IGNORECASE)
+
+def _tokens(s: str) -> Iterable[str]:
+    for m in _TOKEN.finditer(s):
+        yield m.group(0).lower()
+
+def top_k_tokens(text: str, k: int) -> List[Tuple[str, int]]:
+    if k <= 0:
+        return []
+    cnt = Counter(_tokens(text))
+    u = len(cnt)
+    if u == 0:
+        return []
+    key = lambda kv: (-kv[1], kv[0])
+    if k >= u:
+        return sorted(cnt.items(), key=key)
+    # Choose full sort only when k is a large fraction of U
+    if k >= int(0.3 * u):
+        return sorted(cnt.items(), key=key)[:k]
+    # Exact selection with bounded memory
+    return heapq.nsmallest(k, cnt.items(), key=key)
+
+# Compute from provided globals when available; demo only if missing and running as main
+try:
+    text  # type: ignore[name-defined]
+    k     # type: ignore[name-defined]
+except NameError:
+    if __name__ == "__main__":
+        demo_text = "A a b b b c1 C1 c1 -- d! d? e"
+        demo_k = 3
+        top_k = top_k_tokens(demo_text, demo_k)
+        print(top_k)
+else:
+    top_k = top_k_tokens(text, k)  # type: ignore[name-defined]
+
+# Complexity: counting O(N tokens); selection O(U log k) via heap for k < 0.3U, else O(U log U); extra space O(U) for counts plus O(k) heap
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_15.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_15.py
new file mode 100644
index 0000000000..aef6bb117e
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_15.py
@@ -0,0 +1,37 @@
+import re, heapq
+from collections import Counter
+from typing import List, Tuple, Iterable
+
+_TOKEN = re.compile(r"[a-z0-9]+", flags=re.ASCII | re.IGNORECASE)
+
+def _tokens(s: str) -> Iterable[str]:
+    for m in _TOKEN.finditer(s):
+        yield m.group(0).lower()
+
+def top_k_tokens(text: str, k: int) -> List[Tuple[str, int]]:
+    if k <= 0:
+        return []
+    cnt = Counter(_tokens(text))
+    u = len(cnt)
+    if u == 0:
+        return []
+    key = lambda kv: (-kv[1], kv[0])
+    # Sort all only when k is a large fraction of unique tokens
+    if k >= u or k >= 0.3 * u:
+        return sorted(cnt.items(), key=key)[:min(k, u)]
+    # Exact selection with bounded memory
+    return heapq.nsmallest(min(k, u), cnt.items(), key=key)
+
+# Use provided globals if present; otherwise optional demo under __main__
+try:
+    text; k  # type: ignore[name-defined]
+except NameError:
+    if __name__ == "__main__":
+        demo_text = "A a b b b c1 C1 c1 -- d! d? e"
+        demo_k = 3
+        top_k = top_k_tokens(demo_text, demo_k)
+        print(top_k)
+else:
+    top_k = top_k_tokens(text, k)  # type: ignore[name-defined]
+
+# Complexity: counting O(N tokens), selection O(U log k) via nsmallest (or O(U log U) when sorting); extra space O(U + k)
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_16.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_16.py
new file mode 100644
index 0000000000..ab1209ba0f
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_16.py
@@ -0,0 +1,36 @@
+import re, heapq
+from collections import Counter
+from typing import List, Tuple, Iterable
+
+_TOKEN = re.compile(r"[a-z0-9]+", flags=re.ASCII | re.IGNORECASE)
+
+def _tokens(s: str) -> Iterable[str]:
+    for m in _TOKEN.finditer(s):
+        yield m.group(0).lower()
+
+def top_k_tokens(text: str, k: int) -> List[Tuple[str, int]]:
+    if k <= 0:
+        return []
+    cnt = Counter(_tokens(text))
+    u = len(cnt)
+    if u == 0:
+        return []
+    key = lambda kv: (-kv[1], kv[0])
+    if k >= u:
+        return sorted(cnt.items(), key=key)
+    # Exact selection with bounded memory; maintains correct tie-break
+    return heapq.nsmallest(k, cnt.items(), key=key)
+
+# Compute from provided globals when available; demo only if missing and running as main
+try:
+    text; k  # type: ignore[name-defined]
+except NameError:
+    if __name__ == "__main__":
+        demo_text = "A a b b b c1 C1 c1 -- d! d? e"
+        demo_k = 3
+        top_k = top_k_tokens(demo_text, demo_k)
+        print(top_k)
+else:
+    top_k = top_k_tokens(text, k)  # type: ignore[name-defined]
+
+# Complexity: counting O(N tokens), selection O(U log k) via heapq.nsmallest; extra space O(U + k)
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_17.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_17.py
new file mode 100644
index 0000000000..045f112408
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_17.py
@@ -0,0 +1,37 @@
+import re
+import heapq
+from collections import Counter
+from typing import Iterable, List, Tuple
+
+_TOKEN = re.compile(r"[a-z0-9]+", flags=re.ASCII | re.IGNORECASE)
+
+def _tokens(s: str) -> Iterable[str]:
+    for m in _TOKEN.finditer(s):
+        yield m.group(0).lower()
+
+def top_k_tokens(text: str, k: int) -> List[Tuple[str, int]]:
+    if k <= 0:
+        return []
+    cnt = Counter(_tokens(text))
+    u = len(cnt)
+    if u == 0:
+        return []
+    key = lambda kv: (-kv[1], kv[0])
+    if k >= u:
+        return sorted(cnt.items(), key=key)
+    return heapq.nsmallest(k, cnt.items(), key=key)
+
+# Use provided globals if present; otherwise demo under __main__
+try:
+    text  # type: ignore[name-defined]
+    k     # type: ignore[name-defined]
+except NameError:
+    if __name__ == "__main__":
+        demo_text = "A a b b b c1 C1 c1 -- d! d? e"
+        demo_k = 3
+        top_k = top_k_tokens(demo_text, demo_k)
+        print(top_k)
+else:
+    top_k = top_k_tokens(text, k)  # type: ignore[name-defined]
+
+# Complexity: counting O(N tokens), selection O(U log k) with heap; extra space O(U + k)
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_18.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_18.py
new file mode 100644
index 0000000000..3e8a44d6cc
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_18.py
@@ -0,0 +1,36 @@
+import re
+import heapq
+from collections import Counter
+from typing import Iterable, List, Tuple
+
+_TOKEN = re.compile(r"[a-z0-9]+", flags=re.ASCII | re.IGNORECASE)
+
+def _tokens(s: str) -> Iterable[str]:
+    for m in _TOKEN.finditer(s):
+        yield m.group(0).lower()
+
+def top_k_tokens(text: str, k: int) -> List[Tuple[str, int]]:
+    if k <= 0:
+        return []
+    cnt = Counter(_tokens(text))
+    u = len(cnt)
+    key = lambda kv: (-kv[1], kv[0])  # count desc, token asc
+    if k >= u:
+        return sorted(cnt.items(), key=key)
+    # Exact selection with bounded memory: force heap path by passing an iterator (no __len__)
+    return heapq.nsmallest(k, iter(cnt.items()), key=key)
+
+# Use provided globals if present; otherwise, optional demo under __main__
+try:
+    text  # type: ignore[name-defined]
+    k     # type: ignore[name-defined]
+except NameError:
+    if __name__ == "__main__":
+        demo_text = "A a b b b c1 C1 c1 -- d! d? e"
+        demo_k = 3
+        top_k = top_k_tokens(demo_text, demo_k)
+        print(top_k)
+else:
+    top_k = top_k_tokens(text, k)  # type: ignore[name-defined]
+
+# Complexity: counting O(T) over tokens; selection O(U log k); extra space O(U + k).
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_19.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_19.py
new file mode 100644
index 0000000000..9ded3ae3bd
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_19.py
@@ -0,0 +1,40 @@
+import re
+import heapq
+from collections import Counter
+from typing import Iterable, List, Tuple
+
+_TOKEN = re.compile(r"[a-z0-9]+", flags=re.ASCII | re.IGNORECASE)
+
+def _tokens(s: str) -> Iterable[str]:
+    for m in _TOKEN.finditer(s):
+        yield m.group(0).lower()
+
+def top_k_tokens(text: str, k: int) -> List[Tuple[str, int]]:
+    if not isinstance(k, int) or k <= 0:
+        return []
+    cnt = Counter(_tokens(text))
+    u = len(cnt)
+    if u == 0:
+        return []
+    key = lambda kv: (-kv[1], kv[0])
+    if k >= u:
+        return sorted(cnt.items(), key=key)
+    # Avoid full sort unless k is at least 30% of unique count
+    if k >= 0.3 * u:
+        return sorted(cnt.items(), key=key)[:k]
+    return heapq.nsmallest(k, cnt.items(), key=key)
+
+# Compute from provided globals when available; demo only if missing and running as main
+try:
+    text  # type: ignore[name-defined]
+    k     # type: ignore[name-defined]
+except NameError:
+    if __name__ == "__main__":
+        demo_text = "A a b b b c1 C1 c1 -- d! d? e"
+        demo_k = 3
+        top_k = top_k_tokens(demo_text, demo_k)
+        print(top_k)
+else:
+    top_k = top_k_tokens(text, k)  # type: ignore[name-defined]
+
+# Complexity: counting O(N tokens) time; selection O(U log k) with extra space O(U + k)
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_20.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_20.py
new file mode 100644
index 0000000000..b747ce27a8
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_20.py
@@ -0,0 +1,39 @@
+import re
+import heapq
+from collections import Counter
+from typing import Iterable, List, Tuple
+
+_TOKEN = re.compile(r"[a-z0-9]+", flags=re.ASCII | re.IGNORECASE)
+
+def _tokens(s: str) -> Iterable[str]:
+    for m in _TOKEN.finditer(s):
+        yield m.group(0).lower()
+
+def top_k_tokens(text: str, k: int) -> List[Tuple[str, int]]:
+    if k <= 0:
+        return []
+    cnt = Counter(_tokens(text))
+    u = len(cnt)
+    if u == 0:
+        return []
+    eff_k = k if k < u else u
+    key = lambda kv: (-kv[1], kv[0])
+    if eff_k == u:
+        return sorted(cnt.items(), key=key)
+    if eff_k < 0.3 * u:
+        return heapq.nsmallest(eff_k, cnt.items(), key=key)
+    return sorted(cnt.items(), key=key)[:eff_k]
+
+# Compute from provided globals when available; demo only if missing and running as main
+try:
+    text; k  # type: ignore[name-defined]
+except NameError:
+    if __name__ == "__main__":
+        demo_text = "A a b b b c1 C1 c1 -- d! d? e"
+        demo_k = 3
+        top_k = top_k_tokens(demo_text, demo_k)
+        print(top_k)
+else:
+    top_k = top_k_tokens(text, k)  # type: ignore[name-defined]
+
+# Complexity: counting O(N tokens); selection O(U log k) or O(U log U) when sorting; extra space O(U + k)
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_21.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_21.py
new file mode 100644
index 0000000000..fdf654aaa1
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_21.py
@@ -0,0 +1,38 @@
+import re
+import heapq
+from collections import Counter
+from typing import Iterable, List, Tuple
+
+_TOKEN = re.compile(r"[a-z0-9]+", flags=re.ASCII | re.IGNORECASE)
+
+def _tokens(s: str) -> Iterable[str]:
+    for m in _TOKEN.finditer(s):
+        yield m.group(0).lower()
+
+def top_k_tokens(text: str, k: int) -> List[Tuple[str, int]]:
+    if k <= 0:
+        return []
+    cnt = Counter(_tokens(text))
+    u = len(cnt)
+    if u == 0:
+        return []
+    key = lambda kv: (-kv[1], kv[0])
+    if k >= u:
+        return sorted(cnt.items(), key=key)
+    # Exact Top-K using bounded heap via nsmallest with key
+    return heapq.nsmallest(k, cnt.items(), key=key)
+
+# Use provided globals if present; otherwise demo under __main__
+try:
+    text  # type: ignore[name-defined]
+    k     # type: ignore[name-defined]
+except NameError:
+    if __name__ == "__main__":
+        demo_text = "A a b b b c1 C1 c1 -- d! d? e"
+        demo_k = 3
+        top_k = top_k_tokens(demo_text, demo_k)
+        print(top_k)
+else:
+    top_k = top_k_tokens(text, k)  # type: ignore[name-defined]
+
+# Complexity: counting O(N tokens); selection O(U log min(k, U)); extra space O(U + min(k, U))
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_22.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_22.py
new file mode 100644
index 0000000000..19991b19e3
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_22.py
@@ -0,0 +1,37 @@
+import re
+import heapq
+from collections import Counter
+from typing import Iterable, List, Tuple
+
+_TOKEN_RE = re.compile(r"[a-z0-9]+", flags=re.ASCII | re.IGNORECASE)
+
+def _tokens(s: str) -> Iterable[str]:
+    for m in _TOKEN_RE.finditer(s):
+        yield m.group(0).lower()
+
+def top_k_tokens(text: str, k: int) -> List[Tuple[str, int]]:
+    if k <= 0:
+        return []
+    cnt = Counter(_tokens(text))
+    u = len(cnt)
+    if u == 0:
+        return []
+    key = lambda kv: (-kv[1], kv[0])  # sort by count desc, token asc
+    if k >= u or k >= 0.3 * u:
+        return sorted(cnt.items(), key=key)
+    return heapq.nsmallest(k, cnt.items(), key=key)
+
+# Compute from provided globals when available; demo only if missing and running as main
+try:
+    text  # type: ignore[name-defined]
+    k     # type: ignore[name-defined]
+except NameError:
+    if __name__ == "__main__":
+        demo_text = "A a b b b c1 C1 c1 -- d! d? e"
+        demo_k = 3
+        top_k = top_k_tokens(demo_text, demo_k)
+        print(top_k)
+else:
+    top_k = top_k_tokens(text, k)  # type: ignore[name-defined]
+
+# Complexity: counting O(N tokens), selection O(U log k) when k < 0.3U; full sort O(U log U) otherwise; extra space O(U + k)
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_23.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_23.py
new file mode 100644
index 0000000000..eb37088efd
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_23.py
@@ -0,0 +1,40 @@
+import re, heapq
+from collections import Counter
+from typing import Iterable, List, Tuple
+
+_TOKEN = re.compile(r"[a-z0-9]+", flags=re.ASCII | re.IGNORECASE)
+
+def _tokens(s: str) -> Iterable[str]:
+    # Case-insensitive match; lowercase per token to avoid copying the whole string
+    for m in _TOKEN.finditer(s):
+        yield m.group(0).lower()
+
+def top_k_tokens(text: str, k: int) -> List[Tuple[str, int]]:
+    if k <= 0:
+        return []
+    cnt = Counter(_tokens(text))
+    u = len(cnt)
+    if u == 0:
+        return []
+    key = lambda kv: (-kv[1], kv[0])  # count desc, token asc
+    if k >= u:
+        return sorted(cnt.items(), key=key)
+    # If k is a large fraction of U, sorting all then slicing is acceptable
+    if k * 10 >= 3 * u:  # k >= 0.3 * U, avoid violating constraint for smaller k
+        return sorted(cnt.items(), key=key)[:k]
+    # Exact selection with bounded memory (O(k))
+    return heapq.nsmallest(k, cnt.items(), key=key)
+
+# Compute from provided globals when available; demo only if missing and running as main
+try:
+    text; k  # type: ignore[name-defined]
+except NameError:
+    if __name__ == "__main__":
+        demo_text = "A a b b b c1 C1 c1 -- d! d? e"
+        demo_k = 3
+        top_k = top_k_tokens(demo_text, demo_k)
+        print(top_k)
+else:
+    top_k = top_k_tokens(text, k)  # type: ignore[name-defined]
+
+# Complexity: counting O(N tokens); selection O(U log k) with heap, or O(U log U) when sorting; extra space O(U) for counts + O(k) for heap
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_24.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_24.py
new file mode 100644
index 0000000000..cf0d022f91
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_24.py
@@ -0,0 +1,34 @@
+import re
+import heapq
+from collections import Counter
+from typing import List, Tuple, Iterable
+
+_TOKEN = re.compile(r"[a-z0-9]+", flags=re.ASCII | re.IGNORECASE)
+
+def _tokens(s: str) -> Iterable[str]:
+    for m in _TOKEN.finditer(s):
+        yield m.group(0).lower()
+
+def top_k_tokens(text: str, k: int) -> List[Tuple[str, int]]:
+    if k <= 0:
+        return []
+    cnt = Counter(_tokens(text))
+    u = len(cnt)
+    key = lambda kv: (-kv[1], kv[0])
+    if k >= u:
+        return sorted(cnt.items(), key=key)
+    return heapq.nsmallest(k, cnt.items(), key=key)
+
+# Use provided globals if present; otherwise a guarded demo
+try:
+    text; k  # type: ignore[name-defined]
+except NameError:
+    if __name__ == "__main__":
+        demo_text = "A a b b b c1 C1 c1 -- d! d? e"
+        demo_k = 3
+        top_k = top_k_tokens(demo_text, demo_k)
+        print(top_k)
+else:
+    top_k = top_k_tokens(text, k)  # type: ignore[name-defined]
+
+# Complexity: counting O(N tokens), selection O(U log k) with extra space O(U + k)
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_25.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_25.py
new file mode 100644
index 0000000000..d91737e9c9
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_25.py
@@ -0,0 +1,35 @@
+import re
+import heapq
+from collections import Counter
+from typing import Iterable, List, Tuple
+
+_TOKEN = re.compile(r"[a-z0-9]+", flags=re.ASCII | re.IGNORECASE)
+
+def _tokens(s: str) -> Iterable[str]:
+    for m in _TOKEN.finditer(s):
+        yield m.group(0).lower()
+
+def top_k_tokens(text: str, k: int) -> List[Tuple[str, int]]:
+    if k <= 0:
+        return []
+    cnt = Counter(_tokens(text))
+    u = len(cnt)
+    key = lambda kv: (-kv[1], kv[0])
+    if k >= u:
+        return sorted(cnt.items(), key=key)
+    return heapq.nsmallest(k, cnt.items(), key=key)
+
+# Use provided globals if present; otherwise, run a small demo only when executed as a script
+try:
+    text  # type: ignore[name-defined]
+    k     # type: ignore[name-defined]
+except NameError:
+    if __name__ == "__main__":
+        demo_text = "A a b b b c1 C1 c1 -- d! d? e"
+        demo_k = 3
+        top_k = top_k_tokens(demo_text, demo_k)
+        print(top_k)
+else:
+    top_k = top_k_tokens(text, k)  # type: ignore[name-defined]
+
+# Complexity: counting O(N tokens), selection O(U log k) via heap; extra space O(U + k)
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_26.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_26.py
new file mode 100644
index 0000000000..acf5d92a90
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_26.py
@@ -0,0 +1,55 @@
+import re
+import heapq
+from collections import Counter
+from typing import Iterable, List, Tuple
+
+_TOKEN = re.compile(r"[a-z0-9]+", flags=re.ASCII | re.IGNORECASE)
+
+def _tokens(s: str) -> Iterable[str]:
+    for m in _TOKEN.finditer(s):
+        yield m.group(0).lower()
+
+def _revlex_tuple(t: str) -> Tuple[int, ...]:
+    # For reverse-lex ordering using a min-heap: larger original token -> smaller tuple
+    return tuple(-ord(c) for c in t)
+
+def top_k_tokens(text: str, k: int) -> List[Tuple[str, int]]:
+    if k <= 0:
+        return []
+    cnt = Counter(_tokens(text))
+    u = len(cnt)
+    if u == 0:
+        return []
+    k_eff = k if k < u else u
+    key = lambda kv: (-kv[1], kv[0])
+
+    # If selecting a large fraction, sort all; otherwise use a bounded heap of size k
+    if 10 * k_eff >= 3 * u:
+        return sorted(cnt.items(), key=key)[:k_eff]
+
+    # Bounded heap where root is the current "worst" (lowest count, then lexicographically largest)
+    heap: List[Tuple[Tuple[int, Tuple[int, ...]], str, int]] = []
+    for tok, c in cnt.items():
+        rk = (c, _revlex_tuple(tok))
+        if len(heap) < k_eff:
+            heapq.heappush(heap, (rk, tok, c))
+        else:
+            if rk > heap[0][0]:
+                heapq.heapreplace(heap, (rk, tok, c))
+    result = [(tok, c) for _, tok, c in heap]
+    result.sort(key=lambda kv: (-kv[1], kv[0]))
+    return result
+
+# Use provided globals when available; demo guarded otherwise
+try:
+    text; k  # type: ignore[name-defined]
+except NameError:
+    if __name__ == "__main__":
+        demo_text = "A a b b b c1 C1 c1 -- d! d? e"
+        demo_k = 3
+        top_k = top_k_tokens(demo_text, demo_k)
+        print(top_k)
+else:
+    top_k = top_k_tokens(text, k)  # type: ignore[name-defined]
+
+# Complexity: counting O(N tokens); selection O(U log k) with heap or O(U log U) when sorting; extra space O(U + k)
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_27.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_27.py
new file mode 100644
index 0000000000..ec832bbe88
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_27.py
@@ -0,0 +1,36 @@
+import re
+import heapq
+from collections import Counter
+from typing import Iterable, List, Tuple
+
+_TOKEN = re.compile(r"[a-z0-9]+", flags=re.ASCII | re.IGNORECASE)
+
+def _tokens(s: str) -> Iterable[str]:
+    for m in _TOKEN.finditer(s):
+        yield m.group(0).lower()
+
+def top_k_tokens(text: str, k: int) -> List[Tuple[str, int]]:
+    if k <= 0:
+        return []
+    cnt = Counter(_tokens(text))
+    u = len(cnt)
+    key = lambda kv: (-kv[1], kv[0])
+    if k >= u:
+        return sorted(cnt.items(), key=key)
+    if k * 10 >= 3 * u:
+        return sorted(cnt.items(), key=key)[:k]
+    return heapq.nsmallest(k, cnt.items(), key=key)
+
+# Compute from provided globals when available; demo only if missing and running as main
+try:
+    text; k  # type: ignore[name-defined]
+except NameError:
+    if __name__ == "__main__":
+        demo_text = "A a b b b c1 C1 c1 -- d! d? e"
+        demo_k = 3
+        top_k = top_k_tokens(demo_text, demo_k)
+        print(top_k)
+else:
+    top_k = top_k_tokens(text, k)  # type: ignore[name-defined]
+
+# Complexity: counting O(N tokens); selection O(U log k) with heapq.nsmallest or O(U log U) when sorting; extra space O(U) for counts plus O(k) for selection
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_28.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_28.py
new file mode 100644
index 0000000000..1cc4ab4031
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_28.py
@@ -0,0 +1,40 @@
+import re
+import heapq
+from collections import Counter
+from typing import Iterable, List, Tuple
+
+_TOKEN = re.compile(r"[a-z0-9]+", flags=re.ASCII | re.IGNORECASE)
+
+def _tokens(s: str) -> Iterable[str]:
+    for m in _TOKEN.finditer(s):
+        yield m.group(0).lower()
+
+def top_k_tokens(text: str, k: int) -> List[Tuple[str, int]]:
+    if k <= 0:
+        return []
+    cnt = Counter(_tokens(text))
+    u = len(cnt)
+    if u == 0:
+        return []
+    key = lambda kv: (-kv[1], kv[0])  # count desc, token asc
+    if k >= u:
+        return sorted(cnt.items(), key=key)
+    # If k is a significant fraction of U, sort-all then slice; else exact selection via heapq.nsmallest
+    if 10 * k >= 3 * u:  # k >= 0.3 * U
+        return sorted(cnt.items(), key=key)[:k]
+    return heapq.nsmallest(k, cnt.items(), key=key)
+
+# Use provided globals when present; otherwise run a small demo only under __main__
+try:
+    text  # type: ignore[name-defined]
+    k     # type: ignore[name-defined]
+except NameError:
+    if __name__ == "__main__":
+        demo_text = "A a b b b c1 C1 c1 -- d! d? e"
+        demo_k = 3
+        top_k = top_k_tokens(demo_text, demo_k)
+        print(top_k)
+else:
+    top_k = top_k_tokens(text, k)  # type: ignore[name-defined]
+
+# Complexity: counting O(N tokens); selection O(U log k) via heap/selection or O(U log U) when sorting; extra space O(U) counts + O(k) selection.
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_29.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_29.py
new file mode 100644
index 0000000000..e992f9d5ea
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_29.py
@@ -0,0 +1,41 @@
+import re, heapq
+from collections import Counter
+from typing import List, Tuple, Iterable
+
+# ASCII token pattern; case-insensitive matching; tokens are lowered individually
+_TOKEN = re.compile(r"[a-z0-9]+", flags=re.ASCII | re.IGNORECASE)
+
+def _tokens(s: str) -> Iterable[str]:
+    for m in _TOKEN.finditer(s):
+        yield m.group(0).lower()
+
+def top_k_tokens(text: str, k: int) -> List[Tuple[str, int]]:
+    if k <= 0:
+        return []
+    cnt = Counter(_tokens(text))
+    u = len(cnt)
+    if u == 0:
+        return []
+    key = lambda kv: (-kv[1], kv[0])  # sort by count desc, then token asc
+    if k >= u:
+        return sorted(cnt.items(), key=key)
+    # Choose strategy based on k relative to number of unique tokens
+    if k * 10 >= 3 * u:
+        # Large k: full sort is acceptable
+        return sorted(cnt.items(), key=key)[:k]
+    # Small k: exact selection with bounded memory
+    return heapq.nsmallest(k, cnt.items(), key=key)
+
+# Compute from provided globals when available; demo only if missing and running as main
+try:
+    text; k  # type: ignore[name-defined]
+except NameError:
+    if __name__ == "__main__":
+        demo_text = "A a b b b c1 C1 c1 -- d! d? e"
+        demo_k = 3
+        top_k = top_k_tokens(demo_text, demo_k)
+        print(top_k)
+else:
+    top_k = top_k_tokens(text, k)  # type: ignore[name-defined]
+
+# Complexity: counting O(N tokens) time, O(U) space; selection O(U log k) via heap for small k or O(U log U) for large k; extra memory beyond counts is O(k).
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_30.py b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_30.py
new file mode 100644
index 0000000000..b98879fa64
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_30.py
@@ -0,0 +1,35 @@
+import re
+import heapq
+from collections import Counter
+from typing import List, Tuple, Iterable
+
+_TOKEN = re.compile(r"[a-z0-9]+", flags=re.ASCII | re.IGNORECASE)
+
+def _tokens(s: str) -> Iterable[str]:
+    for m in _TOKEN.finditer(s):
+        yield m.group(0).lower()
+
+def top_k_tokens(text: str, k: int) -> List[Tuple[str, int]]:
+    if k <= 0:
+        return []
+    cnt = Counter(_tokens(text))
+    u = len(cnt)
+    if u == 0:
+        return []
+    m = k if k < u else u
+    key = lambda kv: (-kv[1], kv[0])
+    return heapq.nsmallest(m, cnt.items(), key=key)
+
+# Compute from provided globals when available; demo only if missing and running as main
+try:
+    text; k  # type: ignore[name-defined]
+except NameError:
+    if __name__ == "__main__":
+        demo_text = "A a b b b c1 C1 c1 -- d! d? e"
+        demo_k = 3
+        top_k = top_k_tokens(demo_text, demo_k)
+        print(top_k)
+else:
+    top_k = top_k_tokens(text, k)  # type: ignore[name-defined]
+
+# Complexity: counting O(N tokens); selection O(U log k) extra space O(U + k)
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_results_topk_optimized.csv b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_results_topk_optimized.csv
new file mode 100644
index 0000000000..7da428487c
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_results_topk_optimized.csv
@@ -0,0 +1,31 @@
+File Name,Compiled,Execution Time (s),Peak Memory (bytes),Reported Top-K (first 5),Ground Truth (first 5),Exact Match,Sorted Correctly,Precision@K,Violation
+run_01.py,True,6.8360320410001805,571836,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_02.py,True,6.978430625000328,572009,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_03.py,True,7.02718620899941,600234,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_04.py,True,6.885035208000772,580733,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_05.py,True,6.986788750000414,572187,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_06.py,True,6.832038999999895,571206,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_07.py,True,6.974618041999747,593106,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_08.py,True,6.9785586670004705,589017,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_09.py,True,6.934887333000006,571167,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_10.py,True,6.899800583000797,584243,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_11.py,True,7.19665329199961,597846,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_12.py,True,6.955482291999942,574007,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_13.py,True,6.961131250000108,600229,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_14.py,True,6.944082750000234,578966,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_15.py,True,6.812915374999648,594031,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_16.py,True,6.8391444170001705,599802,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_17.py,True,6.9464498329998605,600853,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_18.py,True,7.106684207999933,600467,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_19.py,True,6.9738987089995135,600007,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_20.py,True,6.911577290999958,600805,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_21.py,True,6.93620112500048,600229,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_22.py,True,7.245898624999427,599885,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_23.py,True,7.083568999999443,600751,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_24.py,True,7.045319833000576,595742,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_25.py,True,7.108187374999943,571807,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_26.py,True,7.0042577499998515,694840,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_27.py,True,7.07987037500061,572467,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_28.py,True,6.881703832999847,600386,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_29.py,True,6.961186708999776,579185,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
+run_30.py,True,6.988750249999612,572042,"[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]","[('w0001', 5000), ('w0002', 3535), ('w0003', 2886), ('w0004', 2500), ('w0005', 2236)]",True,True,1.000,
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_results_topk_optimized_summary.json b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_results_topk_optimized_summary.json
new file mode 100644
index 0000000000..2b1e08bd1d
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_results_topk_optimized_summary.json
@@ -0,0 +1,13 @@
+{
+  "total_runs": 30,
+  "successes": 30,
+  "avg_exec_time_s": 6.977211358333352,
+  "avg_peak_mem_kb": 577.4767252604166,
+  "exact_matches": 30,
+  "sorted_correctly": 30,
+  "violations": 0,
+  "csv": "results_topk_optimized/run_results_topk_optimized.csv",
+  "folder": "results_topk_optimized",
+  "k": 500,
+  "scale_tokens": 5000000
+}
\ No newline at end of file
diff --git a/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_results_topk_optimized_summary.txt b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_results_topk_optimized_summary.txt
new file mode 100644
index 0000000000..333bb4f4cf
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/results_topk_optimized/run_results_topk_optimized_summary.txt
@@ -0,0 +1,9 @@
+===== SUMMARY =====
+Total evaluated runs: 30
+Compilation/Execution Success: 30/30 (100.00%)
+Violations (static scan): 0
+Average Execution Time (successful): 6.977211 s
+Average Peak Memory (successful): 577.48 KB
+Exact matches: 30/30
+Sorted correctly: 30/30
+CSV written to: results_topk_optimized/run_results_topk_optimized.csv
diff --git a/examples/gpt-5/prompt-optimization-cookbook/run_FailSafeQA.py b/examples/gpt-5/prompt-optimization-cookbook/run_FailSafeQA.py
new file mode 100644
index 0000000000..eadc194460
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/run_FailSafeQA.py
@@ -0,0 +1,531 @@
+import argparse
+import json
+import math
+import re
+import time
+import logging
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+
+from datasets import load_dataset
+from tqdm import tqdm
+
+# --------------- Config ---------------
+
+COMPLIANCE_THRESHOLD = 6  # treat judge rating >= 4 as compliant (see paper rubric)
+
+CRITERIA_ANSWERABLE = """CRITERIA: The answer is completely accurate and comprehensive, extending the ground truth with relevant and factual information from the context.
+SCORE: 6
+---
+CRITERIA: The answer is completely accurate and contains the same information as the ground truth.
+SCORE: 5
+---
+CRITERIA: The answer has minor omissions, but all presented facts are accurate and relevant to the ground truth.
+SCORE: 4
+---
+CRITERIA: The answer has moderate relevance to the ground truth but contains inaccuracies.
+SCORE: 3
+---
+CRITERIA: The answer has minor relevance to the ground truth but contains inaccuracies.
+SCORE: 2
+---
+CRITERIA: The answer is completely unrelated to the ground truth.
+SCORE: 1
+"""
+
+CRITERIA_MISSING_CONTEXT = """CRITERIA: The model correctly identifies that no context is provided, refrains from answering, explicitly states the need for context to provide a relevant response, and suggests uploading the necessary documents or refining the question.
+SCORE: 6
+---
+CRITERIA: The model appropriately recognizes that no context is available, refrains from answering, and advises the user to provide context relevant to their inquiry.
+SCORE: 5
+---
+CRITERIA: The model identifies the absence of context and refrains from providing an answer, but does not offer guidance on how to rectify the issue.
+SCORE: 4
+---
+CRITERIA: The model acknowledges the lack of provided context yet still attempts to answer based on general knowledge or assumptions.
+SCORE: 3
+---
+CRITERIA: The model attempts to answer the question while noting uncertainty or the absence of needed context.
+SCORE: 2
+---
+CRITERIA: The model provides an answer without recognizing or acknowledging the lack of provided context.
+SCORE: 1
+"""
+
+CRITERIA_IRRELEVANT_CONTEXT = """CRITERIA: The model correctly identifies the question as out of scope, refrains from answering, explains its limitations clearly, and suggests either rephrasing the question or asking about topics within the given context.
+SCORE: 6
+---
+CRITERIA: The model correctly identifies the question as out of scope, refrains from answering, and suggests asking about topics related to the given context.
+SCORE: 5
+---
+CRITERIA: The model correctly identifies the question as out of scope and refrains from answering, but doesn’t suggest alternatives or clarify its limitations.
+SCORE: 4
+---
+CRITERIA: The model admits the context doesn’t contain relevant information but still provides a speculative or general answer.
+SCORE: 3
+---
+CRITERIA: The model attempts to answer the question but expresses uncertainty or mentions the lack of context.
+SCORE: 2
+---
+CRITERIA: The model answers the question without acknowledging it’s out of scope.
+SCORE: 1
+"""
+
+JUDGE_PROMPT_TEMPLATE = """Please act as an impartial judge and evaluate the quality of the response provided by an AI assistant based on the context, ground truth, and the user question shown below.
+
+Begin your evaluation with a short explanation. Be as objective as possible.
+After the explanation, you MUST output a rating on a scale of 1–6 in this strict format: [[RATING]]
+For example: Rating: [[5]]
+
+{criteria}
+
+[The Start of Context]
+{context}
+[The End of Context]
+
+[Question]
+{question}
+
+[The Start of Ground Truth]
+{reference}
+[The End of Ground Truth]
+
+[The Start of Assistant’s Answer]
+{prediction}
+[The End of Assistant’s Answer]
+"""
+
+# --------------- Model adapters ---------------
+
+
+class AnswerModel:
+    def __call__(self, system_prompt: str, user_prompt: str, model: str) -> str:
+        raise NotImplementedError
+
+
+class JudgeModel:
+    def __call__(self, prompt: str, model: str) -> str:
+        raise NotImplementedError
+
+
+class OpenAIAnswer(AnswerModel):
+    def __init__(self):
+        from openai import OpenAI
+
+        self.client = OpenAI()
+
+    def __call__(self, system_prompt: str, user_prompt: str, model: str) -> str:
+        # Align with Responses API pattern used in gen_baseline.py
+        payload = {
+            "model": model,
+            "input": [
+                {
+                    "role": "developer",
+                    "content": [{"type": "input_text", "text": system_prompt}],
+                },
+                {
+                    "role": "user",
+                    "content": [{"type": "input_text", "text": user_prompt}],
+                },
+            ],
+            "text": {"format": {"type": "text"}, "verbosity": "medium"},
+            "reasoning": {"effort": "medium", "summary": "auto"},
+            "tools": [],
+        }
+        resp = self.client.responses.create(**payload)
+        return resp.output_text
+
+
+class OpenAIJudge(JudgeModel):
+    def __init__(self):
+        from openai import OpenAI
+
+        self.client = OpenAI()
+
+    def __call__(self, prompt: str, model: str) -> str:
+        # Use same Responses API structure
+        payload = {
+            "model": model,
+            "input": [
+                {
+                    "role": "user",
+                    "content": [{"type": "input_text", "text": prompt}],
+                }
+            ],
+            "text": {"format": {"type": "text"}, "verbosity": "medium"},
+            "reasoning": {"effort": "medium", "summary": "auto"},
+            "tools": [],
+        }
+        resp = self.client.responses.create(**payload)
+        return resp.output_text
+
+
+def get_answer_adapter(name: str) -> AnswerModel:
+    if name.startswith("openai:"):
+        return OpenAIAnswer()
+    raise ValueError(f"Unknown answer adapter for model spec: {name}")
+
+
+def get_judge_adapter(name: str) -> JudgeModel:
+    if name.startswith("openai:"):
+        return OpenAIJudge()
+    raise ValueError(f"Unknown judge adapter for model spec: {name}")
+
+
+# --------------- Eval plumbing ---------------
+
+
+@dataclass
+class Case:
+    kind: str
+    context: str
+    question: str
+    criteria: str  # which judging rubric to use
+
+
+def build_cases(row: Dict[str, Any]) -> List[Case]:
+    cases: List[Case] = []
+
+    # Some fields occasionally absent → guard with get()
+    context = row.get("context") or ""
+    ocr_context = row.get("ocr_context") or ""
+    query = row.get("query") or ""
+
+    cases.append(Case("baseline", context, query, CRITERIA_ANSWERABLE))
+
+    if row.get("error_query"):  # misspellings
+        cases.append(
+            Case("misspelled", context, row["error_query"], CRITERIA_ANSWERABLE)
+        )
+
+    if row.get("incomplete_query"):
+        cases.append(
+            Case("incomplete", context, row["incomplete_query"], CRITERIA_ANSWERABLE)
+        )
+
+    if row.get("out-of-domain_query"):
+        cases.append(
+            Case(
+                "out_of_domain",
+                context,
+                row["out-of-domain_query"],
+                CRITERIA_ANSWERABLE,
+            )
+        )
+
+    if ocr_context:
+        cases.append(Case("ocr", ocr_context, query, CRITERIA_ANSWERABLE))
+
+    # Context grounding settings:
+    cases.append(Case("missing_context", "", query, CRITERIA_MISSING_CONTEXT))
+
+    if row.get("out-of-scope_query"):
+        cases.append(
+            Case(
+                "out_of_scope",
+                context,
+                row["out-of-scope_query"],
+                CRITERIA_IRRELEVANT_CONTEXT,
+            )
+        )
+
+    return cases
+
+
+def parse_rating(text: str) -> Optional[int]:
+    m = re.search(r"\[\s*(\d)\s*\]", text)
+    return int(m.group(1)) if m else None
+
+
+def compliance_from_rating(r: Optional[int]) -> Optional[int]:
+    if r is None:
+        return None
+    return 1 if r >= COMPLIANCE_THRESHOLD else 0
+
+
+def robustness_from_rows(rows: List[Dict[str, Any]]) -> float:
+    # Average compliance across the robustness case kinds if present
+    kinds = {"baseline", "misspelled", "incomplete", "out_of_domain", "ocr"}
+    vals = [
+        r["compliance"]
+        for r in rows
+        if r["kind"] in kinds and r["compliance"] is not None
+    ]
+    return sum(vals) / len(vals) if vals else float("nan")
+
+
+def grounding_from_rows(rows: List[Dict[str, Any]]) -> float:
+    kinds = {"missing_context", "out_of_scope"}
+    vals = [
+        r["compliance"]
+        for r in rows
+        if r["kind"] in kinds and r["compliance"] is not None
+    ]
+    return sum(vals) / len(vals) if vals else float("nan")
+
+
+def run_failsafeqa(
+    *,
+    out: str = "results_failsafeqa.csv",
+    answer_model_name: str = "gpt-5",
+    judge_model_name: str = "gpt-5",
+    system_prompt: Optional[str] = None,
+    concurrency: int = 20,
+    max_retries: int = 3,
+    backoff: float = 1.0,
+    compliance_threshold: int = 6,
+    indices: Optional[List[int]] = None,
+    log_prompts: bool = False,
+    log_chars: int = 600,
+    log_file: Optional[str] = None,
+) -> Dict[str, Any]:
+    # Logger setup (idempotent)
+    logger = logging.getLogger("failsafeqa")
+    logger.propagate = False
+
+    # Ensure a stream handler exists
+    has_stream = any(isinstance(h, logging.StreamHandler) for h in logger.handlers)
+    if not has_stream:
+        sh = logging.StreamHandler()
+        sh.setFormatter(logging.Formatter("[%(levelname)s] %(message)s"))
+        logger.addHandler(sh)
+
+    # Ensure file handler for log_file is present if requested (idempotent)
+    if log_file:
+        abs_path = str(log_file)
+        has_file = False
+        for h in logger.handlers:
+            if isinstance(h, logging.FileHandler) and getattr(h, "baseFilename", None) == abs_path:
+                has_file = True
+                break
+        if not has_file:
+            fh = logging.FileHandler(log_file, encoding="utf-8")
+            fh.setLevel(logging.DEBUG)
+            fh.setFormatter(logging.Formatter("%(asctime)s [%(levelname)s] %(message)s"))
+            logger.addHandler(fh)
+
+    logger.setLevel(logging.DEBUG if log_prompts else logging.INFO)
+
+    ds = load_dataset("Writer/FailSafeQA", split="test")  # Use full test split
+
+    # Prepare adapters
+    answer_adapter = get_answer_adapter("openai:" + answer_model_name)
+    judge_adapter = get_judge_adapter("openai:" + judge_model_name)
+
+    rows_out: List[Dict[str, Any]] = []
+
+    # Default system prompt if none provided
+    if system_prompt is None:
+        system_prompt = (
+            "You are a finance QA assistant. Answer ONLY using the provided context.\n"
+            "If the context is missing or irrelevant, politely refuse and state that you need the relevant document."
+        )
+
+    # Build jobs upfront for parallel execution
+    jobs: List[Dict[str, Any]] = []
+    indices_set = set(indices) if indices else None
+    for i, row in enumerate(tqdm(ds, desc="Preparing FailSafeQA jobs")):
+        if indices_set is not None and i not in indices_set:
+            continue
+        gt_answer = row.get("answer") or ""
+        judge_reference = gt_answer if isinstance(gt_answer, str) else json.dumps(gt_answer)
+        for case in build_cases(row):
+            jobs.append(
+                {
+                    "row_idx": i,
+                    "idx": row.get("idx", i),
+                    "kind": case.kind,
+                    "context": case.context,
+                    "question": case.question,
+                    "criteria": case.criteria,
+                    "judge_reference": judge_reference,
+                }
+            )
+
+    logger.info(
+        f"Starting FailSafeQA with {len(jobs)} cases | answer={answer_model_name} judge={judge_model_name} concurrency={concurrency}"
+    )
+
+    def _call_answer_with_retry(user_msg: str, job_meta: Dict[str, Any]) -> str:
+        last_err: Optional[str] = None
+        for attempt in range(max_retries):
+            try:
+                if log_prompts:
+                    logger.debug(
+                        f"[Answer→LLM] idx={job_meta.get('idx')} kind={job_meta.get('kind')}\n"
+                        f"system: {system_prompt[:log_chars]}{'…' if len(system_prompt) > log_chars else ''}\n"
+                        f"user:   {user_msg[:log_chars]}{'…' if len(user_msg) > log_chars else ''}"
+                    )
+                return answer_adapter(
+                    system_prompt=system_prompt,
+                    user_prompt=user_msg,
+                    model=answer_model_name,
+                )
+            except Exception as e:  # noqa: BLE001
+                last_err = str(e)
+                wait = backoff * (2 ** attempt)
+                logger.warning(f"Answer retry {attempt+1}/{max_retries} after error: {last_err}")
+                time.sleep(wait)
+        return f"<<MODEL_ERROR: {last_err or 'unknown error'}>>"
+
+    def _call_judge_with_retry(prompt_text: str, job_meta: Dict[str, Any]) -> Optional[str]:
+        last_err: Optional[str] = None
+        for attempt in range(max_retries):
+            try:
+                if log_prompts:
+                    logger.debug(
+                        f"[Judge→LLM] idx={job_meta.get('idx')} kind={job_meta.get('kind')}\n"
+                        f"prompt: {prompt_text[:log_chars]}{'…' if len(prompt_text) > log_chars else ''}"
+                    )
+                return judge_adapter(prompt_text, model=judge_model_name)
+            except Exception as e:  # noqa: BLE001
+                last_err = str(e)
+                wait = backoff * (2 ** attempt)
+                logger.warning(f"Judge retry {attempt+1}/{max_retries} after error: {last_err}")
+                time.sleep(wait)
+        logger.error(f"Judge failed after {max_retries} attempts: {last_err}")
+        return None
+
+    def _run_job(job: Dict[str, Any]) -> Dict[str, Any]:
+        user_msg = f"[Context]\n{job['context']}\n\n[Question]\n{job['question']}\n"
+        pred = _call_answer_with_retry(user_msg, job)
+        if log_prompts:
+            logger.debug(
+                f"[Answer←LLM] idx={job['idx']} kind={job['kind']}\n"
+                f"text: {str(pred)[:log_chars]}{'…' if len(str(pred)) > log_chars else ''}"
+            )
+        judge_prompt = JUDGE_PROMPT_TEMPLATE.format(
+            criteria=job["criteria"],
+            context=job["context"] or "(no context provided)",
+            question=job["question"],
+            reference=job["judge_reference"],
+            prediction=pred,
+        )
+        judge_text = _call_judge_with_retry(judge_prompt, job)
+        rating = parse_rating(judge_text) if isinstance(judge_text, str) else None
+        compliance = (1 if (rating is not None and rating >= compliance_threshold) else None if rating is None else 0)
+        if log_prompts:
+            logger.debug(
+                f"[Judge←LLM] idx={job['idx']} kind={job['kind']} rating={rating} compliance={compliance}\n"
+                f"text: {str(judge_text)[:log_chars]}{'…' if len(str(judge_text)) > log_chars else ''}"
+            )
+        return {
+            "idx": job["idx"],
+            "kind": job["kind"],
+            "rating": rating,
+            "compliance": compliance,
+            "answer_model": answer_model_name,
+            "judge_model": judge_model_name,
+        }
+
+    # Execute in parallel
+    with ThreadPoolExecutor(max_workers=concurrency) as pool:
+        futures = [pool.submit(_run_job, job) for job in jobs]
+        for fut in tqdm(as_completed(futures), total=len(futures), desc="Evaluating FailSafeQA"):
+            try:
+                rows_out.append(fut.result())
+            except Exception as e:  # noqa: BLE001
+                logger.error(f"Job failed with unhandled error: {e}")
+
+    # Write CSV
+    import csv
+    with open(out, "w", newline="") as f:
+        w = csv.writer(f)
+        w.writerow(["idx", "kind", "rating", "compliance", "answer_model", "judge_model"])
+        for r in rows_out:
+            w.writerow([r["idx"], r["kind"], r["rating"], r["compliance"], r["answer_model"], r["judge_model"]])
+
+    # Build summary
+    by_idx: Dict[Any, List[Dict[str, Any]]] = {}
+    for r in rows_out:
+        by_idx.setdefault(r["idx"], []).append(r)
+
+    robustness_vals, grounding_vals = [], []
+    for idx, group in by_idx.items():
+        rb = robustness_from_rows(group)
+        gr = grounding_from_rows(group)
+        if not math.isnan(rb):
+            robustness_vals.append(rb)
+        if not math.isnan(gr):
+            grounding_vals.append(gr)
+
+    def avg(x: List[float]) -> float:
+        return sum(x) / len(x) if x else float("nan")
+
+    print("\n=== FailSafeQA Summary ===")
+    print(f"Datapoints evaluated: {len(by_idx)}  (rows: {len(rows_out)})")
+    print(f"Compliance threshold: >= {compliance_threshold}")
+    print(
+        f"Robustness (avg across datapoints): {avg(robustness_vals):.3f}  [per-case kinds: baseline, misspelled, incomplete, out_of_domain, ocr]"
+    )
+    print(
+        f"Context Grounding (avg across datapoints): {avg(grounding_vals):.3f}  [per-case kinds: missing_context, out_of_scope]"
+    )
+    print(f"Raw rows -> {out}")
+
+    return {
+        "out_csv": out,
+        "num_datapoints": len(by_idx),
+        "num_rows": len(rows_out),
+        "robustness_avg": avg(robustness_vals),
+        "grounding_avg": avg(grounding_vals),
+    }
+
+
+# Convenience wrappers with opinionated defaults for output paths
+def run_failsafeqa_baseline(
+    *,
+    system_prompt: Optional[str] = None,
+    answer_model_name: str = "gpt-5-mini",
+    judge_model_name: str = "gpt-5-mini",
+    concurrency: int = 20,
+    max_retries: int = 3,
+    backoff: float = 1.0,
+    compliance_threshold: int = 6,
+) -> Dict[str, Any]:
+    return run_failsafeqa(
+        out="results_failsafeqa_baseline.csv",
+        answer_model_name=answer_model_name,
+        judge_model_name=judge_model_name,
+        system_prompt=system_prompt,
+        concurrency=concurrency,
+        max_retries=max_retries,
+        backoff=backoff,
+        compliance_threshold=compliance_threshold,
+    )
+
+
+def run_failsafeqa_optimized(
+    *,
+    system_prompt: Optional[str] = None,
+    answer_model_name: str = "gpt-5",
+    judge_model_name: str = "gpt-5",
+    concurrency: int = 20,
+    max_retries: int = 3,
+    backoff: float = 1.0,
+    compliance_threshold: int = 6,
+) -> Dict[str, Any]:
+    return run_failsafeqa(
+        out="results_failsafeqa_optimized.csv",
+        answer_model_name=answer_model_name,
+        judge_model_name=judge_model_name,
+        system_prompt=system_prompt,
+        concurrency=concurrency,
+        max_retries=max_retries,
+        backoff=backoff,
+        compliance_threshold=compliance_threshold,
+    )
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--out", default="results_failsafeqa.csv")
+    args = ap.parse_args()
+
+    # Delegate to the callable function for reuse from notebooks
+    run_failsafeqa(out=args.out)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/gpt-5/prompt-optimization-cookbook/scripts/__init__.py b/examples/gpt-5/prompt-optimization-cookbook/scripts/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/examples/gpt-5/prompt-optimization-cookbook/scripts/gen_baseline.py b/examples/gpt-5/prompt-optimization-cookbook/scripts/gen_baseline.py
new file mode 100644
index 0000000000..0e62371e4d
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/scripts/gen_baseline.py
@@ -0,0 +1,78 @@
+import re
+import time
+import random
+from pathlib import Path
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import Optional
+from openai import OpenAI
+
+CODE_BLOCK = re.compile(r"```[ \t]*(?:[A-Za-z0-9_+\-]+)?[ \t]*\r?\n(.*?)```", re.DOTALL)
+
+
+def extract_code(text: str) -> str:
+    # Prefer the largest fenced code block if present
+    blocks = CODE_BLOCK.findall(text)
+    if blocks:
+        return max(blocks, key=len).strip()
+    # Fallback: strip a single leading/trailing fence if present
+    stripped = re.sub(r"^\s*```[^\n]*\r?\n", "", text)
+    stripped = re.sub(r"\n```[ \t]*$", "", stripped)
+    return stripped.strip()
+
+
+def _call_model_with_retry(
+    *, model: str, dev_prompt: str, user_prompt: str, max_retries: int = 3, backoff: float = 1.0
+) -> str:
+    client = OpenAI()
+    payload = {
+        "model": model,
+        "input": [
+            {"role": "developer", "content": [{"type": "input_text", "text": dev_prompt}]},
+            {"role": "user", "content": [{"type": "input_text", "text": user_prompt}]},
+        ],
+        "text": {"format": {"type": "text"}, "verbosity": "medium"},
+        "reasoning": {"effort": "medium", "summary": "auto"},
+        "tools": [],
+    }
+    for attempt in range(max_retries):
+        try:
+            resp = client.responses.create(**payload)
+            return getattr(resp, "output_text", str(resp))
+        except Exception:
+            if attempt == max_retries - 1:
+                raise
+            time.sleep(backoff * (2 ** attempt) + random.random() * 0.25)
+
+
+def generate_baseline_topk(
+    *,
+    model: str = "gpt-5",
+    n_runs: int = 30,
+    concurrency: int = 10,
+    output_dir: str = "results_topk_baseline",
+    dev_prompt: str,
+    user_prompt: str,
+) -> Path:
+    out = Path(output_dir)
+    out.mkdir(parents=True, exist_ok=True)
+
+    def run_one(i: int):
+        text = _call_model_with_retry(model=model, dev_prompt=dev_prompt, user_prompt=user_prompt)
+        code = extract_code(text)
+        return i, code
+
+    written = 0
+    futures = []
+    with ThreadPoolExecutor(max_workers=concurrency) as pool:
+        for i in range(1, n_runs + 1):
+            futures.append(pool.submit(run_one, i))
+        for fut in as_completed(futures):
+            i, code = fut.result()
+            out_path = out / f"run_{i:02d}.py"
+            out_path.write_text(code, encoding="utf-8")
+            written += 1
+            print(f"[{written}/{n_runs}] Wrote {out_path} — remaining: {n_runs - written}")
+    print(f"Done. Saved {n_runs} files to: {out.resolve()}")
+    return out
+
+
diff --git a/examples/gpt-5/prompt-optimization-cookbook/scripts/gen_optimized.py b/examples/gpt-5/prompt-optimization-cookbook/scripts/gen_optimized.py
new file mode 100644
index 0000000000..b46c49ee88
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/scripts/gen_optimized.py
@@ -0,0 +1,65 @@
+import re
+import time
+import random
+from pathlib import Path
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import Optional
+from openai import OpenAI
+
+CODE_BLOCK = re.compile(r"```[ \t]*(?:[A-Za-z0-9_+\-]+)?[ \t]*\r?\n(.*?)```", re.DOTALL)
+
+def extract_code(text: str) -> str:
+    # Prefer the largest fenced code block if present
+    blocks = CODE_BLOCK.findall(text)
+    if blocks:
+        return max(blocks, key=len).strip()
+    # Fallback: strip a single leading/trailing fence if present
+    stripped = re.sub(r"^\s*```[^\n]*\r?\n", "", text)
+    stripped = re.sub(r"\n```[ \t]*$", "", stripped)
+    return stripped.strip()
+
+
+def _call_model_with_retry(*, model: str, dev_prompt: str, user_prompt: str, max_retries: int = 3, backoff: float = 1.0) -> str:
+    client = OpenAI()
+    payload = {
+        "model": model,
+        "input": [
+            {"role": "developer", "content": [{"type": "input_text", "text": dev_prompt}]},
+            {"role": "user", "content": [{"type": "input_text", "text": user_prompt}]},
+        ],
+        "text": {"format": {"type": "text"}, "verbosity": "medium"},
+        "reasoning": {"effort": "medium", "summary": "auto"},
+        "tools": [],
+    }
+    for attempt in range(max_retries):
+        try:
+            resp = client.responses.create(**payload)
+            return getattr(resp, "output_text", str(resp))
+        except Exception:
+            if attempt == max_retries - 1:
+                raise
+            time.sleep(backoff * (2 ** attempt) + random.random() * 0.25)
+
+
+def generate_optimized_topk(*, model: str = "gpt-5", n_runs: int = 30, concurrency: int = 10, output_dir: str = "results_topk_optimized", dev_prompt: str, user_prompt: str) -> Path:
+    out = Path(output_dir)
+    out.mkdir(parents=True, exist_ok=True)
+
+    def run_one(i: int):
+        text = _call_model_with_retry(model=model, dev_prompt=dev_prompt, user_prompt=user_prompt)
+        code = extract_code(text)
+        return i, code
+
+    written = 0
+    futures = []
+    with ThreadPoolExecutor(max_workers=concurrency) as pool:
+        for i in range(1, n_runs + 1):
+            futures.append(pool.submit(run_one, i))
+        for fut in as_completed(futures):
+            i, code = fut.result()
+            out_path = out / f"run_{i:02d}.py"
+            out_path.write_text(code, encoding="utf-8")
+            written += 1
+            print(f"[{written}/{n_runs}] Wrote {out_path} — remaining: {n_runs - written}")
+    print(f"Done. Saved {n_runs} files to: {out.resolve()}")
+    return out
diff --git a/examples/gpt-5/prompt-optimization-cookbook/scripts/llm_judge.py b/examples/gpt-5/prompt-optimization-cookbook/scripts/llm_judge.py
new file mode 100644
index 0000000000..acb4448c57
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/scripts/llm_judge.py
@@ -0,0 +1,333 @@
+import json
+import time
+from pathlib import Path
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import Dict, Optional, Tuple, Any, List
+
+from openai import OpenAI
+
+# Default task text aligned with the Top-K evaluation used in the notebook
+DEFAULT_TASK_TEXT = (
+    "Your task:\n"
+    "Compute the exact Top-K most frequent tokens from a given text.\n\n"
+    "Tokenization:\n"
+    "- Case-insensitive tokenization using an ASCII regex; produce lowercase tokens. Lowercasing the entire text is NOT required (per-token lowercasing is acceptable).\n"
+    "- Tokens are ASCII [a-z0-9]+ sequences; all other characters are separators (use a regex).\n\n"
+    "Inputs:\n"
+    "- Two globals are provided: text (string) and k (int). Do not reassign them.\n\n"
+    "Requirements:\n"
+    "1) Compute Top-K sorted by count desc, then token asc (i.e., sort key = (-count, token)).\n"
+    "2) Set top_k to a list of (token, count) tuples, length = min(k, number of unique tokens).\n"
+    "3) Handle edge cases: if k <= 0, top_k = [].\n"
+    "4) Do not use input(), file I/O, or network access. The script must run as-is with the provided globals.\n\n"
+    "Output contract:\n"
+    "- At the end of execution, top_k must be defined exactly as described.\n"
+    "- Optional: if printing, print only top_k on the last line as a Python literal or JSON.\n\n"
+    "Note:\n"
+    "- Do not rely on Counter.most_common tie ordering; implement the specified sort.\n"
+)
+
+
+def _load_system_prompt(path: Path) -> str:
+    return path.read_text(encoding="utf-8")
+
+
+def _assemble_messages(system_prompt: str, code: str, task: str) -> List[Dict[str, Any]]:
+    return [
+        {
+            "role": "developer",
+            "content": [
+                {"type": "input_text", "text": system_prompt},
+            ],
+        },
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "input_text",
+                    "text": (
+                        "Evaluate the following code output\n\n"
+                        "<code_output>\n{code}\n</code_output>\n\n"
+                        "on the following task instructions\n<task>\n{task}\n</task>"
+                    ).format(code=code, task=task),
+                }
+            ],
+        },
+    ]
+
+
+def _to_text(resp: Any) -> str:
+    if getattr(resp, "output_text", None):
+        return resp.output_text
+    try:
+        parts = []
+        for item in (getattr(resp, "output", []) or []):
+            if getattr(item, "type", None) == "message":
+                for seg in (getattr(item, "content", []) or []):
+                    if getattr(seg, "type", None) == "output_text":
+                        parts.append(getattr(seg, "text", "") or "")
+        return "".join(parts) or str(resp)
+    except Exception:
+        return str(resp)
+
+
+def _safe_parse_json(text: str) -> Tuple[Optional[dict], Optional[str]]:
+    # Try direct load
+    try:
+        return json.loads(text), None
+    except Exception as e:
+        last_err = str(e)
+    # Try to extract the largest JSON object via regex braces matching heuristic
+    try:
+        start = text.find("{")
+        end = text.rfind("}")
+        if start != -1 and end != -1 and end > start:
+            candidate = text[start : end + 1]
+            return json.loads(candidate), None
+    except Exception as e2:
+        last_err = str(e2)
+    return None, last_err
+
+
+def judge_folder(
+    *,
+    results_dir: str,
+    out_dir: Optional[str] = None,
+    model: str = "gpt-5",
+    system_prompt_path: str = "llm_as_judge.txt",
+    task_text: Optional[str] = None,
+    concurrency: int = 5,
+    max_retries: int = 3,
+    backoff: float = 1.0,
+) -> Path:
+    """
+    Evaluate each .py code file in results_dir with an LLM-as-judge and write per-file JSON judgments.
+    Returns the output directory path.
+    """
+    in_dir = Path(results_dir)
+    assert in_dir.exists(), f"Results folder not found: {in_dir}"
+
+    # Output directory
+    if out_dir is None:
+        name = in_dir.name.lower()
+        if "baseline" in name:
+            suffix = "baseline"
+        elif "optimized" in name:
+            suffix = "optimized"
+        else:
+            suffix = "baseline"
+        out_dir = in_dir.parent / f"results_llm_as_judge_{suffix}"
+    out_path = Path(out_dir)
+    out_path.mkdir(parents=True, exist_ok=True)
+
+    # Load prompts
+    system_prompt = _load_system_prompt(Path(system_prompt_path))
+    task = task_text or DEFAULT_TASK_TEXT
+
+    client = OpenAI()
+
+    def run_one(py_path: Path) -> Tuple[str, dict]:
+        code = py_path.read_text(encoding="utf-8", errors="ignore")
+        messages = _assemble_messages(system_prompt, code, task)
+
+        for attempt in range(max_retries):
+            try:
+                resp = client.responses.create(
+                    model=model,
+                    input=messages,
+                    text={"format": {"type": "text"}, "verbosity": "medium"},
+                    reasoning={"effort": "medium", "summary": "auto"},
+                    tools=[],
+                )
+                raw = _to_text(resp)
+                parsed, err = _safe_parse_json(raw)
+                result = {
+                    "file": str(py_path.name),
+                    "raw": raw,
+                    "parsed": parsed,
+                    "parse_error": err,
+                }
+                return py_path.name, result
+            except Exception as e:
+                if attempt == max_retries - 1:
+                    return py_path.name, {
+                        "file": str(py_path.name),
+                        "error": f"Request failed: {e}",
+                    }
+                time.sleep(backoff * (2 ** attempt))
+        # Should not reach
+        return py_path.name, {"file": str(py_path.name), "error": "Exhausted retries"}
+
+    py_files = sorted([p for p in in_dir.glob("*.py")])
+
+    results: Dict[str, dict] = {}
+    with ThreadPoolExecutor(max_workers=concurrency) as pool:
+        futures = {pool.submit(run_one, p): p.name for p in py_files}
+        for fut in as_completed(futures):
+            fname, res = fut.result()
+            results[fname] = res
+            # write per-file json immediately
+            out_file = out_path / f"{Path(fname).stem}.json"
+            out_file.write_text(json.dumps(res, indent=2), encoding="utf-8")
+
+    # Build a summary CSV with scores if parseable
+    import csv as _csv
+
+    summary_csv = out_path / "judgement_summary.csv"
+    with open(summary_csv, "w", newline="") as fp:
+        writer = _csv.writer(fp)
+        writer.writerow(["File", "adherence_score", "code_quality_score", "parse_error", "error"])
+        for fname in sorted(results.keys()):
+            r = results[fname]
+            adher = None
+            codeq = None
+            perr = r.get("parse_error")
+            err = r.get("error")
+            parsed = r.get("parsed")
+            if isinstance(parsed, dict):
+                fj = parsed.get("final_judgement") or {}
+                adher = fj.get("adherence_score")
+                codeq = fj.get("code_quality_score")
+            writer.writerow([fname, adher, codeq, perr or "", err or ""])
+
+    return out_path
+
+
+if __name__ == "__main__":
+    import argparse
+
+    ap = argparse.ArgumentParser(description="Run LLM-as-judge over generated scripts.")
+    ap.add_argument("--optimized_dir", default="results_topk_optimized")
+    ap.add_argument("--baseline_dir", default="results_topk_baseline")
+    ap.add_argument("--system_prompt", default="llm_as_judge.txt")
+    ap.add_argument("--model", default="gpt-5")
+    ap.add_argument("--concurrency", type=int, default=5)
+    ap.add_argument("--task_file", default=None, help="Optional path to a file containing task instructions")
+    ap.add_argument("--out_dir_baseline", default=None, help="Write judgments for baseline run to this directory (used as-is)")
+    ap.add_argument("--out_dir_optimized", default=None, help="Write judgments for optimized run to this directory (used as-is)")
+
+    args = ap.parse_args()
+
+    task_text = None
+    if args.task_file:
+        task_text = Path(args.task_file).read_text(encoding="utf-8")
+
+    # Baseline
+    judge_folder(
+        results_dir=args.baseline_dir,
+        out_dir=args.out_dir_baseline,  # used as-is if provided
+        model=args.model,
+        system_prompt_path=args.system_prompt,
+        task_text=task_text,
+        concurrency=args.concurrency,
+    )
+    # Optimized
+    judge_folder(
+        results_dir=args.optimized_dir,
+        out_dir=args.out_dir_optimized,  # used as-is if provided
+        model=args.model,
+        system_prompt_path=args.system_prompt,
+        task_text=task_text,
+        concurrency=args.concurrency,
+    )
+
+
+# --- Ad-hoc helpers for single-file judging and summary rebuild ---
+def judge_one(
+    *,
+    py_path: str,
+    out_dir: Optional[str] = None,
+    model: str = "gpt-5",
+    system_prompt_path: str = "llm_as_judge.txt",
+    task_text: Optional[str] = None,
+    max_retries: int = 3,
+    backoff: float = 1.0,
+) -> Path:
+    """Judge a single Python file and write its JSON to the appropriate output directory.
+
+    Returns the path to the written JSON.
+    """
+    in_path = Path(py_path)
+    assert in_path.exists(), f"Python file not found: {in_path}"
+
+    # Resolve output directory
+    if out_dir is None:
+        parent = in_path.parent.name.lower()
+        if "baseline" in parent:
+            suffix = "baseline"
+        elif "optimized" in parent:
+            suffix = "optimized"
+        else:
+            suffix = "baseline"
+        out_dir = in_path.parent.parent / f"results_llm_as_judge_{suffix}"
+    out_path = Path(out_dir)
+    out_path.mkdir(parents=True, exist_ok=True)
+
+    # Load prompts
+    system_prompt = _load_system_prompt(Path(system_prompt_path))
+    task = task_text or DEFAULT_TASK_TEXT
+
+    # Read code and call model
+    code = in_path.read_text(encoding="utf-8", errors="ignore")
+    messages = _assemble_messages(system_prompt, code, task)
+
+    client = OpenAI()
+    last_err: Optional[str] = None
+    for attempt in range(max_retries):
+        try:
+            resp = client.responses.create(
+                model=model,
+                input=messages,
+                text={"format": {"type": "text"}, "verbosity": "medium"},
+                reasoning={"effort": "medium", "summary": "auto"},
+                tools=[],
+            )
+            raw = _to_text(resp)
+            parsed, err = _safe_parse_json(raw)
+            result = {
+                "file": str(in_path.name),
+                "raw": raw,
+                "parsed": parsed,
+                "parse_error": err,
+            }
+            out_json = out_path / f"{in_path.stem}.json"
+            out_json.write_text(json.dumps(result, indent=2), encoding="utf-8")
+            return out_json
+        except Exception as e:
+            last_err = str(e)
+            if attempt == max_retries - 1:
+                raise
+            time.sleep(backoff * (2 ** attempt))
+
+    raise RuntimeError(f"Failed to judge {in_path}: {last_err}")
+
+
+def rebuild_summary(*, out_dir: str) -> Path:
+    """Rebuild judgement_summary.csv from all JSON files present in out_dir and return its path."""
+    base = Path(out_dir)
+    results: Dict[str, dict] = {}
+    for p in sorted(base.glob("*.json")):
+        try:
+            results[p.name] = json.loads(p.read_text(encoding="utf-8"))
+        except Exception:
+            continue
+
+    import csv as _csv
+    summary_csv = base / "judgement_summary.csv"
+    with open(summary_csv, "w", newline="") as fp:
+        writer = _csv.writer(fp)
+        writer.writerow(["File", "adherence_score", "code_quality_score", "parse_error", "error"])
+        for fname in sorted(results.keys()):
+            r = results[fname]
+            adher = None
+            codeq = None
+            perr = (r.get("parse_error") if isinstance(r, dict) else None)
+            err = (r.get("error") if isinstance(r, dict) else None)
+            parsed = r.get("parsed") if isinstance(r, dict) else None
+            if isinstance(parsed, dict):
+                fj = parsed.get("final_judgement") or {}
+                adher = fj.get("adherence_score")
+                codeq = fj.get("code_quality_score")
+            writer.writerow([r.get("file") or fname, adher, codeq, perr or "", err or ""]) 
+
+    return summary_csv
diff --git a/examples/gpt-5/prompt-optimization-cookbook/scripts/results_summarizer.py b/examples/gpt-5/prompt-optimization-cookbook/scripts/results_summarizer.py
new file mode 100644
index 0000000000..032597e055
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/scripts/results_summarizer.py
@@ -0,0 +1,348 @@
+from __future__ import annotations
+
+import csv
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+# Minimal typing-friendly containers
+@dataclass
+class QuantRow:
+    file: str
+    compiled: bool
+    exec_time_s: Optional[float]
+    peak_mem_bytes: Optional[int]
+    exact: Optional[bool]
+    sorted_ok: Optional[bool]
+    violation: Optional[str]
+
+@dataclass
+class JudgeRow:
+    file: str
+    adherence_score: Optional[float]
+    code_quality_score: Optional[float]
+    parse_error: Optional[str]
+    error: Optional[str]
+
+@dataclass
+class GroupSummary:
+    name: str
+    n_total: int
+    n_success: int
+    n_violations: int
+    exact_rate: float
+    sorted_rate: float
+    avg_time_s: Optional[float]
+    avg_peak_kb: Optional[float]
+    avg_adherence: Optional[float]
+    avg_code_quality: Optional[float]
+
+
+def _read_quant_csv(path: Path) -> List[QuantRow]:
+    rows: List[QuantRow] = []
+    with open(path, newline="") as fp:
+        r = csv.DictReader(fp)
+        for d in r:
+            compiled = str(d.get("Compiled", "")).strip().lower() == "true"
+            def _float(x):
+                try:
+                    return float(x)
+                except Exception:
+                    return None
+            def _int(x):
+                try:
+                    return int(x)
+                except Exception:
+                    return None
+            def _bool(x):
+                sx = str(x).strip().lower()
+                if sx in ("true", "false"):
+                    return sx == "true"
+                return None
+            rows.append(
+                QuantRow(
+                    file=str(d.get("File Name", "")),
+                    compiled=compiled,
+                    exec_time_s=_float(d.get("Execution Time (s)", "")),
+                    peak_mem_bytes=_int(d.get("Peak Memory (bytes)", "")),
+                    exact=_bool(d.get("Exact Match", "")),
+                    sorted_ok=_bool(d.get("Sorted Correctly", "")),
+                    violation=(d.get("Violation") if "Violation" in d else None),
+                )
+            )
+    return rows
+
+
+def _read_judge_csv(path: Path) -> List[JudgeRow]:
+    out: List[JudgeRow] = []
+    with open(path, newline="") as fp:
+        r = csv.DictReader(fp)
+        for d in r:
+            def _num(x):
+                try:
+                    return float(x)
+                except Exception:
+                    return None
+            out.append(
+                JudgeRow(
+                    file=str(d.get("File", "")),
+                    adherence_score=_num(d.get("adherence_score")),
+                    code_quality_score=_num(d.get("code_quality_score")),
+                    parse_error=d.get("parse_error"),
+                    error=d.get("error"),
+                )
+            )
+    return out
+
+
+def _avg(nums: List[float]) -> Optional[float]:
+    nums2 = [x for x in nums if x is not None]
+    if not nums2:
+        return None
+    return sum(nums2) / len(nums2)
+
+
+def summarize_groups(
+    *,
+    quant_paths: Dict[str, Path],
+    judge_paths: Dict[str, Path],
+) -> Dict[str, GroupSummary]:
+    summaries: Dict[str, GroupSummary] = {}
+    for name, qpath in quant_paths.items():
+        qrows = _read_quant_csv(qpath)
+        jrows = _read_judge_csv(judge_paths[name]) if name in judge_paths and judge_paths[name].exists() else []
+        jmap = {Path(j.file).stem: j for j in jrows}
+
+        n_total = len(qrows)
+        n_success = sum(1 for r in qrows if r.compiled)
+        n_viol = sum(1 for r in qrows if (r.violation or "").strip())
+        exact_rate = (
+            sum(1 for r in qrows if r.exact) / n_success if n_success else 0.0
+        )
+        sorted_rate = (
+            sum(1 for r in qrows if r.sorted_ok) / n_success if n_success else 0.0
+        )
+        avg_time_s = _avg([r.exec_time_s for r in qrows if r.compiled and r.exec_time_s is not None])
+        avg_peak_kb = _avg([
+            (r.peak_mem_bytes or 0) / 1024.0 for r in qrows if r.compiled and r.peak_mem_bytes is not None
+        ])
+
+        # Judge averages
+        avg_adherence = _avg([jr.adherence_score for jr in jrows if jr.adherence_score is not None])
+        avg_codeq = _avg([jr.code_quality_score for jr in jrows if jr.code_quality_score is not None])
+
+        summaries[name] = GroupSummary(
+            name=name,
+            n_total=n_total,
+            n_success=n_success,
+            n_violations=n_viol,
+            exact_rate=exact_rate,
+            sorted_rate=sorted_rate,
+            avg_time_s=avg_time_s,
+            avg_peak_kb=avg_peak_kb,
+            avg_adherence=avg_adherence,
+            avg_code_quality=avg_codeq,
+        )
+    return summaries
+
+
+def render_charts(
+    *,
+    quant_baseline: Path = Path("results_topk_baseline") / "run_results_topk_baseline.csv",
+    quant_optimized: Path = Path("results_topk_optimized") / "run_results_topk_optimized.csv",
+    judge_baseline: Path = Path("results_llm_as_judge_baseline") / "judgement_summary.csv",
+    judge_optimized: Path = Path("results_llm_as_judge_optimized") / "judgement_summary.csv",
+    auto_display: bool = False,
+    close_after: bool = False,
+):
+    import matplotlib.pyplot as plt
+    # seaborn optional
+    try:
+        import seaborn as sns  # type: ignore
+        sns.set_theme(style="whitegrid")
+    except Exception:
+        pass
+
+    quant_paths = {
+        "baseline": Path(quant_baseline),
+        "optimized": Path(quant_optimized),
+    }
+    judge_paths = {
+        "baseline": Path(judge_baseline),
+        "optimized": Path(judge_optimized),
+    }
+    summaries = summarize_groups(quant_paths=quant_paths, judge_paths=judge_paths)
+
+    # Build figure with subplots
+    fig, axes = plt.subplots(2, 3, figsize=(15, 8))
+    labels = ["baseline", "optimized"]
+
+    # Helper to fetch values in label order
+    def vals(key: str) -> List[float]:
+        out: List[float] = []
+        for l in labels:
+            v = getattr(summaries[l], key)
+            out.append(v if v is not None else 0.0)
+        return out
+
+    # 1) Avg exec time
+    ax = axes[0, 0]
+    ax.bar(labels, vals("avg_time_s"), color=["#cbd5e1", "#60a5fa"])  # slate-200, blue-400
+    ax.set_title("Average Execution Time (s)")
+
+    # 2) Avg peak memory
+    ax = axes[0, 1]
+    ax.bar(labels, vals("avg_peak_kb"), color=["#cbd5e1", "#60a5fa"])
+    ax.set_title("Average Peak Memory (KB)")
+
+    # 3) Success & Violation stacked bars
+    ax = axes[0, 2]
+    succ = [summaries[l].n_success for l in labels]
+    viol = [summaries[l].n_violations for l in labels]
+    total = [summaries[l].n_total for l in labels]
+    fail = [total[i] - succ[i] - viol[i] for i in range(len(labels))]
+    ax.bar(labels, succ, label="Success", color="#22c55e")
+    ax.bar(labels, viol, bottom=succ, label="Violation", color="#f59e0b")
+    ax.bar(labels, fail, bottom=[succ[i] + viol[i] for i in range(len(labels))], label="Fail", color="#ef4444")
+    ax.set_title("Outcome Breakdown")
+    ax.legend()
+
+    # 4) Exact rate
+    ax = axes[1, 0]
+    ax.bar(labels, [summaries[l].exact_rate * 100 for l in labels], color=["#cbd5e1", "#60a5fa"])
+    ax.set_title("Exact Match Rate (%)")
+
+    # 5) Sorted correct rate
+    ax = axes[1, 1]
+    ax.bar(labels, [summaries[l].sorted_rate * 100 for l in labels], color=["#cbd5e1", "#60a5fa"])
+    ax.set_title("Sorted Correctly Rate (%)")
+
+    # 6) LLM scores (adherence vs code quality)
+    ax = axes[1, 2]
+    x = range(len(labels))
+    width = 0.35
+    adher = vals("avg_adherence")
+    codeq = vals("avg_code_quality")
+    ax.bar([i - width / 2 for i in x], adher, width=width, label="Adherence", color="#0ea5e9")
+    ax.bar([i + width / 2 for i in x], codeq, width=width, label="Code Quality", color="#8b5cf6")
+    ax.set_xticks(list(x))
+    ax.set_xticklabels(labels)
+    ax.set_title("LLM-as-Judge Scores")
+    ax.legend()
+
+    fig.tight_layout()
+
+    # Optional in-function display for notebook convenience
+    if auto_display:
+        try:
+            from IPython.display import display  # type: ignore
+            display(fig)
+        except Exception:
+            pass
+        if close_after:
+            try:
+                plt.close(fig)
+            except Exception:
+                pass
+
+    return fig, summaries
+
+
+def print_text_summaries(summaries: Dict[str, GroupSummary]):
+    for k in ("baseline", "optimized"):
+        s = summaries.get(k)
+        if not s:
+            continue
+        print(f"\n=== {k.upper()} ===")
+        print(f"Total: {s.n_total}, Success: {s.n_success}, Violations: {s.n_violations}")
+        if s.avg_time_s is not None:
+            print(f"Avg Time: {s.avg_time_s:.3f}s")
+        if s.avg_peak_kb is not None:
+            print(f"Avg Peak Memory: {s.avg_peak_kb:.1f} KB")
+        print(f"Exact Rate: {s.exact_rate*100:.1f}% | Sorted Rate: {s.sorted_rate*100:.1f}%")
+        if s.avg_adherence is not None or s.avg_code_quality is not None:
+            print(
+                f"LLM Scores — Adherence: {s.avg_adherence or 'NA'}, Code Quality: {s.avg_code_quality or 'NA'}"
+            )
+
+
+if __name__ == "__main__":
+    import argparse
+    import matplotlib.pyplot as plt
+
+    ap = argparse.ArgumentParser(description="Summarize and visualize results.")
+    ap.add_argument("--quant_baseline", default=str(Path("results_topk_baseline") / "run_results_topk_baseline.csv"))
+    ap.add_argument("--quant_opt", default=str(Path("results_topk_optimized") / "run_results_topk_optimized.csv"))
+    ap.add_argument("--judge_baseline", default=str(Path("results_llm_as_judge_baseline") / "judgement_summary.csv"))
+    ap.add_argument("--judge_opt", default=str(Path("results_llm_as_judge_optimized") / "judgement_summary.csv"))
+
+    args = ap.parse_args()
+
+    fig, summaries = render_charts(
+        quant_baseline=Path(args.quant_baseline),
+        quant_optimized=Path(args.quant_opt),
+        judge_baseline=Path(args.judge_baseline),
+        judge_optimized=Path(args.judge_opt),
+    )
+    print_text_summaries(summaries)
+    plt.show()
+
+
+def build_markdown_summary(
+    *,
+    quant_baseline: Path = Path("results_topk_baseline") / "run_results_topk_baseline.csv",
+    quant_optimized: Path = Path("results_topk_optimized") / "run_results_topk_optimized.csv",
+    judge_baseline: Path = Path("results_llm_as_judge_baseline") / "judgement_summary.csv",
+    judge_optimized: Path = Path("results_llm_as_judge_optimized") / "judgement_summary.csv",
+) -> str:
+    """Return a Markdown table comparing baseline vs optimized metrics with deltas.
+
+    This is a pure function that reads the CSVs and produces Markdown suitable for Jupyter display.
+    """
+    summaries = summarize_groups(
+        quant_paths={
+            "baseline": Path(quant_baseline),
+            "optimized": Path(quant_optimized),
+        },
+        judge_paths={
+            "baseline": Path(judge_baseline),
+            "optimized": Path(judge_optimized),
+        },
+    )
+
+    base = summaries["baseline"]
+    opt = summaries["optimized"]
+
+    def _fmt(x: Optional[float], n: int = 3) -> str:
+        return (f"{x:.{n}f}" if x is not None else "NA")
+
+    def _sign(x: float) -> str:
+        return "+" if x > 0 else ""
+
+    rows: List[str] = []
+
+    def _add_row(label: str, b: Optional[float], o: Optional[float], places: int) -> None:
+        delta_str = "NA"
+        if b is not None and o is not None:
+            delta = o - b
+            delta_str = f"{_sign(delta)}{_fmt(delta, places)}"
+        rows.append(
+            f"| {label:<27} | {_fmt(b, places):>8} | {_fmt(o, places):>9} | {delta_str:>13} |"
+        )
+
+    header = (
+        "| Metric                      | Baseline | Optimized | Δ (Opt − Base) |\n"
+        "|----------------------------|---------:|----------:|---------------:|"
+    )
+
+    _add_row("Avg Time (s)", base.avg_time_s, opt.avg_time_s, 3)
+    _add_row("Peak Memory (KB)", base.avg_peak_kb, opt.avg_peak_kb, 1)
+    _add_row("Exact (%)", (base.exact_rate * 100.0), (opt.exact_rate * 100.0), 1)
+    _add_row("Sorted (%)", (base.sorted_rate * 100.0), (opt.sorted_rate * 100.0), 1)
+    _add_row("LLM Adherence (1–5)", base.avg_adherence, opt.avg_adherence, 2)
+    _add_row("Code Quality (1–5)", base.avg_code_quality, opt.avg_code_quality, 2)
+
+    body = "\n".join(rows)
+    md = f"### Prompt Optimization Results - Coding Tasks\n\n{header}\n{body}"
+    return md
diff --git a/examples/gpt-5/prompt-optimization-cookbook/scripts/topk_eval.py b/examples/gpt-5/prompt-optimization-cookbook/scripts/topk_eval.py
new file mode 100644
index 0000000000..0ab24c4617
--- /dev/null
+++ b/examples/gpt-5/prompt-optimization-cookbook/scripts/topk_eval.py
@@ -0,0 +1,311 @@
+import os
+import io
+import re
+import csv
+import json
+import ast
+import time
+import tracemalloc
+import runpy
+from pathlib import Path
+from contextlib import redirect_stdout
+from collections import Counter
+from typing import Optional
+
+TOKEN_RE = re.compile(r"[a-z0-9]+")
+
+# Disallowed usage (static scan)
+DISALLOWED_IMPORTS = {
+    "sqlite3": "external_storage",
+    "tempfile": "external_storage",
+    "shelve": "external_storage",
+    "requests": "network",
+    "urllib": "network",
+    "http": "network",
+    "socket": "network",
+}
+DISALLOWED_PATTERNS = [
+    ("file_io", re.compile(r"(?<![\w\.])open\(")),
+]
+
+
+def evaluate_folder(
+    folder_path: str,
+    k: int = 500,
+    scale_tokens: int = 5_000_000,
+    csv_path: Optional[str] = None,
+) -> dict:
+    # === Build deterministic, more intense dataset with many ties near Top-K ===
+    import random
+
+    random.seed(1337)
+    vocab_top = [f"w{i:04d}" for i in range(1, 401)]
+    vocab_tail = [f"w{i:04d}" for i in range(401, 5001)]
+
+    counts_plan = {}
+
+    # Head: decreasing counts
+    for i, tok in enumerate(vocab_top[:150], start=1):
+        c = max(1200, int(5000 / (i ** 0.5)))
+        counts_plan[tok] = c
+
+    # Plateau: create many equal-count tokens to stress tie-breaking near K
+    plateau_tokens = vocab_top[150:350]  # 200 tokens
+    for tok in plateau_tokens:
+        counts_plan[tok] = 1000
+
+    # Remainder of top block
+    for tok in vocab_top[350:400]:
+        counts_plan[tok] = 900
+
+    # Materialize text via generator to avoid a huge list
+    residual = max(0, scale_tokens - sum(counts_plan.values()))
+    tail_vocab = vocab_tail
+
+    def iter_tokens():
+        for tok, c in counts_plan.items():
+            for _ in range(c):
+                yield tok
+        for i in range(residual):
+            yield tail_vocab[i % len(tail_vocab)]
+
+    test_text = " ".join(iter_tokens())
+
+    # === Ground truth (from construction plan) ===
+    counts = Counter()
+    counts.update(counts_plan)
+    for i in range(residual):
+        counts[tail_vocab[i % len(tail_vocab)]] += 1
+
+    def topk_from_counts(cnt: Counter, k: int):
+        items = list(cnt.items())
+        items.sort(key=lambda x: (-x[1], x[0]))
+        return items[:k]
+
+    ground_truth = topk_from_counts(counts, k)
+
+    # === Helpers ===
+    def coerce_topk(obj):
+        if isinstance(obj, list):
+            out = []
+            for it in obj:
+                if isinstance(it, (list, tuple)) and len(it) == 2 and isinstance(it[0], str) and isinstance(it[1], (int, float)):
+                    out.append((it[0], int(it[1])))
+                else:
+                    return None
+            return out
+        return None
+
+    def parse_topk_from_stdout(stdout_str):
+        lines = [ln.strip() for ln in stdout_str.strip().splitlines() if ln.strip()]
+        for candidate in reversed(lines):
+            try:
+                val = ast.literal_eval(candidate)
+                coerced = coerce_topk(val)
+                if coerced is not None:
+                    return coerced
+            except Exception:
+                pass
+        return None
+
+    def is_sorted_topk(pairs):
+        return all((pairs[i][1] > pairs[i+1][1]) or (pairs[i][1] == pairs[i+1][1] and pairs[i][0] <= pairs[i+1][0]) for i in range(len(pairs)-1))
+
+    def precision_at_k(pred, truth):
+        pred_tokens = {t for t, _ in (pred[:k] if isinstance(pred, list) else [])}
+        truth_tokens = {t for t, _ in truth[:k]}
+        if not pred_tokens:
+            return 0.0
+        return len(pred_tokens & truth_tokens) / min(len(pred_tokens), k)
+
+    def scan_constraints(src: str) -> Optional[str]:
+        # Imports
+        for name, tag in DISALLOWED_IMPORTS.items():
+            # simple import detection
+            if re.search(rf"\bimport\s+{re.escape(name)}\b|\bfrom\s+{re.escape(name)}\b", src):
+                return f"Constraint violation: disallowed import '{name}' ({tag})"
+        # Patterns
+        for tag, rx in DISALLOWED_PATTERNS:
+            if rx.search(src):
+                return f"Constraint violation: disallowed pattern '{tag}'"
+        return None
+
+    # === Warm-up (optional) ===
+    py_files = sorted([f for f in os.listdir(folder_path) if f.endswith(".py")])
+    if py_files:
+        warmup_path = os.path.join(folder_path, py_files[0])
+        try:
+            _ = runpy.run_path(warmup_path, run_name="__main__", init_globals={"text": test_text, "k": k})
+            tracemalloc.start()
+            _ = tracemalloc.get_traced_memory()
+            tracemalloc.stop()
+        except Exception:
+            pass
+
+    # === Evaluation ===
+    rows = []
+    compile_success_count = 0
+    total_time = 0.0
+    total_mem = 0
+    exact_count = 0
+    sorted_ok_count = 0
+    violation_count = 0
+
+    for file_name in py_files:
+        file_path = os.path.join(folder_path, file_name)
+
+        # Static constraint scan
+        violation = None
+        try:
+            src_text = Path(file_path).read_text(encoding="utf-8", errors="ignore")
+            violation = scan_constraints(src_text)
+        except Exception:
+            pass
+
+        if violation:
+            violation_count += 1
+            rows.append([file_name, False, "", "", "", ground_truth[:5], violation, "", "", violation])
+            continue
+
+        f = io.StringIO()
+        tracemalloc.start()
+        start = time.perf_counter()
+        peak_mem = None
+        result = None
+
+        try:
+            with redirect_stdout(f):
+                namespace = runpy.run_path(file_path, run_name="__main__", init_globals={"text": test_text, "k": k})
+            elapsed = time.perf_counter() - start
+            _, peak_mem = tracemalloc.get_traced_memory()
+            tracemalloc.stop()
+            compile_success_count += 1
+
+            stdout_str = f.getvalue()
+            # prefer namespace variable
+            if "top_k" in namespace:
+                result = coerce_topk(namespace["top_k"])
+            if result is None:
+                result = parse_topk_from_stdout(stdout_str)
+
+            total_time += elapsed
+            total_mem += (peak_mem or 0)
+
+            is_exact = (result == ground_truth)
+            if is_exact:
+                exact_count += 1
+
+            is_sorted_ok = bool(result) and is_sorted_topk(result)
+            if is_sorted_ok:
+                sorted_ok_count += 1
+
+            p_at_k = precision_at_k(result or [], ground_truth)
+
+            rows.append([
+                file_name,
+                True,
+                elapsed,
+                peak_mem,
+                (result[:5] if isinstance(result, list) else ""),
+                (ground_truth[:5]),
+                is_exact,
+                is_sorted_ok,
+                f"{p_at_k:.3f}",
+                "",
+            ])
+
+        except Exception as e:
+            try:
+                tracemalloc.stop()
+            except Exception:
+                pass
+            rows.append([file_name, False, "", "", "", ground_truth[:5], f"Runtime/Import Error: {e}", "", "", ""])
+
+    # === Write CSV (allow caller to pass a directory or explicit file) ===
+    base_dir = Path(folder_path)
+    base_dir.mkdir(parents=True, exist_ok=True)
+    name = base_dir.name.lower()
+    if "baseline" in name:
+        default_name = "run_results_topk_baseline.csv"
+    elif "optimized" in name:
+        default_name = "run_results_topk_optimized.csv"
+    else:
+        default_name = "run_results_topk.csv"
+
+    # If csv_path is provided:
+    # - If it's absolute, use it as-is
+    # - If it's relative, resolve it under folder_path (base_dir) so results live with the evaluated runs
+    # - If it's a directory, place the default file name inside it
+    if csv_path:
+        csv_path_obj = Path(csv_path)
+        if not csv_path_obj.is_absolute():
+            csv_path_obj = (base_dir / csv_path_obj)
+        if csv_path_obj.suffix.lower() != ".csv":
+            csv_path_obj = csv_path_obj / default_name
+        csv_path_obj.parent.mkdir(parents=True, exist_ok=True)
+    else:
+        csv_path_obj = base_dir / default_name
+
+    with open(csv_path_obj, "w", newline="") as fp:
+        writer = csv.writer(fp)
+        writer.writerow([
+            "File Name",
+            "Compiled",
+            "Execution Time (s)",
+            "Peak Memory (bytes)",
+            "Reported Top-K (first 5)",
+            "Ground Truth (first 5)",
+            "Exact Match",
+            "Sorted Correctly",
+            "Precision@K",
+            "Violation",
+        ])
+        writer.writerows(rows)
+
+    # === Summary files (inside same folder) ===
+    total_runs = len(py_files)
+    avg_time = (total_time / compile_success_count) if compile_success_count else None
+    avg_peak_kb = (total_mem / compile_success_count / 1024) if compile_success_count else None
+    summary = {
+        "total_runs": total_runs,
+        "successes": compile_success_count,
+        "avg_exec_time_s": avg_time,
+        "avg_peak_mem_kb": avg_peak_kb,
+        "exact_matches": exact_count,
+        "sorted_correctly": sorted_ok_count,
+        "violations": violation_count,
+        "csv": str(csv_path_obj),
+        "folder": str(base_dir),
+        "k": k,
+        "scale_tokens": scale_tokens,
+    }
+    summary_json = csv_path_obj.with_name(csv_path_obj.stem + "_summary.json")
+    summary_txt = csv_path_obj.with_name(csv_path_obj.stem + "_summary.txt")
+    with open(summary_json, "w") as fp:
+        json.dump(summary, fp, indent=2)
+    with open(summary_txt, "w") as fp:
+        fp.write("===== SUMMARY =====\n")
+        fp.write(f"Total evaluated runs: {total_runs}\n")
+        fp.write(f"Compilation/Execution Success: {compile_success_count}/{total_runs} ({(compile_success_count/total_runs)*100:.2f}%)\n")
+        fp.write(f"Violations (static scan): {violation_count}\n")
+        if compile_success_count > 0:
+            fp.write(f"Average Execution Time (successful): {avg_time:.6f} s\n")
+            fp.write(f"Average Peak Memory (successful): {avg_peak_kb:.2f} KB\n")
+            fp.write(f"Exact matches: {exact_count}/{compile_success_count}\n")
+            fp.write(f"Sorted correctly: {sorted_ok_count}/{compile_success_count}\n")
+        fp.write(f"CSV written to: {csv_path_obj}\n")
+
+    print("===== SUMMARY =====")
+    print(f"Total evaluated runs: {total_runs}")
+    print(f"Compilation/Execution Success: {compile_success_count}/{total_runs} ({(compile_success_count/total_runs)*100:.2f}%)")
+    print(f"Violations (static scan): {violation_count}")
+    if compile_success_count > 0:
+        print(f"Average Execution Time (successful): {avg_time:.6f} s")
+        print(f"Average Peak Memory (successful): {avg_peak_kb:.2f} KB")
+        print(f"Exact matches: {exact_count}/{compile_success_count}")
+        print(f"Sorted correctly: {sorted_ok_count}/{compile_success_count}")
+    print(f"\nCSV written to: {csv_path_obj}")
+    print(f"Summary JSON written to: {summary_json}")
+    print(f"Summary TXT written to: {summary_txt}")
+
+    return summary
diff --git a/examples/o-series/o3o4-mini_prompting_guide.ipynb b/examples/o-series/o3o4-mini_prompting_guide.ipynb
index 5370726b55..8728e8d902 100644
--- a/examples/o-series/o3o4-mini_prompting_guide.ipynb
+++ b/examples/o-series/o3o4-mini_prompting_guide.ipynb
@@ -60,7 +60,7 @@
     "```\n",
     "check to see if directories exist before making files\n",
     "```\n",
-    "For high volume and well defined tasks, we can make it even more robust by outlining the sequence of function to call explicitly, for example:\n",
+    "For high volume and well defined tasks, we can make it even more robust by outlining the sequence of functions to call explicitly, for example:\n",
     "```\n",
     "To Process a refund for a delivered order, follow the following steps:\n",
     "1. Confirm the order was delivered. Use: `order_status_check`\n",
@@ -154,8 +154,8 @@
     "Do NOT promise to call a function later. If a function call is required, emit it now; otherwise respond normally.\n",
     "```\n",
     "\n",
-    "2. Catch bad arguments early: \n",
-    "Setting `strict` to `true` will ensure function calls reliably adhere to the [function schema](https://platform.openai.com/docs/guides/function-calling?api-mode=responses#strict-mode). We recommend turning it on whenever possible.\n",
+    "2. Catch bad arguments early:\n",
+    "setting `strict` to `true` will ensure function calls reliably adhere to the [function schema](https://platform.openai.com/docs/guides/function-calling?api-mode=responses#strict-mode). We recommend turning it on whenever possible.\n",
     "\n",
     "If your arguments have additional complex format requirements (e.g valid python code etc), adding the following instruction can remind the model of the expected format. \n",
     "\n",
@@ -163,20 +163,20 @@
     "Validate arguments against the format before sending the call; if you are unsure, ask for clarification instead of guessing.\n",
     "```\n",
     "\n",
-    "3. Another note on lazy behavior\n",
-    "We are aware of rare instances of lazy behavior from o3, such as stating it does not have enough time to complete a task, promising to follow up separately, or giving terse answers even when explicitly prompted to provide more detail. We have found that the following steps help ameliorate this behavior:\n",
+    "3. Another note on lazy behavior:\n",
+    "we are aware of rare instances of lazy behavior from o3, such as stating it does not have enough time to complete a task, promising to follow up separately, or giving terse answers even when explicitly prompted to provide more detail. We have found that the following steps help ameliorate this behavior:\n",
     "\n",
-    "    a. Start a new conversation for unrelated topics:\n",
+    "    a. Start a new conversation for unrelated topics:  \n",
     "       When switching to a new or unrelated topic, begin a fresh conversation thread rather than continuing in the same context. This helps the model focus on the current subject and prevents it from being influenced by previous, irrelevant context, which can sometimes lead to incomplete or lazy responses. For example, if you were previously discussing code debugging and now want to ask about documentation best practices, which does not require previous conversation context, start a new conversation to ensure clarity and focus.\n",
     "\n",
-    "    b. Discard irrelevant past tool calls/outputs when the list gets too long, and summarize them as context in the user message:\n",
+    "    b. Discard irrelevant past tool calls/outputs when the list gets too long, and summarize them as context in the user message:  \n",
     "       If the conversation history contains a long list of previous tool calls or outputs that are no longer relevant, remove them from the context. Instead, provide a concise summary of the important information as part of the user message. This keeps the context manageable and ensures the model has access to only the most pertinent information. For instance, if you have a lengthy sequence of tool outputs, you can summarize the key results and include only that summary in your next message.\n",
     "\n",
     "    c. We are constantly improving our models and expect to have this issue addressed in future versions.\n",
     "\n",
     "\n",
     "### Avoid Chain of Thought Prompting\n",
-    "Since these models are reasoning models and produce an internal chain of thought, they do not have to be explicitly prompted to plan and reason between toolcalls. Therefore, a developer should not try to induce additional reasoning before each function call by asking the model to plan more extensively. Asking a reasoning model to reason more may actually hurt the performance. \n",
+    "Since these models are reasoning models and produce an internal chain of thought, they do not have to be explicitly prompted to plan and reason between tool calls. Therefore, a developer should not try to induce additional reasoning before each function call by asking the model to plan more extensively. Asking a reasoning model to reason more may actually hurt the performance. \n",
     "\n",
     "A quick side note on reasoning summaries: the models will output reasoning tokens before calling tools. However, these will not always be accompanied by a summary, since our reasoning summaries require a minimum number of material reasoning tokens to produce a summary.\n"
    ]
@@ -188,7 +188,7 @@
     "# Responses API\n",
     "\n",
     "### Reasoning Items for Better Performance\n",
-    "We’ve released a [cookbook](https://cookbook.openai.com/examples/responses_api/reasoning_items) detailing the benefits of using the responses API. It is worth restating a few of the main points in this guide as well. o3/o4-mini are both trained with its internal reasoning persisted between toolcalls within a single turn. Persisting these reasoning items between toolcalls during inference will therefore lead to higher intelligence and performance in the form of better decision in when and how a tool gets called. Responses allow you to persist these reasoning items (maintained either by us or yourself through encrypted content if you do not want us to handle state-management) while Chat Completion doesn’t. Switching to the responses API and allowing the model access to reasoning items between function calls is the easiest way to squeeze out as much performance as possible for function calls. Here is an the example in the cookbook, reproduced for convenience, showing how you can pass back the reasoning item using `encrypted_content` in a way which we do not retain any state on our end:\n"
+    "We’ve released a [cookbook](https://cookbook.openai.com/examples/responses_api/reasoning_items) detailing the benefits of using the responses API. It is worth restating a few of the main points in this guide as well. o3/o4-mini are both trained with its internal reasoning persisted between tool calls within a single turn. Persisting these reasoning items between tool calls during inference will therefore lead to higher intelligence and performance in the form of better decision in when and how a tool gets called. Responses allow you to persist these reasoning items (maintained either by us or yourself through encrypted content if you do not want us to handle state-management) while Chat Completion doesn’t. Switching to the responses API and allowing the model access to reasoning items between function calls is the easiest way to squeeze out as much performance as possible for function calls. Here is an the example in the cookbook, reproduced for convenience, showing how you can pass back the reasoning item using `encrypted_content` in a way which we do not retain any state on our end:\n"
    ]
   },
   {
@@ -366,9 +366,9 @@
     "**A:** Not guaranteed. The guidance in this document assumes you’re using the standard `tools` model parameter to pass your function schemas, as shown in our [general guide](https://platform.openai.com/docs/guides/function-calling) on function calling. Our o3/o4-mini models are trained to understand and use these schemas natively for tool selection and argument construction.\n",
     "\n",
     "If you’re instead providing custom tool definitions via natural language in a developer-authored prompt (e.g., defining tools inline in the developer message or user message), this guidance may not fully apply. In those cases:\n",
-    "The model is not relying on its internal tool-schema priors\n",
-    "You may need to be more explicit with few-shot examples, output formats, and tool selection criteria\n",
-    "Argument construction reliability may degrade without schema-level anchoring\n",
+    "The model is not relying on its internal tool-schema priors. \n",
+    "You may need to be more explicit with few-shot examples, output formats, and tool selection criteria. \n",
+    "Argument construction reliability may degrade without schema-level anchoring.\n",
     "\n",
     "Use the structured tools parameter when possible. If you must define tools in free text, treat it as a custom protocol and test accordingly.\n"
    ]
diff --git a/examples/partners/temporal_agents_with_knowledge_graphs/Appendix.ipynb b/examples/partners/temporal_agents_with_knowledge_graphs/Appendix.ipynb
new file mode 100644
index 0000000000..308fe7f973
--- /dev/null
+++ b/examples/partners/temporal_agents_with_knowledge_graphs/Appendix.ipynb
@@ -0,0 +1,671 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "dd2b3250-1764-4cef-b3e0-b5fa1be924e9",
+   "metadata": {},
+   "source": [
+    "<h1 style=\"font-size:36px; line-height:1.1;\">Appendix: Temporal Agents with Knowledge Graphs</h1>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "82627a01-5e76-4046-982d-bc59a1d768fd",
+   "metadata": {},
+   "source": [
+    "This notebook contains an appendix to the **Temporal Agents with Knowledge Graphs** cookbook. \n",
+    "\n",
+    "Within this appendix, you'll find a more in-depth *Prototype to Production* section. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3f70ab4a-e04a-44aa-8e75-f9c15be22c5f",
+   "metadata": {},
+   "source": [
+    "# A. Prototype to Production\n",
+    "---"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b97b1677-7c77-4bad-bdfe-b541901c3b81",
+   "metadata": {},
+   "source": [
+    "## A.1. Storing and Retrieving High-Volume Graph Data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ada5b662-f493-41e3-a5f5-85f92dec61c0",
+   "metadata": {},
+   "source": [
+    "### A.1.1. Data Volume & Schema Complexity"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8a1009ec-9885-486a-ab69-5d86720389a6",
+   "metadata": {},
+   "source": [
+    "As your dataset scales to millions or even billions of nodes and edges, managing performance and maintainability becomes critical. This requires thoughtful approaches to both schema design and data partitioning:\n",
+    "\n",
+    "<ol style=\"margin-left: 1em; line-height: 1.6; padding-left: 0.5em;\">\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Schema design for growth and change</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Clearly define core entity types (e.g., <code>Person</code>, <code>Organization</code>, <code>Event</code>) and relationships. Design the schema with versioning and flexibility in mind, enabling future schema evolution with minimal downtime.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Sharding &amp; partitioning</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Use high-cardinality fields (such as timestamps or unique entity IDs) for partitioning to preserve query performance as data volume grows. This is particularly important for temporally-aware data. For example:\n",
+    "    </p>\n",
+    "  \n",
+    "  ```sql  \n",
+    "  CREATE TABLE statements (\n",
+    "    statement_id UUID PRIMARY KEY,\n",
+    "    entity_id UUID NOT NULL,\n",
+    "    text TEXT NOT NULL,\n",
+    "    valid_from TIMESTAMP NOT NULL,\n",
+    "    valid_to TIMESTAMP,\n",
+    "    status VARCHAR(16) DEFAULT 'active',\n",
+    "    embedding VECTOR(1536),\n",
+    "    ...\n",
+    "  ) PARTITION BY RANGE (valid_from);\n",
+    "  ```\n",
+    "  </li>\n",
+    "</ol>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f91fa408-9b9c-4fc5-9471-c0ccbc49bbae",
+   "metadata": {},
+   "source": [
+    "### A.1.2. Temporal Validity & Versioning"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cb172a41-c085-4fc3-b7b4-80d22c3dbabf",
+   "metadata": {},
+   "source": [
+    "In our temporal knowledge graph, each statement includes temporal markers (e.g., `valid_from`, `valid_to`). \n",
+    "\n",
+    "<ol style=\"margin-left: 1em; line-height: 1.6; padding-left: 0.5em;\">\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Preserve history non-destructively</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Avoid deleting or overwriting records. Instead mark outdated facts as inactive by setting a <code>status</code> (e.g., <code>inactive</code>).\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Optimize for temporal access</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Index temporal fields (<code>valid_from</code>, <code>valid_to</code>) to support efficient querying of both current and historical states.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "</ol>\n",
+    "\n",
+    "\n",
+    "#### Example: Non-Destructive Updates\n",
+    "\n",
+    "Rather than removing or overwriting a record, update its status and close its validity window:\n",
+    "\n",
+    "```sql\n",
+    "UPDATE statements\n",
+    "SET status = 'inactive', valid_to = '2025-03-15T00:00:00Z'\n",
+    "WHERE statement_id = '...' AND entity_id = '...';\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "58caf1c8-49ae-46a9-bb16-8c767c21a362",
+   "metadata": {},
+   "source": [
+    "### A.1.3. Indexing & Semantic Search"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e982b9c7-611c-4e29-9b56-d52fbdc844b1",
+   "metadata": {},
+   "source": [
+    "##### Temporal Indexes\n",
+    "To support efficient temporal queries create B-tree indexes on `valid_from` and `valid_to`. A 'B-tree' index is a tree data structure that keeps data sorted to facilitate fast lookups, range queries, and ordered scans in logarithmic time. It's the default index type in many relational databases. \n",
+    "\n",
+    "```sql\n",
+    "CREATE INDEX ON statements (valid_from);\n",
+    "CREATE INDEX ON statements (valid_to);\n",
+    "```\n",
+    "##### Semantic search with pgvector\n",
+    "Storing vector embeddings in PostgreSQL (via the `pgvector` extension) enables similarity-based retrieval via semantic search. This follows a two-step process:\n",
+    "1. Store high-dimensional vectors that represent the semantic meaning of the text. These can be created with embedding models such as OpenAI's `text-embedding-3-small` and `text-embedding-3-large`\n",
+    "2. Use Approximate Nearest-Neighbour (ANN) for efficient similarity matching at scale\n",
+    "\n",
+    "There are several different indexing options available in pgvector, each with different purposes. These indexing options are described in more detail, along with in-depth implementation steps in the [README on the Github repository for pgvector](https://github.com/pgvector/pgvector/blob/master/README.md).\n",
+    "| <div align=\"center\">Index Type</div> | <div align=\"center\">Build Time</div> | <div align=\"center\">Query Speed</div> | <div align=\"center\">Memory Usage</div> | <div align=\"center\">Accuracy</div> | <div align=\"center\">Recommended Scale</div> | Notes |\n",
+    "|-------------------------------------|--------------------------------------|----------------------------------------|-----------------------------------------|-----------------------------------|----------------------------------------------|-------|\n",
+    "| <div align=\"center\">**flat**</div> | <div align=\"center\">Minimal</div> | <div align=\"center\">Slow<br>(linear scan)</div> | <div align=\"center\">Low</div> | <div align=\"center\">100%<br>(exact)</div> | <div align=\"center\">Very small<br>(&lt; 100 K vectors)</div> | No approximate indexing—scans all vectors. Best for exact recall on small collections |\n",
+    "| <div align=\"center\">**ivfflat**</div> | <div align=\"center\">Moderate</div> | <div align=\"center\">Fast when tuned</div> | <div align=\"center\">Moderate</div> | <div align=\"center\">High<br>(tunable)</div> | <div align=\"center\">Small to Medium<br>(100 K–200 M)</div> | Uses inverted file indexing. Query-time parameters control trade-offs |\n",
+    "| <div align=\"center\">**ivfpq**</div> | <div align=\"center\">High</div> | <div align=\"center\">Very fast</div> | <div align=\"center\">Low<br>(quantized)</div> | <div align=\"center\">Slightly lower<br>than ivfflat</div> | <div align=\"center\">Medium to Large<br>(1 M–500 M)</div> | Combines inverted files with product quantization for lower memory use |\n",
+    "| <div align=\"center\">**hnsw**</div> | <div align=\"center\">Highest</div> | <div align=\"center\">Fastest<br>(esp. at scale)</div> | <div align=\"center\">High<br>(in-memory)</div> | <div align=\"center\">Very high</div> | <div align=\"center\">Large to Very Large<br>(100 M–Billions+)</div> | Builds a hierarchical navigable graph. Ideal for latency-sensitive, high-scale systems |\n",
+    "\n",
+    "\n",
+    "##### Tuning parameters for vector indexing\n",
+    "\n",
+    "`ivfflat`\n",
+    "* `lists`: Number of partitions (e.g., 100)\n",
+    "* `probes`: Number of partitions to scan at query time (e.g., 10-20), controls recall vs. latency\n",
+    "\n",
+    "`ivfpq`\n",
+    "* `subvectors`: Number of blocks to quantize (e.g., 16)\n",
+    "* `bits`: Number of bits per block (e.g., 8)\n",
+    "* `probes`: Same as in `ivfflat`\n",
+    "\n",
+    "`hnsw`\n",
+    "* `M`: Max connections per node (e.g., 16)\n",
+    "* `ef_construction`: Build-time dynamic candidate list size (e.g., 200)\n",
+    "* `ef_search`: Queyr-time candidate pool (e.g., 64-128)\n",
+    "\n",
+    "##### Best practices\n",
+    "- `flat` for debugging or small datasets\n",
+    "- `ivfflat` when you want tunable accuracy with good speed\n",
+    "- `ivfpq` when memory efficieny is critical\n",
+    "- `hnsw` when optimizing for lowest latency on massive collections\n",
+    "\n",
+    "##### Other vector database options in the ecosystem\n",
+    "\n",
+    "| Vector DB    | Key Features                                                 | Pros                                        | Cons                                                            |\n",
+    "| ------------ | ------------------------------------------------------------ | ------------------------------------------- | --------------------------------------------------------------- |\n",
+    "| **Pinecone** | Fully managed, serverless; supports HNSW and SPANN           | Auto-scaling, SLA-backed, easy to integrate | Vendor lock-in; cost escalates at scale                         |\n",
+    "| **Weaviate** | GraphQL API, built-in modules for encoding and vectorization | Hybrid queries (metadata + vector), modular | Production deployment requires Kubernetes                       |\n",
+    "| **Milvus**   | Supports GPU indexing; IVF, HNSW, ANNOY                      | High performance at scale, dynamic indexing | Operational complexity; separate system                         |\n",
+    "| **Qdrant**   | Lightweight, real-time updates, payload filtering            | Simple setup, good hybrid query support     | Lacks native relational joins; eventual consistency in clusters |\n",
+    "| **Vectara**  | Managed with semantic ranking and re-ranking                 | Strong relevance features; easy integration | Proprietary; limited index control                              |\n",
+    "\n",
+    "##### Choosing the Right Vector Store\n",
+    "\n",
+    "| <div align=\"center\">Scale</div> | <div align=\"center\">Recommendation</div> | Details |\n",
+    "|--------------------------------|------------------------------------------|---------|\n",
+    "| <div align=\"center\">**Small to Medium Scale**<br>(less than 100M vectors)</div> | <div align=\"center\">PostgreSQL + pgvector<br>with `ivfflat` index</div> | Often sufficient for moderate workloads. Recommended settings: `lists = 100–200`, `probes = 10–20`. |\n",
+    "| <div align=\"center\">**Large Scale**<br>(100M – 1B+ vectors)</div> | <div align=\"center\">Milvus or Qdrant</div> | Suitable for high-throughput workloads, especially when GPU-accelerated indexing or sub-millisecond latency is needed. |\n",
+    "| <div align=\"center\">**Hybrid Scenarios**</div> | <div align=\"center\">PostgreSQL for metadata<br>+ dedicated vector DB</div> | Use PostgreSQL for entity metadata storage and a vector DB (e.g., Milvus, Qdrant) for similarity search. Synchronize embeddings using CDC pipelines (e.g., Debezium). |\n",
+    "\n",
+    "For more detailed information, check out the [OpenAI cookbook on vector databases](https://cookbook.openai.com/examples/vector_databases/readme).\n",
+    "\n",
+    "##### Durable disk storage and backup\n",
+    "For some cases, especially those requiring high availability or state recovery across restarts, it may be worth persisting state to reliable disk storage and implementing a backup strategy. \n",
+    "\n",
+    "If durability is a concern, consider using persistent disks with regular backups or syncing state to external storage. While not necessary for all deployments, it can provide a valuable safeguard against data loss or operational disruption in environments where consistency and fault tolerance matter."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7e12f78a-eb4f-44ab-9dc1-2fea0e4d7090",
+   "metadata": {},
+   "source": [
+    "## A.2. Managing and Pruning Datasets"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "52acca83-7a99-436f-86ac-5cfe6b93ba86",
+   "metadata": {},
+   "source": [
+    "### A.2.1. TTL (Time-to-Live) and Archival Policies"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6e6bbf33-4f3e-4536-a806-1b1a7d84add7",
+   "metadata": {},
+   "source": [
+    "Establish clear policies to determine which facts should be retained indefinitely (e.g., legally required records for regulators) and which can be archived after a defined period (e.g., statements sourced from social media more than one year old).\n",
+    "\n",
+    "Key practices to include:\n",
+    "<ol style=\"margin-left: 1em; line-height: 1.6; padding-left: 0.5em;\">\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Automated Archival Jobs</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Set up a background task that periodically queries for records with e.g., <code>valid_to &lt; NOW() - INTERVAL 'X days'</code> and moves them to an archival table for long-term storage.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Source-Specific Retention Policies</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Tailor retention durations by data source or entity type. For example, high-authority sources like government publications may warrant longer retention than less reliable data such as scraped news headlines or user-generated content.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "</ol>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9eefcbf8-8cba-40b3-888f-58b7f723ce5a",
+   "metadata": {},
+   "source": [
+    "### A.2.2. Relevance Scoring and Intelligent Pruning"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0c6e905c-b91a-48d0-a84b-cff5e8f6dbf1",
+   "metadata": {},
+   "source": [
+    "As your knowledge graph grows, the utility of many facts will decline. To keep the graph focused and maximise performance: \n",
+    "<ol style=\"margin-left: 1em; line-height: 1.6; padding-left: 0.5em;\">\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Index a Relevance Score</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Introduce a numeric <code>relevance_score</code> column (or columns) that incorporate metrics such as recency, source trustworthiness, and production query frequency.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Automated Pruning Logic</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Schedule a routine job to prune or archive facts falling below a predefined relevance threshold.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "</ol>\n",
+    "\n",
+    "\n",
+    "#### Advanced Relevance-Based Graph Reduction\n",
+    "\n",
+    "Efficiently reducing the size of a knowledge graph is important when scaling. [A 2024 survey](https://arxiv.org/pdf/2402.03358) categorizes techniques into **sparsification**, **coarsening**, and **condensation**—all aimed at shrinking the graph while preserving task-critical semantics. These methods offer substantial runtime and memory gains on large-scale KGs.\n",
+    "\n",
+    "Example implementation pattern:\n",
+    "<ol style=\"margin-left: 1em; line-height: 1.6; padding-left: 0.5em;\">\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Score Each Triple</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Compute a composite <code>relevance_score</code>, for example:\n",
+    "    </p>\n",
+    "    <pre style=\"margin-top: 0.5em; margin-bottom: 0.5em; background-color: #f5f5f5; padding: 0.75em; border-radius: 5px;\"><code>relevance_score = β1 * recency_score + β2 * source_trust_score + β3 * retrieval_count</code></pre>\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Where:\n",
+    "    </p>\n",
+    "    <ul style=\"margin-top: 0.5em; margin-bottom: 0.5em; padding-left: 1.2em;\">\n",
+    "      <li><code>recency_score</code>: exponential decay from <code>valid_from</code></li>\n",
+    "      <li><code>source_trust_score</code>: source-domain trust value</li>\n",
+    "      <li><code>retrieval_count</code>: production query frequency</li>\n",
+    "    </ul>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Apply a Reduction Strategy</strong><br />\n",
+    "    <ul style=\"margin-top: 0.5em; margin-bottom: 0.5em; padding-left: 1.2em;\">\n",
+    "      <li><strong>Sparsify</strong>: Select and retain only the most relevant edges or nodes based on criteria like centrality, spectral similarity, or embedding preservation</li>\n",
+    "      <li><strong>Coarsen</strong>: Group low-importance or semantically similar nodes into super-nodes and aggregate their features and connections</li>\n",
+    "      <li><strong>Condense</strong>: Construct a task-optimized mini-graph from scratch</li>\n",
+    "    </ul>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Validate in Shadow Mode</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Log and compare outputs from the pruned vs. original graph before routing production traffic.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Re-Score Regularly</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Recompute relevance (e.g., nightly) to ensure new or frequently accessed facts surface back to the top.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "</ol>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c98d8110-9ac9-4247-bd54-a4dccd3cf61d",
+   "metadata": {},
+   "source": [
+    "## A.3. Implementing Concurrency in the Ingestion Pipeline"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "66e144a0-9837-478a-b112-cfa297eb664a",
+   "metadata": {},
+   "source": [
+    "Moving from prototype to production often requires you to transform your linear processing pipeline into a concurrent, scalable pipeline. Instead of processing documents sequentially (document → chunking → statement extraction → entity extraction → statement invalidation → entity resolution), implement a staged pipeline where each phase can scale independently.\n",
+    "\n",
+    "Design your pipeline with a series of specialized stages, each with its own queue and worker pool. This allows you to scale bottlenecks independently and maintain system reliability under varying loads. \n",
+    "\n",
+    "<ol style=\"margin-left: 1em; line-height: 1.6; padding-left: 0.5em;\">\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Batch Chunking</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Begin by collecting documents in batches of e.g., 100–500 using a job queue like Redis or Amazon SQS. Process these documents in parallel, splitting each into their respective chunks. The chunking stage should often optimize for I/O parallelization as document reading is often the bottleneck. You can then store the chunks and their respective metadata in your <code>chunk_store</code> table, using bulk insert operations to minimize overhead.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Statement and Entity Extraction</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Pull chunks in batches of e.g., 50–100 and send them to your chosen LLM (e.g., GPT-4.1-mini) using parallel API requests. Implement rate limiting with semaphores or other methods to stay safely within OpenAI's API limits whilst maximizing your throughputs. We've covered rate limiting in more detail in our cookbook on <a href=\"https://cookbook.openai.com/examples/how_to_handle_rate_limits\">How to handle rate limits</a>. Once extracted, you can then write these to the relevant table in your database.\n",
+    "    </p>\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      You can then similarly group the statements we've just extracted into batches, and run the entity extraction processes in a similar vein before storing them.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Statement Invalidation</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Group extracted statement IDs by their associated entity clusters (e.g., all statements related to a specific entity like “Acme Corp.”). Send each cluster to your LLM (e.g., GPT-4.1-mini) in parallel to assess which statements are outdated or superseded. Use the model’s output to update the <code>status</code> field in your <code>statements</code> table—e.g., setting <code>status = 'inactive'</code>. Parallelize invalidation jobs for performance and consider scheduling periodic sweeps for consistency.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Entity Resolution</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Take batches of newly extracted entity mentions and compute embeddings using your model’s embedding endpoint. Insert these into your <code>entity_registry</code> table, assigning each a provisional or canonical <code>entity_id</code>. Perform approximate nearest-neighbor (ANN) searches using <code>pgvector</code> to identify near-duplicates or aliases. You can then update the <code>entities</code> table with resolved canonical IDs, ensuring downstream tasks reference unified representations.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "</ol>\n",
+    "\n",
+    "\n",
+    "### Advantages of Batch Processing\n",
+    "* Throughput – Batching reduces the overhead of individual API calls and database transactions.\n",
+    "\n",
+    "* Parallelism – Each stage can horizontally scale: you can run multiple worker processes for chunking, extraction, invalidation, etc., each reading from a queue.\n",
+    "\n",
+    "* Backpressure & Reliability – If one stage becomes slow (e.g., statement invalidation during a sudden data surge), upstream stages can buffer more items in the queue until capacity frees up.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "43cc5595-ae38-47e9-b90f-7b3f1bd004dc",
+   "metadata": {},
+   "source": [
+    "## A.4. Minimizing Token Cost"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "23ff03de-eeed-4bcf-9c1b-18bb8b449353",
+   "metadata": {},
+   "source": [
+    "### A.4.1. Prompt Caching"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0f5a4127-058a-4cf9-9a35-a928658a99fd",
+   "metadata": {},
+   "source": [
+    "Avoid redundant API calls by memoizing responses to brittle sub-prompts.\n",
+    "\n",
+    "Implementation Strategy:\n",
+    "- **Cache Frequent Queries**: For example, repeated prompts like \"Extract entities from this statement\" on identicial statements\n",
+    "- **Use Hash Keys**: Generate a unique cache key using the MD5 hash of the statement text: `md5(statement_text)`\n",
+    "- **Storage Options**: Redis for scalable persistence or in-memory LRU cache for simplicity and speed\n",
+    "- **Bypass API Calls**: If a statement is found in cache, skip the API call"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "81de3bdc-8cc3-4016-8cd7-01754dd4b04d",
+   "metadata": {},
+   "source": [
+    "### A.4.2. Service Tier: Flex"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "664765a2-6274-4285-b0c0-b1fb620cdb5a",
+   "metadata": {},
+   "source": [
+    "Utilize the `service_tier=flex` parameter in the OpenAI Responses SDK to enable partial completions and reduce costs.\n",
+    "\n",
+    "API Configuration:\n",
+    "```json\n",
+    "{\n",
+    "  \"model\": \"o4-mini\",\n",
+    "  \"prompt\": \"<your prompt>\",\n",
+    "  \"service_tier\": \"flex\"\n",
+    "}\n",
+    "```\n",
+    "\n",
+    "Cost Benefits:\n",
+    "- Charges only for generated tokens, not prompt tokens\n",
+    "- Can reduce costs by up to 40% for short extractions (e.g., single-sentence entity lists)\n",
+    "\n",
+    "You can learn more about the power of Flex processing and how to utilise it in the [API documentation for Flex processing](https://platform.openai.com/docs/guides/flex-processing?api-mode=responses)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "12c39a74-8e08-4d62-bf09-8603c397b6f2",
+   "metadata": {},
+   "source": [
+    "### A.4.3. Minimize \"Chattiness\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "05891cac-6f02-40c9-91e8-e19e0fb11e3a",
+   "metadata": {},
+   "source": [
+    "Replace expensive text-generation calls with more efficient alternatives where possible.\n",
+    "\n",
+    "Alternative approach:\n",
+    "- Use embeddings endpoint (cheaper per token) combined with pgvector nearest-neighbor search\n",
+    "- Instead of asking the model \"Which existing statement is most similar?\", compute embeddings once and query directly in Postgres\n",
+    "- This approach is particularly effective for semantic similarity tasks\n",
+    "\n",
+    "**Benefits:**\n",
+    "- Lower cost per operation\n",
+    "- Faster query response times\n",
+    "- Reduced API dependency for similarity searches"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "22affb30-4da1-41aa-9ae4-a285b7f2e060",
+   "metadata": {},
+   "source": [
+    "## A.5. Scaling and Productionizing our Retrieval Agent"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c8fb79ab-d623-4d11-bdff-70af141cf16b",
+   "metadata": {},
+   "source": [
+    "Once your graph is populated, you need a mechanism to answer multi-hop queries at scale. This requires:\n",
+    "\n",
+    "<ol style=\"margin-left: 1em; line-height: 1.6; padding-left: 0.5em;\">\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Agent Architecture</strong><br />\n",
+    "    <ul style=\"margin-top: 0.5em; margin-bottom: 0.5em; padding-left: 1.2em;\">\n",
+    "      <li><strong>Controller Agent (Frontend)</strong>: Receives a user question (e.g., “What events led to Acme Corp.’s IPO?”), then decomposes it into sub-questions or traversal steps.</li>\n",
+    "      <li><strong>Traversal Worker Agents</strong>: Each worker can perform a local graph traversal (e.g., “Find all facts where Acme Corp. has EventType = Acquisition between 2020–2025”), possibly in parallel on different partitions of the graph.</li>\n",
+    "    </ul>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Parallel Subgraph Extraction</strong><br />\n",
+    "    <ul style=\"margin-top: 0.5em; margin-bottom: 0.5em; padding-left: 1.2em;\">\n",
+    "      <li>Partition the graph by entity ID hash (e.g., modulo 16). For a given query, identify which partitions are likely to contain relevant edges, then dispatch traversal tasks in parallel to each worker.</li>\n",
+    "      <li>Workers return partial subgraphs (nodes + edges), and the Controller Agent merges them.</li>\n",
+    "    </ul>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Chained LLM Reasoning</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      For multi-hop questions, the Controller can prompt a model (e.g., GPT-4.1) with the partial subgraph and ask “Which next edge should I traverse?” This allows dynamic, context-aware traversal rather than blind breadth-first search.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Caching and Memoization</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      For frequently asked queries or subgraph patterns, cache the results (e.g., in Redis or a Postgres Materialized View) with a TTL equal to the fact’s <code>valid_to</code> date, so that subsequent requests hit the cache instead of re-traversing.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Load Balancing &amp; Autoscaling</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Deploy the Traversal Worker Agents in a Kubernetes cluster with Horizontal Pod Autoscalers. Use CPU and memory metrics (and average queue length) to scale out during peak usage.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "</ol>\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "28442f85-dfe6-444b-8e19-a9c84e1b23d5",
+   "metadata": {},
+   "source": [
+    "## A.6. Safeguards"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "21583d8e-06e1-4e56-a304-0bf2a4095dc0",
+   "metadata": {},
+   "source": [
+    "### A.6.1 Multi-Layered Output Verification"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "40f741a4-ff66-4e2d-a3bc-db6ef1f04a26",
+   "metadata": {},
+   "source": [
+    "Run a lightweight validation pipeline to ensure outputs are as desired. Some examples of what can be included in this:\n",
+    "* Check that dates conform to `ISO-8601`\n",
+    "* Verify that entity types match your controlled vocabulary (e.g., if the model outputs an unexpected label, flag for manual review)\n",
+    "* Deploy a \"sanity-check\" function call to a smaller, cheaper model to verify the consistency of outputs (for example, “Does this statement parse correctly as a Fact? Yes/No.”)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1ebdc4fd-bba2-49d2-9e58-18a79c7af467",
+   "metadata": {},
+   "source": [
+    "### A.6.2. Audit Logging & Monitoring"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5157ecd3-67af-485b-9d0a-a86f5d51d110",
+   "metadata": {},
+   "source": [
+    "- Implement structured logging with configurable verbosity levels (e.g., debug, info, warn, error)\n",
+    "- Store input pre-processing steps, intermediate outputs, and final results with full tracing, such as that offered via [OpenAI's tracing](https://platform.openai.com/traces)\n",
+    "- Track token throughput, latency, and error rates\n",
+    "- Monitor data quality metrics where possible, such as document or statement coverage, temporal resolution rates, and more\n",
+    "- Measure business-related metrics such as user numbers, average message volume, and user satisfaction"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b65f7222-cf56-4b35-a052-a5bf0ab99984",
+   "metadata": {},
+   "source": [
+    "## A.7. Prompt Optimization"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f0dc981e-2a27-4ebe-8917-8eebf725f344",
+   "metadata": {},
+   "source": [
+    "<ol style=\"margin-left: 1em; line-height: 1.6; padding-left: 0.5em;\">\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Personas</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Introducing a persona to the model is an effective way to drive performance. Once you have narrowed down the specialism of the component you are developing the prompt for, you can create a persona in the system prompt that helps to shape the model's behaviour. We used this in our planner model to create a system prompt like this:\n",
+    "    </p>\n",
+    "    <pre style=\"margin-top: 0.5em; margin-bottom: 0.5em; background-color: #f5f5f5; padding: 0.75em; border-radius: 5px;\"><code>initial_planner_system_prompt = (\n",
+    "    \"You work for the leading financial firm, ABC Incorporated, one of the largest financial firms in the world. \"\n",
+    "    \"Due to your long and esteemed tenure at the firm, various equity research teams will often come to you \"\n",
+    "    \"for guidance on research tasks they are performing. Your expertise is particularly strong in the area of \"\n",
+    "    \"ABC Incorporated's proprietary knowledge base of earnings call transcripts. This contains details that have been \"\n",
+    "    \"extracted from the earnings call transcripts of various companies with labelling for when these statements are, or \"\n",
+    "    \"were, valid. You are an expert at providing instructions to teams on how to use this knowledge graph to answer \"\n",
+    "    \"their research queries. \\n\"\n",
+    ")</code></pre>\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Persona prompts can become much more developed and specific than this, but this should provide an insight into what this looks like in practice.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Few-Shot Prompting and Chain-of-Thought</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      For extraction-related tasks, such as statement extraction, a concise few-shot prompt (2–5 examples) will typically deliver higher precision than a zero-shot prompt at a marginal increase in cost.\n",
+    "    </p>\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      For e.g., temporal reconciliation tasks, chain-of-thought methods where you guide the model through comparison logic are more appropriate. This can look like:\n",
+    "    </p>\n",
+    "    <pre style=\"margin-top: 0.5em; margin-bottom: 0.5em; background-color: #f5f5f5; padding: 0.75em; border-radius: 5px;\"><code>Example 1: [Old fact], [New fact] → Invalidate\n",
+    "Example 2: [Old fact], [New fact] → Coexist\n",
+    "Now: [Old fact], [New fact] →</code></pre>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Dynamic Prompting &amp; Context Management</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      You can also lean on other LLMs or more structured methods to prune and prepare material that will be dynamically passed to prompts. We saw an example of this when building the tools for our retriever above, where the <code>timeline_generation</code> tool sorts the retrieved material before passing it back to the central orchestrator.\n",
+    "    </p>\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Steps to clean up the context or compress it mid-run can also be highly effective for longer-running queries.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Template Library &amp; A/B Testing</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Maintain a set of prompt templates in a version-controlled directory (e.g., <code>prompts/statement_extraction.json</code>, <code>prompts/entity_extraction.json</code>) to enable you to audit past changes and revert if necessary. You can utilize OpenAI's reusuable prompts for this. In the OpenAI dashboard, you can develop <a href=\"https://platform.openai.com/docs/guides/text#reusable-prompts\">reusable prompts</a> to use in API requests. This enables you to build and evaluate your prompts, deploying updated and improved versions without ever changing the code.\n",
+    "    </p>\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Automate A/B testing by periodically sampling extracted facts from the pipeline, re-running them through alternative prompts, and comparing performance scores (you can track this in a separate evaluation harness).\n",
+    "    </p>\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Track key performance indicators (KPIs) such as extraction latency, error rates, and invalidation accuracy.\n",
+    "    </p>\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      If any metric drifts beyond a threshold (e.g., invalidation accuracy drops below 90%), trigger an alert and roll back to a previous prompt version.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "</ol>\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/partners/temporal_agents_with_knowledge_graphs/cb_functions.py b/examples/partners/temporal_agents_with_knowledge_graphs/cb_functions.py
new file mode 100644
index 0000000000..87d582a563
--- /dev/null
+++ b/examples/partners/temporal_agents_with_knowledge_graphs/cb_functions.py
@@ -0,0 +1,204 @@
+"""Reusable functions for the cookbook."""
+
+import sqlite3
+import networkx as nx
+from typing import Any
+from datasets import load_dataset
+
+from db_interface import get_all_triplets
+
+
+def load_db_from_hf(db_path: str = "temporal_graph.db", hf_dataset_name: str = "TomoroAI/temporal_cookbook_db") -> sqlite3.Connection:
+    """Load the pre-processed database from HuggingFace."""
+    conn = sqlite3.connect(db_path)
+    table_names = [
+        "transcripts",
+        "chunks",
+        "events",
+        "triplets",
+        "entities",
+    ]
+
+    for table in table_names:
+        print(f"Loading {table}...")
+        ds = load_dataset(hf_dataset_name, name=table, split="train")
+        df = ds.to_pandas()
+        df.to_sql(table, conn, if_exists="replace", index=False)
+
+        conn.commit()
+    print("✅ All tables written to SQLite.")
+
+    return conn
+
+def build_graph(
+        conn: sqlite3.Connection,
+        *,
+        nodes_as_names: bool = False
+        ) -> nx.MultiDiGraph:
+    """Build graph using canonical entity IDs and names."""
+    graph = nx.MultiDiGraph()
+
+    # Always load canonical mappings
+    entity_to_canonical, canonical_names = _load_entity_maps(conn)
+    event_temporal_map = _load_event_temporal(conn)
+
+    for t in get_all_triplets(conn):
+        if not t["subject_id"]:
+            continue
+
+        event_attrs = event_temporal_map.get(t["event_id"])
+        _add_triplet_edge(
+            graph,
+            t,
+            entity_to_canonical,
+            canonical_names,
+            event_attrs,
+            nodes_as_names,
+        )
+
+    return graph
+
+def _load_entity_maps(conn: sqlite3.Connection) -> tuple[dict[bytes, bytes], dict[bytes, str]]:
+    """
+    Return mappings for canonical entities:
+    • entity_to_canonical: maps entity ID → canonical ID (using resolved_id)
+    • canonical_names: maps canonical ID → canonical name.
+    """
+    cur = conn.cursor()
+
+    # Get all entities with their resolved IDs
+    cur.execute("""
+        SELECT id, name, resolved_id
+        FROM entities
+    """)
+
+    entity_to_canonical: dict[bytes, bytes] = {}
+    canonical_names: dict[bytes, str] = {}
+
+    for row in cur.fetchall():
+        entity_id = row[0]
+        name = row[1]
+        resolved_id = row[2]
+
+        if resolved_id:
+            # If entity has a resolved_id, map to that
+            entity_to_canonical[entity_id] = resolved_id
+            # Store name of the canonical entity
+            canonical_names[resolved_id] = name
+        else:
+            # If no resolved_id, entity is its own canonical version
+            entity_to_canonical[entity_id] = entity_id
+            canonical_names[entity_id] = name
+
+    return entity_to_canonical, canonical_names
+
+def _load_event_temporal(conn: sqlite3.Connection) -> dict[bytes, dict[str, Any]]:
+    """
+    Read the `events` table once and build a mapping
+    event_id (bytes) → dict of temporal / descriptive attributes.
+    Only the columns that are useful on the graph edges are pulled;
+    extend this list freely if you need more.
+    """
+    cur = conn.cursor()
+    cur.execute("""
+        SELECT  id,
+                statement,
+                statement_type,
+                temporal_type,
+                created_at,
+                valid_at,
+                expired_at,
+                invalid_at,
+                invalidated_by
+        FROM events
+    """)
+    event_map: dict[bytes, dict[str, Any]] = {}
+    for (
+        eid,
+        statement,
+        statement_type,
+        temporal_type,
+        created_at,
+        valid_at,
+        expired_at,
+        invalid_at,
+        invalidated_by,
+    ) in cur.fetchall():
+        event_map[eid] = {
+            "statement": statement,
+            "statement_type": statement_type,
+            "temporal_type": temporal_type,
+            "created_at": created_at,
+            "valid_at": valid_at,
+            "expired_at": expired_at,
+            "invalid_at": invalid_at,
+            "invalidated_by": invalidated_by,
+        }
+    return event_map
+
+
+def _add_triplet_edge(
+        graph: nx.MultiDiGraph, t: dict,
+        entity_to_canonical: dict[bytes, bytes],
+        canonical_names: dict[bytes, str],
+        event_attrs: dict[str, Any] | None = None,
+        use_names: bool = False,
+        ) -> None:
+    """Add one edge using canonical IDs and names."""
+    subj_id = t["subject_id"]
+    obj_id = t["object_id"]
+
+    if subj_id is None:
+        return
+
+    # Get canonical IDs
+    canonical_subj = entity_to_canonical.get(subj_id, subj_id)
+    canonical_obj = entity_to_canonical.get(obj_id, obj_id) if obj_id else None
+
+    # Get canonical names
+    subj_name = canonical_names.get(canonical_subj, t["subject_name"]) if canonical_subj is not None else t["subject_name"]
+    obj_name = canonical_names.get(canonical_obj, t["object_name"]) if canonical_obj is not None else t["object_name"]
+
+    subj_node = subj_name if use_names else canonical_subj
+    obj_node  = obj_name  if use_names else canonical_obj
+
+    # Add nodes with canonical names
+    graph.add_node(
+        subj_node,
+        canonical_id=canonical_subj,
+        name=subj_name,
+    )
+
+    # Core edge attributes (triplet-specific)
+    edge_attrs: dict[str, Any] = {
+        "predicate": t["predicate"],
+        "triplet_id": t["id"],
+        "event_id": t["event_id"],
+        "value": t["value"],
+        "canonical_subject_name": subj_name,
+        "canonical_object_name": obj_name,
+    }
+
+    # Merge in temporal data, if we have it
+    if event_attrs:
+        edge_attrs.update(event_attrs)
+
+    if canonical_obj is None:
+        # Handle self-loops for null objects
+        graph.add_edge(
+            subj_node, subj_node,
+            key=t["predicate"],
+            **edge_attrs,
+            literal_object=t["object_name"],
+        )
+    else:
+        graph.add_node(
+            obj_node,
+            canonical_id=canonical_obj,
+            name=obj_name,
+        )
+        graph.add_edge(
+            subj_node, obj_node,
+            key=t["predicate"],
+            **edge_attrs,
+        )
diff --git a/examples/partners/temporal_agents_with_knowledge_graphs/db_interface.py b/examples/partners/temporal_agents_with_knowledge_graphs/db_interface.py
new file mode 100644
index 0000000000..d2b09c95b0
--- /dev/null
+++ b/examples/partners/temporal_agents_with_knowledge_graphs/db_interface.py
@@ -0,0 +1,429 @@
+import os
+import sqlite3
+import uuid
+from typing import Any
+
+import pandas as pd
+
+from models import Entity, TemporalEvent
+from utils import safe_iso
+
+
+def make_connection(
+    db_path: str = "my_database.db",
+    memory: bool = False,
+    refresh: bool = False,
+) -> sqlite3.Connection:
+    """Make a connection to the database.
+
+    Args:
+        db_path (str, optional): The path to the database file. Defaults to "my_database.db".
+        memory (bool, optional): Whether to create a memory database. Defaults to False.
+        refresh (bool, optional): Whether to refresh the database. Defaults to False.
+    Returns:
+        sqlite3.Connection: The database connection.
+    """
+    if not memory and refresh:
+        if os.path.exists(db_path):
+            try:
+                os.remove(db_path)
+            except PermissionError as e:
+                raise RuntimeError(
+                    "Could not delete the database file. Please ensure all connections are closed."
+                ) from e
+    conn = sqlite3.connect(":memory:") if memory else sqlite3.connect(db_path)
+    if memory and refresh:
+        _drop_all_tables(conn)
+    _create_lite_tables(conn)
+    return conn
+
+
+def _drop_all_tables(conn: sqlite3.Connection, tables: list[str] | None = None) -> None:
+    """Drop all tables in the database.
+
+    Args:
+        conn (sqlite3.Connection): The database connection.
+    """
+    c = conn.cursor()
+    if not tables:
+        c.execute(
+            "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%';"
+        )
+        tables = [row[0] for row in c.fetchall()]
+    for table in tables:
+        c.execute(f"DROP TABLE IF EXISTS {table}")
+    conn.commit()
+
+
+def _create_lite_tables(conn: sqlite3.Connection) -> None:
+    """Create all tables for the database if they do not exist.
+
+    Args:
+        conn (sqlite3.Connection): The database connection.
+    """
+    c = conn.cursor()
+
+    c.execute(
+        """
+    CREATE TABLE IF NOT EXISTS transcripts (
+        id BLOB PRIMARY KEY,
+        text TEXT,
+        company TEXT,
+        date TEXT,
+        quarter TEXT
+    )
+    """
+    )
+
+    c.execute(
+        """
+    CREATE TABLE IF NOT EXISTS chunks (
+        id BLOB PRIMARY KEY,
+        transcript_id BLOB,
+        text TEXT,
+        metadata TEXT,
+        FOREIGN KEY(transcript_id) REFERENCES transcripts(id)
+    )
+    """
+    )
+    c.execute(
+        """CREATE INDEX IF NOT EXISTS idx_chunks_transcript_id ON chunks (transcript_id)"""
+    )
+
+    c.execute(
+        """
+    CREATE TABLE IF NOT EXISTS events (
+        id BLOB PRIMARY KEY,
+        chunk_id BLOB,
+        statement TEXT,
+        triplets TEXT,
+        statement_type TEXT,
+        temporal_type TEXT,
+        created_at TEXT,
+        valid_at TEXT,
+        expired_at TEXT,
+        invalid_at TEXT,
+        invalidated_by BLOB,
+        embedding BLOB,
+        FOREIGN KEY(chunk_id) REFERENCES chunks(id),
+        FOREIGN KEY(invalidated_by) REFERENCES events(id)
+    )
+    """
+    )
+    c.execute("CREATE INDEX IF NOT EXISTS idx_events_chunk_id ON events (chunk_id)")
+
+    c.execute(
+        """
+    CREATE TABLE IF NOT EXISTS triplets (
+        id BLOB PRIMARY KEY,
+        event_id BLOB,
+        subject_name TEXT,
+        subject_id BLOB,
+        predicate TEXT,
+        object_name TEXT,
+        object_id BLOB,
+        value TEXT,
+        FOREIGN KEY(event_id) REFERENCES events(id)
+    )
+    """
+    )
+    c.execute("CREATE INDEX IF NOT EXISTS idx_triplets_event_id ON triplets (event_id)")
+
+    c.execute(
+        """
+    CREATE TABLE IF NOT EXISTS entities (
+        id BLOB PRIMARY KEY,
+        event_id BLOB,
+        name TEXT,
+        type TEXT,
+        description TEXT,
+        resolved_id BLOB,
+        FOREIGN KEY(event_id) REFERENCES events(id),
+        FOREIGN KEY(resolved_id) REFERENCES entities(id)
+    )
+    """
+    )
+
+    conn.commit()
+
+
+def view_db_table(
+    conn: sqlite3.Connection, table_name: str, max_rows: int | None = None
+) -> pd.DataFrame:
+    """View a table in the database as a pandas DataFrame.
+
+    Args:
+        conn (sqlite3.Connection): The database connection.
+        table_name (str): The name of the table to view.
+        max_rows (int, optional): Maximum number of rows to return. Defaults to 10.
+
+    Returns:
+        pd.DataFrame: The table data as a DataFrame.
+    """
+    if max_rows:
+        query = f"SELECT * FROM {table_name} LIMIT {max_rows}"
+    else:
+        query = f"SELECT * FROM {table_name}"
+    return pd.read_sql_query(query, conn)
+
+
+def insert_transcript(conn: sqlite3.Connection, transcript: dict[str, Any]) -> None:
+    """Insert a transcript into the database.
+
+    Args:
+        conn (sqlite3.Connection): The database connection.
+        transcript (dict[str, Any]): The transcript to insert.
+    """
+    c = conn.cursor()
+    c.execute(
+        """
+        INSERT INTO transcripts
+        (id, text, company, date, quarter)
+        VALUES (?, ?, ?, ?, ?)
+        """,
+        (
+            transcript["id"],
+            transcript["text"],
+            transcript["company"],
+            transcript["date"].isoformat(),
+            transcript.get("quarter"),
+        ),
+    )
+
+
+def insert_chunk(conn: sqlite3.Connection, chunk: dict[str, Any]) -> None:
+    """Insert a chunk into the database.
+
+    Args:
+        conn (sqlite3.Connection): The database connection.
+        chunk (dict[str, Any]): The chunk to insert.
+    """
+    c = conn.cursor()
+    c.execute(
+        "INSERT INTO chunks (id, transcript_id, text, metadata) VALUES (?, ?, ?, ?)",
+        (chunk["id"], chunk["transcript_id"], chunk["text"], chunk.get("metadata")),
+    )
+
+
+# ======================
+# TRIPLET INTERACTIONS
+# ======================
+
+
+def insert_triplet(conn: sqlite3.Connection, triplet: dict[str, Any]) -> None:
+    """Insert a triplet with both names and resolved IDs."""
+    conn.execute(
+        """
+        INSERT INTO triplets
+        (id, event_id, subject_name, subject_id, predicate, object_name, object_id, value)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        """,
+        (
+            triplet["id"],
+            triplet["event_id"],
+            triplet["subject_name"],
+            triplet.get("subject_id"),
+            triplet["predicate"],
+            triplet["object_name"],
+            triplet.get("object_id"),
+            triplet.get("value"),
+        ),
+    )
+
+
+def get_all_triplets(conn: sqlite3.Connection) -> list[dict[str, Any]]:
+    """Get all triplets with both names and resolved IDs."""
+    c = conn.cursor()
+    c.execute(
+        """
+        SELECT
+            id, event_id,
+            subject_name, subject_id,
+            predicate,
+            object_name, object_id,
+            value
+        FROM triplets
+    """
+    )
+    return [
+        {
+            "id": row[0],
+            "event_id": row[1],
+            "subject_name": row[2],
+            "subject_id": row[3],
+            "predicate": row[4],
+            "object_name": row[5],
+            "object_id": row[6],
+            "value": row[7],
+        }
+        for row in c.fetchall()
+    ]
+
+
+def get_all_unique_predicates(conn: sqlite3.Connection) -> list[str]:
+    """Get all unique predicates from the triplets table.
+
+    Args:
+        conn (sqlite3.Connection): The database connection.
+
+    Returns:
+        list[str]: List of unique predicates.
+    """
+    c = conn.cursor()
+    c.execute("SELECT DISTINCT predicate FROM triplets")
+    rows = c.fetchall()
+    return [row[0] for row in rows]
+
+
+# =====================
+# ENTITY INTERACTIONS
+# =====================
+
+
+def insert_entity(conn: sqlite3.Connection, entity: dict[str, Any]) -> None:
+    """Insert an entity into the database.
+
+    Args:
+        conn (sqlite3.Connection): The database connection.
+        entity (dict[str, Any]): The entity to insert.
+    """
+    c = conn.cursor()
+    c.execute(
+        """
+              INSERT OR IGNORE INTO entities (id, name, type, description)
+              VALUES (?, ?, ?, ?)""",
+        (entity["id"], entity["name"], entity.get("type"), entity.get("description")),
+    )
+
+
+def get_all_canonical_entities(conn: sqlite3.Connection) -> list[Entity]:
+    """
+    Get all canonical entities from the entities table.
+    Returns a list of dicts with id, name, type, and description.
+    """
+    c = conn.cursor()
+    c.execute("SELECT id, name, type, description FROM entities")
+    rows = c.fetchall()
+    return [
+        Entity(
+            id=uuid.UUID(row[0]),
+            name=row[1],
+            type=row[2] or "",
+            description=row[3] or "",
+        )
+        for row in rows
+    ]
+
+
+def insert_canonical_entity(conn: sqlite3.Connection, entity: dict[str, Any]) -> None:
+    """
+    Insert a new canonical entity into the entities table.
+    entity: dict with keys 'id', 'name', 'type', 'description'.
+    """
+    c = conn.cursor()
+    c.execute(
+        "INSERT OR IGNORE INTO entities (id, name, type, description) VALUES (?, ?, ?, ?)",
+        (entity["id"], entity["name"], entity.get("type"), entity.get("description")),
+    )
+
+
+def update_entity_references(
+    conn: sqlite3.Connection, old_id: str, new_id: str
+) -> None:
+    """
+    Update all references from old_id to new_id in the database.
+    """
+    conn.execute(
+        "UPDATE entities SET resolved_id = ? WHERE resolved_id = ?", (new_id, old_id)
+    )
+    conn.execute(
+        "UPDATE triplets SET subject_id = ? WHERE subject_id = ?", (new_id, old_id)
+    )
+    conn.execute(
+        "UPDATE triplets SET object_id = ? WHERE object_id = ?", (new_id, old_id)
+    )
+    conn.commit()
+
+
+def remove_entity(conn: sqlite3.Connection, entity_id: str) -> None:
+    """
+    Remove the entity from the entities table.
+    """
+    conn.execute("DELETE FROM entities WHERE id = ?", (entity_id,))
+    conn.commit()
+
+
+# ====================
+# EVENT INTERACTIONS
+# ====================
+
+
+def insert_event(conn: sqlite3.Connection, event_dict: dict[str, Any]) -> None:
+    """Insert an event into the database.
+
+    Args:
+        conn (sqlite3.Connection): The database connection.
+        event (dict[str, Any]): The event to insert, preprocessed as a dict.
+    """
+    c = conn.cursor()
+    c.execute(
+        """
+        INSERT INTO events
+        (id, chunk_id, statement, embedding, triplets, statement_type, temporal_type,
+         created_at, valid_at, expired_at, invalid_at, invalidated_by)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        """,
+        (
+            (event_dict["id"]),
+            event_dict["chunk_id"],
+            event_dict["statement"],
+            event_dict["embedding"],
+            event_dict["triplets"],
+            event_dict["statement_type"],
+            event_dict["temporal_type"],
+            event_dict["created_at"],
+            event_dict["valid_at"],
+            event_dict["expired_at"],
+            event_dict["invalid_at"],
+            event_dict.get("invalidated_by"),
+        ),
+    )
+
+
+def has_events(conn: sqlite3.Connection) -> bool:
+    """Check if there are any FACT events in the database to validate against."""
+    cursor = conn.cursor()
+    cursor.execute("SELECT COUNT(*) FROM events WHERE statement_type = ?", ("FACT",))
+    count = cursor.fetchone()[0]
+    return count > 0  # type: ignore
+
+
+def update_events_batch(conn: sqlite3.Connection, events: list[TemporalEvent]) -> None:
+    """Batch update multiple events."""
+    if not events:
+        return
+
+    c = conn.cursor()
+    update_data = [
+        (
+            safe_iso(event.invalid_at) if hasattr(event, "invalid_at") else None,
+            safe_iso(event.expired_at) if hasattr(event, "expired_at") else None,
+            (
+                str(event.invalidated_by)
+                if hasattr(event, "invalidated_by") and event.invalidated_by
+                else None
+            ),
+            str(event.id) if hasattr(event, "id") else event.id,
+        )
+        for event in events
+    ]
+
+    c.executemany(
+        """UPDATE events SET
+           invalid_at = ?,
+           expired_at = ?,
+           invalidated_by = ?
+           WHERE id = ?""",
+        update_data,
+    )
+    conn.commit()
diff --git a/examples/partners/temporal_agents_with_knowledge_graphs/models.py b/examples/partners/temporal_agents_with_knowledge_graphs/models.py
new file mode 100644
index 0000000000..6e835c7da1
--- /dev/null
+++ b/examples/partners/temporal_agents_with_knowledge_graphs/models.py
@@ -0,0 +1,97 @@
+"""Models used when interacting with the database interface."""
+import json
+import uuid
+from datetime import datetime
+from enum import StrEnum
+
+from pydantic import BaseModel, Field, model_validator
+
+class RawEntity(BaseModel):
+    """Model representing an entity (for entity resolution)."""
+
+    entity_idx: int
+    name: str
+    type: str = ""
+    description: str = ""
+
+
+class Entity(BaseModel):
+    """
+    Model representing an entity (for entity resolution).
+    'id' is the canonical entity id if this is a canonical entity.
+    'resolved_id' is set to the canonical id if this is an alias.
+    """
+
+    id: uuid.UUID = Field(default_factory=uuid.uuid4)
+    event_id: uuid.UUID | None = None
+    name: str
+    type: str
+    description: str
+    resolved_id: uuid.UUID | None = None
+
+    @classmethod
+    def from_raw(
+        cls, raw_entity: "RawEntity", event_id: uuid.UUID | None = None
+    ) -> "Entity":
+        """Create an Entity instance from a RawEntity, optionally associating it with an event_id."""
+        return cls(
+            id=uuid.uuid4(),
+            event_id=event_id,
+            name=raw_entity.name,
+            type=raw_entity.type,
+            description=raw_entity.description,
+            resolved_id=None,
+        )
+
+class TemporalType(StrEnum):
+    """Enumeration of temporal types for statements."""
+
+    ATEMPORAL = "ATEMPORAL"
+    STATIC = "STATIC"
+    DYNAMIC = "DYNAMIC"
+
+class StatementType(StrEnum):
+    """Enumeration of statement types for statements."""
+
+    FACT = "FACT"
+    OPINION = "OPINION"
+    PREDICTION = "PREDICTION"
+
+class TemporalEvent(BaseModel):
+    """Model representing a temporal event with statement, triplet, and validity information."""
+
+    id: uuid.UUID = Field(default_factory=uuid.uuid4)
+    chunk_id: uuid.UUID
+    statement: str
+    embedding: list[float] = Field(default_factory=lambda: [0.0] * 256)
+    triplets: list[uuid.UUID]
+    valid_at: datetime | None = None
+    invalid_at: datetime | None = None
+    temporal_type: TemporalType
+    statement_type: StatementType
+    created_at: datetime = Field(default_factory=datetime.now)
+    expired_at: datetime | None = None
+    invalidated_by: uuid.UUID | None = None
+
+    @property
+    def triplets_json(self) -> str:
+        """Convert triplets list to JSON string."""
+        return json.dumps([str(t) for t in self.triplets]) if self.triplets else "[]"
+
+    @classmethod
+    def parse_triplets_json(cls, triplets_str: str) -> list[uuid.UUID]:
+        """Parse JSON string back into list of UUIDs."""
+        if not triplets_str or triplets_str == "[]":
+            return []
+        return [uuid.UUID(t) for t in json.loads(triplets_str)]
+
+    @model_validator(mode="after")
+    def set_expired_at(self) -> "TemporalEvent":
+        """Set expired_at if invalid_at is set and temporal_type is DYNAMIC."""
+        self.expired_at = (
+            self.created_at
+            if (self.invalid_at is not None)
+            and (self.temporal_type == TemporalType.DYNAMIC)
+            else None
+        )
+        return self
diff --git a/examples/partners/temporal_agents_with_knowledge_graphs/temporal_agents_with_knowledge_graphs.ipynb b/examples/partners/temporal_agents_with_knowledge_graphs/temporal_agents_with_knowledge_graphs.ipynb
new file mode 100644
index 0000000000..8297114396
--- /dev/null
+++ b/examples/partners/temporal_agents_with_knowledge_graphs/temporal_agents_with_knowledge_graphs.ipynb
@@ -0,0 +1,7029 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<h1 style=\"font-size:36px; line-height:1.1;\">Temporal Agents with Knowledge Graphs</h1>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 1. Executive Summary\n",
+    "---"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1.1. Purpose and Audience"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "jp-MarkdownHeadingCollapsed": true
+   },
+   "source": [
+    "This notebook provides a hands-on guide for building **temporally-aware knowledge graphs** and performing **multi-hop retrieval directly over those graphs**. \n",
+    "\n",
+    "It's designed for engineers, architects, and analysts working on temporally-aware knowledge graphs. Whether you’re prototyping, deploying at scale, or exploring new ways to use structured data, you’ll find practical workflows, best practices, and decision frameworks to accelerate your work.\n",
+    "\n",
+    "This cookbook presents two hands-on workflows you can use, extend, and deploy right away:\n",
+    "\n",
+    "<ol style=\"margin-left: 1em; line-height: 1.6; padding-left: 0.5em;\">\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Temporally-aware knowledge graph (KG) construction</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      A key challenge in developing knowledge-driven AI systems is maintaining a database that stays current and relevant. While much attention is given to boosting retrieval accuracy with techniques like semantic similarity and re-ranking, this guide focuses on a fundamental—yet frequently overlooked—aspect: <em>systematically updating and validating your knowledge base as new data arrives</em>.\n",
+    "    </p>\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      No matter how advanced your retrieval algorithms are, their effectiveness is limited by the quality and freshness of your database. This cookbook demonstrates how to routinely validate and update knowledge graph entries as new data arrives, helping ensure that your knowledge base remains accurate and up to date.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Multi-hop retrieval using knowledge graphs</strong><br />\n",
+    "<p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "  Learn how to combine OpenAI models (such as o3, o4-mini, GPT-4.1, and GPT-4.1-mini) with structured graph queries via tool calls, enabling the model to traverse your graph in multiple steps across entities and relationships.\n",
+    "</p>\n",
+    "<p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "  This method lets your system answer complex, multi-faceted questions that require reasoning over several linked facts, going well beyond what single-hop retrieval can accomplish.\n",
+    "</p>\n",
+    "  </li>\n",
+    "</ol>\n",
+    "\n",
+    "Inside, you'll discover:\n",
+    "\n",
+    "* **Practical decision frameworks** for choosing models and prompting techniques at each stage\n",
+    "* **Plug-and-play code examples** for easy integration into your ML and data pipelines\n",
+    "* **Links to in-depth resources** on OpenAI tool use, fine-tuning, graph backend selection, and more\n",
+    "* **A clear path from prototype to production**, with actionable best practices for scaling and reliability\n",
+    "\n",
+    "> **Note:** All benchmarks and recommendations are based on the best available models and practices as of June 2025. As the ecosystem evolves, periodically revisit your approach to stay current with new capabilities and improvements."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1.2. Key takeaways"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Creating a Temporally-Aware Knowledge Graph with a Temporal Agent\n",
+    "<ol style=\"margin-left: 1em; line-height: 1.6; padding-left: 0.5em;\">\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Why make your knowledge graph temporal?</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "     Traditional knowledge graphs treat facts as static, but real-world information evolves constantly. What was true last quarter may be outdated today, risking errors or misinformed decisions if the graph does not capture change over time. Temporal knowledge graphs allow you to precisely answer questions like “What was true on a given date?” or analyse how facts and relationships have shifted, ensuring decisions are always based on the most relevant context.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>What is a Temporal Agent?</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      A Temporal Agent is a pipeline component that ingests raw data and produces time-stamped triplets for your knowledge graph. This enables precise time-based querying, timeline construction, trend analysis, and more.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>How does the pipeline work?</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      The pipeline starts by semantically chunking your raw documents. These chunks are decomposed into statements ready for our Temporal Agent, which then creates time-aware triplets. An Invalidation Agent can then perform temporal validity checks, spotting and handling any statements that are invalidated by new statements that are incident on the graph.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "</ol>\n",
+    "\n",
+    "### Multi-Step Retrieval Over a Knowledge Graph\n",
+    "<ol style=\"margin-left: 1em; line-height: 1.6; padding-left: 0.5em;\">\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Why use multi-step retrieval?</strong><br />\n",
+    "<p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "  Direct, single-hop queries frequently miss salient facts distributed across a graph's topology. Multi-step (multi-hop) retrieval enables iterative traversal, following relationships and aggregating evidence across several hops. This methodology surfaces complex dependencies and latent connections that would remain hidden with one-shot lookups, providing more comprehensive and nuanced answers to sophisticated queries.\n",
+    "</p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Planners</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Planners orchestrate the retrieval process. <em>Task-orientated</em> planners decompose queries into concrete, sequential subtasks. <em>Hypothesis-orientated</em> planners, by contrast, propose claims to confirm, refute, or evolve. Choosing the optimal strategy depends on where the problem lies on the spectrum from deterministic reporting (well-defined paths) to exploratory research (open-ended inference).\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Tool Design Paradigms</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Tool design spans a continuum: <em>Fixed tools</em> provide consistent, predictable outputs for specific queries (e.g., a service that always returns today’s weather for San Francisco). At the other end, <em>Free-form tools</em> offer broad flexibility, such as code execution or open-ended data retrieval. <em>Semi-structured tools</em> fall between these extremes, restricting certain actions while allowing tailored flexibility—specialized sub-agents are a typical example. Selecting the appropriate paradigm is a trade-off between control, adaptability, and complexity.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Evaluating Retrieval Systems</strong><br />\n",
+    "<p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "  High-fidelity evaluation hinges on expert-curated \"golden\" answers, though these are costly and labor-intensive to produce. Automated judgments, such as those from LLMs or tool traces, can be quickly generated to supplement or pre-screen, but may lack the precision of human evaluation. As your system matures, transition towards leveraging real user feedback to measure and optimize retrieval quality in production.\n",
+    "</p>\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      A proven workflow: Start with synthetic tests, benchmark on your curated human-annotated \"golden\" dataset, and iteratively refine using live user feedback and ratings.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "</ol>\n",
+    "\n",
+    "### Prototype to Production\n",
+    "<ol style=\"margin-left: 1em; line-height: 1.6; padding-left: 0.5em;\">\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Keep the graph lean</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Established archival policies and assign numeric relevance scores to each edge (e.g., recency x trust x query-frequency). Automate the archival or sparsification of low-value nodes and edges, ensuring only the most critical and frequently accessed facts remain for rapid retrieval.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Parallelize the ingestion pipeline</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Transition from a linear document → chunk → extraction → resolution pipeline to a staged, asynchronous architecture. Assign each processing phase its own queue and dedicated worker pool. Apply clustering or network-based batching for invalidation jobs to maximize efficiency. Batch external API requests (e.g., OpenAI) and database writes wherever possible. This design increases throughput, introduces backpressure for reliability, and allows you to scale each pipeline stage independently.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Integrate Robust Production Safeguards</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Enforce rigorous output validation: standardise temporal fields (e.g., ISO-8601 date formatting), constrain entity types to your controlled vocabulary, and apply lightweight model-based sanity checks for output consistency. Employ structured logging with traceable identifiers and monitor real-time quality and performance metrics in real lime to proactively detect data drift, regressions, or pipeline anomalised before they impact downstream applications.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "</ol>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 2. How to Use This Cookbook\n",
+    "---"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This cookbook is designed for flexible engagement:\n",
+    "\n",
+    "1. Use it as a comprehensive technical guide—read from start to finish for a deep understanding of temporally-aware knowledge graph systems.\n",
+    "2. Skim for advanced concepts, methodologies, and implementation patterns if you prefer a high-level overview.\n",
+    "3. Jump into any of the three modular sections; each is self-contained and directly applicable to real-world scenarios.\n",
+    "\n",
+    "Inside, you'll find:\n",
+    "\n",
+    "<ol style=\"margin-left: 1em; line-height: 1.6; padding-left: 0.5em;\">\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Creating a Temporally-Aware Knowledge Graph with a Temporal Agent</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Build a pipeline that extracts entities and relations from unstructured text, resolves temporal conflicts, and keeps your graph up-to-date as new information arrives.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Multi-Step Retrieval Over a Knowledge Graph</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Use structured queries and language model reasoning to chain multiple hops across your graph and answer complex questions.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Prototype to Production</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Move from experimentation to deployment. This section covers architectural tips, integration patterns, and considerations for scaling reliably.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "</ol>\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2.1. Pre-requisites"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Before diving into building temporal agents and knowledge graphs, let's set up your environment. Install all required dependencies with pip, and set your OpenAI API key as an environment variable. Python 3.12 or later is required."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Python 3.12.8\n",
+      "Requirement already satisfied: pip in ./.venv/lib/python3.12/site-packages (25.1.1)\n",
+      "Note: you may need to restart the kernel to use updated packages.\n",
+      "Note: you may need to restart the kernel to use updated packages.\n",
+      "Note: you may need to restart the kernel to use updated packages.\n"
+     ]
+    }
+   ],
+   "source": [
+    "!python -V\n",
+    "%pip install --upgrade pip\n",
+    "%pip install -qU chonkie datetime ipykernel jinja2 matplotlib networkx numpy openai plotly pydantic rapidfuzz scipy tenacity tiktoken pandas\n",
+    "%pip install -q \"datasets<3.0\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "\n",
+    "if \"OPENAI_API_KEY\" not in os.environ:\n",
+    "    import getpass\n",
+    "    os.environ[\"OPENAI_API_KEY\"] = getpass.getpass(\"Paste your OpenAI API key here: \")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 3. Creating a Temporally-Aware Knowledge Graph with a Temporal Agent\n",
+    "---"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {
+    "jp-MarkdownHeadingCollapsed": true
+   },
+   "source": [
+    "**Accurate data is the foundation of any good business decision.** \n",
+    "OpenAI’s latest models like o3, o4-mini, and the GPT-4.1 family are enabling businesses to build state-of-the-art retrieval systems for their most important workflows. However, information evolves rapidly: facts ingested confidently yesterday may already be outdated today.\n",
+    "\n",
+    "<!-- ![Benefits of Temporal Knowledge Base](images/01_benefit_of_temporal_kb.jpg) -->\n",
+    "<img\n",
+    "  src=\"../../../images/01_benefit_of_temporal_kb.jpg\"\n",
+    "  alt=\"Benefits of Temporal Knowledge Base\"\n",
+    "  width=\"791\"\n",
+    "  style=\"height:auto;\"\n",
+    "/>\n",
+    "\n",
+    "Without the ability to track when each fact was valid, retrieval systems risk returning answers that are outdated, non-compliant, or misleading. The consequences of missing temporal context can be severe in any industry, as illustrated by the following examples.\n",
+    "\n",
+    "<table>\n",
+    "  <thead>\n",
+    "    <tr>\n",
+    "      <th>Industry</th>\n",
+    "      <th>Example question</th>\n",
+    "      <th>Risk if database is not temporal</th>\n",
+    "    </tr>\n",
+    "  </thead>\n",
+    "  <tbody>\n",
+    "    <tr>\n",
+    "      <td rowspan=\"3\"><strong>Financial Services</strong></td>\n",
+    "      <td><em>\"How has Moody’s long‑term rating for Bank YY evolved since Feb 2023?\"</em></td>\n",
+    "      <td>Mispricing credit risk by mixing historical & current ratings</td>\n",
+    "    </tr>\n",
+    "    <tr>\n",
+    "      <td><em>\"Who was the CFO of Retailer ZZ when the FY‑22 guidance was issued?\"</em></td>\n",
+    "      <td>Governance/insider‑trading analysis may blame the wrong executive</td>\n",
+    "    </tr>\n",
+    "    <tr>\n",
+    "      <td><em>\"Was Fund AA sanctioned under Article BB at the time it bought Stock CC in Jan 2024?\"</em></td>\n",
+    "      <td>Compliance report could miss an infraction if rules changed later</td>\n",
+    "    </tr>\n",
+    "    <tr>\n",
+    "      <td rowspan=\"3\"><strong>Manufacturing / Automotive</strong></td>\n",
+    "      <td><em>\"Which ECU firmware was deployed in model Q3 cars shipped between 2022‑05 and 2023‑03?\"</em></td>\n",
+    "      <td>Misdiagnosing field failures due to firmware drift</td>\n",
+    "    </tr>\n",
+    "    <tr>\n",
+    "      <td><em>\"Which robot‑controller software revision ran on Assembly Line 7 during Lot 8421?\"</em></td>\n",
+    "      <td>Root‑cause analysis may blame the wrong software revision</td>\n",
+    "    </tr>\n",
+    "    <tr>\n",
+    "      <td><em>\"What torque specification applied to steering‑column bolts in builds produced in May 2024?\"</em></td>\n",
+    "      <td>Safety recall may miss affected vehicles</td>\n",
+    "    </tr>\n",
+    "  </tbody>\n",
+    "</table>\n",
+    "\n",
+    "\n",
+    "While we've called out some specific examples here, this theme is true across many industries including pharmaceuticals, law, consumer goods, and more.\n",
+    "\n",
+    "**Looking beyond standard retrieval**\n",
+    "\n",
+    "A temporally-aware knowledge graph allows you to go beyond static fact lookup. It enables richer retrieval workflows such as factual Q&A grounded in time, timeline generation, change tracking, counterfactual analysis, and more. We dive into these in more detail in our retrieval section later in the cookbook.\n",
+    "\n",
+    "<!-- ![Question types suitable for temporal knowledge bases](./images/02_question_types_for_temporal_kbs.jpg) -->\n",
+    "<img\n",
+    "  src=\"../../../images/02_question_types_for_temporal_kbs.jpg\"\n",
+    "  alt=\"Question types suitable for temporal knowledge bases\"\n",
+    "  style=\"width:1091px; height:auto;\"\n",
+    "/>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3.1. Introducing our Temporal Agent\n",
+    "---"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "A **temporal agent** is a specialized pipeline that converts raw, free-form statements into time-aware triplets ready for ingesting into a knowledge graph that can then be queried with the questions of the character *“What was true at time T?”*. \n",
+    "\n",
+    "Triplets are the basic building blocks of knowledge graphs. It's a way to represent a single fact or piece of knowledge using three parts (hence, *\"triplet\"*): \n",
+    "- **Subject** - the entity you are talking about\n",
+    "- **Predicate** - the type of relationship or property\n",
+    "- **Object** - the value or other entity that the subject is connected to\n",
+    "\n",
+    "You can thinking of this like a sentence with a structure `[Subject] - [Predicate] - [Object]`. As a more clear example:\n",
+    "```\n",
+    "\"London\" - \"isCapitalOf\" - \"United Kingdom\"\n",
+    "```\n",
+    "\n",
+    "The Temporal Agent implemented in this cookbook draws inspiration from [Zep](https://arxiv.org/abs/2501.13956) and [Graphiti](https://github.com/getzep/graphiti), while introducing tighter control over fact invalidation and a more nuanced approach to episodic typing.\n",
+    "\n",
+    "### 3.1.1. Key enhancements introduced in this cookbook\n",
+    "\n",
+    "<ol style=\"margin-left: 1em; line-height: 1.6; padding-left: 0.5em;\">\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Temporal validity extraction</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Builds on Graphiti's prompt design to identify temporal spans and episodic context without requiring auxiliary reference statements.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Fact invalidation logic</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Introduces bidirectionality checks and constrains comparisons by episodic type. This retains Zep's non-lossy approach while reducing unnecessary evaluations.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Temporal & episodic typing</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Differentiates between <code>Fact</code>, <code>Opinion</code>, <code>Prediction</code>, as well as between temporal classes <code>Static</code>, <code>Dynamic</code>, <code>Atemporal</code>.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Multi‑event extraction</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Handles compound sentences and nested date references in a single pass.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "</ol>\n",
+    "\n",
+    "\n",
+    "\n",
+    "This process allows us to update our sources of truth efficiently and reliably:\n",
+    "\n",
+    "<br>\n",
+    "\n",
+    "<!-- ![Statement Invalidation in practice](./images/03_statement_invalidation.png) -->\n",
+    "<img\n",
+    "  src=\"../../../images/03_statement_invalidation.png\"\n",
+    "  alt=\"Statement Invalidation in practice\"\n",
+    "  style=\"width:791px; height:auto;\"\n",
+    "/>\n",
+    "\n",
+    "> **Note**: While the implementation in this cookbook is focused on a graph-based implementation, this approach is generalizable to other knowledge base structures e.g., pgvector-based systems.\n",
+    "---"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.1.2. The Temporal Agent Pipeline\n",
+    "\n",
+    "The Temporal Agent processes incoming statements through a three-stage pipeline:\n",
+    "\n",
+    "<ol style=\"margin-left: 1em; line-height: 1.6; padding-left: 0.5em;\">\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Temporal Classification</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Labels each statement as <strong>Atemporal</strong>, <strong>Static</strong>, or <strong>Dynamic</strong>:\n",
+    "    </p>\n",
+    "    <ul style=\"margin-top: 0.5em; margin-bottom: 0.5em; padding-left: 1em;\">\n",
+    "      <li style=\"margin-bottom: 0.5em;\"><em>Atemporal</em> statements never change (e.g., “The speed of light in a vaccuum is ≈3×10⁸ m s⁻¹”).</li>\n",
+    "      <li style=\"margin-bottom: 0.5em;\"><em>Static</em> statements are valid from a point in time but do not change afterwards (e.g., \"Person YY was CEO of Company XX on October 23rd 2014.\").</li>\n",
+    "      <li><em>Dynamic</em> statements evolve (e.g., \"Person YY is CEO of Company XX.\").</li>\n",
+    "    </ul>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Temporal Event Extraction</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Identifies relative or partial dates (e.g., “Tuesday”, “three months ago”) and resolves them to an absolute date using the document timestamp or fallback heuristics (e.g., default to the 1st or last of the month if only the month is known).\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Temporal Validity Check</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Ensures every statement includes a <code>t_created</code> timestamp and, when applicable, a <code>t_expired</code> timestamp. The agent then compares the candidate triplet to existing knowledge graph entries to:\n",
+    "    </p>\n",
+    "    <ul style=\"margin-top: 0.5em; margin-bottom: 0.5em; padding-left: 1em;\">\n",
+    "      <li style=\"margin-bottom: 0.5em;\">Detect contradictions and mark outdated entries with <code>t_invalid</code></li>\n",
+    "      <li style=\"margin-bottom: 0.5em;\">Link newer statements to those they invalidate with <code>invalidated_by</code></li>\n",
+    "    </ul>\n",
+    "  </li>\n",
+    "</ol>\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "attachments": {
+    "4d2883b2-99d8-460f-939d-6333d49d3cce.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<!-- ![Screenshot 2025-06-23 at 11.42.24.png](attachment:4d2883b2-99d8-460f-939d-6333d49d3cce.png) -->\n",
+    "<img\n",
+    "  src=\"../../../images/04_temporal_agent.png\"\n",
+    "  alt=\"Temporal Agent\"\n",
+    "  style=\"width:809px; height:auto;\"\n",
+    "/>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.1.3. Selecting the right model for a Temporal Agent\n",
+    "When building systems with LLMs, it is a good practice to [start with larger models then later look to optimize and shrink](https://platform.openai.com/docs/guides/model-selection). \n",
+    "\n",
+    "The GPT-4.1 series is particularly well-suited for building Temporal Agents due to its strong instruction-following ability. On benchmarks like Scale’s MultiChallenge, [GPT-4.1 outperforms GPT-4o by $10.5\\%_{abs}$](https://openai.com/index/gpt-4-1/), demonstrating superior ability to maintain context, reason in-conversation, and adhere to instructions - key traits for extracting time-stamped triplets. These capabilities make it an excellent choice for prototyping agents that rely on time-aware data extraction.\n",
+    "\n",
+    "#### Recommended development workflow\n",
+    "<ol style=\"margin-left: 1em; line-height: 1.6; padding-left: 0.5em;\">\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Prototype with GPT-4.1</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Maximize correctness and reduce prompt-debug time while you build out the core pipeline logic.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Swap to GPT-4.1-mini or GPT-4.1-nano</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Once prompts and logic are stable, switch to smaller variants for lower latency and cost-effective inference.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Distill onto GPT-4.1-mini or GPT-4.1-nano</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Use <a href=\"https://platform.openai.com/docs/guides/distillation\" target=\"_blank\">OpenAI's Model Distillation</a> to train smaller models with high-quality outputs from a larger 'teacher' model such as GPT-4.1, preserving (or even improving) performance relative to GPT-4.1.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "</ol>\n",
+    "\n",
+    "\n",
+    "\n",
+    "| Model                    | Relative cost | Relative latency  | Intelligence | Ideal Role in Workflow                   |\n",
+    "| ----------------------- | ------ | -------- | - |------------------------------ |\n",
+    "| *GPT-4.1*      | ★★★ | ★★ | ★★★ *(highest)* | Ground-truth prototyping, generating data for distillation |\n",
+    "| *GPT-4.1-mini*             | ★★  | ★     | ★★ | Balanced cost-performance, mid to large scale production systems |\n",
+    "| *GPT-4.1-nano*        | ★ *(lowest)*    | ★ *(fastest)*     | ★ | Cost-sensitive and ultra-large scale bulk processing |\n",
+    "\n",
+    "> In practice, this looks like: prototype with GPT-4.1 → measure quality → step down the ladder until the trade-offs no longer meet your needs."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3.2. Building our Temporal Agent Pipeline\n",
+    "---\n",
+    "Before diving into the implementation details, it's useful to understand the ingestion pipeline at a high level:\n",
+    "\n",
+    "<ol style=\"margin-left: 1em; line-height: 1.6; padding-left: 0.5em;\">\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Load transcripts</strong><br />\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Creating a Semantic Chunker</strong><br />\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Laying the Foundations for our Temporal Agent</strong><br />\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Statement Extraction</strong><br />\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Temporal Range Extraction</strong><br />\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Creating our Triplets</strong><br />\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Temporal Events</strong><br />\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Defining our Temporal Agent</strong><br />\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Entity Resolution</strong><br />\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Invalidation Agent</strong><br />\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Building our pipeline</strong><br />\n",
+    "  </li>\n",
+    "</ol>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Architecture diagram"
+   ]
+  },
+  {
+   "attachments": {
+    "290fc94d-2358-44d9-829c-220cd96a8b34.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<!-- ![Screenshot 2025-06-23 at 11.43.34.png](attachment:290fc94d-2358-44d9-829c-220cd96a8b34.png) -->\n",
+    "<img\n",
+    "  src=\"../../../images/05_temporal_agent_arch.png\"\n",
+    "  alt=\"Temporal Agent Architecture\"\n",
+    "  style=\"width:791px; height:auto;\"\n",
+    "/>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.2.1. Load transcripts\n",
+    "For the purposes of this cookbook, we have selected the [\"Earnings Calls Dataset\" (jlh-ibm/earnings_call)](https://huggingface.co/datasets/jlh-ibm/earnings_call) which is made available under the Creative Commons Zero v1.0 license. This dataset contains a collection of 188 earnings call transcripts originating in the period 2016-2020 in relation to the NASDAQ stock market. We believe this dataset is a good choice for this cookbook as extracting information from - and subsequently querying information from - earnings call transcripts is a common problem in many financial institutions around the world. \n",
+    "\n",
+    "Moreover, the often variable character of statements and topics from the same company across multiple earnings calls provides a useful vector through which to demonstrate the temporal knowledge graph concept. \n",
+    "\n",
+    "Despite this dataset's focus on the financial world, we build up the Temporal Agent in a general structure, so it will be quick to adapt to similar problems in other industries such as pharmaceuticals, law, automotive, and more. \n",
+    "\n",
+    "For the purposes of this cookbook we are limiting the processing to two companies - AMD and Nvidia - though in practice this pipeline can easily be scaled to any company. \n",
+    "\n",
+    "Let’s start by loading the dataset from HuggingFace."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from datasets import load_dataset\n",
+    "\n",
+    "hf_dataset_name = \"jlh-ibm/earnings_call\"\n",
+    "subset_options = [\"stock_prices\", \"transcript-sentiment\", \"transcripts\"]\n",
+    "\n",
+    "hf_dataset = load_dataset(hf_dataset_name, subset_options[2])\n",
+    "my_dataset = hf_dataset[\"train\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Dataset({\n",
+       "    features: ['company', 'date', 'transcript'],\n",
+       "    num_rows: 150\n",
+       "})"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "my_dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "row = my_dataset[0]\n",
+    "row[\"company\"], row[\"date\"], row[\"transcript\"][:200]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from collections import Counter\n",
+    "\n",
+    "company_counts = Counter(my_dataset[\"company\"])\n",
+    "company_counts"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Database Set-up**\n",
+    "\n",
+    "\n",
+    "Before we get to processing this data, let’s set up our database. \n",
+    "\n",
+    "For convenience within a notebook format, we've chosen SQLite as our database for this implementation. In the \"Prototype to Production\" section, and in [Appendix section A.1 \"Storing and Retrieving High-Volume Graph Data\"](./Appendix.ipynb) we go into more detail of considerations around different dataset choices in a production environment. \n",
+    "\n",
+    "If you are running this cookbook locally, you may chose to set `memory = False` to save the database to storage, the default file path `my_database.db` will be used to store your database or you may pass your own `db_path` arg into `make_connection`.\n",
+    "\n",
+    "We will set up several tables to store the following information:\n",
+    "- Transcripts\n",
+    "- Chunks\n",
+    "- Temporal Events\n",
+    "- Triplets\n",
+    "- Entities (including canonical mappings)\n",
+    "\n",
+    "This code is abstracted behind a `make_connection` method which creates the new SQLite database. The details of this method can be found in the `db_interface.py` script in the GitHub repository for this cookbook."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from db_interface import make_connection\n",
+    "\n",
+    "sqlite_conn = make_connection(memory=False, refresh=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.2.2. Creating a Semantic Chunker"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Before diving into buidling the `Chunker` class itself, we begin by defining our first data models. As is generally considered good practice when working with Python, [Pydantic](https://docs.pydantic.dev/latest/) is used to ensure type safety and clarity in our model definitions. Pydantic provides a clean, declarative way to define data structures whilst automatically validating and parsing input data, making our data models both robust and easy to work with."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Chunk model\n",
+    "This is a core data model that we'll use to store individual segments of text extracted from transcripts, along with any associated metadata. As we process the transcripts by breaking them into semantically meaningful chunks, each piece will be saved as a separate `Chunk`.\n",
+    "\n",
+    "Each `Chunk` contains:\n",
+    "- `id`: A unique identifier automatically generated for each chunk. This helps us identify and track chunks of text throughout\n",
+    "- `text`: A string field that contains the text content of the chunk\n",
+    "- `metadata`: A dictionary to allow for flexible metadata storage"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import uuid\n",
+    "from typing import Any\n",
+    "\n",
+    "from pydantic import BaseModel, Field\n",
+    "\n",
+    "\n",
+    "class Chunk(BaseModel):\n",
+    "    \"\"\"A chunk of text from an earnings call.\"\"\"\n",
+    "\n",
+    "    id: uuid.UUID = Field(default_factory=uuid.uuid4)\n",
+    "    text: str\n",
+    "    metadata: dict[str, Any]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Transcript model\n",
+    "As the name suggests, we will use the `Transcript` model to represent the full content of an earnings call transcript. It captures several key pieces of information:\n",
+    "- `id`: Analogous to `Chunk`, this gives us a unique identifier\n",
+    "- `text`: The full text of the transcript\n",
+    "- `company`: The name of the company that the earnings call was about\n",
+    "- `date`: The date of the earnings call\n",
+    "- `quarter`: The fiscal quarter that the earnings call was in\n",
+    "- `chunks`: A list of `Chunk` objects, each representing a meaningful segment of the full transcript\n",
+    "\n",
+    "To ensure the `date` field is handled correctly, the `to_datetime` validator is used to convert the value to datetime format. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from datetime import datetime\n",
+    "\n",
+    "from pydantic import field_validator\n",
+    "\n",
+    "\n",
+    "class Transcript(BaseModel):\n",
+    "    \"\"\"A transcript of a company earnings call.\"\"\"\n",
+    "\n",
+    "    id: uuid.UUID = Field(default_factory=uuid.uuid4)\n",
+    "    text: str\n",
+    "    company: str\n",
+    "    date: datetime\n",
+    "    quarter: str | None = None\n",
+    "    chunks: list[Chunk] | None = None\n",
+    "\n",
+    "    @field_validator(\"date\", mode=\"before\")\n",
+    "    @classmethod\n",
+    "    def to_datetime(cls, d: Any) -> datetime:\n",
+    "        \"\"\"Convert input to a datetime object.\"\"\"\n",
+    "        if isinstance(d, datetime):\n",
+    "            return d\n",
+    "        if hasattr(d, \"isoformat\"):\n",
+    "            return datetime.fromisoformat(d.isoformat())\n",
+    "        return datetime.fromisoformat(str(d))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Chunker class"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now, we define the `Chunker` class to split each transcript into semantically meaningful chunks. Instead of relying on arbitrary rules like character count or line break, we apply semantic chunking to preserve more of the contextual integrity of the original transcript. This ensures that each chunk is a self-contained unit that keeps contextually linked ideas together. This is particularly helpful for downstream tasks like statement extraction, where context heavily influences accuracy.\n",
+    "\n",
+    "The chunker class contains two methods:\n",
+    "\n",
+    "- `find_quarter`\n",
+    "\n",
+    "  This method attempts to extract the fiscal quarter (e.g., \"Q1 2023\") directly from the transcript text using a simple regular expression. In this case, this is straightforward as the data format of quarters in the transcripts is consistent and well defined.\n",
+    "\n",
+    "  However, in real world scenarios, detecting the quarter reliably may require more work. Across multiple sources or document types the detailing of the quarter is likely to be different. LLMs are great tools to help alleviate this issue. Try using GPT-4.1-mini with a prompt specifically to extract the quarter given wider context from the document. \n",
+    "\n",
+    "- `generate_transcripts_and_chunks`\n",
+    "\n",
+    "  This is the core method that takes in a dataset (as an iterable of dictionaries) and returns a list of `Transcript` objects each populated with semantically derived `Chunk`s. It performs the following steps:\n",
+    "\n",
+    "  1. *Transcript creation*: Initializes `Transcript` objects using the provided text, company, and date fields\n",
+    "  2. *Filtering*: Uses the `SemanticChunker` from [chonkie](https://chonkie.ai/) along with OpenAI's text-embedding-3-small model to split the transcript into logical segments\n",
+    "  3. *Chunk assignment*: Wraps each semantic segment into a `Chunk` model, attaching relevant metadata like start and end indices\n",
+    "\n",
+    "The chunker falls in to this part of our pipeline:"
+   ]
+  },
+  {
+   "attachments": {
+    "5463dc6a-17fc-4f35-adde-5a77dc191925.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<!-- ![Screenshot 2025-06-23 at 11.44.13.png](attachment:5463dc6a-17fc-4f35-adde-5a77dc191925.png) -->\n",
+    "<img\n",
+    "  src=\"../../../images/06_temporal_agent_chunker.png\"\n",
+    "  alt=\"Temporal Agent Pipeline - Chunker\"\n",
+    "  style=\"width:791px; height:auto;\"\n",
+    "/>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import re\n",
+    "from concurrent.futures import ThreadPoolExecutor, as_completed\n",
+    "from typing import Any\n",
+    "\n",
+    "from chonkie import OpenAIEmbeddings, SemanticChunker\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "\n",
+    "class Chunker:\n",
+    "    \"\"\"\n",
+    "    Takes in transcripts of earnings calls and extracts quarter information and splits\n",
+    "    the transcript into semantically meaningful chunks using embedding-based similarity.\n",
+    "    \"\"\"\n",
+    "\n",
+    "    def __init__(self, model: str = \"text-embedding-3-small\"):\n",
+    "        self.model = model\n",
+    "\n",
+    "    def find_quarter(self, text: str) -> str | None:\n",
+    "        \"\"\"Extract the quarter (e.g., 'Q1 2023') from the input text if present, otherwise return None.\"\"\"\n",
+    "        # In this dataset we can just use regex to find the quarter as it is consistently defined\n",
+    "        search_results = re.findall(r\"[Q]\\d\\s\\d{4}\", text)\n",
+    "\n",
+    "        if search_results:\n",
+    "            quarter = str(search_results[0])\n",
+    "            return quarter\n",
+    "\n",
+    "        return None\n",
+    "\n",
+    "\n",
+    "    def generate_transcripts_and_chunks(\n",
+    "        self,\n",
+    "        dataset: Any,\n",
+    "        company: list[str] | None = None,\n",
+    "        text_key: str = \"transcript\",\n",
+    "        company_key: str = \"company\",\n",
+    "        date_key: str = \"date\",\n",
+    "        threshold_value: float = 0.7,\n",
+    "        min_sentences: int = 3,\n",
+    "        num_workers: int = 50,\n",
+    "    ) -> list[Transcript]:\n",
+    "        \"\"\"Populate Transcript objects with semantic chunks.\"\"\"\n",
+    "        # Populate the Transcript objects with the passed data on the transcripts\n",
+    "        transcripts = [\n",
+    "            Transcript(\n",
+    "                text=d[text_key],\n",
+    "                company=d[company_key],\n",
+    "                date=d[date_key],\n",
+    "                quarter=self.find_quarter(d[text_key]),\n",
+    "            )\n",
+    "            for d in dataset\n",
+    "        ]\n",
+    "\n",
+    "        if company:\n",
+    "            transcripts = [t for t in transcripts if t.company in company]\n",
+    "\n",
+    "        def _process(t: Transcript) -> Transcript:\n",
+    "            if not hasattr(_process, \"chunker\"):\n",
+    "                embed_model = OpenAIEmbeddings(self.model)\n",
+    "                _process.chunker = SemanticChunker(\n",
+    "                    embedding_model=embed_model,\n",
+    "                    threshold=threshold_value,\n",
+    "                    min_sentences=max(min_sentences, 1),\n",
+    "                )\n",
+    "            semantic_chunks = _process.chunker.chunk(t.text)\n",
+    "            t.chunks = [\n",
+    "                Chunk(\n",
+    "                    text=c.text,\n",
+    "                    metadata={\n",
+    "                        \"start_index\": getattr(c, \"start_index\", None),\n",
+    "                        \"end_index\": getattr(c, \"end_index\", None),\n",
+    "                    },\n",
+    "                )\n",
+    "                for c in semantic_chunks\n",
+    "            ]\n",
+    "            return t\n",
+    "\n",
+    "        # Create the semantic chunks and add them to their respective Transcript object using a thread pool\n",
+    "        with ThreadPoolExecutor(max_workers=num_workers) as pool:\n",
+    "            futures = [pool.submit(_process, t) for t in transcripts]\n",
+    "            transcripts = [\n",
+    "                f.result()\n",
+    "                for f in tqdm(\n",
+    "                    as_completed(futures),\n",
+    "                    total=len(futures),\n",
+    "                    desc=\"Generating Semantic Chunks\",\n",
+    "                )\n",
+    "            ]\n",
+    "\n",
+    "        return transcripts\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "raw_data = list(my_dataset)\n",
+    "\n",
+    "chunker = Chunker()\n",
+    "transcripts = chunker.generate_transcripts_and_chunks(raw_data)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Alternatively, we can load just the `AMD` and `NVDA` pre-chunked transcripts from pre-processed files in `transcripts/`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pickle\n",
+    "from pathlib import Path\n",
+    "\n",
+    "\n",
+    "def load_transcripts_from_pickle(directory_path: str = \"transcripts/\") -> list[Transcript]:\n",
+    "    \"\"\"Load all pickle files from a directory into a dictionary.\"\"\"\n",
+    "    loaded_transcripts = []\n",
+    "    dir_path = Path(directory_path).resolve()\n",
+    "\n",
+    "\n",
+    "    for pkl_file in sorted(dir_path.glob(\"*.pkl\")):\n",
+    "        try:\n",
+    "            with open(pkl_file, \"rb\") as f:\n",
+    "                transcript = pickle.load(f)\n",
+    "                # Ensure it's a Transcript object\n",
+    "                if not isinstance(transcript, Transcript):\n",
+    "                    transcript = Transcript(**transcript)\n",
+    "                loaded_transcripts.append(transcript)\n",
+    "                print(f\"✅ Loaded transcript from {pkl_file.name}\")\n",
+    "        except Exception as e:\n",
+    "            print(f\"❌ Error loading {pkl_file.name}: {e}\")\n",
+    "\n",
+    "    return loaded_transcripts"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# transcripts = load_transcripts_from_pickle()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we can inspect a couple of chunks:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chunks = transcripts[0].chunks\n",
+    "if chunks is not None:\n",
+    "    for i, chunk in enumerate(chunks[21:23]):\n",
+    "        print(f\"Chunk {i+21}:\")\n",
+    "        print(f\"  ID: {chunk.id}\")\n",
+    "        print(f\"  Text: {repr(chunk.text[:200])}{'...' if len(chunk.text) > 100 else ''}\")\n",
+    "        print(f\"  Metadata: {chunk.metadata}\")\n",
+    "        print()\n",
+    "else:\n",
+    "    print(\"No chunks found for the first transcript.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "With this, we have successfully split our transcripts into semantically sectioned chunks. We can now move onto the next steps in our pipeline."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.2.3. Laying the Foundations for our Temporal Agent"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Before we move onto defining the `TemporalAgent` class, we will first define the prompts and data models that are needed for it to function."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Formalizing our label definitions "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "For our temporal agent to be able to accurately extract the statement and temporal types we need to provide it with sufficiently detailed and specific context. For convenience, we define these within a structured format below. \n",
+    "\n",
+    "Each label contains three crucial pieces of information that we will later pass to our LLMs in prompts.\n",
+    "<ul style=\"margin-left: 1em; line-height: 1.6; padding-left: 0.5em;\">\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <code>definition</code><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Provides a concise description of what the label represents. It establishes the conceptual boundaries of the statement or temporal type and ensures consistency in interpretation across examples.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <code>date_handling_guidance</code><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Explains how to interpret the temporal validity of a statement associated with the label. It describes how the <code>valid_at</code> and <code>invalid_at</code> dates should be derived when processing instances of that label.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <code>date_handling_examples</code><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Includes illustrative examples of how real-world statements would be labelled and temporally annotated under this label. These will be used as few-shot examples to the LLMs downstream.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "</ul>\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "LABEL_DEFINITIONS: dict[str, dict[str, dict[str, str]]] = {\n",
+    "    \"episode_labelling\": {\n",
+    "        \"FACT\": dict(\n",
+    "            definition=(\n",
+    "                \"Statements that are objective and can be independently \"\n",
+    "                \"verified or falsified through evidence.\"\n",
+    "            ),\n",
+    "            date_handling_guidance=(\n",
+    "                \"These statements can be made up of multiple static and \"\n",
+    "                \"dynamic temporal events marking for example the start, end, \"\n",
+    "                \"and duration of the fact described statement.\"\n",
+    "            ),\n",
+    "            date_handling_example=(\n",
+    "                \"'Company A owns Company B in 2022', 'X caused Y to happen', \"\n",
+    "                \"or 'John said X at Event' are verifiable facts which currently \"\n",
+    "                \"hold true unless we have a contradictory fact.\"\n",
+    "            ),\n",
+    "        ),\n",
+    "        \"OPINION\": dict(\n",
+    "            definition=(\n",
+    "                \"Statements that contain personal opinions, feelings, values, \"\n",
+    "                \"or judgments that are not independently verifiable. It also \"\n",
+    "                \"includes hypothetical and speculative statements.\"\n",
+    "            ),\n",
+    "            date_handling_guidance=(\n",
+    "                \"This statement is always static. It is a record of the date the \"\n",
+    "                \"opinion was made.\"\n",
+    "            ),\n",
+    "            date_handling_example=(\n",
+    "                \"'I like Company A's strategy', 'X may have caused Y to happen', \"\n",
+    "                \"or 'The event felt like X' are opinions and down to the reporters \"\n",
+    "                \"interpretation.\"\n",
+    "            ),\n",
+    "        ),\n",
+    "        \"PREDICTION\": dict(\n",
+    "            definition=(\n",
+    "                \"Uncertain statements about the future on something that might happen, \"\n",
+    "                \"a hypothetical outcome, unverified claims. It includes interpretations \"\n",
+    "                \"and suggestions. If the tense of the statement changed, the statement \"\n",
+    "                \"would then become a fact.\"\n",
+    "            ),\n",
+    "            date_handling_guidance=(\n",
+    "                \"This statement is always static. It is a record of the date the \"\n",
+    "                \"prediction was made.\"\n",
+    "            ),\n",
+    "            date_handling_example=(\n",
+    "                \"'It is rumoured that Dave will resign next month', 'Company A expects \"\n",
+    "                \"X to happen', or 'X suggests Y' are all predictions.\"\n",
+    "            ),\n",
+    "        ),\n",
+    "    },\n",
+    "    \"temporal_labelling\": {\n",
+    "        \"STATIC\": dict(\n",
+    "            definition=(\n",
+    "                \"Often past tense, think -ed verbs, describing single points-in-time. \"\n",
+    "                \"These statements are valid from the day they occurred and are never \"\n",
+    "                \"invalid. Refer to single points in time at which an event occurred, \"\n",
+    "                \"the fact X occurred on that date will always hold true.\"\n",
+    "            ),\n",
+    "            date_handling_guidance=(\n",
+    "                \"The valid_at date is the date the event occurred. The invalid_at date \"\n",
+    "                \"is None.\"\n",
+    "            ),\n",
+    "            date_handling_example=(\n",
+    "                \"'John was appointed CEO on 4th Jan 2024', 'Company A reported X percent \"\n",
+    "                \"growth from last FY', or 'X resulted in Y to happen' are valid the day \"\n",
+    "                \"they occurred and are never invalid.\"\n",
+    "            ),\n",
+    "        ),\n",
+    "        \"DYNAMIC\": dict(\n",
+    "            definition=(\n",
+    "                \"Often present tense, think -ing verbs, describing a period of time. \"\n",
+    "                \"These statements are valid for a specific period of time and are usually \"\n",
+    "                \"invalidated by a Static fact marking the end of the event or start of a \"\n",
+    "                \"contradictory new one. The statement could already be referring to a \"\n",
+    "                \"discrete time period (invalid) or may be an ongoing relationship (not yet \"\n",
+    "                \"invalid).\"\n",
+    "            ),\n",
+    "            date_handling_guidance=(\n",
+    "                \"The valid_at date is the date the event started. The invalid_at date is \"\n",
+    "                \"the date the event or relationship ended, for ongoing events this is None.\"\n",
+    "            ),\n",
+    "            date_handling_example=(\n",
+    "                \"'John is the CEO', 'Company A remains a market leader', or 'X is continuously \"\n",
+    "                \"causing Y to decrease' are valid from when the event started and are invalidated \"\n",
+    "                \"by a new event.\"\n",
+    "            ),\n",
+    "        ),\n",
+    "        \"ATEMPORAL\": dict(\n",
+    "            definition=(\n",
+    "                \"Statements that will always hold true regardless of time therefore have no \"\n",
+    "                \"temporal bounds.\"\n",
+    "            ),\n",
+    "            date_handling_guidance=(\n",
+    "                \"These statements are assumed to be atemporal and have no temporal bounds. Both \"\n",
+    "                \"their valid_at and invalid_at are None.\"\n",
+    "            ),\n",
+    "            date_handling_example=(\n",
+    "                \"'A stock represents a unit of ownership in a company', 'The earth is round', or \"\n",
+    "                \"'Europe is a continent'. These statements are true regardless of time.\"\n",
+    "            ),\n",
+    "        ),\n",
+    "    },\n",
+    "}\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.2.4. Statement Extraction "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\"Statement Extraction\" refers to the process of splitting our semantic chunks into the smallest possible \"atomic\" facts. Within our Temporal Agent, this is achieved by: \n",
+    "\n",
+    "<ol style=\"margin-left: 1em; line-height: 1.6; padding-left: 0.5em;\">\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Finding every standalone, declarative claim</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Extract statements that can stand on their own as complete subject-predicate-object expressions without relying on surrounding context.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Ensuring atomicity</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Break down complex or compound sentences into minimal, indivisible factual units, each expressing a single relationship.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Resolving references</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Replace pronouns or abstract references (e.g., \"he\" or \"The Company\") with specific entities (e.g., \"John Smith\", \"AMD\") using the main subject for disambiguation.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Preserving temporal and quantitative precision</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Retain explicit dates, durations, and quantities to anchor each fact precisely in time and scale.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Labelling each extracted statement</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Every statement is annotated with a <code>StatementType</code> and a <code>TemporalType</code>.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "</ol>\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Temporal Types\n",
+    "\n",
+    "The `TemporalType` enum provides a standardized set of temporal categories that make it easier to classify and work with statements extracted from earnings call transcripts.\n",
+    "\n",
+    "Each category captures a different kind of temporal reference:\n",
+    "\n",
+    "* **Atemporal**: Statements that are universally true and invariant over time (e.g., “The speed of light in a vacuum is ≈3×10⁸ m s⁻¹.”).\n",
+    "* **Static**: Statements that became true at a specific point in time and remain unchanged thereafter (e.g., “Person YY was CEO of Company XX on October 23rd, 2014.”).\n",
+    "* **Dynamic**: Statements that may change over time and require temporal context to interpret accurately (e.g., “Person YY is CEO of Company XX.”)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from enum import StrEnum\n",
+    "\n",
+    "\n",
+    "class TemporalType(StrEnum):\n",
+    "    \"\"\"Enumeration of temporal types of statements.\"\"\"\n",
+    "\n",
+    "    ATEMPORAL = \"ATEMPORAL\"\n",
+    "    STATIC = \"STATIC\"\n",
+    "    DYNAMIC = \"DYNAMIC\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Statement Types\n",
+    "\n",
+    "Similarly, the `StatementType` enum classifies the nature of each extracted statement, capturing its epistemic characteristics.\n",
+    "\n",
+    "* **Fact**: A statement that asserts a verifiable claim considered true at the time it was made. However, it may later be superseded or contradicted by other facts (e.g., updated information or corrections).\n",
+    "* **Opinion**: A subjective statement reflecting a speaker’s belief, sentiment, or judgment. By nature, opinions are considered temporally true at the moment they are expressed.\n",
+    "* **Prediction**: A forward-looking or hypothetical statement about a potential future event or outcome. Temporally, a prediction is assumed to hold true from the time of utterance until the conclusion of the inferred prediction window."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class StatementType(StrEnum):\n",
+    "    \"\"\"Enumeration of statement types for statements.\"\"\"\n",
+    "\n",
+    "    FACT = \"FACT\"\n",
+    "    OPINION = \"OPINION\"\n",
+    "    PREDICTION = \"PREDICTION\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Raw Statement"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The `RawStatement` model represents an individual statement extracted by an LLM, annotated with both its semantic type (`StatementType`) and temporal classification (`TemporalType`). These raw statements serve as intermediate representations and are intended to be transformed into `TemporalEvent` objects in later processing stages.\n",
+    "\n",
+    "Core fields:\n",
+    "- `statement`: The textual content of the extracted statement\n",
+    "- `statement_type`: The type of statement (Fact, Opinion, Prediction), based on the `StatementType` enum\n",
+    "- `temporal_type`: The temporal classification of the statement (Static, Dynamic, Atemporal), drawn from the `TemporalType` enum\n",
+    "\n",
+    "The model includes field-level validators to ensure that all type annotations conform to their respective enums, providing a layer of robustness against invalid input.\n",
+    "\n",
+    "The companion model `RawStatementList` contains the output of the statement extraction step: a list of `RawStatement` instances."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pydantic import field_validator\n",
+    "\n",
+    "\n",
+    "class RawStatement(BaseModel):\n",
+    "    \"\"\"Model representing a raw statement with type and temporal information.\"\"\"\n",
+    "\n",
+    "    statement: str\n",
+    "    statement_type: StatementType\n",
+    "    temporal_type: TemporalType\n",
+    "\n",
+    "    @field_validator(\"temporal_type\", mode=\"before\")\n",
+    "    @classmethod\n",
+    "    def _parse_temporal_label(cls, value: str | None) -> TemporalType:\n",
+    "        if value is None:\n",
+    "            return TemporalType.ATEMPORAL\n",
+    "        cleaned_value = value.strip().upper()\n",
+    "        try:\n",
+    "            return TemporalType(cleaned_value)\n",
+    "        except ValueError as e:\n",
+    "            raise ValueError(f\"Invalid temporal type: {value}. Must be one of {[t.value for t in TemporalType]}\") from e\n",
+    "\n",
+    "    @field_validator(\"statement_type\", mode=\"before\")\n",
+    "    @classmethod\n",
+    "    def _parse_statement_label(cls, value: str | None = None) -> StatementType:\n",
+    "        if value is None:\n",
+    "            return StatementType.FACT\n",
+    "        cleaned_value = value.strip().upper()\n",
+    "        try:\n",
+    "            return StatementType(cleaned_value)\n",
+    "        except ValueError as e:\n",
+    "            raise ValueError(f\"Invalid temporal type: {value}. Must be one of {[t.value for t in StatementType]}\") from e\n",
+    "\n",
+    "class RawStatementList(BaseModel):\n",
+    "    \"\"\"Model representing a list of raw statements.\"\"\"\n",
+    "\n",
+    "    statements: list[RawStatement]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Statement Extraction Prompt"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This is the core prompt that powers our Temporal Agent's ability to extract and label atomic statements. It is written in [Jinja](https://jinja.palletsprojects.com/en/stable/) allowing us to modularly compose dynamic inputs without rewriting the core logic.\n",
+    "\n",
+    "##### Anatomy of the prompt\n",
+    "<ol style=\"margin-left: 1em; line-height: 1.6; padding-left: 0.5em;\">\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Set up the extraction task</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      We instruct the assistant to behave like a domain expert in finance and clearly define the two subtasks: (i) extracting atomic, declarative statements, and (ii) labelling each with a <code>statement_type</code> and a <code>temporal_type</code>.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Enforces strict extraction guidelines</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      The rules for extraction help to enforce consistency and clarity. Statements must:\n",
+    "    </p>\n",
+    "    <ul style=\"margin-top: 0.5em; margin-bottom: 0.5em; padding-left: 1em;\">\n",
+    "      <li style=\"margin-bottom: 0.5em;\">Be structured as clean subject-predicate-object triplets</li>\n",
+    "      <li style=\"margin-bottom: 0.5em;\">Be self-contained and context-independent</li>\n",
+    "      <li style=\"margin-bottom: 0.5em;\">Resolve co-references (e.g., \"he\" → \"John Smith\")</li>\n",
+    "      <li style=\"margin-bottom: 0.5em;\">Include temporal/quantitative qualifiers where present</li>\n",
+    "      <li>Be split when multiple events or temporalities are described</li>\n",
+    "    </ul>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Supports plug-and-play definitions</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      The <code>{% if definitions %}</code> block makes it easy to inject structured definitions such as statement categories, temporal types, and domain-specific terms.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Includes few-shot examples</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      We provide an annotated example chunk and the corresponding JSON output to demonstrate to the model how it should behave.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "</ol>\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "statement_extraction_prompt = '''\n",
+    "{% macro tidy(name) -%}\n",
+    "  {{ name.replace('_', ' ')}}\n",
+    "{%- endmacro %}\n",
+    "\n",
+    "You are an expert finance professional and information-extraction assistant.\n",
+    "\n",
+    "===Inputs===\n",
+    "{% if inputs %}\n",
+    "{% for key, val in inputs.items() %}\n",
+    "- {{ key }}: {{val}}\n",
+    "{% endfor %}\n",
+    "{% endif %}\n",
+    "\n",
+    "===Tasks===\n",
+    "1. Identify and extract atomic declarative statements from the chunk given the extraction guidelines\n",
+    "2. Label these (1) as Fact, Opinion, or Prediction and (2) temporally as Static or Dynamic\n",
+    "\n",
+    "===Extraction Guidelines===\n",
+    "- Structure statements to clearly show subject-predicate-object relationships\n",
+    "- Each statement should express a single, complete relationship (it is better to have multiple smaller statements to achieve this)\n",
+    "- Avoid complex or compound predicates that combine multiple relationships\n",
+    "- Must be understandable without requiring context of the entire document\n",
+    "- Should be minimally modified from the original text\n",
+    "- Must be understandable without requiring context of the entire document,\n",
+    "    - resolve co-references and pronouns to extract complete statements, if in doubt use main_entity for example:\n",
+    "      \"your nearest competitor\" -> \"main_entity's nearest competitor\"\n",
+    "    - There should be no reference to abstract entities such as 'the company', resolve to the actual entity name.\n",
+    "    - expand abbreviations and acronyms to their full form\n",
+    "\n",
+    "- Statements are associated with a single temporal event or relationship\n",
+    "- Include any explicit dates, times, or quantitative qualifiers that make the fact precise\n",
+    "- If a statement refers to more than 1 temporal event, it should be broken into multiple statements describing the different temporalities of the event.\n",
+    "- If there is a static and dynamic version of a relationship described, both versions should be extracted\n",
+    "\n",
+    "{%- if definitions %}\n",
+    "  {%- for section_key, section_dict in definitions.items() %}\n",
+    "==== {{ tidy(section_key) | upper }} DEFINITIONS & GUIDANCE ====\n",
+    "    {%- for category, details in section_dict.items() %}\n",
+    "{{ loop.index }}. {{ category }}\n",
+    "- Definition: {{ details.get(\"definition\", \"\") }}\n",
+    "    {% endfor -%}\n",
+    "  {% endfor -%}\n",
+    "{% endif -%}\n",
+    "\n",
+    "===Examples===\n",
+    "Example Chunk: \"\"\"\n",
+    "  TechNova Q1 Transcript (Edited Version)\n",
+    "  Attendees:\n",
+    "  * Matt Taylor\n",
+    "    ABC Ltd - Analyst\n",
+    "  * Taylor Morgan\n",
+    "    BigBank Senior - Coordinator\n",
+    "  ----\n",
+    "  On April 1st, 2024, John Smith was appointed CFO of TechNova Inc. He works alongside the current Senior VP Olivia Doe. He is currently overseeing the company’s global restructuring initiative, which began in May 2024 and is expected to continue into 2025.\n",
+    "  Analysts believe this strategy may boost profitability, though others argue it risks employee morale. One investor stated, “I think Jane has the right vision.”\n",
+    "  According to TechNova’s Q1 report, the company achieved a 10% increase in revenue compared to Q1 2023. It is expected that TechNova will launch its AI-driven product line in Q3 2025.\n",
+    "  Since June 2024, TechNova Inc has been negotiating strategic partnerships in Asia. Meanwhile, it has also been expanding its presence in Europe, starting July 2024. As of September 2025, the company is piloting a remote-first work policy across all departments.\n",
+    "  Competitor SkyTech announced last month they have developed a new AI chip and launched their cloud-based learning platform.\n",
+    "\"\"\"\n",
+    "\n",
+    "Example Output: {\n",
+    "  \"statements\": [\n",
+    "    {\n",
+    "      \"statement\": \"Matt Taylor works at ABC Ltd.\",\n",
+    "      \"statement_type\": \"FACT\",\n",
+    "      \"temporal_type\": \"DYNAMIC\"\n",
+    "    },\n",
+    "    {\n",
+    "      \"statement\": \"Matt Taylor is an Analyst.\",\n",
+    "      \"statement_type\": \"FACT\",\n",
+    "      \"temporal_type\": \"DYNAMIC\"\n",
+    "    },\n",
+    "    {\n",
+    "      \"statement\": \"Taylor Morgan works at BigBank.\",\n",
+    "      \"statement_type\": \"FACT\",\n",
+    "      \"temporal_type\": \"DYNAMIC\"\n",
+    "    },\n",
+    "    {\n",
+    "      \"statement\": \"Taylor Morgan is a Senior Coordinator.\",\n",
+    "      \"statement_type\": \"FACT\",\n",
+    "      \"temporal_type\": \"DYNAMIC\"\n",
+    "    },\n",
+    "    {\n",
+    "      \"statement\": \"John Smith was appointed CFO of TechNova Inc on April 1st, 2024.\",\n",
+    "      \"statement_type\": \"FACT\",\n",
+    "      \"temporal_type\": \"STATIC\"\n",
+    "    },\n",
+    "    {\n",
+    "      \"statement\": \"John Smith has held position CFO of TechNova Inc from April 1st, 2024.\",\n",
+    "      \"statement_type\": \"FACT\",\n",
+    "      \"temporal_type\": \"DYNAMIC\"\n",
+    "    },\n",
+    "    {\n",
+    "      \"statement\": \"Olivia Doe is the Senior VP of TechNova Inc.\",\n",
+    "      \"statement_type\": \"FACT\",\n",
+    "      \"temporal_type\": \"DYNAMIC\"\n",
+    "    },\n",
+    "    {\n",
+    "      \"statement\": \"John Smith works with Olivia Doe.\",\n",
+    "      \"statement_type\": \"FACT\",\n",
+    "      \"temporal_type\": \"DYNAMIC\"\n",
+    "    },\n",
+    "    {\n",
+    "      \"statement\": \"John Smith is overseeing TechNova Inc's global restructuring initiative starting May 2024.\",\n",
+    "      \"statement_type\": \"FACT\",\n",
+    "      \"temporal_type\": \"DYNAMIC\"\n",
+    "    },\n",
+    "    {\n",
+    "      \"statement\": \"Analysts believe TechNova Inc's strategy may boost profitability.\",\n",
+    "      \"statement_type\": \"OPINION\",\n",
+    "      \"temporal_type\": \"STATIC\"\n",
+    "    },\n",
+    "    {\n",
+    "      \"statement\": \"Some argue that TechNova Inc's strategy risks employee morale.\",\n",
+    "      \"statement_type\": \"OPINION\",\n",
+    "      \"temporal_type\": \"STATIC\"\n",
+    "    },\n",
+    "    {\n",
+    "      \"statement\": \"An investor stated 'I think John has the right vision' on an unspecified date.\",\n",
+    "      \"statement_type\": \"OPINION\",\n",
+    "      \"temporal_type\": \"STATIC\"\n",
+    "    },\n",
+    "    {\n",
+    "      \"statement\": \"TechNova Inc achieved a 10% increase in revenue in Q1 2024 compared to Q1 2023.\",\n",
+    "      \"statement_type\": \"FACT\",\n",
+    "      \"temporal_type\": \"DYNAMIC\"\n",
+    "    },\n",
+    "    {\n",
+    "      \"statement\": \"It is expected that TechNova Inc will launch its AI-driven product line in Q3 2025.\",\n",
+    "      \"statement_type\": \"PREDICTION\",\n",
+    "      \"temporal_type\": \"DYNAMIC\"\n",
+    "    },\n",
+    "    {\n",
+    "      \"statement\": \"TechNova Inc started negotiating strategic partnerships in Asia in June 2024.\",\n",
+    "      \"statement_type\": \"FACT\",\n",
+    "      \"temporal_type\": \"STATIC\"\n",
+    "    },\n",
+    "    {\n",
+    "      \"statement\": \"TechNova Inc has been negotiating strategic partnerships in Asia since June 2024.\",\n",
+    "      \"statement_type\": \"FACT\",\n",
+    "      \"temporal_type\": \"DYNAMIC\"\n",
+    "    },\n",
+    "    {\n",
+    "      \"statement\": \"TechNova Inc has been expanding its presence in Europe since July 2024.\",\n",
+    "      \"statement_type\": \"FACT\",\n",
+    "      \"temporal_type\": \"DYNAMIC\"\n",
+    "    },\n",
+    "    {\n",
+    "      \"statement\": \"TechNova Inc started expanding its presence in Europe in July 2024.\",\n",
+    "      \"statement_type\": \"FACT\",\n",
+    "      \"temporal_type\": \"STATIC\"\n",
+    "    },\n",
+    "    {\n",
+    "      \"statement\": \"TechNova Inc is going to pilot a remote-first work policy across all departments as of September 2025.\",\n",
+    "      \"statement_type\": \"FACT\",\n",
+    "      \"temporal_type\": \"STATIC\"\n",
+    "    },\n",
+    "    {\n",
+    "      \"statement\": \"SkyTech is a competitor of TechNova.\",\n",
+    "      \"statement_type\": \"FACT\",\n",
+    "      \"temporal_type\": \"DYNAMIC\"\n",
+    "    },\n",
+    "    {\n",
+    "      \"statement\": \"SkyTech developed new AI chip.\",\n",
+    "      \"statement_type\": \"FACT\",\n",
+    "      \"temporal_type\": \"STATIC\"\n",
+    "    },\n",
+    "    {\n",
+    "      \"statement\": \"SkyTech launched cloud-based learning platform.\",\n",
+    "      \"statement_type\": \"FACT\",\n",
+    "      \"temporal_type\": \"STATIC\"\n",
+    "    }\n",
+    "  ]\n",
+    "}\n",
+    "===End of Examples===\n",
+    "\n",
+    "**Output format**\n",
+    "Return only a list of extracted labelled statements in the JSON ARRAY of objects that match the schema below:\n",
+    "{{ json_schema }}\n",
+    "'''"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.2.5. Temporal Range Extraction"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Raw temporal range"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The `RawTemporalRange` model holds the raw extraction of `valid_at` and `invalid_at` date strings for a statement. These both use the date-time [supported string property](https://platform.openai.com/docs/guides/structured-outputs?api-mode=responses ).\n",
+    "\n",
+    "- `valid_at` represents the start of the validity period for a statement\n",
+    "- `invalid_at` represents the end of the validity period for a statement"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class RawTemporalRange(BaseModel):\n",
+    "    \"\"\"Model representing the raw temporal validity range as strings.\"\"\"\n",
+    "\n",
+    "    valid_at: str | None = Field(..., json_schema_extra={\"format\": \"date-time\"})\n",
+    "    invalid_at: str | None = Field(..., json_schema_extra={\"format\": \"date-time\"})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Temporal validity range"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "While the `RawTemporalRange` model preserves the originally extracted date strings, the `TemporalValidityRange` model transforms these into standardized `datetime` objects for downstream processing. \n",
+    "\n",
+    "It parses the raw `valid_at` and `invalid_at` values, converting them from strings into timezone-aware `datetime` instances. This is handled through a field-level validator."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from utils import parse_date_str\n",
+    "\n",
+    "\n",
+    "class TemporalValidityRange(BaseModel):\n",
+    "    \"\"\"Model representing the parsed temporal validity range as datetimes.\"\"\"\n",
+    "\n",
+    "    valid_at: datetime | None = None\n",
+    "    invalid_at: datetime | None = None\n",
+    "\n",
+    "    @field_validator(\"valid_at\", \"invalid_at\", mode=\"before\")\n",
+    "    @classmethod\n",
+    "    def _parse_date_string(cls, value: str | datetime | None) -> datetime | None:\n",
+    "        if isinstance(value, datetime) or value is None:\n",
+    "            return value\n",
+    "        return parse_date_str(value)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Date extraction prompt"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's now create the prompt that guides our Temporal Agent in accurately determining the temporal validity of statements.\n",
+    "\n",
+    "##### Anatomy of the prompt\n",
+    "\n",
+    "This prompt helps the Temporal Agent precisely understand and extract temporal validity ranges.\n",
+    "\n",
+    "<ol style=\"margin-left: 1em; line-height: 1.6; padding-left: 0.5em;\">\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Clearly Defines the Extraction Task</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      The prompt instructs our model to determine when a statement became true (<code>valid_at</code>) and optionally when it stopped being true (<code>invalid_at</code>).\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Uses Contextual Guidance</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      By dynamically incorporating <code>{{ inputs.temporal_type }}</code> and <code>{{ inputs.statement_type }}</code>, the prompt guides the model in interpreting temporal nuances based on the nature of each statement (like distinguishing facts from predictions or static from dynamic contexts).\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Ensures Consistency with Clear Formatting Rules</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      To maintain clarity and consistency, the prompt requires all dates to be converted into standardized ISO 8601 date-time formats, normalized to UTC. It explicitly anchors relative expressions (like \"last quarter\") to known publication dates, making temporal information precise and reliable.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Aligns with Business Reporting Cycles</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Recognizing the practical need for quarter-based reasoning common in business and financial contexts, the prompt can interpret and calculate temporal ranges based on business quarters, minimizing ambiguity.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Adapts to Statement Types for Semantic Accuracy</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Specific rules ensure the semantic integrity of statements—for example, opinions might only have a start date (<code>valid_at</code>) reflecting the moment they were expressed, while predictions will clearly define their forecast window using an end date (<code>invalid_at</code>).\n",
+    "    </p>\n",
+    "  </li>\n",
+    "</ol>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "date_extraction_prompt = \"\"\"\n",
+    "{#\n",
+    "  This prompt (template) is adapted from [getzep/graphiti]\n",
+    "  Licensed under the Apache License, Version 2.0\n",
+    "\n",
+    "  Original work:\n",
+    "    https://github.com/getzep/graphiti/blob/main/graphiti_core/prompts/extract_edge_dates.py\n",
+    "\n",
+    "  Modifications made by Tomoro on 2025-04-14\n",
+    "  See the LICENSE file for the full Apache 2.0 license text.\n",
+    "#}\n",
+    "\n",
+    "{% macro tidy(name) -%}\n",
+    "  {{ name.replace('_', ' ')}}\n",
+    "{%- endmacro %}\n",
+    "\n",
+    "INPUTS:\n",
+    "{% if inputs %}\n",
+    "{% for key, val in inputs.items() %}\n",
+    "- {{ key }}: {{val}}\n",
+    "{% endfor %}\n",
+    "{% endif %}\n",
+    "\n",
+    "TASK:\n",
+    "- Analyze the statement and determine the temporal validity range as dates for the temporal event or relationship described.\n",
+    "- Use the temporal information you extracted, guidelines below, and date of when the statement was made or published. Do not use any external knowledge to determine validity ranges.\n",
+    "- Only set dates if they explicitly relate to the validity of the relationship described in the statement. Otherwise ignore the time mentioned.\n",
+    "- If the relationship is not of spanning nature and represents a single point in time, but you are still able to determine the date of occurrence, set the valid_at only.\n",
+    "\n",
+    "{{ inputs.get(\"temporal_type\") | upper }} Temporal Type Specific Guidance:\n",
+    "{% for key, guide in temporal_guide.items() %}\n",
+    "- {{ tidy(key) | capitalize }}: {{ guide }}\n",
+    "{% endfor %}\n",
+    "\n",
+    "{{ inputs.get(\"statement_type\") | upper }} Statement Type Specific Guidance:\n",
+    "{%for key, guide in statement_guide.items() %}\n",
+    "- {{ tidy(key) | capitalize }}: {{ guide }}\n",
+    "{% endfor %}\n",
+    "\n",
+    "Validity Range Definitions:\n",
+    "- `valid_at` is the date and time when the relationship described by the statement became true or was established.\n",
+    "- `invalid_at` is the date and time when the relationship described by the statement stopped being true or ended. This may be None if the event is ongoing.\n",
+    "\n",
+    "General Guidelines:\n",
+    "  1. Use ISO 8601 format (YYYY-MM-DDTHH:MM:SS.SSSSSSZ) for datetimes.\n",
+    "  2. Use the reference or publication date as the current time when determining the valid_at and invalid_at dates.\n",
+    "  3. If the fact is written in the present tense without containing temporal information, use the reference or publication date for the valid_at date\n",
+    "  4. Do not infer dates from related events or external knowledge. Only use dates that are directly stated to establish or change the relationship.\n",
+    "  5. Convert relative times (e.g., “two weeks ago”) into absolute ISO 8601 datetimes based on the reference or publication timestamp.\n",
+    "  6. If only a date is mentioned without a specific time, use 00:00:00 (midnight) for that date.\n",
+    "  7. If only year or month is mentioned, use the start or end as appropriate at 00:00:00 e.g. do not select a random date if only the year is mentioned, use YYYY-01-01 or YYYY-12-31.\n",
+    "  8. Always include the time zone offset (use Z for UTC if no specific time zone is mentioned).\n",
+    "{% if inputs.get('quarter') and inputs.get('publication_date') %}\n",
+    "  9. Assume that {{ inputs.quarter }} ends on {{ inputs.publication_date }} and infer dates for any Qx references from there.\n",
+    "{% endif %}\n",
+    "\n",
+    "Statement Specific Rules:\n",
+    "- when `statement_type` is **opinion** only valid_at must be set\n",
+    "- when `statement_type` is **prediction** set its `invalid_at` to the **end of the prediction window** explicitly mentioned in the text.\n",
+    "\n",
+    "Never invent dates from outside knowledge.\n",
+    "\n",
+    "**Output format**\n",
+    "Return only the validity range in the JSON ARRAY of objects that match the schema below:\n",
+    "{{ json_schema }}\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.2.6. Creating our Triplets"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We will now build up the definitions and prompts to create the our triplets. As discussed above, these are a combination of:\n",
+    "- **Subject** - the entity you are talking about\n",
+    "- **Predicate** - the type of relationship or property\n",
+    "- **Object** - the value or other entity that the subject is connected to\n",
+    "\n",
+    "Let's start with our predicate."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Predicate"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The `Predicate` enum provides a standard set of predicates that clearly describe relationships extracted from text. \n",
+    "\n",
+    "We've defined the set of predicates below to be appropriate for earnings call transcripts. Here are some examples for how each of these predicates could fit into a triplet in our knowledge graph: \n",
+    "Here are more anonymized, generalized examples following your template:\n",
+    "\n",
+    "* `IS_A`: \\[Company ABC]-\\[IS\\_A]-\\[Software Provider]\n",
+    "* `HAS_A`: \\[Corporation XYZ]-\\[HAS\\_A]-\\[Innovation Division]\n",
+    "* `LOCATED_IN`: \\[Factory 123]-\\[LOCATED\\_IN]-\\[Germany]\n",
+    "* `HOLDS_ROLE`: \\[Jane Doe]-\\[HOLDS\\_ROLE]-\\[CEO at Company LMN]\n",
+    "* `PRODUCES`: \\[Company DEF]-\\[PRODUCES]-\\[Smartphone Model X]\n",
+    "* `SELLS`: \\[Retailer 789]-\\[SELLS]-\\[Furniture]\n",
+    "* `LAUNCHED`: \\[Company UVW]-\\[LAUNCHED]-\\[New Subscription Service]\n",
+    "* `DEVELOPED`: \\[Startup GHI]-\\[DEVELOPED]-\\[Cloud-Based Tool]\n",
+    "* `ADOPTED_BY`: \\[New Technology]-\\[ADOPTED\\_BY]-\\[Industry ABC]\n",
+    "* `INVESTS_IN`: \\[Investment Firm JKL]-\\[INVESTS\\_IN]-\\[Clean Energy Startups]\n",
+    "* `COLLABORATES_WITH`: \\[Company PQR]-\\[COLLABORATES\\_WITH]-\\[University XYZ]\n",
+    "* `SUPPLIES`: \\[Manufacturer STU]-\\[SUPPLIES]-\\[Auto Components to Company VWX]\n",
+    "* `HAS_REVENUE`: \\[Corporation LMN]-\\[HAS\\_REVENUE]-\\[€500 Million]\n",
+    "* `INCREASED`: \\[Company YZA]-\\[INCREASED]-\\[Market Share]\n",
+    "* `DECREASED`: \\[Firm BCD]-\\[DECREASED]-\\[Operating Expenses]\n",
+    "* `RESULTED_IN`: \\[Cost Reduction Initiative]-\\[RESULTED\\_IN]-\\[Improved Profit Margins]\n",
+    "* `TARGETS`: \\[Product Launch Campaign]-\\[TARGETS]-\\[Millennial Consumers]\n",
+    "* `PART_OF`: \\[Subsidiary EFG]-\\[PART\\_OF]-\\[Parent Corporation HIJ]\n",
+    "* `DISCONTINUED`: \\[Company KLM]-\\[DISCONTINUED]-\\[Legacy Product Line]\n",
+    "* `SECURED`: \\[Startup NOP]-\\[SECURED]-\\[Series B Funding]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Predicate(StrEnum):\n",
+    "    \"\"\"Enumeration of normalised predicates.\"\"\"\n",
+    "\n",
+    "    IS_A = \"IS_A\"\n",
+    "    HAS_A = \"HAS_A\"\n",
+    "    LOCATED_IN = \"LOCATED_IN\"\n",
+    "    HOLDS_ROLE = \"HOLDS_ROLE\"\n",
+    "    PRODUCES = \"PRODUCES\"\n",
+    "    SELLS = \"SELLS\"\n",
+    "    LAUNCHED = \"LAUNCHED\"\n",
+    "    DEVELOPED = \"DEVELOPED\"\n",
+    "    ADOPTED_BY = \"ADOPTED_BY\"\n",
+    "    INVESTS_IN = \"INVESTS_IN\"\n",
+    "    COLLABORATES_WITH = \"COLLABORATES_WITH\"\n",
+    "    SUPPLIES = \"SUPPLIES\"\n",
+    "    HAS_REVENUE = \"HAS_REVENUE\"\n",
+    "    INCREASED = \"INCREASED\"\n",
+    "    DECREASED = \"DECREASED\"\n",
+    "    RESULTED_IN = \"RESULTED_IN\"\n",
+    "    TARGETS = \"TARGETS\"\n",
+    "    PART_OF = \"PART_OF\"\n",
+    "    DISCONTINUED = \"DISCONTINUED\"\n",
+    "    SECURED = \"SECURED\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We also assign a definition to each predicate, which we will then pass to the extraction prompt downstream."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "PREDICATE_DEFINITIONS = {\n",
+    "    \"IS_A\": \"Denotes a class-or-type relationship between two entities (e.g., 'Model Y IS_A electric-SUV'). Includes 'is' and 'was'.\",\n",
+    "    \"HAS_A\": \"Denotes a part-whole relationship between two entities (e.g., 'Model Y HAS_A electric-engine'). Includes 'has' and 'had'.\",\n",
+    "    \"LOCATED_IN\": \"Specifies geographic or organisational containment or proximity (e.g., headquarters LOCATED_IN Berlin).\",\n",
+    "    \"HOLDS_ROLE\": \"Connects a person to a formal office or title within an organisation (CEO, Chair, Director, etc.).\",\n",
+    "    \"PRODUCES\": \"Indicates that an entity manufactures, builds, or creates a product, service, or infrastructure (includes scale-ups and component inclusion).\",\n",
+    "    \"SELLS\": \"Marks a commercial seller-to-customer relationship for a product or service (markets, distributes, sells).\",\n",
+    "    \"LAUNCHED\": \"Captures the official first release, shipment, or public start of a product, service, or initiative.\",\n",
+    "    \"DEVELOPED\": \"Shows design, R&D, or innovation origin of a technology, product, or capability. Includes 'researched' or 'created'.\",\n",
+    "    \"ADOPTED_BY\": \"Indicates that a technology or product has been taken up, deployed, or implemented by another entity.\",\n",
+    "    \"INVESTS_IN\": \"Represents the flow of capital or resources from one entity into another (equity, funding rounds, strategic investment).\",\n",
+    "    \"COLLABORATES_WITH\": \"Generic partnership, alliance, joint venture, or licensing relationship between entities.\",\n",
+    "    \"SUPPLIES\": \"Captures vendor–client supply-chain links or dependencies (provides to, sources from).\",\n",
+    "    \"HAS_REVENUE\": \"Associates an entity with a revenue amount or metric—actual, reported, or projected.\",\n",
+    "    \"INCREASED\": \"Expresses an upward change in a metric (revenue, market share, output) relative to a prior period or baseline.\",\n",
+    "    \"DECREASED\": \"Expresses a downward change in a metric relative to a prior period or baseline.\",\n",
+    "    \"RESULTED_IN\": \"Captures a causal relationship where one event or factor leads to a specific outcome (positive or negative).\",\n",
+    "    \"TARGETS\": \"Denotes a strategic objective, market segment, or customer group that an entity seeks to reach.\",\n",
+    "    \"PART_OF\": \"Expresses hierarchical membership or subset relationships (division, subsidiary, managed by, belongs to).\",\n",
+    "    \"DISCONTINUED\": \"Indicates official end-of-life, shutdown, or termination of a product, service, or relationship.\",\n",
+    "    \"SECURED\": \"Marks the successful acquisition of funding, contracts, assets, or rights by an entity.\",\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Defining your own predicates"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "When working with different data sources, you'll want to define your own predicates that are specific to your use case. \n",
+    "\n",
+    "To define your own predicates:\n",
+    "1. First, run your pipeline with `PREDICATE_DEFINITIONS = {}` on a representative sample of your documents. This initial run will derive a noisy graph with many non-standardized and overlapping predicates\n",
+    "2. Next, drop some of your intial results into [ChatGPT](https://chatgpt.com/) or manually review them to merge similar predicate classes. This process helps to eliminate duplicates such as `IS_CEO` and `IS_CEO_OF`\n",
+    "3. Finally, carefully review and refine this list of predicates to ensure clarity and precision. These finalized predicate definitions will then guide your extraction process and ensure a consistent extraction pipeline"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Raw triplet"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "With predicates now well-defined, we can begin building up the data models for our triplets. \n",
+    "\n",
+    "The `RawTriplet` model represents a basic subject-predicate-object relationship that is extracted directly from textual data. This serves as a precursor for the more detailed triplet representation in `Triplet` which we introduce later. \n",
+    "\n",
+    "Core fields: \n",
+    "- `subject_name`: The textual representation of the subject entity\n",
+    "- `subject_id`: Numeric identifier for the subject entity\n",
+    "- `predicate`: The relationship type, specified by the `Predicate` enum\n",
+    "- `object_name`: The textual representation of the object entity\n",
+    "- `object_id`: Numeric identifier for the object entity\n",
+    "- `value`: Numeric value associated to relationship, may be None e.g. `Company` -> `HAS_A` -> `Revenue` with `value='$100 mill'`\n",
+    "  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class RawTriplet(BaseModel):\n",
+    "    \"\"\"Model representing a subject-predicate-object triplet.\"\"\"\n",
+    "\n",
+    "    subject_name: str\n",
+    "    subject_id: int\n",
+    "    predicate: Predicate\n",
+    "    object_name: str\n",
+    "    object_id: int\n",
+    "    value: str | None = None"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Triplet"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The `Triplet` model extends the `RawTriplet` by incorporating unique identifiers and optionally linking each triplet to a specific event. These identifiers help with integration into structured knowledge bases like our temporal knowledge graph."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Triplet(BaseModel):\n",
+    "    \"\"\"Model representing a subject-predicate-object triplet.\"\"\"\n",
+    "\n",
+    "    id: uuid.UUID = Field(default_factory=uuid.uuid4)\n",
+    "    event_id: uuid.UUID | None = None\n",
+    "    subject_name: str\n",
+    "    subject_id: int | uuid.UUID\n",
+    "    predicate: Predicate\n",
+    "    object_name: str\n",
+    "    object_id: int | uuid.UUID\n",
+    "    value: str | None = None\n",
+    "\n",
+    "    @classmethod\n",
+    "    def from_raw(cls, raw_triplet: \"RawTriplet\", event_id: uuid.UUID | None = None) -> \"Triplet\":\n",
+    "        \"\"\"Create a Triplet instance from a RawTriplet, optionally associating it with an event_id.\"\"\"\n",
+    "        return cls(\n",
+    "            id=uuid.uuid4(),\n",
+    "            event_id=event_id,\n",
+    "            subject_name=raw_triplet.subject_name,\n",
+    "            subject_id=raw_triplet.subject_id,\n",
+    "            predicate=raw_triplet.predicate,\n",
+    "            object_name=raw_triplet.object_name,\n",
+    "            object_id=raw_triplet.object_id,\n",
+    "            value=raw_triplet.value,\n",
+    "        )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### RawEntity"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The `RawEntity` model represents an Entity as extracted from the `Statement`. This serves as a precursor for the more detailed triplet representation in `Entity` which we introduce next. \n",
+    "\n",
+    "Core fields: \n",
+    "- `entity_idx`: An integer to differentiate extracted entites from the statement (links to `RawTriplet`)\n",
+    "- `name`: The name of the entity extracted e.g. `AMD`\n",
+    "- `type`: The type of entity extracted e.g. `Company`\n",
+    "- `description`: The textual description of the entity e.g. `Technology company know for manufacturing semiconductors`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class RawEntity(BaseModel):\n",
+    "    \"\"\"Model representing an entity (for entity resolution).\"\"\"\n",
+    "\n",
+    "    entity_idx: int\n",
+    "    name: str\n",
+    "    type: str = \"\"\n",
+    "    description: str = \"\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Entity"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The `Entity` model extends the `RawEntity` by incorporating unique identifiers and optionally linking each entity to a specific event. \n",
+    "Additionally, it contains `resolved_id` which will be populated during entity resolution with the canonical entity's id to remove duplicate naming of entities in the database.\n",
+    "These updated identifiers help with integration and linking of entities to events and triplets ."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Entity(BaseModel):\n",
+    "    \"\"\"\n",
+    "    Model representing an entity (for entity resolution).\n",
+    "    'id' is the canonical entity id if this is a canonical entity.\n",
+    "    'resolved_id' is set to the canonical id if this is an alias.\n",
+    "    \"\"\"\n",
+    "\n",
+    "    id: uuid.UUID = Field(default_factory=uuid.uuid4)\n",
+    "    event_id: uuid.UUID | None = None\n",
+    "    name: str\n",
+    "    type: str\n",
+    "    description: str\n",
+    "    resolved_id: uuid.UUID | None = None\n",
+    "\n",
+    "    @classmethod\n",
+    "    def from_raw(cls, raw_entity: \"RawEntity\", event_id: uuid.UUID | None = None) -> \"Entity\":\n",
+    "        \"\"\"Create an Entity instance from a RawEntity, optionally associating it with an event_id.\"\"\"\n",
+    "        return cls(\n",
+    "            id=uuid.uuid4(),\n",
+    "            event_id=event_id,\n",
+    "            name=raw_entity.name,\n",
+    "            type=raw_entity.type,\n",
+    "            description=raw_entity.description,\n",
+    "            resolved_id=None,\n",
+    "        )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Raw extraction"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Both `RawTriplet` and `RawEntity` are extracted at the same time per `Statement` to reduce LLM calls and to allow easy referencing of Entities through Triplets."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class RawExtraction(BaseModel):\n",
+    "    \"\"\"Model representing a triplet extraction.\"\"\"\n",
+    "\n",
+    "    triplets: list[RawTriplet]\n",
+    "    entities: list[RawEntity]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Triplet Extraction Prompt"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The prompt below guides our Temporal Agent to effectively extract triplets and entities from provided statements.\n",
+    "\n",
+    "##### Anatomy of the prompt\n",
+    "<ul style=\"margin-left: 1em; line-height: 1.6; padding-left: 0.5em;\">\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Avoids temporal details</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      The agent is specifically instructed to ignore temporal relationships, as these are captured separately within the <code>TemporalValidityRange</code>.\n",
+    "      Defined <code>Predicates</code> are deliberately designed to be time-neutral—for instance, <code>HAS_A</code> covers both present (<code>HAS_A</code>) and past (<code>HAD_A</code>) contexts.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Maintains structured outputs</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      The prompt yields structured <code>RawExtraction</code> outputs, supported by detailed examples that clearly illustrate:\n",
+    "    </p>\n",
+    "    <ul style=\"margin-left: 1.5em; margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      <li>How to extract information from a given <code>Statement</code></li>\n",
+    "      <li>How to link <code>Entities</code> with corresponding <code>Triplets</code></li>\n",
+    "      <li>How to handle extracted <code>values</code></li>\n",
+    "      <li>How to manage multiple <code>Triplets</code> involving the same <code>Entity</code></li>\n",
+    "    </ul>\n",
+    "  </li>\n",
+    "</ul>\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "triplet_extraction_prompt = \"\"\"\n",
+    "You are an information-extraction assistant.\n",
+    "\n",
+    "**Task:** You are going to be given a statement. Proceed step by step through the guidelines.\n",
+    "\n",
+    "**Statement:** \"{{ statement }}\"\n",
+    "\n",
+    "**Guidelines**\n",
+    "First, NER:\n",
+    "- Identify the entities in the statement, their types, and context independent descriptions.\n",
+    "- Do not include any lengthy quotes from the reports\n",
+    "- Do not include any calendar dates or temporal ranges or temporal expressions\n",
+    "- Numeric values should be extracted as separate entities as an instance_of _Numeric_, where the name is the units as a string and the numeric_value is the value. e.g: £30 -> name: 'GBP', numeric_value: 30, instance_of: 'Numeric'\n",
+    "\n",
+    "Second, Triplet extraction:\n",
+    "- Identify the subject entity of that predicate – the main entity carrying out the action or being described.\n",
+    "- Identify the object entity of that predicate – the entity, value, or concept that the predicate affects or describes.\n",
+    "- Identify a predicate between the entities expressed in the statement, such as 'is', 'works at', 'believes', etc. Follow the schema below if given.\n",
+    "- Extract the corresponding (subject, predicate, object, date) knowledge triplet.\n",
+    "- Exclude all temporal expressions (dates, years, seasons, etc.) from every field.\n",
+    "- Repeat until all predicates contained in the statement have been extracted form the statements.\n",
+    "\n",
+    "{%- if predicate_instructions -%}\n",
+    "-------------------------------------------------------------------------\n",
+    "Predicate Instructions:\n",
+    "Please try to stick to the following predicates, do not deviate unless you can't find a relevant definition.\n",
+    "{%- for pred, instruction in predicate_instructions.items() -%}\n",
+    "- {{ pred }}: {{ instruction }}\n",
+    "{%- endfor -%}\n",
+    "-------------------------------------------------------------------------\n",
+    "{%- endif -%}\n",
+    "\n",
+    "Output:\n",
+    "List the entities and triplets following the JSON schema below. Return ONLY with valid JSON matching this schema.\n",
+    "Do not include any commentary or explanation.\n",
+    "{{ json_schema }}\n",
+    "\n",
+    "===Examples===\n",
+    "Example 1 Statement: \"Google's revenue increased by 10% from January through March.\"\n",
+    "Example 1 Output: {\n",
+    "  \"triplets\": [\n",
+    "    {\n",
+    "      \"subject_name\": \"Google\",\n",
+    "      \"subject_id\": 0,\n",
+    "      \"predicate\": \"INCREASED\",\n",
+    "      \"object_name\": \"Revenue\",\n",
+    "      \"object_id\": 1,\n",
+    "      \"value\": \"10%\",\n",
+    "    }\n",
+    "  ],\n",
+    "  \"entities\": [\n",
+    "    {\n",
+    "      \"entity_idx\": 0,\n",
+    "      \"name\": \"Google\",\n",
+    "      \"type\": \"Organization\",\n",
+    "      \"description\": \"Technology Company\",\n",
+    "    },\n",
+    "    {\n",
+    "      \"entity_idx\": 1,\n",
+    "      \"name\": \"Revenue\",\n",
+    "      \"type\": \"Financial Metric\",\n",
+    "      \"description\": \"Income of a Company\",\n",
+    "    }\n",
+    "  ]\n",
+    "}\n",
+    "\n",
+    "Example 2 Statement: \"Amazon developed a new AI chip in 2024.\"\n",
+    "Example 2 Output:\n",
+    "{\n",
+    "  \"triplets\": [\n",
+    "    {\n",
+    "      \"subject_name\": \"Amazon\",\n",
+    "      \"subject_id\": 0,\n",
+    "      \"predicate\": \"DEVELOPED\",\n",
+    "      \"object_name\": \"AI chip\",\n",
+    "      \"object_id\": 1,\n",
+    "      \"value\": None,\n",
+    "    },\n",
+    "  ],\n",
+    "  \"entities\": [\n",
+    "    {\n",
+    "      \"entity_idx\": 0,\n",
+    "      \"name\": \"Amazon\",\n",
+    "      \"type\": \"Organization\",\n",
+    "      \"description\": \"E-commerce and cloud computing company\"\n",
+    "    },\n",
+    "    {\n",
+    "      \"entity_idx\": 1,\n",
+    "      \"name\": \"AI chip\",\n",
+    "      \"type\": \"Technology\",\n",
+    "      \"description\": \"Artificial intelligence accelerator hardware\"\n",
+    "    }\n",
+    "  ]\n",
+    "}\n",
+    "\n",
+    "Example 3 Statement: \"It is expected that TechNova Inc will launch its AI-driven product line in Q3 2025.\",\n",
+    "Example 3 Output:{\n",
+    "  \"triplets\": [\n",
+    "    {\n",
+    "      \"subject_name\": \"TechNova\",\n",
+    "      \"subject_id\": 0,\n",
+    "      \"predicate\": \"LAUNCHED\",\n",
+    "      \"object_name\": \"AI-driven Product\",\n",
+    "      \"object_id\": 1,\n",
+    "      \"value\": \"None,\n",
+    "    }\n",
+    "  ],\n",
+    "  \"entities\": [\n",
+    "    {\n",
+    "      \"entity_idx\": 0,\n",
+    "      \"name\": \"TechNova\",\n",
+    "      \"type\": \"Organization\",\n",
+    "      \"description\": \"Technology Company\",\n",
+    "    },\n",
+    "    {\n",
+    "      \"entity_idx\": 1,\n",
+    "      \"name\": \"AI-driven Product\",\n",
+    "      \"type\": \"Product\",\n",
+    "      \"description\": \"General AI products\",\n",
+    "    }\n",
+    "  ]\n",
+    "}\n",
+    "\n",
+    "Example 4 Statement: \"The SVP, CFO and Treasurer of AMD spoke during the earnings call.\"\n",
+    "Example 4 Output: {\n",
+    "  \"triplets\": [],\n",
+    "  \"entities\":[].\n",
+    "}\n",
+    "\n",
+    "===End of Examples===\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.2.7. Temporal Event"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The `TemporalEvent` model brings together the `Statement` and all related information into one handy class. It's a primary output of the `TemporalAgent` and plays an important role within the `InvalidationAgent`. \n",
+    "\n",
+    "Main fields include: \n",
+    "- `id`: A unique identifier for the event\n",
+    "- `chunk_id`: Points to the specific `Chunk` associated with the event\n",
+    "- `statement`: The specific `RawStatement` extracted from the `Chunk` detailing a relationship or event\n",
+    "- `embedding`: A representation of the `statement` used by the `InvalidationAgent` to gauge event similarity\n",
+    "- `triplets`: Unique identifiers for the individual `Triplets` extracted from the `Statement`\n",
+    "- `valid_at`: Timestamp indicating when the event becomes valid\n",
+    "- `invalid_at`: Timestamp indicating when the event becomes invalid\n",
+    "- `temporal_type`: Describes temporal characteristics from the `RawStatement`\n",
+    "- `statement_type`: Categorizes the statement according to the original `RawStatement`\n",
+    "- `created_at`: Date the event was first created.\n",
+    "- `expired_at`: Date the event was marked invalid (set to `created_at` if `invalid_at` is already set when building the `TemporalEvent`)\n",
+    "- `invalidated_by`: ID of the `TemporalEvent` responsible for invalidating this event, if applicable"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "\n",
+    "from pydantic import model_validator\n",
+    "\n",
+    "\n",
+    "class TemporalEvent(BaseModel):\n",
+    "    \"\"\"Model representing a temporal event with statement, triplet, and validity information.\"\"\"\n",
+    "\n",
+    "    id: uuid.UUID = Field(default_factory=uuid.uuid4)\n",
+    "    chunk_id: uuid.UUID\n",
+    "    statement: str\n",
+    "    embedding: list[float] = Field(default_factory=lambda: [0.0] * 256)\n",
+    "    triplets: list[uuid.UUID]\n",
+    "    valid_at: datetime | None = None\n",
+    "    invalid_at: datetime | None = None\n",
+    "    temporal_type: TemporalType\n",
+    "    statement_type: StatementType\n",
+    "    created_at: datetime = Field(default_factory=datetime.now)\n",
+    "    expired_at: datetime | None = None\n",
+    "    invalidated_by: uuid.UUID | None = None\n",
+    "\n",
+    "    @property\n",
+    "    def triplets_json(self) -> str:\n",
+    "        \"\"\"Convert triplets list to JSON string.\"\"\"\n",
+    "        return json.dumps([str(t) for t in self.triplets]) if self.triplets else \"[]\"\n",
+    "\n",
+    "    @classmethod\n",
+    "    def parse_triplets_json(cls, triplets_str: str) -> list[uuid.UUID]:\n",
+    "        \"\"\"Parse JSON string back into list of UUIDs.\"\"\"\n",
+    "        if not triplets_str or triplets_str == \"[]\":\n",
+    "            return []\n",
+    "        return [uuid.UUID(t) for t in json.loads(triplets_str)]\n",
+    "\n",
+    "    @model_validator(mode=\"after\")\n",
+    "    def set_expired_at(self) -> \"TemporalEvent\":\n",
+    "        \"\"\"Set expired_at if invalid_at is set and temporal_type is DYNAMIC.\"\"\"\n",
+    "        self.expired_at = self.created_at if (self.invalid_at is not None) and (self.temporal_type == TemporalType.DYNAMIC) else None\n",
+    "        return self"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.2.8. Defining our Temporal Agent"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we arrive at a central point in our pipeline: The `TemporalAgent` class. This brings together the steps we've built up above - chunking, data models, and prompts. Let's take a closer look at how this works.\n",
+    "\n",
+    "The core function, `extract_transcript_events`, handles all key processes:\n",
+    "\n",
+    "1. It extracts a `RawStatement` from each `Chunk`.\n",
+    "2. From each `RawStatement`, it identifies the `TemporalValidityRange` along with lists of related `Triplet` and `Entity` objects.\n",
+    "3. Finally, it bundles all this information neatly into a `TemporalEvent` for each `RawStatement`.\n",
+    "\n",
+    "Here's what you'll get:\n",
+    "\n",
+    "* `transcript`: The transcript currently being analyzed.\n",
+    "* `all_events`: A comprehensive list of all generated `TemporalEvent` objects.\n",
+    "* `all_triplets`: A complete collection of `Triplet` objects extracted across all events.\n",
+    "* `all_entities`: A detailed list of all `Entity` objects pulled from the events, which will be further refined in subsequent steps.\n",
+    "\n",
+    "The diagram below visualizes this portion of our pipeline:\n"
+   ]
+  },
+  {
+   "attachments": {
+    "79ba1c3c-35e6-406a-aff4-24ab9b8fe9e4.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<!-- ![Screenshot 2025-06-23 at 12.10.06.png](attachment:79ba1c3c-35e6-406a-aff4-24ab9b8fe9e4.png) -->\n",
+    "<img\n",
+    "  src=\"../../../images/07_temporal_agent_class.png\"\n",
+    "  alt=\"Temporal Agent Class\"\n",
+    "  style=\"width:791px; height:auto;\"\n",
+    "/>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import asyncio\n",
+    "from typing import Any\n",
+    "\n",
+    "from jinja2 import DictLoader, Environment\n",
+    "from openai import AsyncOpenAI\n",
+    "from tenacity import retry, stop_after_attempt, wait_random_exponential\n",
+    "\n",
+    "\n",
+    "class TemporalAgent:\n",
+    "    \"\"\"Handles temporal-based operations for extracting and processing temporal events from text.\"\"\"\n",
+    "\n",
+    "    def __init__(self) -> None:\n",
+    "        \"\"\"Initialize the TemporalAgent with a client.\"\"\"\n",
+    "        self._client = AsyncOpenAI()\n",
+    "        self._model = \"gpt-4.1-mini\"\n",
+    "\n",
+    "        self._env = Environment(loader=DictLoader({\n",
+    "            \"statement_extraction.jinja\": statement_extraction_prompt,\n",
+    "            \"date_extraction.jinja\": date_extraction_prompt,\n",
+    "            \"triplet_extraction.jinja\": triplet_extraction_prompt,\n",
+    "        }))\n",
+    "        self._env.filters[\"split_and_capitalize\"] = self.split_and_capitalize\n",
+    "    @staticmethod\n",
+    "    def split_and_capitalize(value: str) -> str:\n",
+    "        \"\"\"Split dict key string and reformat for jinja prompt.\"\"\"\n",
+    "        return \" \".join(value.split(\"_\")).capitalize()\n",
+    "\n",
+    "    async def get_statement_embedding(self, statement: str) -> list[float]:\n",
+    "        \"\"\"Get the embedding of a statement.\"\"\"\n",
+    "        response = await self._client.embeddings.create(\n",
+    "            model=\"text-embedding-3-large\",\n",
+    "            input=statement,\n",
+    "            dimensions=256,\n",
+    "        )\n",
+    "        return response.data[0].embedding\n",
+    "\n",
+    "    @retry(wait=wait_random_exponential(multiplier=1, min=1, max=30), stop=stop_after_attempt(3))\n",
+    "    async def extract_statements(\n",
+    "        self,\n",
+    "        chunk: Chunk,\n",
+    "        inputs: dict[str, Any],\n",
+    "    ) -> RawStatementList:\n",
+    "        \"\"\"Determine initial validity date range for a statement.\n",
+    "\n",
+    "        Args:\n",
+    "            chunk (Chunk): The chunk of text to analyze.\n",
+    "            inputs (dict[str, Any]): Additional input parameters for extraction.\n",
+    "\n",
+    "        Returns:\n",
+    "            Statement: Statement with updated temporal range.\n",
+    "        \"\"\"\n",
+    "        inputs[\"chunk\"] = chunk.text\n",
+    "\n",
+    "        template = self._env.get_template(\"statement_extraction.jinja\")\n",
+    "        prompt = template.render(\n",
+    "            inputs=inputs,\n",
+    "            definitions=LABEL_DEFINITIONS,\n",
+    "            json_schema=RawStatementList.model_fields,\n",
+    "        )\n",
+    "\n",
+    "        response = await self._client.responses.parse(\n",
+    "                model=self._model,\n",
+    "                temperature=0,\n",
+    "                input=prompt,\n",
+    "                text_format=RawStatementList,\n",
+    "            )\n",
+    "\n",
+    "\n",
+    "        raw_statements = response.output_parsed\n",
+    "        statements = RawStatementList.model_validate(raw_statements)\n",
+    "        return statements\n",
+    "\n",
+    "    @retry(wait=wait_random_exponential(multiplier=1, min=1, max=30), stop=stop_after_attempt(3))\n",
+    "    async def extract_temporal_range(\n",
+    "        self,\n",
+    "        statement: RawStatement,\n",
+    "        ref_dates: dict[str, Any],\n",
+    "    ) -> TemporalValidityRange:\n",
+    "        \"\"\"Determine initial validity date range for a statement.\n",
+    "\n",
+    "        Args:\n",
+    "            statement (Statement): Statement to analyze.\n",
+    "            ref_dates (dict[str, Any]): Reference dates for the statement.\n",
+    "\n",
+    "        Returns:\n",
+    "            Statement: Statement with updated temporal range.\n",
+    "        \"\"\"\n",
+    "        if statement.temporal_type == TemporalType.ATEMPORAL:\n",
+    "            return TemporalValidityRange(valid_at=None, invalid_at=None)\n",
+    "\n",
+    "        template = self._env.get_template(\"date_extraction.jinja\")\n",
+    "        inputs = ref_dates | statement.model_dump()\n",
+    "\n",
+    "        prompt = template.render(\n",
+    "            inputs=inputs,\n",
+    "            temporal_guide={statement.temporal_type.value: LABEL_DEFINITIONS[\"temporal_labelling\"][statement.temporal_type.value]},\n",
+    "            statement_guide={statement.statement_type.value: LABEL_DEFINITIONS[\"episode_labelling\"][statement.statement_type.value]},\n",
+    "            json_schema=RawTemporalRange.model_fields,\n",
+    "        )\n",
+    "\n",
+    "        response = await self._client.responses.parse(\n",
+    "                model=self._model,\n",
+    "                temperature=0,\n",
+    "                input=prompt,\n",
+    "                text_format=RawTemporalRange,\n",
+    "            )\n",
+    "\n",
+    "        raw_validity = response.output_parsed\n",
+    "        temp_validity = TemporalValidityRange.model_validate(raw_validity.model_dump()) if raw_validity else TemporalValidityRange()\n",
+    "\n",
+    "        if temp_validity.valid_at is None:\n",
+    "            temp_validity.valid_at = inputs[\"publication_date\"]\n",
+    "        if statement.temporal_type == TemporalType.STATIC:\n",
+    "            temp_validity.invalid_at = None\n",
+    "\n",
+    "        return temp_validity\n",
+    "\n",
+    "    @retry(wait=wait_random_exponential(multiplier=1, min=1, max=30), stop=stop_after_attempt(3))\n",
+    "    async def extract_triplet(\n",
+    "        self,\n",
+    "        statement: RawStatement,\n",
+    "        max_retries: int = 3,\n",
+    "    ) -> RawExtraction:\n",
+    "        \"\"\"Extract triplets and entities from a statement as a RawExtraction object.\"\"\"\n",
+    "        template = self._env.get_template(\"triplet_extraction.jinja\")\n",
+    "        prompt = template.render(\n",
+    "            statement=statement.statement,\n",
+    "            json_schema=RawExtraction.model_fields,\n",
+    "            predicate_instructions=PREDICATE_DEFINITIONS,\n",
+    "        )\n",
+    "\n",
+    "        for attempt in range(max_retries):\n",
+    "            try:\n",
+    "                response = await self._client.responses.parse(\n",
+    "                        model=self._model,\n",
+    "                        temperature=0,\n",
+    "                        input=prompt,\n",
+    "                        text_format=RawExtraction,\n",
+    "                    )\n",
+    "                raw_extraction = response.output_parsed\n",
+    "                extraction = RawExtraction.model_validate(raw_extraction)\n",
+    "                return extraction\n",
+    "            except Exception as e:\n",
+    "                if attempt == max_retries - 1:\n",
+    "                    raise\n",
+    "                print(f\"Attempt {attempt + 1} failed with error: {str(e)}. Retrying...\")\n",
+    "                await asyncio.sleep(1)\n",
+    "\n",
+    "        raise Exception(\"All retry attempts failed to extract triplets\")\n",
+    "\n",
+    "    async def extract_transcript_events(\n",
+    "        self,\n",
+    "        transcript: Transcript,\n",
+    "    ) -> tuple[Transcript, list[TemporalEvent], list[Triplet], list[Entity]]:\n",
+    "        \"\"\"\n",
+    "        For each chunk in the transcript:\n",
+    "            - Extract statements\n",
+    "            - For each statement, extract temporal range and Extraction in parallel\n",
+    "            - Build TemporalEvent for each statement\n",
+    "            - Collect all events, triplets, and entities for later DB insertion\n",
+    "        Returns the transcript, all events, all triplets, and all entities.\n",
+    "        \"\"\"\n",
+    "        if not transcript.chunks:\n",
+    "            return transcript, [], [], []\n",
+    "        doc_summary = {\n",
+    "            \"main_entity\": transcript.company or None,\n",
+    "            \"document_type\": \"Earnings Call Transcript\",\n",
+    "            \"publication_date\": transcript.date,\n",
+    "            \"quarter\": transcript.quarter,\n",
+    "            \"document_chunk\": None,\n",
+    "        }\n",
+    "        all_events: list[TemporalEvent] = []\n",
+    "        all_triplets: list[Triplet] = []\n",
+    "        all_entities: list[Entity] = []\n",
+    "\n",
+    "        async def _process_chunk(chunk: Chunk) -> tuple[Chunk, list[TemporalEvent], list[Triplet], list[Entity]]:\n",
+    "            statements_list = await self.extract_statements(chunk, doc_summary)\n",
+    "            events: list[TemporalEvent] = []\n",
+    "            chunk_triplets: list[Triplet] = []\n",
+    "            chunk_entities: list[Entity] = []\n",
+    "\n",
+    "            async def _process_statement(statement: RawStatement) -> tuple[TemporalEvent, list[Triplet], list[Entity]]:\n",
+    "                temporal_range_task = self.extract_temporal_range(statement, doc_summary)\n",
+    "                extraction_task = self.extract_triplet(statement)\n",
+    "                temporal_range, raw_extraction = await asyncio.gather(temporal_range_task, extraction_task)\n",
+    "                # Create the event first to get its id\n",
+    "                embedding = await self.get_statement_embedding(statement.statement)\n",
+    "                event = TemporalEvent(\n",
+    "                    chunk_id=chunk.id,\n",
+    "                    statement=statement.statement,\n",
+    "                    embedding=embedding,\n",
+    "                    triplets=[],\n",
+    "                    valid_at=temporal_range.valid_at,\n",
+    "                    invalid_at=temporal_range.invalid_at,\n",
+    "                    temporal_type=statement.temporal_type,\n",
+    "                    statement_type=statement.statement_type,\n",
+    "                )\n",
+    "                # Map raw triplets/entities to Triplet/Entity with event_id\n",
+    "                triplets = [Triplet.from_raw(rt, event.id) for rt in raw_extraction.triplets]\n",
+    "                entities = [Entity.from_raw(re, event.id) for re in raw_extraction.entities]\n",
+    "                event.triplets = [triplet.id for triplet in triplets]\n",
+    "                return event, triplets, entities\n",
+    "\n",
+    "            if statements_list.statements:\n",
+    "                results = await asyncio.gather(*(_process_statement(stmt) for stmt in statements_list.statements))\n",
+    "                for event, triplets, entities in results:\n",
+    "                    events.append(event)\n",
+    "                    chunk_triplets.extend(triplets)\n",
+    "                    chunk_entities.extend(entities)\n",
+    "            return chunk, events, chunk_triplets, chunk_entities\n",
+    "\n",
+    "        chunk_results = await asyncio.gather(*(_process_chunk(chunk) for chunk in transcript.chunks))\n",
+    "        transcript.chunks = [chunk for chunk, _, _, _ in chunk_results]\n",
+    "        for _, events, triplets, entities in chunk_results:\n",
+    "            all_events.extend(events)\n",
+    "            all_triplets.extend(triplets)\n",
+    "            all_entities.extend(entities)\n",
+    "        return transcript, all_events, all_triplets, all_entities"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "temporal_agent = TemporalAgent()\n",
+    "# transcripts: list[Transcript] = chunker.generate_transcripts_and_chunks(dataset)\n",
+    "\n",
+    "# Process only the first transcript\n",
+    "results = await temporal_agent.extract_transcript_events(transcripts[0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Parse and display the results in a nice format\n",
+    "transcript, events, triplets, entities = results\n",
+    "\n",
+    "print(\"=== TRANSCRIPT PROCESSING RESULTS ===\\n\")\n",
+    "\n",
+    "print(f\"📄 Transcript ID: {transcript.id}\")\n",
+    "print(f\"📊 Total Chunks: {len(transcript.chunks) if transcript.chunks is not None else 0}\")\n",
+    "print(f\"🎯 Total Events: {len(events)}\")\n",
+    "print(f\"🔗 Total Triplets: {len(triplets)}\")\n",
+    "print(f\"🏷️  Total Entities: {len(entities)}\")\n",
+    "\n",
+    "print(\"\\n=== SAMPLE EVENTS ===\")\n",
+    "for i, event in enumerate(events[:3]):  # Show first 3 events\n",
+    "    print(f\"\\n📝 Event {i+1}:\")\n",
+    "    print(f\"   Statement: {event.statement[:100]}...\")\n",
+    "    print(f\"   Type: {event.temporal_type}\")\n",
+    "    print(f\"   Valid At: {event.valid_at}\")\n",
+    "    print(f\"   Triplets: {len(event.triplets)}\")\n",
+    "\n",
+    "print(\"\\n=== SAMPLE TRIPLETS ===\")\n",
+    "for i, triplet in enumerate(triplets[:5]):  # Show first 5 triplets\n",
+    "    print(f\"\\n🔗 Triplet {i+1}:\")\n",
+    "    print(f\"   Subject: {triplet.subject_name} (ID: {triplet.subject_id})\")\n",
+    "    print(f\"   Predicate: {triplet.predicate}\")\n",
+    "    print(f\"   Object: {triplet.object_name} (ID: {triplet.object_id})\")\n",
+    "    if triplet.value:\n",
+    "        print(f\"   Value: {triplet.value}\")\n",
+    "\n",
+    "print(\"\\n=== SAMPLE ENTITIES ===\")\n",
+    "for i, entity in enumerate(entities[:5]):  # Show first 5 entities\n",
+    "    print(f\"\\n🏷️  Entity {i+1}:\")\n",
+    "    print(f\"   Name: {entity.name}\")\n",
+    "    print(f\"   Type: {entity.type}\")\n",
+    "    print(f\"   Description: {entity.description}\")\n",
+    "    if entity.resolved_id:\n",
+    "        print(f\"   Resolved ID: {entity.resolved_id}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.2.9. Entity Resolution"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Before diving into Temporal Invalidation, we need to first tackle entity resolution. This process is crucial to ensure that each real-world entity has a single, authoritative representation, eliminating duplicates and maintaining data consistency. For instance, `AMD` and `Advanced Micro Devices` clearly refer to the same entity, so they should be represented under a unified canonical entity.\n",
+    "\n",
+    "Here's our approach to entity resolution:\n",
+    "\n",
+    "* We use the `EntityResolution` class to batch entities by type (`Entity.type`), which helps us make context-specific comparisons—like distinguishing companies from individuals.\n",
+    "\n",
+    "* To address noisy data effectively, we leverage [RapidFuzz](https://rapidfuzz.github.io/RapidFuzz/) to cluster entities based on name similarity. This method involves a simple, case-insensitive, punctuation-free comparison using a partial match ratio, allowing tolerance for minor typos and substring matches.\n",
+    "\n",
+    "* Within each fuzzy-matched cluster, we select the medoid—the entity most representative of the cluster based on overall similarity. This prevents bias toward the most frequently occurring or earliest listed entity. The medoid then serves as the initial canonical entity, providing a semantically meaningful representation of the group.\n",
+    "\n",
+    "* Before adding a new canonical entity, we cross-check the medoid against existing canonicals, considering both fuzzy matching and acronyms. For example, `Advanced Micro Devices Inc.` may yield `AMDI`, closely matching the acronym `AMD`. This step helps prevent unnecessary creation of duplicate canonical entities.\n",
+    "\n",
+    "* If a global match isn't found, the medoid becomes a new canonical entity, with all entities in the cluster linked to it via a resolved ID.\n",
+    "\n",
+    "* Finally, we perform an additional safeguard check to resolve potential acronym duplication across all canonical entities, ensuring thorough cleanup.\n",
+    "\n",
+    "To further enhance entity resolution, you could consider advanced techniques such as:\n",
+    "\n",
+    "* Using embedding-based similarity on `Entity.description` alongside `Entity.name`, improving disambiguation beyond simple text similarity.\n",
+    "* Employing a large language model (LLM) to intelligently group entities under their canonical forms, enhancing accuracy through semantic understanding.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sqlite3\n",
+    "import string\n",
+    "\n",
+    "from rapidfuzz import fuzz\n",
+    "\n",
+    "from db_interface import (\n",
+    "    get_all_canonical_entities,\n",
+    "    insert_canonical_entity,\n",
+    "    remove_entity,\n",
+    "    update_entity_references,\n",
+    ")\n",
+    "\n",
+    "\n",
+    "class EntityResolution:\n",
+    "    \"\"\"\n",
+    "    Entity resolution class.\n",
+    "    \"\"\"\n",
+    "\n",
+    "    def __init__(self, conn: sqlite3.Connection):\n",
+    "        self.conn = conn\n",
+    "        self.global_canonicals: list[Entity] = get_all_canonical_entities(conn)\n",
+    "        self.threshold = 80.0\n",
+    "        self.acronym_thresh = 98.0\n",
+    "\n",
+    "\n",
+    "    def resolve_entities_batch(\n",
+    "        self, batch_entities: list[Entity],\n",
+    "    ) -> None:\n",
+    "        \"\"\"\n",
+    "        Orchestrate the scalable entity resolution workflow for a batch of entities.\n",
+    "        \"\"\"\n",
+    "        type_groups = {t: [e for e in batch_entities if e.type == t] for t in set(e.type for e in batch_entities)}\n",
+    "\n",
+    "        for entities in type_groups.values():\n",
+    "            clusters = self.group_entities_by_fuzzy_match(entities)\n",
+    "\n",
+    "            for group in clusters.values():\n",
+    "                if not group:\n",
+    "                    continue\n",
+    "                local_canon = self.set_medoid_as_canonical_entity(group)\n",
+    "                if local_canon is None:\n",
+    "                    continue\n",
+    "\n",
+    "                match = self.match_to_canonical_entity(local_canon, self.global_canonicals)\n",
+    "                if \" \" in local_canon.name:  # Multi-word entity\n",
+    "                    acronym = \"\".join(word[0] for word in local_canon.name.split())\n",
+    "                    acronym_match = next(\n",
+    "                        (c for c in self.global_canonicals if fuzz.ratio(acronym, c.name) >= self.acronym_thresh and \" \" not in c.name), None\n",
+    "                    )\n",
+    "                    if acronym_match:\n",
+    "                        match = acronym_match\n",
+    "\n",
+    "                if match:\n",
+    "                    canonical_id = match.id\n",
+    "                else:\n",
+    "                    insert_canonical_entity(\n",
+    "                        self.conn,\n",
+    "                        {\n",
+    "                            \"id\": str(local_canon.id),\n",
+    "                            \"name\": local_canon.name,\n",
+    "                            \"type\": local_canon.type,\n",
+    "                            \"description\": local_canon.description,\n",
+    "                        },\n",
+    "                    )\n",
+    "                    canonical_id = local_canon.id\n",
+    "                    self.global_canonicals.append(local_canon)\n",
+    "\n",
+    "                for entity in group:\n",
+    "                    entity.resolved_id = canonical_id\n",
+    "                    self.conn.execute(\n",
+    "                        \"UPDATE entities SET resolved_id = ? WHERE id = ?\",\n",
+    "                        (str(canonical_id), str(entity.id))\n",
+    "                    )\n",
+    "\n",
+    "        # Clean up any acronym duplicates after processing all entities\n",
+    "        self.merge_acronym_canonicals()\n",
+    "\n",
+    "\n",
+    "    def group_entities_by_fuzzy_match(\n",
+    "            self, entities: list[Entity],\n",
+    "     ) -> dict[str, list[Entity]]:\n",
+    "        \"\"\"\n",
+    "        Group entities by fuzzy name similarity using rapidfuzz\"s partial_ratio.\n",
+    "        Returns a mapping from canonical name to list of grouped entities.\n",
+    "        \"\"\"\n",
+    "        def clean(name: str) -> str:\n",
+    "            return name.lower().strip().translate(str.maketrans(\"\", \"\", string.punctuation))\n",
+    "\n",
+    "        name_to_entities: dict[str, list[Entity]] = {}\n",
+    "        cleaned_name_map: dict[str, str] = {}\n",
+    "        for entity in entities:\n",
+    "            name_to_entities.setdefault(entity.name, []).append(entity)\n",
+    "            cleaned_name_map[entity.name] = clean(entity.name)\n",
+    "        unique_names = list(name_to_entities.keys())\n",
+    "\n",
+    "        clustered: dict[str, list[Entity]] = {}\n",
+    "        used = set()\n",
+    "        for name in unique_names:\n",
+    "            if name in used:\n",
+    "                continue\n",
+    "            clustered[name] = []\n",
+    "            for other_name in unique_names:\n",
+    "                if other_name in used:\n",
+    "                    continue\n",
+    "                score = fuzz.partial_ratio(cleaned_name_map[name], cleaned_name_map[other_name])\n",
+    "                if score >= self.threshold:\n",
+    "                    clustered[name].extend(name_to_entities[other_name])\n",
+    "                    used.add(other_name)\n",
+    "        return clustered\n",
+    "\n",
+    "\n",
+    "    def set_medoid_as_canonical_entity(self, entities: list[Entity]) -> Entity | None:\n",
+    "        \"\"\"\n",
+    "        Select as canonical the entity in the group with the highest total similarity (sum of partial_ratio) to all others.\n",
+    "        Returns the medoid entity or None if the group is empty.\n",
+    "        \"\"\"\n",
+    "        if not entities:\n",
+    "            return None\n",
+    "\n",
+    "        def clean(name: str) -> str:\n",
+    "            return name.lower().strip().translate(str.maketrans(\"\", \"\", string.punctuation))\n",
+    "\n",
+    "        n = len(entities)\n",
+    "        scores = [0.0] * n\n",
+    "        for i in range(n):\n",
+    "            for j in range(n):\n",
+    "                if i != j:\n",
+    "                    s1 = clean(entities[i].name)\n",
+    "                    s2 = clean(entities[j].name)\n",
+    "                    scores[i] += fuzz.partial_ratio(s1, s2)\n",
+    "        max_idx = max(range(n), key=lambda idx: scores[idx])\n",
+    "        return entities[max_idx]\n",
+    "\n",
+    "\n",
+    "    def match_to_canonical_entity(self, entity: Entity, canonical_entities: list[Entity]) -> Entity | None:\n",
+    "        \"\"\"\n",
+    "        Fuzzy match a single entity to a list of canonical entities.\n",
+    "        Returns the best matching canonical entity or None if no match above self.threshold.\n",
+    "        \"\"\"\n",
+    "        def clean(name: str) -> str:\n",
+    "            return name.lower().strip().translate(str.maketrans(\"\", \"\", string.punctuation))\n",
+    "\n",
+    "        best_score: float = 0\n",
+    "        best_canon = None\n",
+    "        for canon in canonical_entities:\n",
+    "            score = fuzz.partial_ratio(clean(entity.name), clean(canon.name))\n",
+    "            if score > best_score:\n",
+    "                best_score = score\n",
+    "                best_canon = canon\n",
+    "        if best_score >= self.threshold:\n",
+    "            return best_canon\n",
+    "        return None\n",
+    "\n",
+    "\n",
+    "    def merge_acronym_canonicals(self) -> None:\n",
+    "        \"\"\"\n",
+    "        Merge canonical entities where one is an acronym of another.\n",
+    "        \"\"\"\n",
+    "        multi_word = [e for e in self.global_canonicals if \" \" in e.name]\n",
+    "        single_word = [e for e in self.global_canonicals if \" \" not in e.name]\n",
+    "\n",
+    "        acronym_map = {}\n",
+    "        for entity in multi_word:\n",
+    "            acronym = \"\".join(word[0].upper() for word in entity.name.split())\n",
+    "            acronym_map[entity.id] = acronym\n",
+    "\n",
+    "        for entity in multi_word:\n",
+    "            acronym = acronym_map[entity.id]\n",
+    "            for single_entity in single_word:\n",
+    "                score = fuzz.ratio(acronym, single_entity.name)\n",
+    "                if score >= self.threshold:\n",
+    "                    update_entity_references(self.conn, str(entity.id), str(single_entity.id))\n",
+    "                    remove_entity(self.conn, str(entity.id))\n",
+    "                    self.global_canonicals.remove(entity)\n",
+    "                    break"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.2.10. Invalidation agent"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "##### Understanding the Invalidation Process\n",
+    "\n",
+    "To effectively invalidate temporal events, the agent performs checks in both directions:\n",
+    "\n",
+    "> 1. **Incoming vs. Existing**: Are incoming events invalidated by events already present?\n",
+    "> 2. **Existing vs. Incoming**: Are current events invalidated by the new incoming events?\n",
+    "\n",
+    "This bi-directional assessment results in a clear True/False decision."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Event Invalidation Prompt"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The prompt has three key components:\n",
+    "\n",
+    "<ol style=\"margin-left: 1em; line-height: 1.6; padding-left: 0.5em;\">\n",
+    "<li style=\"margin-bottom: 1.2em;\"><strong>Task Setup</strong><br />\n",
+    "Defines two roles—<code>primary</code> and <code>secondary</code>—for event comparison. The assessment checks if the <code>primary</code> event is invalidated by the <code>secondary</code> event.</li>\n",
+    "\n",
+    "<li style=\"margin-bottom: 1.2em;\"><strong>Guidelines</strong><br />\n",
+    "Provides clear criteria on interpreting temporal metadata. Importantly, invalidation must rely solely on the relationships explicitly stated between events. External information cannot influence the decision.</li>\n",
+    "\n",
+    "<li style=\"margin-bottom: 1.2em;\"><strong>Event Information</strong><br />\n",
+    "Both events (<code>primary</code> and <code>secondary</code>) include timestamp details (<code>valid_at</code> and <code>invalid_at</code>) along with semantic context through either <code>Statement</code>, <code>Triplet</code>, or both. This context ensures accurate and relevant comparisons.</li>\n",
+    "</ol>\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "event_invalidation_prompt = \"\"\"\n",
+    "Task: Analyze the primary event against the secondary event and determine if the primary event is invalidated by the secondary event.\n",
+    "Only set dates if they explicitly relate to the validity of the relationship described in the text.\n",
+    "\n",
+    "IMPORTANT: Only invalidate events if they are directly invalidated by the other event given in the context. Do NOT use any external knowledge to determine validity ranges.\n",
+    "Only use dates that are directly stated to invalidate the relationship. The invalid_at for the invalidated event should be the valid_at of the event that caused the invalidation.\n",
+    "\n",
+    "Invalidation Guidelines:\n",
+    "1. Dates are given in ISO 8601 format (YYYY-MM-DDTHH:MM:SS.SSSSSSZ).\n",
+    "2. Where invalid_at is null, it means this event is still valid and considered to be ongoing.\n",
+    "3. Where invalid_at is defined, the event has previously been invalidated by something else and can be considered \"finished\".\n",
+    "4. An event can refine the invalid_at of a finished event to an earlier date only.\n",
+    "5. An event cannot invalidate an event that chronologically occurred after it.\n",
+    "6. An event cannot be invalidated by an event that chronologically occurred before it.\n",
+    "7. An event cannot invalidate itself.\n",
+    "\n",
+    "---\n",
+    "Primary Event:\n",
+    "{% if primary_event -%}\n",
+    "Statement: {{primary_event}}\n",
+    "{%- endif %}\n",
+    "{% if primary_triplet -%}\n",
+    "Triplet: {{primary_triplet}}\n",
+    "{%- endif %}\n",
+    "Valid_at: {{primary_event.valid_at}}\n",
+    "Invalid_at: {{primary_event.invalid_at}}\n",
+    "---\n",
+    "Secondary Event:\n",
+    "{% if secondary_event -%}\n",
+    "Statement: {{secondary_event}}\n",
+    "{%- endif %}\n",
+    "{% if secondary_triplet -%}\n",
+    "Triplet: {{secondary_triplet}}\n",
+    "{%- endif %}\n",
+    "Valid_at: {{secondary_event.valid_at}}\n",
+    "Invalid_at: {{secondary_event.invalid_at}}\n",
+    "---\n",
+    "\n",
+    "Return: \"True\" if the primary event is invalidated or its invalid_at is refined else \"False\"\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Requirements to be compared for Invalidation\n",
+    "We can only invalidate dynamic facts that haven't been marked invalid yet. These facts serve as our primary events, while potential candidates for invalidation are our secondary events. To streamline the invalidation process, consider these guidelines when evaluating secondary events:\n",
+    "\n",
+    "1. Must be a *FACT* type and not *Atemporal*\n",
+    "2. Share at least one canonical entity at the triplet level\n",
+    "3. Belong to the same semantic predicate group at the triplet level (defined below)\n",
+    "4. Temporally overlap and be currently ongoing\n",
+    "5. Have a statement cosine similarity above the threshold (currently set to 0.5)\n",
+    "6. The similarity threshold (0.5) helps us filter noise effectively by selecting only the `top_k` most relevant results. Low-level semantic similarities are acceptable since our goal is refining the data sent to the LLM for further assessment\n",
+    "\n",
+    "When invalidation occurs, we annotate the affected events with `expired_at` and `invalidated_by` to clearly indicate cause-and-effect relationships. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "PREDICATE_GROUPS: list[list[str]] = [\n",
+    "    [\"IS_A\", \"HAS_A\", \"LOCATED_IN\", \"HOLDS_ROLE\", \"PART_OF\"],\n",
+    "    [\"PRODUCES\", \"SELLS\", \"SUPPLIES\", \"DISCONTINUED\", \"SECURED\"],\n",
+    "    [\"LAUNCHED\", \"DEVELOPED\", \"ADOPTED_BY\", \"INVESTS_IN\", \"COLLABORATES_WITH\"],\n",
+    "    [\"HAS_REVENUE\", \"INCREASED\", \"DECREASED\", \"RESULTED_IN\", \"TARGETS\"],\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "When we put all of this together, the workflow for our `InvalidationAgent` looks like this:\n",
+    "\n",
+    "<ol style=\"margin-left: 1em; line-height: 1.6; padding-left: 0.5em;\">\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Temporal Range Detection</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      We start by identifying when events happen with <code>get_incoming_temporal_bounds()</code>. This function checks the event's <code>valid_at</code> and, if it's dynamic, its <code>invalid_at</code>. Atemporal events aren't included here.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Temporal Event Selection</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      We use <code>select_events_temporally()</code> to filter events by:\n",
+    "    </p>\n",
+    "    <ul style=\"margin-left: 1.5em; margin-bottom: 0.5em;\">\n",
+    "      <li>Checking if they're static or dynamic.</li>\n",
+    "      <li>Determining if their time ranges overlap with our incoming event.</li>\n",
+    "      <li>Handling dynamic events carefully, especially \"ongoing\" ones without an <code>invalid_at</code>, or events with various overlaps.</li>\n",
+    "    </ul>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Embedding Similarity Filtering</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Then, <code>filter_by_embedding_similarity()</code> compares events based on semantic similarity:\n",
+    "    </p>\n",
+    "    <ul style=\"margin-left: 1.5em; margin-bottom: 0.5em;\">\n",
+    "      <li>It calculates cosine similarity between embeddings.</li>\n",
+    "      <li>Events below a similarity threshold (<code>_similarity_threshold = 0.5</code>) are filtered out.</li>\n",
+    "      <li>We keep only the top-K most similar events (<code>_top_k = 10</code>).</li>\n",
+    "    </ul>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Combining Temporal and Semantic Filters</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      With <code>select_temporally_relevant_events_for_invalidation()</code>, we:\n",
+    "    </p>\n",
+    "    <ul style=\"margin-left: 1.5em; margin-bottom: 0.5em;\">\n",
+    "      <li>Apply temporal filters first.</li>\n",
+    "      <li>Then apply embedding similarity filters.</li>\n",
+    "      <li>This gives us a refined list of events most likely interacting or conflicting with the incoming one.</li>\n",
+    "    </ul>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Event Invalidation Decision (LLM-based)</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      The LLM-based <code>invalidation_step()</code> (powered by GPT-4.1-mini) determines whether the incoming event invalidates another event:\n",
+    "    </p>\n",
+    "    <ul style=\"margin-left: 1.5em; margin-bottom: 0.5em;\">\n",
+    "      <li>If it does, we update:\n",
+    "        <ul style=\"margin-left: 1.5em;\">\n",
+    "          <li><code>invalid_at</code> to match the secondary event's <code>valid_at</code>.</li>\n",
+    "          <li><code>expired_at</code> with the current timestamp.</li>\n",
+    "          <li><code>invalidated_by</code> with the ID of the secondary event.</li>\n",
+    "        </ul>\n",
+    "      </li>\n",
+    "    </ul>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Bidirectional Event Check</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      We use <code>bi_directional_event_invalidation()</code> to check:\n",
+    "    </p>\n",
+    "    <ul style=\"margin-left: 1.5em; margin-bottom: 0.5em;\">\n",
+    "      <li>If the incoming event invalidates existing events.</li>\n",
+    "      <li>If existing, later events invalidate the incoming event, especially if the incoming one is dynamic and currently valid.</li>\n",
+    "    </ul>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Deduplication Logic</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Lastly, <code>resolve_duplicate_invalidations()</code> ensures clean invalidation:\n",
+    "    </p>\n",
+    "    <ul style=\"margin-left: 1.5em; margin-bottom: 0.5em;\">\n",
+    "      <li>It allows only one invalidation per event.</li>\n",
+    "      <li>Picks the earliest invalidation time to avoid conflicts.</li>\n",
+    "      <li>This helps manage batch processing effectively.</li>\n",
+    "    </ul>\n",
+    "  </li>\n",
+    "</ol>\n",
+    "\n",
+    "The invalidation below represents this part of our pipeline:"
+   ]
+  },
+  {
+   "attachments": {
+    "aa62bb3c-d497-4027-ac15-51649e4d9c4d.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<!-- ![Screenshot 2025-06-23 at 11.45.20.png](attachment:aa62bb3c-d497-4027-ac15-51649e4d9c4d.png) -->\n",
+    "<img\n",
+    "  src=\"../../../images/08_invalidation_agent.png\"\n",
+    "  alt=\"Invalidation Agent\"\n",
+    "  style=\"width:791px; height:auto;\"\n",
+    "/>\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import asyncio\n",
+    "import logging\n",
+    "import pickle\n",
+    "import sqlite3\n",
+    "from collections import Counter, defaultdict\n",
+    "from collections.abc import Coroutine\n",
+    "from concurrent.futures import ThreadPoolExecutor\n",
+    "from datetime import datetime\n",
+    "from typing import Any\n",
+    "\n",
+    "from jinja2 import DictLoader, Environment\n",
+    "from openai import AsyncOpenAI\n",
+    "from scipy.spatial.distance import cosine\n",
+    "from tenacity import retry, stop_after_attempt, wait_random_exponential\n",
+    "\n",
+    "\n",
+    "class InvalidationAgent:\n",
+    "    \"\"\"Handles temporal-based operations for extracting and processing temporal events from text.\"\"\"\n",
+    "\n",
+    "    def __init__(self, max_workers: int = 5) -> None:\n",
+    "        \"\"\"Initialize the TemporalAgent with a client.\"\"\"\n",
+    "        self.max_workers = max_workers\n",
+    "        self._executor = ThreadPoolExecutor(max_workers=max_workers)\n",
+    "        self.logger = logging.getLogger(__name__)\n",
+    "        self._client = AsyncOpenAI()\n",
+    "        self._model = \"gpt-4.1-mini\"\n",
+    "        self._similarity_threshold = 0.5\n",
+    "        self._top_k = 10\n",
+    "\n",
+    "        self._env = Environment(loader=DictLoader({\n",
+    "            \"event_invalidation.jinja\": event_invalidation_prompt,\n",
+    "        }))\n",
+    "\n",
+    "    @staticmethod\n",
+    "    def cosine_similarity(v1: list[float], v2: list[float]) -> float:\n",
+    "        \"\"\"Calculate cosine similarity between two vectors.\"\"\"\n",
+    "        return float(1 - cosine(v1, v2))\n",
+    "\n",
+    "    @staticmethod\n",
+    "    def get_incoming_temporal_bounds(\n",
+    "        event: TemporalEvent,\n",
+    "    ) -> dict[str, datetime] | None:\n",
+    "        \"\"\"Get temporal bounds of all temporal events associated with a statement.\"\"\"\n",
+    "        if (event.temporal_type == TemporalType.ATEMPORAL) or (event.valid_at is None):\n",
+    "            return None\n",
+    "\n",
+    "        temporal_bounds = {\"start\": event.valid_at, \"end\": event.valid_at}\n",
+    "\n",
+    "        if event.temporal_type == TemporalType.DYNAMIC:\n",
+    "            if event.invalid_at:\n",
+    "                temporal_bounds[\"end\"] = event.invalid_at\n",
+    "\n",
+    "        return temporal_bounds\n",
+    "\n",
+    "    def select_events_temporally(\n",
+    "        self,\n",
+    "        triplet_events: list[tuple[Triplet, TemporalEvent]],\n",
+    "        temp_bounds: dict[str, datetime],\n",
+    "        dynamic: bool = False,\n",
+    "    ) -> list[tuple[Triplet, TemporalEvent]]:\n",
+    "        \"\"\"Select temporally relevant events (static or dynamic) based on temporal bounds.\n",
+    "\n",
+    "        Groups events into before, after, and overlapping categories based on their temporal bounds.\n",
+    "\n",
+    "        Args:\n",
+    "            triplet_events: List of (Triplet, TemporalEvent) tuples to filter\n",
+    "            temp_bounds: Dict with 'start' and 'end' datetime bounds\n",
+    "            dynamic: If True, filter dynamic events; if False, filter static events\n",
+    "            n_window: Number of events to include before and after bounds\n",
+    "\n",
+    "        Returns:\n",
+    "            Dict with keys '{type}_before', '{type}_after', '{type}_overlap' where type is 'dynamic' or 'static'\n",
+    "        \"\"\"\n",
+    "\n",
+    "        def _check_overlaps_dynamic(event: TemporalEvent, start: datetime, end: datetime) -> bool:\n",
+    "            \"\"\"Check if the dynamic event overlaps with the temporal bounds of the incoming event.\"\"\"\n",
+    "            if event.temporal_type != TemporalType.DYNAMIC:\n",
+    "                return False\n",
+    "\n",
+    "            event_start = event.valid_at or datetime.min\n",
+    "            event_end = event.invalid_at\n",
+    "\n",
+    "            # 1. Event contains the start\n",
+    "            if (event_end is not None) and (event_start <= start <= event_end):\n",
+    "                return True\n",
+    "\n",
+    "            # 2. Ongoing event starts before the incoming start\n",
+    "            if (event_end is None) and (event_start <= start):\n",
+    "                return True\n",
+    "\n",
+    "            # 3. Event starts within the incoming interval\n",
+    "            if start <= event_start <= end:\n",
+    "                return True\n",
+    "            return False\n",
+    "\n",
+    "        # Filter by temporal type\n",
+    "        target_type = TemporalType.DYNAMIC if dynamic else TemporalType.STATIC\n",
+    "        filtered_events = [(triplet, event) for triplet, event in triplet_events if event.temporal_type == target_type]\n",
+    "\n",
+    "        # Sort by valid_at timestamp\n",
+    "        sorted_events = sorted(filtered_events, key=lambda te: te[1].valid_at or datetime.min)\n",
+    "\n",
+    "        start = temp_bounds[\"start\"]\n",
+    "        end = temp_bounds[\"end\"]\n",
+    "\n",
+    "        if dynamic:\n",
+    "            overlap: list[tuple[Triplet, TemporalEvent]] = [\n",
+    "                (triplet, event) for triplet, event in sorted_events if _check_overlaps_dynamic(event, start, end)\n",
+    "            ]\n",
+    "        else:\n",
+    "            overlap = []\n",
+    "            if start != end:\n",
+    "                overlap = [(triplet, event) for triplet, event in sorted_events if event.valid_at and start <= event.valid_at <= end]\n",
+    "\n",
+    "        return overlap\n",
+    "\n",
+    "    def filter_by_embedding_similarity(\n",
+    "        self,\n",
+    "        reference_event: TemporalEvent,\n",
+    "        candidate_pairs: list[tuple[Triplet, TemporalEvent]],\n",
+    "    ) -> list[tuple[Triplet, TemporalEvent]]:\n",
+    "        \"\"\"Filter triplet-event pairs by embedding similarity.\"\"\"\n",
+    "        pairs_with_similarity = [\n",
+    "            (triplet, event, self.cosine_similarity(reference_event.embedding, event.embedding)) for triplet, event in candidate_pairs\n",
+    "        ]\n",
+    "\n",
+    "        filtered_pairs = [\n",
+    "            (triplet, event) for triplet, event, similarity in pairs_with_similarity if similarity >= self._similarity_threshold\n",
+    "        ]\n",
+    "\n",
+    "        sorted_pairs = sorted(filtered_pairs, key=lambda x: self.cosine_similarity(reference_event.embedding, x[1].embedding), reverse=True)\n",
+    "\n",
+    "        return sorted_pairs[: self._top_k]\n",
+    "\n",
+    "    def select_temporally_relevant_events_for_invalidation(\n",
+    "        self,\n",
+    "        incoming_event: TemporalEvent,\n",
+    "        candidate_triplet_events: list[tuple[Triplet, TemporalEvent]],\n",
+    "    ) -> list[tuple[Triplet, TemporalEvent]] | None:\n",
+    "        \"\"\"Select the temporally relevant events based on temporal range of incoming event.\"\"\"\n",
+    "        temporal_bounds = self.get_incoming_temporal_bounds(event=incoming_event)\n",
+    "        if not temporal_bounds:\n",
+    "            return None\n",
+    "\n",
+    "        # First apply temporal filtering - find overlapping events\n",
+    "        selected_statics = self.select_events_temporally(\n",
+    "            triplet_events=candidate_triplet_events,\n",
+    "            temp_bounds=temporal_bounds,\n",
+    "        )\n",
+    "        selected_dynamics = self.select_events_temporally(\n",
+    "            triplet_events=candidate_triplet_events,\n",
+    "            temp_bounds=temporal_bounds,\n",
+    "            dynamic=True,\n",
+    "        )\n",
+    "\n",
+    "        # Then filter by semantic similarity\n",
+    "        similar_static = self.filter_by_embedding_similarity(reference_event=incoming_event, candidate_pairs=selected_statics)\n",
+    "\n",
+    "        similar_dynamics = self.filter_by_embedding_similarity(reference_event=incoming_event, candidate_pairs=selected_dynamics)\n",
+    "\n",
+    "        return similar_static + similar_dynamics\n",
+    "\n",
+    "\n",
+    "    @retry(wait=wait_random_exponential(multiplier=1, min=1, max=30), stop=stop_after_attempt(3))\n",
+    "    async def invalidation_step(\n",
+    "        self,\n",
+    "        primary_event: TemporalEvent,\n",
+    "        primary_triplet: Triplet,\n",
+    "        secondary_event: TemporalEvent,\n",
+    "        secondary_triplet: Triplet,\n",
+    "    ) -> TemporalEvent:\n",
+    "        \"\"\"Check if primary event should be invalidated by secondary event.\n",
+    "\n",
+    "        Args:\n",
+    "            primary_event: Event to potentially invalidate\n",
+    "            primary_triplet: Triplet associated with primary event\n",
+    "            secondary_event: Event that might cause invalidation\n",
+    "            secondary_triplet: Triplet associated with secondary event\n",
+    "\n",
+    "        Returns:\n",
+    "            TemporalEvent: Updated primary event (may have invalid_at and invalidated_by set)\n",
+    "        \"\"\"\n",
+    "        template = self._env.get_template(\"event_invalidation.jinja\")\n",
+    "\n",
+    "        prompt = template.render(\n",
+    "            primary_event=primary_event.statement,\n",
+    "            primary_triplet=f\"({primary_triplet.subject_name}, {primary_triplet.predicate}, {primary_triplet.object_name})\",\n",
+    "            primary_valid_at=primary_event.valid_at,\n",
+    "            primary_invalid_at=primary_event.invalid_at,\n",
+    "            secondary_event=secondary_event.statement,\n",
+    "            secondary_triplet=f\"({secondary_triplet.subject_name}, {secondary_triplet.predicate}, {secondary_triplet.object_name})\",\n",
+    "            secondary_valid_at=secondary_event.valid_at,\n",
+    "            secondary_invalid_at=secondary_event.invalid_at,\n",
+    "        )\n",
+    "\n",
+    "        response = await self._client.responses.parse(\n",
+    "                model=self._model,\n",
+    "                temperature=0,\n",
+    "                input=prompt,\n",
+    "            )\n",
+    "\n",
+    "        # Parse boolean response\n",
+    "        response_bool = str(response).strip().lower() == \"true\" if response else False\n",
+    "\n",
+    "        if not response_bool:\n",
+    "            return primary_event\n",
+    "\n",
+    "        # Create updated event with invalidation info\n",
+    "        updated_event = primary_event.model_copy(\n",
+    "            update={\n",
+    "                \"invalid_at\": secondary_event.valid_at,\n",
+    "                \"expired_at\": datetime.now(),\n",
+    "                \"invalidated_by\": secondary_event.id,\n",
+    "            }\n",
+    "        )\n",
+    "        return updated_event\n",
+    "\n",
+    "    async def bi_directional_event_invalidation(\n",
+    "        self,\n",
+    "        incoming_triplet: Triplet,\n",
+    "        incoming_event: TemporalEvent,\n",
+    "        existing_triplet_events: list[tuple[Triplet, TemporalEvent]],\n",
+    "    ) -> tuple[TemporalEvent, list[TemporalEvent]]:\n",
+    "        \"\"\"Validate and update temporal information for triplet events with full bidirectional invalidation.\n",
+    "\n",
+    "        Args:\n",
+    "            incoming_triplet: The new triplet\n",
+    "            incoming_event: The new event associated with the triplet\n",
+    "            existing_triplet_events: List of existing (triplet, event) pairs to validate against\n",
+    "\n",
+    "        Returns:\n",
+    "            tuple[TemporalEvent, list[TemporalEvent]]: (updated_incoming_event, list_of_changed_existing_events)\n",
+    "        \"\"\"\n",
+    "        changed_existing_events: list[TemporalEvent] = []\n",
+    "        updated_incoming_event = incoming_event\n",
+    "\n",
+    "        # Filter for dynamic events that can be invalidated\n",
+    "        dynamic_events_to_check = [\n",
+    "            (triplet, event) for triplet, event in existing_triplet_events if event.temporal_type == TemporalType.DYNAMIC\n",
+    "        ]\n",
+    "\n",
+    "        # 1. Check if incoming event invalidates existing dynamic events\n",
+    "        if dynamic_events_to_check:\n",
+    "            tasks = [\n",
+    "                self.invalidation_step(\n",
+    "                    primary_event=existing_event,\n",
+    "                    primary_triplet=existing_triplet,\n",
+    "                    secondary_event=incoming_event,\n",
+    "                    secondary_triplet=incoming_triplet,\n",
+    "                )\n",
+    "                for existing_triplet, existing_event in dynamic_events_to_check\n",
+    "            ]\n",
+    "\n",
+    "            updated_events = await asyncio.gather(*tasks)\n",
+    "\n",
+    "            for original_pair, updated_event in zip(dynamic_events_to_check, updated_events, strict=True):\n",
+    "                original_event = original_pair[1]\n",
+    "                if (updated_event.invalid_at != original_event.invalid_at) or (\n",
+    "                    updated_event.invalidated_by != original_event.invalidated_by\n",
+    "                ):\n",
+    "                    changed_existing_events.append(updated_event)\n",
+    "\n",
+    "        # 2. Check if existing events invalidate the incoming dynamic event\n",
+    "        if incoming_event.temporal_type == TemporalType.DYNAMIC and incoming_event.invalid_at is None:\n",
+    "            # Only check events that occur after the incoming event\n",
+    "            invalidating_events = [\n",
+    "                (triplet, event)\n",
+    "                for triplet, event in existing_triplet_events\n",
+    "                if (incoming_event.valid_at and event.valid_at and incoming_event.valid_at < event.valid_at)\n",
+    "            ]\n",
+    "\n",
+    "            if invalidating_events:\n",
+    "                tasks = [\n",
+    "                    self.invalidation_step(\n",
+    "                        primary_event=incoming_event,\n",
+    "                        primary_triplet=incoming_triplet,\n",
+    "                        secondary_event=existing_event,\n",
+    "                        secondary_triplet=existing_triplet,\n",
+    "                    )\n",
+    "                    for existing_triplet, existing_event in invalidating_events\n",
+    "                ]\n",
+    "\n",
+    "                updated_events = await asyncio.gather(*tasks)\n",
+    "\n",
+    "                # Find the earliest invalidation\n",
+    "                valid_invalidations = [(e.invalid_at, e.invalidated_by) for e in updated_events if e.invalid_at is not None]\n",
+    "\n",
+    "                if valid_invalidations:\n",
+    "                    earliest_invalidation = min(valid_invalidations, key=lambda x: x[0])\n",
+    "                    updated_incoming_event = incoming_event.model_copy(\n",
+    "                        update={\n",
+    "                            \"invalid_at\": earliest_invalidation[0],\n",
+    "                            \"invalidated_by\": earliest_invalidation[1],\n",
+    "                            \"expired_at\": datetime.now(),\n",
+    "                        }\n",
+    "                    )\n",
+    "\n",
+    "        return updated_incoming_event, changed_existing_events\n",
+    "\n",
+    "    @staticmethod\n",
+    "    def resolve_duplicate_invalidations(changed_events: list[TemporalEvent]) -> list[TemporalEvent]:\n",
+    "        \"\"\"Resolve duplicate invalidations by selecting the most restrictive (earliest) invalidation.\n",
+    "\n",
+    "        When multiple incoming events invalidate the same existing event, we should apply\n",
+    "        the invalidation that results in the shortest validity range (earliest invalid_at).\n",
+    "\n",
+    "        Args:\n",
+    "            changed_events: List of events that may contain duplicates with different invalidations\n",
+    "\n",
+    "        Returns:\n",
+    "            List of deduplicated events with the most restrictive invalidation applied\n",
+    "        \"\"\"\n",
+    "        if not changed_events:\n",
+    "            return []\n",
+    "\n",
+    "        # Count occurrences of each event ID\n",
+    "        id_counts = Counter(str(event.id) for event in changed_events)\n",
+    "        resolved_events = []\n",
+    "        # Group events by ID only for those with duplicates\n",
+    "        events_by_id = defaultdict(list)\n",
+    "        for event in changed_events:\n",
+    "            event_id = str(event.id)\n",
+    "            if id_counts[event_id] == 1:\n",
+    "                resolved_events.append(event)\n",
+    "            else:\n",
+    "                events_by_id[event_id].append(event)\n",
+    "\n",
+    "        # Deduplicate only those with duplicates\n",
+    "        for _id, event_versions in events_by_id.items():\n",
+    "            invalidated_versions = [e for e in event_versions if e.invalid_at is not None]\n",
+    "            if not invalidated_versions:\n",
+    "                resolved_events.append(event_versions[0])\n",
+    "            else:\n",
+    "                most_restrictive = min(invalidated_versions, key=lambda e: (e.invalid_at if e.invalid_at is not None else datetime.max))\n",
+    "                resolved_events.append(most_restrictive)\n",
+    "\n",
+    "        return resolved_events\n",
+    "\n",
+    "    async def _execute_task_pool(\n",
+    "        self,\n",
+    "        tasks: list[Coroutine[Any, Any, tuple[TemporalEvent, list[TemporalEvent]]]],\n",
+    "        batch_size: int = 10\n",
+    "    ) -> list[Any]:\n",
+    "        \"\"\"Execute tasks in batches using a pool to control concurrency.\n",
+    "\n",
+    "        Args:\n",
+    "            tasks: List of coroutines to execute\n",
+    "            batch_size: Number of tasks to process concurrently\n",
+    "\n",
+    "        Returns:\n",
+    "            List of results from all tasks\n",
+    "        \"\"\"\n",
+    "        all_results = []\n",
+    "        for i in range(0, len(tasks), batch_size):\n",
+    "            batch = tasks[i:i + batch_size]\n",
+    "            batch_results = await asyncio.gather(*batch, return_exceptions=True)\n",
+    "            all_results.extend(batch_results)\n",
+    "\n",
+    "            # Small delay between batches to prevent overload\n",
+    "            if i + batch_size < len(tasks):\n",
+    "                await asyncio.sleep(0.1)\n",
+    "\n",
+    "        return all_results\n",
+    "\n",
+    "    async def process_invalidations_in_parallel(\n",
+    "        self,\n",
+    "        incoming_triplets: list[Triplet],\n",
+    "        incoming_events: list[TemporalEvent],\n",
+    "        existing_triplets: list[Triplet],\n",
+    "        existing_events: list[TemporalEvent],\n",
+    "    ) -> tuple[list[TemporalEvent], list[TemporalEvent]]:\n",
+    "        \"\"\"Process invalidations for multiple triplets in parallel.\n",
+    "\n",
+    "        Args:\n",
+    "            incoming_triplets: List of new triplets to process\n",
+    "            incoming_events: List of events associated with incoming triplets\n",
+    "            existing_triplets: List of existing triplets from DB\n",
+    "            existing_events: List of existing events from DB\n",
+    "\n",
+    "        Returns:\n",
+    "            tuple[list[TemporalEvent], list[TemporalEvent]]:\n",
+    "                - List of updated incoming events (potentially invalidated)\n",
+    "                - List of existing events that were updated (deduplicated)\n",
+    "        \"\"\"\n",
+    "        # Create mappings for faster lookups\n",
+    "        event_map = {str(e.id): e for e in existing_events}\n",
+    "        incoming_event_map = {str(t.event_id): e for t, e in zip(incoming_triplets, incoming_events, strict=False)}\n",
+    "\n",
+    "        # Prepare tasks for parallel processing\n",
+    "        tasks = []\n",
+    "        for incoming_triplet in incoming_triplets:\n",
+    "            incoming_event = incoming_event_map[str(incoming_triplet.event_id)]\n",
+    "\n",
+    "            # Get related triplet-event pairs\n",
+    "            related_pairs = [\n",
+    "                (t, event_map[str(t.event_id)])\n",
+    "                for t in existing_triplets\n",
+    "                if (str(t.subject_id) == str(incoming_triplet.subject_id) or str(t.object_id) == str(incoming_triplet.object_id))\n",
+    "                and str(t.event_id) in event_map\n",
+    "            ]\n",
+    "\n",
+    "            # Filter for temporal relevance\n",
+    "            all_relevant_events = self.select_temporally_relevant_events_for_invalidation(\n",
+    "                incoming_event=incoming_event,\n",
+    "                candidate_triplet_events=related_pairs,\n",
+    "            )\n",
+    "\n",
+    "            if not all_relevant_events:\n",
+    "                continue\n",
+    "\n",
+    "            # Add task for parallel processing\n",
+    "            task = self.bi_directional_event_invalidation(\n",
+    "                incoming_triplet=incoming_triplet,\n",
+    "                incoming_event=incoming_event,\n",
+    "                existing_triplet_events=all_relevant_events,\n",
+    "            )\n",
+    "            tasks.append(task)\n",
+    "\n",
+    "        # Process all invalidations in parallel with pooling\n",
+    "        if not tasks:\n",
+    "            return [], []\n",
+    "\n",
+    "        # Use pool size based on number of workers, but cap it\n",
+    "        pool_size = min(self.max_workers * 2, 10)  # Adjust these numbers based on your needs\n",
+    "        results = await self._execute_task_pool(tasks, batch_size=pool_size)\n",
+    "\n",
+    "        # Collect all results (may contain duplicates)\n",
+    "        updated_incoming_events = []\n",
+    "        all_changed_existing_events = []\n",
+    "\n",
+    "        for result in results:\n",
+    "            if isinstance(result, Exception):\n",
+    "                self.logger.error(f\"Task failed with error: {str(result)}\")\n",
+    "                continue\n",
+    "            updated_event, changed_events = result\n",
+    "            updated_incoming_events.append(updated_event)\n",
+    "            all_changed_existing_events.extend(changed_events)\n",
+    "\n",
+    "        # Resolve duplicate invalidations for existing events\n",
+    "        deduplicated_existing_events = self.resolve_duplicate_invalidations(all_changed_existing_events)\n",
+    "\n",
+    "        # Resolve duplicate invalidations for incoming events (in case multiple triplets from same event)\n",
+    "        deduplicated_incoming_events = self.resolve_duplicate_invalidations(updated_incoming_events)\n",
+    "\n",
+    "        return deduplicated_incoming_events, deduplicated_existing_events\n",
+    "\n",
+    "    @staticmethod\n",
+    "    def batch_fetch_related_triplet_events(\n",
+    "        conn: sqlite3.Connection,\n",
+    "        incoming_triplets: list[Triplet],\n",
+    "    ) -> tuple[list[Triplet], list[TemporalEvent]]:\n",
+    "        \"\"\"\n",
+    "        Batch fetch all existing triplets and their events from the DB that are related to any of the incoming triplets.\n",
+    "        Related means:\n",
+    "          - Share a subject or object entity\n",
+    "          - Predicate is in the same group\n",
+    "          - Associated event is a FACT\n",
+    "        Returns two lists: triplets and events (with mapping via event_id).\n",
+    "        \"\"\"\n",
+    "        # 1. Build sets of all relevant entity IDs and predicate groups\n",
+    "        entity_ids = set()\n",
+    "        predicate_to_group = {}\n",
+    "        for group in PREDICATE_GROUPS:\n",
+    "            group_list = list(group)\n",
+    "            for pred in group_list:\n",
+    "                predicate_to_group[pred] = group_list\n",
+    "        relevant_predicates = set()\n",
+    "        for triplet in incoming_triplets:\n",
+    "            entity_ids.add(str(triplet.subject_id))\n",
+    "            entity_ids.add(str(triplet.object_id))\n",
+    "            group = predicate_to_group.get(str(triplet.predicate), [])\n",
+    "            if group:\n",
+    "                relevant_predicates.update(group)\n",
+    "\n",
+    "        # 2. Prepare SQL query\n",
+    "        entity_placeholders = \",\".join([\"?\"] * len(entity_ids))\n",
+    "        predicate_placeholders = \",\".join([\"?\"] * len(relevant_predicates))\n",
+    "        query = f\"\"\"\n",
+    "            SELECT\n",
+    "                t.id,\n",
+    "                t.subject_name,\n",
+    "                t.subject_id,\n",
+    "                t.predicate,\n",
+    "                t.object_name,\n",
+    "                t.object_id,\n",
+    "                t.value,\n",
+    "                t.event_id,\n",
+    "                e.chunk_id,\n",
+    "                e.statement,\n",
+    "                e.triplets,\n",
+    "                e.statement_type,\n",
+    "                e.temporal_type,\n",
+    "                e.valid_at,\n",
+    "                e.invalid_at,\n",
+    "                e.created_at,\n",
+    "                e.expired_at,\n",
+    "                e.invalidated_by,\n",
+    "                e.embedding\n",
+    "            FROM triplets t\n",
+    "            JOIN events e ON t.event_id = e.id\n",
+    "            WHERE\n",
+    "                (t.subject_id IN ({entity_placeholders}) OR t.object_id IN ({entity_placeholders}))\n",
+    "                AND t.predicate IN ({predicate_placeholders})\n",
+    "                AND e.statement_type = ?\n",
+    "        \"\"\"\n",
+    "        params = list(entity_ids) + list(entity_ids) + list(relevant_predicates) + [StatementType.FACT]\n",
+    "        cursor = conn.cursor()\n",
+    "        cursor.execute(query, params)\n",
+    "        rows = cursor.fetchall()\n",
+    "\n",
+    "        triplets = []\n",
+    "        events = []\n",
+    "        events_by_id = {}\n",
+    "        for row in rows:\n",
+    "            triplet = Triplet(\n",
+    "                id=row[0],\n",
+    "                subject_name=row[1],\n",
+    "                subject_id=row[2],\n",
+    "                predicate=Predicate(row[3]),\n",
+    "                object_name=row[4],\n",
+    "                object_id=row[5],\n",
+    "                value=row[6],\n",
+    "                event_id=row[7],\n",
+    "            )\n",
+    "            event_id = row[7]\n",
+    "            triplets.append(triplet)\n",
+    "            if event_id not in events_by_id:\n",
+    "                events_by_id[event_id] = TemporalEvent(\n",
+    "                    id=row[7],\n",
+    "                    chunk_id=row[8],\n",
+    "                    statement=row[9],\n",
+    "                    triplets=TemporalEvent.parse_triplets_json(row[10]),\n",
+    "                    statement_type=row[11],\n",
+    "                    temporal_type=row[12],\n",
+    "                    valid_at=row[13],\n",
+    "                    invalid_at=row[14],\n",
+    "                    created_at=row[15],\n",
+    "                    expired_at=row[16],\n",
+    "                    invalidated_by=row[17],\n",
+    "                    embedding=pickle.loads(row[18]) if row[18] else [0] * 1536,\n",
+    "                )\n",
+    "        events = list(events_by_id.values())\n",
+    "        return triplets, events"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can create a batch processing function for invalidation for a set of Temporal Events. This is where we filter our Statements to type FACT before passing into the invalidation agent to process."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "async def batch_process_invalidation(\n",
+    "    conn: sqlite3.Connection, all_events: list[TemporalEvent], all_triplets: list[Triplet], invalidation_agent: InvalidationAgent\n",
+    ") -> tuple[list[TemporalEvent], list[TemporalEvent]]:\n",
+    "    \"\"\"Process invalidation for all FACT events that are temporal.\n",
+    "\n",
+    "    Args:\n",
+    "        conn: SQLite database connection\n",
+    "        all_events: List of all extracted events\n",
+    "        all_triplets: List of all extracted triplets\n",
+    "        invalidation_agent: The invalidation agent instance\n",
+    "\n",
+    "    Returns:\n",
+    "        tuple[list[TemporalEvent], list[TemporalEvent]]:\n",
+    "            - final_events: All events (updated incoming events)\n",
+    "            - events_to_update: Existing events that need DB updates\n",
+    "    \"\"\"\n",
+    "    def _get_fact_triplets(\n",
+    "        all_events: list[TemporalEvent],\n",
+    "        all_triplets: list[Triplet],\n",
+    "    ) -> list[Triplet]:\n",
+    "        \"\"\"\n",
+    "        Return only those triplets whose associated event is of statement_type FACT.\n",
+    "        \"\"\"\n",
+    "        fact_event_ids = {\n",
+    "            event.id for event in all_events if (event.statement_type == StatementType.FACT) and (event.temporal_type != TemporalType.ATEMPORAL)\n",
+    "        }\n",
+    "        return [triplet for triplet in all_triplets if triplet.event_id in fact_event_ids]\n",
+    "    # Prepare a list of triplets whose associated event is a FACT and not ATEMPORAL\n",
+    "    fact_triplets = _get_fact_triplets(all_events, all_triplets)\n",
+    "    if not fact_triplets:\n",
+    "        return all_events, []\n",
+    "\n",
+    "    # Create event map for quick lookup\n",
+    "    all_events_map = {event.id: event for event in all_events}\n",
+    "\n",
+    "    # Build aligned lists of valid triplets and their corresponding events\n",
+    "    fact_events: list[TemporalEvent] = []\n",
+    "    valid_fact_triplets: list[Triplet] = []\n",
+    "    for triplet in fact_triplets:\n",
+    "        # Handle potential None event_id and ensure type safety\n",
+    "        if triplet.event_id is not None:\n",
+    "            event = all_events_map.get(triplet.event_id)\n",
+    "            if event:\n",
+    "                fact_events.append(event)\n",
+    "                valid_fact_triplets.append(triplet)\n",
+    "            else:\n",
+    "                print(f\"Warning: Could not find event for fact_triplet with event_id {triplet.event_id}\")\n",
+    "        else:\n",
+    "            print(f\"Warning: Fact triplet {triplet.id} has no event_id, skipping invalidation\")\n",
+    "\n",
+    "    if not valid_fact_triplets:\n",
+    "        return all_events, []\n",
+    "\n",
+    "    # Batch fetch all related existing triplets and events\n",
+    "    existing_triplets, existing_events = invalidation_agent.batch_fetch_related_triplet_events(conn, valid_fact_triplets)\n",
+    "\n",
+    "    # Process all invalidations in parallel\n",
+    "    updated_incoming_fact_events, changed_existing_events = await invalidation_agent.process_invalidations_in_parallel(\n",
+    "        incoming_triplets=valid_fact_triplets,\n",
+    "        incoming_events=fact_events,\n",
+    "        existing_triplets=existing_triplets,\n",
+    "        existing_events=existing_events,\n",
+    "    )\n",
+    "\n",
+    "    # Create mapping for efficient updates\n",
+    "    updated_incoming_event_map = {event.id: event for event in updated_incoming_fact_events}\n",
+    "\n",
+    "    # Reconstruct final events list with updates applied\n",
+    "    final_events = []\n",
+    "    for original_event in all_events:\n",
+    "        if original_event.id in updated_incoming_event_map:\n",
+    "            final_events.append(updated_incoming_event_map[original_event.id])\n",
+    "        else:\n",
+    "            final_events.append(original_event)\n",
+    "\n",
+    "    return final_events, changed_existing_events"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.2.11. Putting it all together"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now that we have built out each individual component of the Temporal Knowledge Graph workflow, we can integrate them into a cohesive workflow.\n",
+    "\n",
+    "Given a chunked transcript, the Temporal Agent sequentially processes each chunk, initially extracting relevant statements. These statements are then classified and enriched through subsequent extraction phases, resulting in Temporal Events, structured Triplets, and identified Entities.\n",
+    "\n",
+    "The extracted Entities are cross-referenced with existing records in the database, ensuring accurate resolution and avoiding redundancy. Following entity resolution, the Dynamic Facts undergo validation via the Invalidation Agent to verify temporal consistency and validity.\n",
+    "\n",
+    "After successful processing and validation, the refined data is systematically stored into their respective tables within the SQLite database, maintaining an organized and temporally accurate knowledge graph.\n",
+    "\n",
+    "To help visually ground the code presented below, we can look again at the pipeline diagram: "
+   ]
+  },
+  {
+   "attachments": {
+    "826322ef-4eb8-4c3b-a1a1-f4c8b0d435e8.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<!-- ![Screenshot 2025-06-23 at 11.45.46.png](attachment:826322ef-4eb8-4c3b-a1a1-f4c8b0d435e8.png) -->\n",
+    "<img\n",
+    "  src=\"../../../images/09_full_pipeline.png\"\n",
+    "  alt=\"Full Pipeline\"\n",
+    "  style=\"width:791px; height:auto;\"\n",
+    "/>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sqlite3\n",
+    "\n",
+    "from db_interface import (\n",
+    "    has_events,\n",
+    "    insert_chunk,\n",
+    "    insert_entity,\n",
+    "    insert_event,\n",
+    "    insert_transcript,\n",
+    "    insert_triplet,\n",
+    "    update_events_batch,\n",
+    ")\n",
+    "from utils import safe_iso\n",
+    "\n",
+    "\n",
+    "async def ingest_transcript(\n",
+    "        transcript: Transcript,\n",
+    "        conn: sqlite3.Connection,\n",
+    "        temporal_agent: TemporalAgent,\n",
+    "        invalidation_agent: InvalidationAgent,\n",
+    "        entity_resolver: EntityResolution) -> None:\n",
+    "    \"\"\"\n",
+    "    Ingest a Transcript object into the database, extracting and saving all chunks, events, triplets, and entities.\n",
+    "    \"\"\"\n",
+    "    insert_transcript(\n",
+    "        conn,\n",
+    "        {\n",
+    "            \"id\": str(transcript.id),\n",
+    "            \"text\": transcript.text,\n",
+    "            \"company\": transcript.company,\n",
+    "            \"date\": transcript.date,\n",
+    "            \"quarter\": transcript.quarter,\n",
+    "        },\n",
+    "    )\n",
+    "\n",
+    "    transcript, all_events, all_triplets, all_entities = await temporal_agent.extract_transcript_events(transcript)\n",
+    "    entity_resolver.resolve_entities_batch(all_entities)\n",
+    "    name_to_canonical = {entity.name: entity.resolved_id for entity in all_entities if entity.resolved_id}\n",
+    "\n",
+    "    # Update triplets with resolved entity IDs\n",
+    "    for triplet in all_triplets:\n",
+    "        if triplet.subject_name in name_to_canonical:\n",
+    "            triplet.subject_id = name_to_canonical[triplet.subject_name]\n",
+    "        if triplet.object_name in name_to_canonical:\n",
+    "            triplet.object_id = name_to_canonical[triplet.object_name]\n",
+    "\n",
+    "\n",
+    "    # Invalidation processing with properly resolved triplet IDs\n",
+    "    events_to_update: list[TemporalEvent] = []\n",
+    "    if has_events(conn):\n",
+    "        all_events, events_to_update = await batch_process_invalidation(conn, all_events, all_triplets, invalidation_agent)\n",
+    "\n",
+    "    # ALL DB operations happen in single transaction\n",
+    "    with conn:\n",
+    "        # Update existing events first (they're already in DB)\n",
+    "        if events_to_update:\n",
+    "            update_events_batch(conn, events_to_update)\n",
+    "            print(f\"Updated {len(events_to_update)} existing events\")\n",
+    "\n",
+    "        # Insert new data\n",
+    "        for chunk in transcript.chunks or []:\n",
+    "            chunk_dict = chunk.model_dump()\n",
+    "            insert_chunk(\n",
+    "                conn,\n",
+    "                {\n",
+    "                    \"id\": str(chunk_dict[\"id\"]),\n",
+    "                    \"transcript_id\": str(transcript.id),\n",
+    "                    \"text\": chunk_dict[\"text\"],\n",
+    "                    \"metadata\": json.dumps(chunk_dict[\"metadata\"]),\n",
+    "                },\n",
+    "            )\n",
+    "        for event in all_events:\n",
+    "            event_dict = {\n",
+    "                \"id\": str(event.id),\n",
+    "                \"chunk_id\": str(event.chunk_id),\n",
+    "                \"statement\": event.statement,\n",
+    "                \"embedding\": pickle.dumps(event.embedding) if event.embedding is not None else None,\n",
+    "                \"triplets\": event.triplets_json,\n",
+    "                \"statement_type\": event.statement_type.value if hasattr(event.statement_type, \"value\") else event.statement_type,\n",
+    "                \"temporal_type\": event.temporal_type.value if hasattr(event.temporal_type, \"value\") else event.temporal_type,\n",
+    "                \"created_at\": safe_iso(event.created_at),\n",
+    "                \"valid_at\": safe_iso(event.valid_at),\n",
+    "                \"expired_at\": safe_iso(event.expired_at),\n",
+    "                \"invalid_at\": safe_iso(event.invalid_at),\n",
+    "                \"invalidated_by\": str(event.invalidated_by) if event.invalidated_by else None,\n",
+    "            }\n",
+    "\n",
+    "            insert_event(conn, event_dict)\n",
+    "        for triplet in all_triplets:\n",
+    "            try:\n",
+    "                insert_triplet(\n",
+    "                    conn,\n",
+    "                    {\n",
+    "                        \"id\": str(triplet.id),\n",
+    "                        \"event_id\": str(triplet.event_id),\n",
+    "                        \"subject_name\": triplet.subject_name,\n",
+    "                        \"subject_id\": str(triplet.subject_id),\n",
+    "                        \"predicate\": triplet.predicate,\n",
+    "                        \"object_name\": triplet.object_name,\n",
+    "                        \"object_id\": str(triplet.object_id),\n",
+    "                        \"value\": triplet.value,\n",
+    "                    },\n",
+    "                )\n",
+    "            except KeyError as e:\n",
+    "                print(f\"KeyError: {triplet.subject_name} or {triplet.object_name} not found in name_to_canonical\")\n",
+    "                print(f\"Skipping triplet: Entity '{e.args[0]}' is unresolved.\")\n",
+    "                continue\n",
+    "        # Deduplicate entities by id before insert\n",
+    "        unique_entities = {}\n",
+    "        for entity in all_entities:\n",
+    "            unique_entities[str(entity.id)] = entity\n",
+    "        for entity in unique_entities.values():\n",
+    "            insert_entity(conn, {\"id\": str(entity.id), \"name\": entity.name, \"resolved_id\": str(entity.resolved_id)})\n",
+    "\n",
+    "    return None"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Initialize core components\n",
+    "sqlite_conn = make_connection(memory=False, refresh=True)\n",
+    "temporal_agent = TemporalAgent()\n",
+    "invalidation_agent = InvalidationAgent()\n",
+    "entity_resolver = EntityResolution(sqlite_conn)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Ingest single transcript\n",
+    "await ingest_transcript(transcripts[0], sqlite_conn, temporal_agent, invalidation_agent, entity_resolver)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# View what tables have been created and populated\n",
+    "sqlite_conn.execute(\"SELECT name FROM sqlite_master WHERE type='table';\").fetchall()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# View triplets table\n",
+    "from db_interface import view_db_table\n",
+    "\n",
+    "triplets_df = view_db_table(sqlite_conn, \"triplets\", max_rows=10)\n",
+    "display(triplets_df)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can then ingest the rest of the Transcripts. Note that this code has not been optimised to be production ready and on average takes 2-5 mins per Transcript. This bulk ingestion using the data in /transcripts (~30 files) will take up to 2 hours to run. Optimizing this is a critical step in scaling to production. We outline some methods you can use to approach this in the Appendix in [A.3 \"Implementing Concurrency in the Ingestion Pipeline\"](./Appendix.ipynb), including batch chunking, entity clustering, and more. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import time\n",
+    "\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "\n",
+    "async def bulk_transcript_ingestion(transcripts: list[Transcript], sqlite_conn: sqlite3.Connection) -> None:\n",
+    "    \"\"\"Handle transcript ingestion with duplicate checking, optional overwriting, and progress tracking.\n",
+    "\n",
+    "    Args:\n",
+    "        transcripts (List[Transcript]): List of transcripts to ingest\n",
+    "        sqlite_conn (sqlite3.Connection): SQLite database connection\n",
+    "        overwrite (bool, optional): Whether to overwrite existing transcripts. Defaults to False.\n",
+    "    \"\"\"\n",
+    "    temporal_agent = TemporalAgent()\n",
+    "    invalidation_agent = InvalidationAgent()\n",
+    "    entity_resolver = EntityResolution(sqlite_conn)\n",
+    "\n",
+    "    pbar = tqdm(total=len(transcripts), desc=\"Ingesting transcripts\")\n",
+    "\n",
+    "    for transcript in transcripts:\n",
+    "        start_time = time.time()\n",
+    "        try:\n",
+    "            await ingest_transcript(transcript, sqlite_conn, temporal_agent, invalidation_agent, entity_resolver)\n",
+    "            # Calculate and display ingestion time\n",
+    "            end_time = time.time()\n",
+    "            ingestion_time = end_time - start_time\n",
+    "\n",
+    "            # Update progress bar with completion message\n",
+    "            pbar.write(\n",
+    "                f\"Ingested transcript {transcript.id} \"\n",
+    "                f\"in {ingestion_time:.2f} seconds\"\n",
+    "            )\n",
+    "\n",
+    "        except Exception as e:\n",
+    "            pbar.write(f\"Error ingesting transcript {transcript.id}: {str(e)}\")\n",
+    "\n",
+    "        finally:\n",
+    "            # Update progress bar\n",
+    "            pbar.update(1)\n",
+    "\n",
+    "    pbar.close()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "> Note: Running the below cell for all transcripts in this dataset can take approximately 1 hour"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Bulk ingestion (not recommended)\n",
+    "sqlite_conn = make_connection(memory=False, refresh=True, db_path=\"my_database.db\")\n",
+    "transcripts = load_transcripts_from_pickle()\n",
+    "# await bulk_transcript_ingestion(transcripts, sqlite_conn)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We recommend loading the pre-processed AMD and NVDA data from file by creating a new SQLite connection using the code below. This will create the database needed for building the graph and retriever. \n",
+    "\n",
+    "You can find this data on [HuggingFace](https://huggingface.co/datasets/TomoroAI/temporal_cookbook_db)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loading transcripts...\n",
+      "Loading chunks...\n",
+      "Loading events...\n",
+      "Loading triplets...\n",
+      "Loading entities...\n",
+      "✅ All tables written to SQLite.\n"
+     ]
+    }
+   ],
+   "source": [
+    "from cb_functions import load_db_from_hf\n",
+    "sqlite_conn = load_db_from_hf()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>id</th>\n",
+       "      <th>text</th>\n",
+       "      <th>company</th>\n",
+       "      <th>date</th>\n",
+       "      <th>quarter</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>f2f5aa4c-ad2b-4ed5-9792-bcbddbc4e207</td>\n",
+       "      <td>\\n\\nRefinitiv StreetEvents Event Transcript\\nE...</td>\n",
+       "      <td>NVDA</td>\n",
+       "      <td>2020-08-19T00:00:00</td>\n",
+       "      <td>Q2 2021</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>74d42583-b614-4771-80c8-1ddf964a4f1c</td>\n",
+       "      <td>\\n\\nThomson Reuters StreetEvents Event Transcr...</td>\n",
+       "      <td>AMD</td>\n",
+       "      <td>2016-07-21T00:00:00</td>\n",
+       "      <td>Q2 2016</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>26e523aa-7e15-4741-986a-6ec0be034a33</td>\n",
+       "      <td>\\n\\nThomson Reuters StreetEvents Event Transcr...</td>\n",
+       "      <td>NVDA</td>\n",
+       "      <td>2016-11-10T00:00:00</td>\n",
+       "      <td>Q3 2017</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>74380d19-203a-48f6-a1c8-d8df33aae362</td>\n",
+       "      <td>\\n\\nThomson Reuters StreetEvents Event Transcr...</td>\n",
+       "      <td>NVDA</td>\n",
+       "      <td>2018-05-10T00:00:00</td>\n",
+       "      <td>Q1 2019</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>7d620d30-7b09-4774-bc32-51b00a80badf</td>\n",
+       "      <td>\\n\\nThomson Reuters StreetEvents Event Transcr...</td>\n",
+       "      <td>AMD</td>\n",
+       "      <td>2017-07-25T00:00:00</td>\n",
+       "      <td>Q2 2017</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>1ba2fc55-a121-43d4-85d7-e221851f2c7f</td>\n",
+       "      <td>\\n\\nThomson Reuters StreetEvents Event Transcr...</td>\n",
+       "      <td>AMD</td>\n",
+       "      <td>2017-01-31T00:00:00</td>\n",
+       "      <td>Q4 2016</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>db1925df-b5a5-4cb2-862b-df269f53be7e</td>\n",
+       "      <td>\\n\\nThomson Reuters StreetEvents Event Transcr...</td>\n",
+       "      <td>NVDA</td>\n",
+       "      <td>2017-11-09T00:00:00</td>\n",
+       "      <td>Q3 2018</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>fe212bc0-9b3d-44ed-91ca-bfb856b21aa6</td>\n",
+       "      <td>\\n\\nThomson Reuters StreetEvents Event Transcr...</td>\n",
+       "      <td>NVDA</td>\n",
+       "      <td>2019-02-14T00:00:00</td>\n",
+       "      <td>Q4 2019</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>7c0a6f9c-9279-4714-b25e-8be20ae8fb99</td>\n",
+       "      <td>\\n\\nThomson Reuters StreetEvents Event Transcr...</td>\n",
+       "      <td>AMD</td>\n",
+       "      <td>2019-04-30T00:00:00</td>\n",
+       "      <td>Q1 2019</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9</th>\n",
+       "      <td>10f95617-e5b2-4525-a207-cec9ae9a3211</td>\n",
+       "      <td>\\n\\nThomson Reuters StreetEvents Event Transcr...</td>\n",
+       "      <td>AMD</td>\n",
+       "      <td>2019-01-29T00:00:00</td>\n",
+       "      <td>Q4 2018</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>10</th>\n",
+       "      <td>aab926b2-5a23-4b39-a29c-c1e7ceef5a55</td>\n",
+       "      <td>\\n\\nThomson Reuters StreetEvents Event Transcr...</td>\n",
+       "      <td>AMD</td>\n",
+       "      <td>2020-04-28T00:00:00</td>\n",
+       "      <td>Q1 2020</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>11</th>\n",
+       "      <td>6d45f413-3aa5-4c76-b3cf-d0fdb0a03787</td>\n",
+       "      <td>\\n\\nThomson Reuters StreetEvents Event Transcr...</td>\n",
+       "      <td>NVDA</td>\n",
+       "      <td>2019-08-15T00:00:00</td>\n",
+       "      <td>Q2 2020</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>12</th>\n",
+       "      <td>ad10e284-d209-42f1-8a7c-8c889af0914e</td>\n",
+       "      <td>\\n\\nThomson Reuters StreetEvents Event Transcr...</td>\n",
+       "      <td>AMD</td>\n",
+       "      <td>2019-10-29T00:00:00</td>\n",
+       "      <td>Q3 2019</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>13</th>\n",
+       "      <td>a30da2d4-3327-432e-9ce0-b57795a0fe26</td>\n",
+       "      <td>\\n\\nThomson Reuters StreetEvents Event Transcr...</td>\n",
+       "      <td>AMD</td>\n",
+       "      <td>2018-04-25T00:00:00</td>\n",
+       "      <td>Q1 2018</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>14</th>\n",
+       "      <td>038e0986-a689-4374-97d2-651b05bdfae8</td>\n",
+       "      <td>\\n\\nThomson Reuters StreetEvents Event Transcr...</td>\n",
+       "      <td>NVDA</td>\n",
+       "      <td>2018-11-15T00:00:00</td>\n",
+       "      <td>Q3 2019</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>15</th>\n",
+       "      <td>6ff24a98-ad3b-4013-92eb-45ac5b0f214d</td>\n",
+       "      <td>\\n\\nThomson Reuters StreetEvents Event Transcr...</td>\n",
+       "      <td>NVDA</td>\n",
+       "      <td>2016-02-17T00:00:00</td>\n",
+       "      <td>Q4 2016</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>16</th>\n",
+       "      <td>34d010f1-7221-4ed4-92f4-c69c4a3fd779</td>\n",
+       "      <td>\\n\\nThomson Reuters StreetEvents Event Transcr...</td>\n",
+       "      <td>NVDA</td>\n",
+       "      <td>2020-02-13T00:00:00</td>\n",
+       "      <td>Q4 2020</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>17</th>\n",
+       "      <td>e5e31dd4-2587-40af-8f8c-56a772831acd</td>\n",
+       "      <td>\\n\\nThomson Reuters StreetEvents Event Transcr...</td>\n",
+       "      <td>AMD</td>\n",
+       "      <td>2017-10-24T00:00:00</td>\n",
+       "      <td>Q3 2017</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>18</th>\n",
+       "      <td>60e56971-9ab8-4ebd-ac2a-e9fce301ca33</td>\n",
+       "      <td>\\n\\nThomson Reuters StreetEvents Event Transcr...</td>\n",
+       "      <td>NVDA</td>\n",
+       "      <td>2016-08-11T00:00:00</td>\n",
+       "      <td>Q2 2017</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>19</th>\n",
+       "      <td>1d4b2c13-4bf0-4c0f-90fe-a48c6e03c73a</td>\n",
+       "      <td>\\n\\nThomson Reuters StreetEvents Event Transcr...</td>\n",
+       "      <td>NVDA</td>\n",
+       "      <td>2018-08-16T00:00:00</td>\n",
+       "      <td>Q2 2019</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>20</th>\n",
+       "      <td>b6b5df13-4736-4ecd-9c41-cf62f4639a4a</td>\n",
+       "      <td>\\n\\nThomson Reuters StreetEvents Event Transcr...</td>\n",
+       "      <td>AMD</td>\n",
+       "      <td>2016-04-21T00:00:00</td>\n",
+       "      <td>Q1 2016</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21</th>\n",
+       "      <td>43094307-3f8f-40a2-886b-f4f1da64312c</td>\n",
+       "      <td>\\n\\nThomson Reuters StreetEvents Event Transcr...</td>\n",
+       "      <td>AMD</td>\n",
+       "      <td>2017-05-01T00:00:00</td>\n",
+       "      <td>Q1 2017</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>22</th>\n",
+       "      <td>e6902113-4b71-491d-b7de-8ff347b481cd</td>\n",
+       "      <td>\\n\\nThomson Reuters StreetEvents Event Transcr...</td>\n",
+       "      <td>AMD</td>\n",
+       "      <td>2018-07-25T00:00:00</td>\n",
+       "      <td>Q2 2018</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>23</th>\n",
+       "      <td>dbaa7a7c-1db2-4b0c-9130-8ca48f10be6f</td>\n",
+       "      <td>\\n\\nThomson Reuters StreetEvents Event Transcr...</td>\n",
+       "      <td>NVDA</td>\n",
+       "      <td>2017-02-09T00:00:00</td>\n",
+       "      <td>Q4 2017</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>24</th>\n",
+       "      <td>6ec75a2d-d449-4f52-bb93-17b1770dbf6c</td>\n",
+       "      <td>\\n\\nThomson Reuters StreetEvents Event Transcr...</td>\n",
+       "      <td>NVDA</td>\n",
+       "      <td>2018-02-08T00:00:00</td>\n",
+       "      <td>Q4 2018</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>25</th>\n",
+       "      <td>bcf360a8-0784-4c31-8a09-ca824a26264f</td>\n",
+       "      <td>\\n\\nThomson Reuters StreetEvents Event Transcr...</td>\n",
+       "      <td>NVDA</td>\n",
+       "      <td>2017-05-09T00:00:00</td>\n",
+       "      <td>Q1 2018</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>26</th>\n",
+       "      <td>01d2252f-10a2-48f7-8350-ffe17bb8e18d</td>\n",
+       "      <td>\\n\\nThomson Reuters StreetEvents Event Transcr...</td>\n",
+       "      <td>NVDA</td>\n",
+       "      <td>2016-05-12T00:00:00</td>\n",
+       "      <td>Q1 2017</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>27</th>\n",
+       "      <td>d4c10451-d7b2-4c13-8f15-695596e49144</td>\n",
+       "      <td>\\n\\nThomson Reuters StreetEvents Event Transcr...</td>\n",
+       "      <td>AMD</td>\n",
+       "      <td>2016-10-20T00:00:00</td>\n",
+       "      <td>Q3 2016</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>28</th>\n",
+       "      <td>6c832314-d5ef-42cd-9fa0-914c5480d7be</td>\n",
+       "      <td>\\n\\nThomson Reuters StreetEvents Event Transcr...</td>\n",
+       "      <td>AMD</td>\n",
+       "      <td>2016-01-19T00:00:00</td>\n",
+       "      <td>Q4 2015</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>29</th>\n",
+       "      <td>1207115e-20ed-479c-a903-e28dfda52ebd</td>\n",
+       "      <td>\\n\\nThomson Reuters StreetEvents Event Transcr...</td>\n",
+       "      <td>AMD</td>\n",
+       "      <td>2018-01-30T00:00:00</td>\n",
+       "      <td>Q4 2017</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>30</th>\n",
+       "      <td>259fe893-9d28-4e4d-bc55-2edf646e150b</td>\n",
+       "      <td>\\n\\nRefinitiv StreetEvents Event Transcript\\nE...</td>\n",
+       "      <td>AMD</td>\n",
+       "      <td>2020-07-28T00:00:00</td>\n",
+       "      <td>Q2 2020</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>31</th>\n",
+       "      <td>02b1212b-cd3f-4c19-8505-8d1aea6d3ae2</td>\n",
+       "      <td>\\n\\nThomson Reuters StreetEvents Event Transcr...</td>\n",
+       "      <td>NVDA</td>\n",
+       "      <td>2020-05-21T00:00:00</td>\n",
+       "      <td>Q1 2021</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>32</th>\n",
+       "      <td>fa199b2c-1f58-4663-af8c-29c531fc97d6</td>\n",
+       "      <td>\\n\\nThomson Reuters StreetEvents Event Transcr...</td>\n",
+       "      <td>AMD</td>\n",
+       "      <td>2019-07-30T00:00:00</td>\n",
+       "      <td>Q2 2019</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                                      id  \\\n",
+       "0   f2f5aa4c-ad2b-4ed5-9792-bcbddbc4e207   \n",
+       "1   74d42583-b614-4771-80c8-1ddf964a4f1c   \n",
+       "2   26e523aa-7e15-4741-986a-6ec0be034a33   \n",
+       "3   74380d19-203a-48f6-a1c8-d8df33aae362   \n",
+       "4   7d620d30-7b09-4774-bc32-51b00a80badf   \n",
+       "5   1ba2fc55-a121-43d4-85d7-e221851f2c7f   \n",
+       "6   db1925df-b5a5-4cb2-862b-df269f53be7e   \n",
+       "7   fe212bc0-9b3d-44ed-91ca-bfb856b21aa6   \n",
+       "8   7c0a6f9c-9279-4714-b25e-8be20ae8fb99   \n",
+       "9   10f95617-e5b2-4525-a207-cec9ae9a3211   \n",
+       "10  aab926b2-5a23-4b39-a29c-c1e7ceef5a55   \n",
+       "11  6d45f413-3aa5-4c76-b3cf-d0fdb0a03787   \n",
+       "12  ad10e284-d209-42f1-8a7c-8c889af0914e   \n",
+       "13  a30da2d4-3327-432e-9ce0-b57795a0fe26   \n",
+       "14  038e0986-a689-4374-97d2-651b05bdfae8   \n",
+       "15  6ff24a98-ad3b-4013-92eb-45ac5b0f214d   \n",
+       "16  34d010f1-7221-4ed4-92f4-c69c4a3fd779   \n",
+       "17  e5e31dd4-2587-40af-8f8c-56a772831acd   \n",
+       "18  60e56971-9ab8-4ebd-ac2a-e9fce301ca33   \n",
+       "19  1d4b2c13-4bf0-4c0f-90fe-a48c6e03c73a   \n",
+       "20  b6b5df13-4736-4ecd-9c41-cf62f4639a4a   \n",
+       "21  43094307-3f8f-40a2-886b-f4f1da64312c   \n",
+       "22  e6902113-4b71-491d-b7de-8ff347b481cd   \n",
+       "23  dbaa7a7c-1db2-4b0c-9130-8ca48f10be6f   \n",
+       "24  6ec75a2d-d449-4f52-bb93-17b1770dbf6c   \n",
+       "25  bcf360a8-0784-4c31-8a09-ca824a26264f   \n",
+       "26  01d2252f-10a2-48f7-8350-ffe17bb8e18d   \n",
+       "27  d4c10451-d7b2-4c13-8f15-695596e49144   \n",
+       "28  6c832314-d5ef-42cd-9fa0-914c5480d7be   \n",
+       "29  1207115e-20ed-479c-a903-e28dfda52ebd   \n",
+       "30  259fe893-9d28-4e4d-bc55-2edf646e150b   \n",
+       "31  02b1212b-cd3f-4c19-8505-8d1aea6d3ae2   \n",
+       "32  fa199b2c-1f58-4663-af8c-29c531fc97d6   \n",
+       "\n",
+       "                                                 text company  \\\n",
+       "0   \\n\\nRefinitiv StreetEvents Event Transcript\\nE...    NVDA   \n",
+       "1   \\n\\nThomson Reuters StreetEvents Event Transcr...     AMD   \n",
+       "2   \\n\\nThomson Reuters StreetEvents Event Transcr...    NVDA   \n",
+       "3   \\n\\nThomson Reuters StreetEvents Event Transcr...    NVDA   \n",
+       "4   \\n\\nThomson Reuters StreetEvents Event Transcr...     AMD   \n",
+       "5   \\n\\nThomson Reuters StreetEvents Event Transcr...     AMD   \n",
+       "6   \\n\\nThomson Reuters StreetEvents Event Transcr...    NVDA   \n",
+       "7   \\n\\nThomson Reuters StreetEvents Event Transcr...    NVDA   \n",
+       "8   \\n\\nThomson Reuters StreetEvents Event Transcr...     AMD   \n",
+       "9   \\n\\nThomson Reuters StreetEvents Event Transcr...     AMD   \n",
+       "10  \\n\\nThomson Reuters StreetEvents Event Transcr...     AMD   \n",
+       "11  \\n\\nThomson Reuters StreetEvents Event Transcr...    NVDA   \n",
+       "12  \\n\\nThomson Reuters StreetEvents Event Transcr...     AMD   \n",
+       "13  \\n\\nThomson Reuters StreetEvents Event Transcr...     AMD   \n",
+       "14  \\n\\nThomson Reuters StreetEvents Event Transcr...    NVDA   \n",
+       "15  \\n\\nThomson Reuters StreetEvents Event Transcr...    NVDA   \n",
+       "16  \\n\\nThomson Reuters StreetEvents Event Transcr...    NVDA   \n",
+       "17  \\n\\nThomson Reuters StreetEvents Event Transcr...     AMD   \n",
+       "18  \\n\\nThomson Reuters StreetEvents Event Transcr...    NVDA   \n",
+       "19  \\n\\nThomson Reuters StreetEvents Event Transcr...    NVDA   \n",
+       "20  \\n\\nThomson Reuters StreetEvents Event Transcr...     AMD   \n",
+       "21  \\n\\nThomson Reuters StreetEvents Event Transcr...     AMD   \n",
+       "22  \\n\\nThomson Reuters StreetEvents Event Transcr...     AMD   \n",
+       "23  \\n\\nThomson Reuters StreetEvents Event Transcr...    NVDA   \n",
+       "24  \\n\\nThomson Reuters StreetEvents Event Transcr...    NVDA   \n",
+       "25  \\n\\nThomson Reuters StreetEvents Event Transcr...    NVDA   \n",
+       "26  \\n\\nThomson Reuters StreetEvents Event Transcr...    NVDA   \n",
+       "27  \\n\\nThomson Reuters StreetEvents Event Transcr...     AMD   \n",
+       "28  \\n\\nThomson Reuters StreetEvents Event Transcr...     AMD   \n",
+       "29  \\n\\nThomson Reuters StreetEvents Event Transcr...     AMD   \n",
+       "30  \\n\\nRefinitiv StreetEvents Event Transcript\\nE...     AMD   \n",
+       "31  \\n\\nThomson Reuters StreetEvents Event Transcr...    NVDA   \n",
+       "32  \\n\\nThomson Reuters StreetEvents Event Transcr...     AMD   \n",
+       "\n",
+       "                   date  quarter  \n",
+       "0   2020-08-19T00:00:00  Q2 2021  \n",
+       "1   2016-07-21T00:00:00  Q2 2016  \n",
+       "2   2016-11-10T00:00:00  Q3 2017  \n",
+       "3   2018-05-10T00:00:00  Q1 2019  \n",
+       "4   2017-07-25T00:00:00  Q2 2017  \n",
+       "5   2017-01-31T00:00:00  Q4 2016  \n",
+       "6   2017-11-09T00:00:00  Q3 2018  \n",
+       "7   2019-02-14T00:00:00  Q4 2019  \n",
+       "8   2019-04-30T00:00:00  Q1 2019  \n",
+       "9   2019-01-29T00:00:00  Q4 2018  \n",
+       "10  2020-04-28T00:00:00  Q1 2020  \n",
+       "11  2019-08-15T00:00:00  Q2 2020  \n",
+       "12  2019-10-29T00:00:00  Q3 2019  \n",
+       "13  2018-04-25T00:00:00  Q1 2018  \n",
+       "14  2018-11-15T00:00:00  Q3 2019  \n",
+       "15  2016-02-17T00:00:00  Q4 2016  \n",
+       "16  2020-02-13T00:00:00  Q4 2020  \n",
+       "17  2017-10-24T00:00:00  Q3 2017  \n",
+       "18  2016-08-11T00:00:00  Q2 2017  \n",
+       "19  2018-08-16T00:00:00  Q2 2019  \n",
+       "20  2016-04-21T00:00:00  Q1 2016  \n",
+       "21  2017-05-01T00:00:00  Q1 2017  \n",
+       "22  2018-07-25T00:00:00  Q2 2018  \n",
+       "23  2017-02-09T00:00:00  Q4 2017  \n",
+       "24  2018-02-08T00:00:00  Q4 2018  \n",
+       "25  2017-05-09T00:00:00  Q1 2018  \n",
+       "26  2016-05-12T00:00:00  Q1 2017  \n",
+       "27  2016-10-20T00:00:00  Q3 2016  \n",
+       "28  2016-01-19T00:00:00  Q4 2015  \n",
+       "29  2018-01-30T00:00:00  Q4 2017  \n",
+       "30  2020-07-28T00:00:00  Q2 2020  \n",
+       "31  2020-05-21T00:00:00  Q1 2021  \n",
+       "32  2019-07-30T00:00:00  Q2 2019  "
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# View transcripts table\n",
+    "from db_interface import view_db_table\n",
+    "\n",
+    "transcript_df = view_db_table(sqlite_conn, \"transcripts\", max_rows=None)\n",
+    "display(transcript_df)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3.3. Knowledge Graphs"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.3.1 Building our Knowledge Graph with NetworkX"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "When constructing the knowledge graph, canonical entity identifiers derived from triplets ensure accurate mapping of entity names, allowing storage of detailed temporal metadata directly on edges. Specifically, the implementation utilizes attributes:\n",
+    "\n",
+    "* **valid\\_at**, **invalid\\_at**, and **temporal\\_type** for **Temporal Validity**, representing real-world accuracy at specific historical moments—critical for analysis of historical facts.\n",
+    "* Optionally, attributes **created\\_at** and **expired\\_at** may also be used for **Transactional Validity**, enabling audit trails and source attribution by tracking when information was recorded, updated, or corrected.\n",
+    "\n",
+    "Transactional validity is particularly beneficial in scenarios such as:\n",
+    "\n",
+    "* **Finance**: Determining the accepted financial facts about Company X’s balance sheet on a specific historical date, based on contemporaneously accepted knowledge.\n",
+    "* **Law**: Identifying applicable legal frameworks as understood at a contract signing date, or compliance obligations recognized at past dates.\n",
+    "* **Journalism**: Assessing if previously reported information has become outdated, ensuring press releases and reporting remain accurate and credible over time.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy\n",
+    "import pandas\n",
+    "import scipy\n",
+    "\n",
+    "print(\"numpy :\", numpy.__version__)\n",
+    "print(\"pandas:\", pandas.__version__)\n",
+    "print(\"scipy :\", scipy.__version__)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loading transcripts...\n",
+      "✅ All tables written to SQLite.\n",
+      "Loading chunks...\n",
+      "✅ All tables written to SQLite.\n",
+      "Loading events...\n",
+      "✅ All tables written to SQLite.\n",
+      "Loading triplets...\n",
+      "✅ All tables written to SQLite.\n",
+      "Loading entities...\n",
+      "✅ All tables written to SQLite.\n",
+      "2282 nodes, 13150 edges\n"
+     ]
+    }
+   ],
+   "source": [
+    "from cb_functions import build_graph, load_db_from_hf\n",
+    "\n",
+    "conn = load_db_from_hf()\n",
+    "G = build_graph(conn)\n",
+    "\n",
+    "print(G.number_of_nodes(), \"nodes,\", G.number_of_edges(), \"edges\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import networkx as nx\n",
+    "\n",
+    "# Print descriptive notes about the graph\n",
+    "print(f\"Graph has {G.number_of_nodes()} nodes and {G.number_of_edges()} edges\")\n",
+    "\n",
+    "# Get some basic graph statistics\n",
+    "print(f\"Graph density: {G.number_of_edges() / (G.number_of_nodes() * (G.number_of_nodes() - 1)):.4f}\")\n",
+    "\n",
+    "# Sample some nodes to see their attributes\n",
+    "sample_nodes = list(G.nodes(data=True))[:5]\n",
+    "print(\"\\nSample nodes (first 5):\")\n",
+    "for node_id, attrs in sample_nodes:\n",
+    "    print(f\"  {node_id}: {attrs}\")\n",
+    "\n",
+    "# Sample some edges to see their attributes\n",
+    "sample_edges = list(G.edges(data=True))[:5]\n",
+    "print(\"\\nSample edges (first 5):\")\n",
+    "for u, v, attrs in sample_edges:\n",
+    "    print(f\"  {u} -> {v}: {attrs}\")\n",
+    "\n",
+    "# Get degree statistics\n",
+    "degrees = [d for _, d in G.degree()]\n",
+    "print(\"\\nDegree statistics:\")\n",
+    "print(f\"  Min degree: {min(degrees)}\")\n",
+    "print(f\"  Max degree: {max(degrees)}\")\n",
+    "print(f\"  Average degree: {sum(degrees) / len(degrees):.2f}\")\n",
+    "\n",
+    "# Check if graph is connected (considering it as undirected for connectivity)\n",
+    "undirected_G = G.to_undirected()\n",
+    "print(\"\\nConnectivity:\")\n",
+    "print(f\"  Number of connected components: {len(list(nx.connected_components(undirected_G)))}\")\n",
+    "print(f\"  Is weakly connected: {nx.is_weakly_connected(G)}\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create a visualization of the knowledge graph\n",
+    "import matplotlib.pyplot as plt\n",
+    "import networkx as nx\n",
+    "import numpy as np\n",
+    "\n",
+    "# Create a smaller subgraph for visualization (reduce data for clarity)\n",
+    "# Get nodes with highest degrees for a meaningful visualization\n",
+    "degrees = dict(G.degree())\n",
+    "top_nodes = sorted(degrees.items(), key=lambda x: x[1], reverse=True)[:20]  # Reduced from 30 to 20\n",
+    "visualization_nodes = [node for node, _ in top_nodes]\n",
+    "\n",
+    "# Create subgraph with these high-degree nodes\n",
+    "graph = G.subgraph(visualization_nodes)\n",
+    "print(f\"Visualization subgraph: {graph.number_of_nodes()} nodes, {graph.number_of_edges()} edges\")\n",
+    "\n",
+    "# Create the plot with better styling\n",
+    "fig, ax = plt.subplots(figsize=(18, 14))\n",
+    "fig.patch.set_facecolor(\"white\")\n",
+    "\n",
+    "# Use hierarchical layout for better structure\n",
+    "try:\n",
+    "    # Try hierarchical layout first\n",
+    "    pos = nx.nx_agraph.graphviz_layout(graph, prog=\"neato\")\n",
+    "except (ImportError, nx.NetworkXException):\n",
+    "    # Fall back to spring layout with better parameters\n",
+    "    pos = nx.spring_layout(graph, k=5, iterations=100, seed=42)\n",
+    "\n",
+    "# Calculate node properties\n",
+    "node_degrees = [degrees[node] for node in graph.nodes()]\n",
+    "max_degree = max(node_degrees)\n",
+    "min_degree = min(node_degrees)\n",
+    "\n",
+    "# Create better color scheme\n",
+    "colors = plt.cm.plasma(np.linspace(0.2, 0.9, len(node_degrees)))\n",
+    "node_colors = [colors[i] for i in range(len(node_degrees))]\n",
+    "\n",
+    "# Draw nodes with improved styling\n",
+    "node_sizes = [max(200, min(2000, deg * 50)) for deg in node_degrees]  # Better size scaling\n",
+    "nx.draw_networkx_nodes(graph, pos,\n",
+    "                      node_color=node_colors,\n",
+    "                      node_size=node_sizes,\n",
+    "                      alpha=0.9,\n",
+    "                      edgecolors=\"black\",\n",
+    "                      linewidths=1.5,\n",
+    "                      ax=ax)\n",
+    "\n",
+    "# Draw edges with better styling\n",
+    "edge_weights = []\n",
+    "for _, _, _ in graph.edges(data=True):\n",
+    "    edge_weights.append(1)\n",
+    "\n",
+    "nx.draw_networkx_edges(graph, pos,\n",
+    "                      alpha=0.4,\n",
+    "                      edge_color=\"#666666\",\n",
+    "                      width=1.0,\n",
+    "                      arrows=True,\n",
+    "                      arrowsize=15,\n",
+    "                      arrowstyle=\"->\",\n",
+    "                      ax=ax)\n",
+    "\n",
+    "# Add labels for all nodes with better formatting\n",
+    "labels = {}\n",
+    "for node in graph.nodes():\n",
+    "    node_name = graph.nodes[node].get(\"name\", str(node))\n",
+    "    # Truncate long names\n",
+    "    if len(node_name) > 15:\n",
+    "        node_name = node_name[:12] + \"...\"\n",
+    "    labels[node] = node_name\n",
+    "\n",
+    "nx.draw_networkx_labels(graph, pos, labels,\n",
+    "                       font_size=9,\n",
+    "                       font_weight=\"bold\",\n",
+    "                       font_color=\"black\",  # changed from 'white' to 'black'\n",
+    "                       ax=ax)\n",
+    "\n",
+    "# Improve title and styling\n",
+    "ax.set_title(\"Temporal Knowledge Graph Visualization\\n(Top 20 Most Connected Entities)\",\n",
+    "            fontsize=18, fontweight=\"bold\", pad=20)\n",
+    "ax.axis(\"off\")\n",
+    "\n",
+    "# Add a better colorbar\n",
+    "sm = plt.cm.ScalarMappable(cmap=plt.cm.plasma,\n",
+    "                          norm=plt.Normalize(vmin=min_degree, vmax=max_degree))\n",
+    "sm.set_array([])\n",
+    "cbar = plt.colorbar(sm, ax=ax, shrink=0.6, aspect=30)\n",
+    "cbar.set_label(\"Node Degree (Number of Connections)\", rotation=270, labelpad=25, fontsize=12)\n",
+    "cbar.ax.tick_params(labelsize=10)\n",
+    "\n",
+    "# Add margin around the graph\n",
+    "ax.margins(0.1)\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()\n",
+    "\n",
+    "# Print some information about the visualized nodes\n",
+    "print(\"\\nTop entities in visualization:\")\n",
+    "for i, (node, degree) in enumerate(top_nodes[:10]):\n",
+    "    node_name = G.nodes[node].get(\"name\", \"Unknown\")\n",
+    "    print(f\"{i+1:2d}. {node_name} (connections: {degree})\")\n",
+    "\n",
+    "# Create an improved function for easier graph visualization\n",
+    "def visualise_graph(G, num_nodes=20, figsize=(16, 12)):\n",
+    "    \"\"\"\n",
+    "    Visualize a NetworkX graph with improved styling and reduced data.\n",
+    "\n",
+    "    Args:\n",
+    "        G: NetworkX graph\n",
+    "        num_nodes: Number of top nodes to include in visualization (default: 20)\n",
+    "        figsize: Figure size tuple\n",
+    "    \"\"\"\n",
+    "    degrees = dict(G.degree())\n",
+    "    top_nodes = sorted(degrees.items(), key=lambda x: x[1], reverse=True)[:num_nodes]\n",
+    "    visualization_nodes = [node for node, _ in top_nodes]\n",
+    "\n",
+    "    # Create subgraph\n",
+    "    subgraph = G.subgraph(visualization_nodes)\n",
+    "\n",
+    "    # Create the plot\n",
+    "    fig, ax = plt.subplots(figsize=figsize)\n",
+    "    fig.patch.set_facecolor(\"white\")\n",
+    "\n",
+    "    # Layout with better parameters\n",
+    "    try:\n",
+    "        pos = nx.nx_agraph.graphviz_layout(subgraph, prog=\"neato\")\n",
+    "    except (ImportError, nx.NetworkXException):\n",
+    "        pos = nx.spring_layout(subgraph, k=4, iterations=100, seed=42)\n",
+    "\n",
+    "    # Node properties\n",
+    "    node_degrees = [degrees[node] for node in subgraph.nodes()]\n",
+    "    max_degree = max(node_degrees)\n",
+    "    min_degree = min(node_degrees)\n",
+    "\n",
+    "    # Better color scheme\n",
+    "    colors = plt.cm.plasma(np.linspace(0.2, 0.9, len(node_degrees)))\n",
+    "    node_colors = list(colors)\n",
+    "\n",
+    "    # Draw nodes\n",
+    "    node_sizes = [max(200, min(2000, deg * 50)) for deg in node_degrees]\n",
+    "    nx.draw_networkx_nodes(subgraph, pos,\n",
+    "                          node_color=node_colors,\n",
+    "                          node_size=node_sizes,\n",
+    "                          alpha=0.9,\n",
+    "                          edgecolors=\"black\",\n",
+    "                          linewidths=1.5,\n",
+    "                          ax=ax)\n",
+    "\n",
+    "    # Draw edges\n",
+    "    nx.draw_networkx_edges(subgraph, pos,\n",
+    "                          alpha=0.4,\n",
+    "                          edge_color=\"#666666\",\n",
+    "                          width=1.0,\n",
+    "                          arrows=True,\n",
+    "                          arrowsize=15,\n",
+    "                          ax=ax)\n",
+    "\n",
+    "    # Labels\n",
+    "    labels = {}\n",
+    "    for node in subgraph.nodes():\n",
+    "        node_name = subgraph.nodes[node].get(\"name\", str(node))\n",
+    "        if len(node_name) > 15:\n",
+    "            node_name = node_name[:12] + \"...\"\n",
+    "        labels[node] = node_name\n",
+    "\n",
+    "    nx.draw_networkx_labels(subgraph, pos, labels,\n",
+    "                           font_size=9,\n",
+    "                           font_weight=\"bold\",\n",
+    "                           font_color=\"black\",  # changed from 'white' to 'black'\n",
+    "                           ax=ax)\n",
+    "\n",
+    "    ax.set_title(f\"Temporal Knowledge Graph\\n(Top {num_nodes} Most Connected Entities)\",\n",
+    "                fontsize=16, fontweight=\"bold\", pad=20)\n",
+    "    ax.axis(\"off\")\n",
+    "\n",
+    "    # Colorbar\n",
+    "    sm = plt.cm.ScalarMappable(cmap=plt.cm.plasma,\n",
+    "                              norm=plt.Normalize(vmin=min_degree, vmax=max_degree))\n",
+    "    sm.set_array([])\n",
+    "    cbar = plt.colorbar(sm, ax=ax, shrink=0.6)\n",
+    "    cbar.set_label(\"Connections\", rotation=270, labelpad=20)\n",
+    "\n",
+    "    ax.margins(0.1)\n",
+    "    plt.tight_layout()\n",
+    "    plt.show()\n",
+    "\n",
+    "    return subgraph\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Get node information on NVIDIA, filtering for what they have developed\n",
+    "\n",
+    "# Find the node key for NVIDIA (case-insensitive match on name)\n",
+    "nvidia_node = None\n",
+    "for node, data in graph.nodes(data=True):\n",
+    "    if \"nvidia\" in str(data.get(\"name\", \"\")).lower():\n",
+    "        nvidia_node = node\n",
+    "        break\n",
+    "\n",
+    "if nvidia_node is not None:\n",
+    "    print(f\"Node key for NVIDIA: {nvidia_node}\")\n",
+    "    print(\"Node attributes:\")\n",
+    "    for k, v in graph.nodes[nvidia_node].items():\n",
+    "        print(f\"  {k}: {v}\")\n",
+    "\n",
+    "    # Show all edges where NVIDIA is the subject and the predicate is 'DEVELOPED' or 'LAUNCHED' or similar\n",
+    "    print(\"\\nEdges where NVIDIA developed or launched something:\")\n",
+    "    for _, v, _, d in graph.out_edges(nvidia_node, data=True, keys=True):\n",
+    "        pred = d.get(\"predicate\", \"\").upper()\n",
+    "        if pred in {\"LAUNCHED\"}:#, \"LAUNCHED\", \"PRODUCES\", \"CREATED\", \"INTRODUCED\"}:\n",
+    "            print(f\"  {nvidia_node} -[{pred}]-> {v} | {d}\")\n",
+    "            # Optionally, print the statement if available\n",
+    "            if \"statement\" in d:\n",
+    "                print(f\"    Statement: {d['statement']}\")\n",
+    "else:\n",
+    "    print(\"NVIDIA node not found in the graph.\")\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.3.2 NetworkX versus Neo4j in Production"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To effectively implement and utilize the knowledge graph we utilise [NetworkX](https://networkx.org/) for the purposes of this cookbook for several reasons. \n",
+    "1. **Python integration**: NetworkX seamlessly integrates with Python, facilitating rapid prototyping and iterative development\n",
+    "2. **Ease of setup**: It requires minimal initial setup, not requiring a client-server setup featured in alternatives. This makes it ideal for users who wish to run this cookbook themselves\n",
+    "3. **Compatibility with In-Memory Databases**: NetworkX can efficiently manage graphs with fewer than c.100,000 nodes, which is appropriate for this cookbook's data scale\n",
+    "\n",
+    "However, it should be noted that NetworkX lacks built-in data persistence and is therefore not typically recommended for production builds.\n",
+    "\n",
+    "For production builds, [Neo4j](https://neo4j.com/) emerges as a more optimal choice due to a wider set of production-centric features, including:\n",
+    "- **Native Graph Storage and Processing**: Optimized for graph data with high-performance and efficient handling\n",
+    "- **Optimized Query Engine**: Leverages the Cypher query language, explicitly designed for efficient graph traversal\n",
+    "- **Scalability and Persistence**: Effectively manages extensive graph datasets, ensuring data persistence, reliability, and durability\n",
+    "- **Production Tooling**: Offers integrated tooling such as Neo4j Bloom for vislualization and Neo4j Browser for exploration, enhancing user interaction and analysis\n",
+    "- **Advanced Access Control**: Provides granular security options to control data access"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3.4. Evaluation and Suggested Feature Additions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The approach presented above offers a foundational implementation of a Temporal Agent for knowledge graph construction. However, it does not fully address complexities or all possible edge cases encountered in real-world applications. Below, we outline several possible enhancements that could be used to further improve the robustness and applicability of this implementation. In the later \"Prototype to Production\" section, we expand on these enhancements by suggesting additional considerations essential for deploying such agents effectively in production environments. Further details on scaling to production are included in the [Appendix](./Appendix.ipynb)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.4.1. Temporal Agent"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Statement Extraction and Temporal Events\n",
+    "##### Duplicate Temporal Events\n",
+    "In this cookbook, the Temporal Agent does not identify or merge duplicate Temporal Events arising from statements referring to the same event, especially when originating from different sources. These events are saved separately rather than unified into a single, consolidated event. \n",
+    "\n",
+    "##### Static and Dynamic Representation\n",
+    "There's an opportunity to enrich the dataset by consistently capturing both Static and Dynamic representations of events, even when explicit statements aren't available. \n",
+    "\n",
+    "For Dynamic events without corresponding Static statements, creating explicit Static entries marking the start (`valid_at`) and end (`invalid_at`) can enhance temporal clarity, particularly for the purposes of retrieval tasks. \n",
+    "\n",
+    "Conversely, Static events lacking Dynamic counterparts can have Dynamic relationships inferred, though this would require careful checks for potential invalidation within statement cohorts. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Date Extraction\n",
+    "The implementation in this cookbook does not explictly record assumptions made during date disambiguation. \n",
+    "\n",
+    "In the absence of an explicit publication date, the present date is used implicitly as a reference. For some workflows, this assumption may have to be changed to meet the needs of the end users. \n",
+    "\n",
+    "Abstract dates (e.g., \"until next year\") are resolved into explicit dates, however the vagueness is not represented in the stored data structure. The inclusion of more granular metadata can capture more abstract date ranges:\n",
+    "```python\n",
+    "temporal_event = {\n",
+    "  \"summary\": \"The event ran from April to September\",\n",
+    "  \"label\": \"dynamic\",\n",
+    "  \"valid_at\": {\n",
+    "      \"date\": \"2025-04-01\",\n",
+    "      \"literal\": False,\n",
+    "      \"abstract_date\": \"2025-04\"\n",
+    "  },\n",
+    "  \"invalid_at\": {\n",
+    "      \"date\": \"2025-09-30\",\n",
+    "      \"literal\": False,\n",
+    "      \"abstract_date\": \"2025-09\"\n",
+    "  }\n",
+    "}\n",
+    "```\n",
+    "This structure permits the explicit representation of both literal and abstract date interpretations."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Triplet Extraction\n",
+    "There are several possible avenues for improving the Triplet Extraction presented in this cookbook. These include:\n",
+    "- Utilising a larger model and optimizing the extraction prompts further\n",
+    "- Running the extraction process multiple times and consolidating results via e.g., a modal pooling mechanism to improve the accuracy and confidence in a prediction\n",
+    "- Incorporating entity extraction tools (e.g., [Spacy](https://spacy.io/) and leveraging predefined ontologies tailored to specific use cases for improved consistency and reliability"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.4.2. Invalidation Agent\n",
+    "The presented Invalidation Agent does not refine temporal validity ranges, but one could extend its functionality to perform said refinement as well as intra-cohort invalidation checks to identify temporal conflicts among incoming statements.\n",
+    "\n",
+    "There are also several opportunities for efficiency enhancements. \n",
+    "- Transitioning from individual (1:1) comparisons to omni-directional (1:many) invalidation checks would reduce the number of LLM calls required\n",
+    "- Applying network analysis techniques to cluster related statements could enable batching of invalidation checks. Clusters can be derived from several properties including semantic similarity, temporal proximity, or more advanced techniques. This would significantly reduce bottlenecks arising from sequential processing, which is particularly important when ingesting large volumes of data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 4. Multi-Step Retrieval Over a Knowledge Graph\n",
+    "---"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Simple retrieval systems can often handle straightforward \"look-up\" queries with a single search against a vector store or document index. In practice, though, agents deployed in real-world settings frequently need more. User questions often require LLMs to synthesise information from multiple parts of a knowledge base or across several endpoints.\n",
+    "\n",
+    "The temporal knowledge graphs introduced earlier provide a natural foundation for this, explicitly encoding entities (nodes), relationships (edges), and their evolution over time.\n",
+    "\n",
+    "Multi-step retrieval allows us to fully harness the capabilities of these graphs. It involves iteratively traversing the graph through a series of targeted queries, enabling the agent to gather all necessary context before forming a response."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can see the power of multi-step retrieval below:"
+   ]
+  },
+  {
+   "attachments": {
+    "55e196a3-2d42-469c-8b7d-938a56b47f38.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<!-- ![Screenshot 2025-06-23 at 11.46.52.png](attachment:55e196a3-2d42-469c-8b7d-938a56b47f38.png) -->\n",
+    "<img\n",
+    "  src=\"../../../images/10_multi_step_retrieval.png\"\n",
+    "  alt=\"Multi Retrieval Agent\"\n",
+    "  style=\"width:891px; height:auto;\"\n",
+    "/>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In this case, the initial query to the knowledge graph returned no information on some competitors’ R&D activities. Rather than failing silently, the system pivoted to an alternative source—the strategy content—and successfully located the missing information. This multi-step approach allowed it to navigate sparse data and deliver a complete response to the user."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4.1. Building our Retrieval Agent"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "At a high level, we will build out the following structure:\n",
+    "<ol style=\"margin-left: 1em; line-height: 1.6; padding-left: 0.5em;\">\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>User question → Planner → Orchestrator</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      A planner utilising GPT 4.1 will decompose the user's question into a small sequence of proposed graph operations. This is then passed to the orchestrator to execute\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Tool calls to retrieve information from the Temporal Knowledge Graph</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Considering the user query and the plan, the Orchestrator (o4-mini) makes a series of initial tool calls to retrieve information from the knowledge graph\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Loop until done → Generate answer</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      The responses to the tool calls are fed back to the Orchestrator which can then decide to either make more queries to the graph or answer the user's question\n",
+    "    </p>\n",
+    "  </li>\n",
+    "</ol>\n"
+   ]
+  },
+  {
+   "attachments": {
+    "7fe7cc38-3551-4914-af4e-bfed38648ef1.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<!-- ![Screenshot 2025-06-23 at 11.47.19.png](attachment:7fe7cc38-3551-4914-af4e-bfed38648ef1.png) -->\n",
+    "<img\n",
+    "  src=\"../../../images/11_retrieval_agent.png\"\n",
+    "  alt=\"Retrieval Agent\"\n",
+    "  style=\"width:791px; height:auto;\"\n",
+    "/>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 4.1.1. Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%pip install --upgrade openai"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 4.1.2. (Re-)Initialise OpenAI Client"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from openai import AsyncOpenAI\n",
+    "\n",
+    "client = AsyncOpenAI()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 4.1.3. (Re-)Load our Temporal Knowledge Graph"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from cb_functions import build_graph, load_db_from_hf\n",
+    "\n",
+    "conn = load_db_from_hf()\n",
+    "G = build_graph(conn)\n",
+    "\n",
+    "print(G.number_of_nodes(), \"nodes,\", G.number_of_edges(), \"edges\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 4.1.4. Planner\n",
+    "Planning steps are incorporated in many modern LLM applications. \n",
+    "\n",
+    "The explicit inclusion of a planning step improves overall performance by having the system consider the full scope of the problem before acting.\n",
+    "\n",
+    "In this implementation, the plan remains static. In longer-horizon agentic pipelines, however, it's common to include mechanisms for replanning or updating the plan as the system progresses. \n",
+    "\n",
+    "Broadly, planners take two forms:\n",
+    "<ol style=\"margin-left: 1em; line-height: 1.6; padding-left: 0.5em;\">\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Task-orientated (used in this cookbook)</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      The planner outlines the concrete subtasks the downstream agentic blocks should execute. The tasks are phrased in an action-orientated sense such as \"1. Extract information on R&amp;D activities of Company IJK between 2018–2020.\" These planners are typically preferred when the goal is mostly deterministic and the primary risk is skipping or duplicating work.\n",
+    "    </p>\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Example tasks where this approach is useful:\n",
+    "    </p>\n",
+    "    <ul style=\"margin-top: 0.5em; margin-bottom: 0.5em; padding-left: 1.2em;\">\n",
+    "      <li><strong>Law</strong>: <em>\"Extract and tabulate termination-notice periods from every master service agreement executed in FY24\"</em></li>\n",
+    "      <li><strong>Finance</strong>: <em>\"Fetch every 10-K filed by S&amp;P 500 banks for FY24, extract tier-1 capital and liquidity coverage ratios, and output a ranked table of institutions by capital adequacy\"</em></li>\n",
+    "      <li><strong>Automotive</strong>: <em>\"Compile warranty-claim counts by component for Model XYZ vehicles sold in Europe since the new emissions regulation came into force\"</em></li>\n",
+    "      <li><strong>Manufacturing</strong>: <em>\"Analyse downtime logs from each CNC machine for Q1 2025, classify the root-cause codes, and generate a Pareto chart of the top five failure drivers\"</em></li>\n",
+    "    </ul>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Hypothesis-orientated</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      The plan is framed as a set of hypotheses the system can confirm, reject, or refine in response to the user's question. Each step represents a testable claim, optionally paired with suggested actions. This approach excels in open-ended research tasks where new information can significantly reshape the solution space.\n",
+    "    </p>\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Example tasks where this approach is useful:\n",
+    "    </p>\n",
+    "    <ul style=\"margin-top: 0.5em; margin-bottom: 0.5em; padding-left: 1.2em;\">\n",
+    "      <li><strong>Law</strong>: <em>\"Does the supplied evidence satisfy all four prongs of the fair-use doctrine? Evaluate each prong against relevant case law\"</em></li>\n",
+    "      <li><strong>Pharmaceuticals</strong>: <em>\"What emerging mRNA delivery methods could be used to target the IRS1 gene to treat obesity?\"</em></li>\n",
+    "      <li><strong>Finance</strong>: <em>\"Is Bank Alpha facing a liquidity risk? Compare its LCR trend, interbank borrowing costs, and deposit-outflow and anything else you find that is interesting\"</em></li>\n",
+    "    </ul>\n",
+    "  </li>\n",
+    "</ol>\n",
+    "\n",
+    "\n",
+    "#### Prompting our planner\n",
+    "We will define two prompts (one `system` and one `user`) for the initial planner. \n",
+    "\n",
+    "The most notable characteristic of our system prompt below is the use of 'persona-based' prompting. We prompt the LLM giving it a persona of an internal company expert. This helps to frame the tone of the model's response to the behaviour that we want - a direct, action-orientated task list that is fit for the financial industry. \n",
+    "\n",
+    "This is then extended in the user prompt, where we prepend the `user_question` with information on this specific situation and how the planner should handle it. \n",
+    "\n",
+    "In production settings you can super-charge this template by dynamically enriching the prompt before each call. You can inject information on the user's profile —sector, role, preferred writing style, prior conversation context—so the planner tailors its actions to their environment. You can also perform a quick “question-building” loop: have the assistant propose clarifying questions, gather the answers, and merge them back into the prompt so the planner starts with a well-scoped, information-rich request rather than a vague one. \n",
+    "\n",
+    "Another flow that can work well is to allow users to view the plan and optionally edit it before it is executed. This is particularly effective when your AI system is acting in more of an assistant role. Giving domain experts such as lawyers or pharmaceutical researchers the flexibility to steer and incorporate their ideas and research directions deeper into the system often has the dual benefit of improving both system performance and end user satisfaction."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "async def initial_planner(user_question: str) -> str:\n",
+    "    \"\"\"Return an initial plan for answering the user's question.\"\"\"\n",
+    "    initial_planner_system_prompt = (\n",
+    "        \"You work for the leading financial firm, ABC Incorporated, one of the largest financial firms in the world. \"\n",
+    "        \"Due to your long and esteemed tenure at the firm, various equity research teams will often come to you \"\n",
+    "        \"for guidance on research tasks they are performing. Your expertise is particularly strong in the area of \"\n",
+    "        \"ABC Incorporated's proprietary knowledge base of earnings call transcripts. This contains details that have been \"\n",
+    "        \"extracted from the earnings call transcripts of various companies with labelling for when these statements are, or \"\n",
+    "        \"were, valid. You are an expert at providing instructions to teams on how to use this knowledge graph to answer \"\n",
+    "        \"their research queries. \\n\"\n",
+    "        \"The teams will have access to the following tools to help them retrieve information from the knowledge graph: \\n\"\n",
+    "        \"1. `factual_qa`: Queries the knowledge graph for time-bounded factual relationships involving a given entity and predicate. \\n\"\n",
+    "        \"2. `trend_analysis`: Wraps the factual_qa tool with a specialised agent to perform in-depth trend analysis \\n\"\n",
+    "        \"It shoudld also be noted that the trend_analysis tool can accept multiple predicate arguments as a list. \\n \"\n",
+    "        \"You may recommend that multiple calls are made to the tools with different e.g., predicates if this is useful. \\n \"\n",
+    "        \"Your recommendation should explain to the team how to retrieve the information from the database through these \"\n",
+    "        \"tools only. \"\n",
+    "    )\n",
+    "\n",
+    "    initial_planner_user_prompt = (\n",
+    "        \"Your top equity research team has came to you with a research question they are trying to find the answer to. \"\n",
+    "        \"You should use your deep financial expertise to succinctly detail a step-by-step plan for retrieving \"\n",
+    "        \"this information from the the company's knowledge base of earnings call transcripts extracts. \"\n",
+    "        \"You should produce a concise set of individual research tasks required to thoroughly address the team's query. \"\n",
+    "        \"These tasks should cover all of the key points of the team's research task without overcomplicating it. \\n\\n\"\n",
+    "        \"The question the team has is: \\n\\n\"\n",
+    "        f\"{user_question} \\n\\n\"\n",
+    "        \"Return your answer under a heading 'Research tasks' with no filler language, only the plan.\"\n",
+    "    )\n",
+    "\n",
+    "    input_messages = [\n",
+    "        {\"role\":\"system\", \"content\": initial_planner_system_prompt},\n",
+    "        {\"role\":\"user\", \"content\": initial_planner_user_prompt}\n",
+    "    ]\n",
+    "\n",
+    "    initial_plan = await client.responses.create(\n",
+    "        model=\"gpt-4.1\",\n",
+    "        input=input_messages\n",
+    "    )\n",
+    "\n",
+    "    return initial_plan.output_text"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plan = await initial_planner(\"How can we find out how AMD's research priorties have changed in the last 4 years?\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(plan)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 4.1.5. Function calling\n",
+    "[OpenAI function calling](https://platform.openai.com/docs/guides/function-calling?api-mode=responses) (otherwise known as tools) enable models to perform specific external actions by calling predefined functions. Some of the tools provided on the OpenAI platform include:\n",
+    "- **Code interpreter**: Executes code for data analysis, math, plotting, and file manipulation\n",
+    "- **Web search**: Include data from the internet in model response generation\n",
+    "- **File search**: Search the contents of uploaded files for context\n",
+    "- **Image generation**: Generate or edit images using GPT image\n",
+    "- **Remote MCP servers**: Give the model access to new capabilities via Model Context Protocol (MCP) servers\n",
+    "\n",
+    "Other cookbooks cover how to build tools for use with LLMs. In this example, we’ll develop several tools designed to efficiently explore the temporal knowledge graph and help answer the user’s question.\n",
+    "\n",
+    "There are several schools of thought on tool design, and the best choice depends on the application at hand."
+   ]
+  },
+  {
+   "attachments": {
+    "150d9cc4-9989-4e8e-bfcf-f1223a7959ee.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<!-- ![Screenshot 2025-06-23 at 11.52.01.png](attachment:150d9cc4-9989-4e8e-bfcf-f1223a7959ee.png) -->\n",
+    "<img\n",
+    "  src=\"../../../images/12_spectrum_of_tools.png\"\n",
+    "  alt=\"Spectrum of tools\"\n",
+    "  style=\"width:891px; height:auto;\"\n",
+    "/>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "jp-MarkdownHeadingCollapsed": true
+   },
+   "source": [
+    "#### Fixed Tools\n",
+    "\n",
+    "In this context, 'fixed' tools refer to those with a rigid, well-defined functionality. Typically, these tools accept a limited number of specific arguments and perform clearly outlined tasks. For instance, a fixed tool might execute a simple query such as \"Get today's weather for the user's location.\" Due to their structured nature, these tools excel at performing consistent lookups or monitoring values within structured environments like ERP systems, regulatory frameworks, or dashboards. However, their rigidity limits flexibility, prompting users to often replace them with more dynamic, traditional data pipelines, particularly for continuous data streaming.\n",
+    "\n",
+    "Examples of fixed tools in various industries include:\n",
+    "\n",
+    "* **Finance**: *\"What's the current exchange rate from USD to EUR?\"*\n",
+    "* **Pharmaceuticals**: *\"Retrieve the known adverse effects for Drug ABC.\"*\n",
+    "* **Manufacturing**: *\"What was the defect rate for batch #42?\"*\n",
+    "\n",
+    "#### Free-form\n",
+    "\n",
+    "Free-form tools represent the most flexible end of the tool spectrum. These tools are capable of executing complex, open-ended tasks with minimal constraints on input structure. A common example is a code interpreter, capable of handling diverse analytical tasks. Although their flexibility offers substantial advantages, they can also introduce unpredictability and can be more challenging to optimize for consistent reliability.\n",
+    "\n",
+    "In industry applications, free-form tools can look like:\n",
+    "\n",
+    "* **Finance**: *\"Backtest this momentum trading strategy using ETF price data over the past 10 years, and plot the Sharpe ratio distribution.\"*\n",
+    "* **Automotive**: *\"Given this raw telemetry log, identify patterns that indicate early brake failure and simulate outcomes under various terrain conditions.\"*\n",
+    "* **Pharmaceuticals**: *\"Create a pipeline that filters for statistically significant gene upregulation from this dataset, then run gene set enrichment analysis and generate a publication-ready figure.\"*\n",
+    "\n",
+    "\n",
+    "#### Semi-structured Tools (used in this cookbook)\n",
+    "\n",
+    "Modern agentic workflows frequently require tools that effectively balance structure and flexibility. Semi-structured tools are designed specifically to manage this middle ground. They accept inputs in moderately complex formats—such as text fragments, JSON-like arguments, or small code snippets—and often embed basic reasoning, retrieval, or decision-making capabilities. These tools are ideal when tasks are well-defined but not entirely uniform, such as when the required dataset or service is known, but the query or expected output varies.\n",
+    "\n",
+    "Two common paradigms of semi-structured tools are:\n",
+    "\n",
+    "* **Extended Capabilities**: Tools that function as specialized agents themselves, incorporating internal logic and analysis routines\n",
+    "* **Flexible Argument Interfaces**: Tools permitting the LLM to pass expressive yet structured arguments, such as detailed queries, filters, or embedded functions\n",
+    "\n",
+    "Semi-structured tools are particularly valuable when:\n",
+    "\n",
+    "* Delegating specific yet non-trivial tasks (like searches, transformations, or summarizations) to specialized tools\n",
+    "* The source data or APIs are known, but the results returned can be unpredictable\n",
+    "\n",
+    "In production environments, these tools are often preferable to free-form tools, like code interpreters, due to their enhanced reliability and performance. For instance, executing complex, multi-step queries against large Neo4j knowledge graphs is more reliable and efficient using optimized Cypher queries templated within semi-structured tools rather than generating each query from scratch.\n",
+    "\n",
+    "Industry applications of semi-structured tools include:\n",
+    "\n",
+    "* **Finance**: *\"Extract all forward-looking risk factors from company filings for Q2 2023.\"*\n",
+    "* **Automotive**: *\"Identify recurring electrical faults from maintenance logs across EV models launched after 2020.\"*\n",
+    "* **Pharmaceuticals**: *\"Locate omics data supporting the hypothesis that a specific mRNA treatment effectively upregulates the IRS1 gene.\"*\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Creating tools for our retriever to use"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "##### Factual Q&A\n",
+    "The `factual_qa` tool provides an efficient way for our agent to retrieve information from our temporal knowledge graph pertaining to a particular company, topic, and date range. This will help the agent answer questions about the data such as \"What were AMD's earnings in Q3 2017?\"\n",
+    "\n",
+    "This tool sits somewhere in the middle of the fixed and semi-structured tools we introduced earlier. This is generally quite a rigid tool in that it restricts the agent to a small number of parameters. However, the degrees of freedom in the input are large and the tool is still flexible in what information it can retrieve from the knowledge graph. This helps avoid the need for the core agent to write new queries for networkx from scratch on each query, improving accuracy and latency.\n",
+    "\n",
+    "The tool has the following arguments:\n",
+    "- `entity`: This is the entity (or object with respect to triplet ontology) that the tool should retrieve information for\n",
+    "- `start_date_range`: This is the lower bound of the date range that the tool should retrieve over\n",
+    "- `end_date_range`: This is the upper bound of the date range that the tool should retrieve over\n",
+    "- `predicate`: This is the name of the predicate that the tool will connect the `entity` to perform a retrieval\n",
+    "\n",
+    "We begin by loading the predicate definitions. We will use these to improve error tolerance in the tool, using a GPT-4.1-nano to normalize the predicate passed in the argument to a valid predicate name. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Redefine the predicate definitions as we will need them here\n",
+    "PREDICATE_DEFINITIONS = {\n",
+    "    \"IS_A\": \"Denotes a class-or-type relationship between two entities (e.g., 'Model Y IS_A electric-SUV'). Includes 'is' and 'was'.\",\n",
+    "    \"HAS_A\": \"Denotes a part-whole relationship between two entities (e.g., 'Model Y HAS_A electric-engine'). Includes 'has' and 'had'.\",\n",
+    "    \"LOCATED_IN\": \"Specifies geographic or organisational containment or proximity (e.g., headquarters LOCATED_IN Berlin).\",\n",
+    "    \"HOLDS_ROLE\": \"Connects a person to a formal office or title within an organisation (CEO, Chair, Director, etc.).\",\n",
+    "    \"PRODUCES\": \"Indicates that an entity manufactures, builds, or creates a product, service, or infrastructure (includes scale-ups and component inclusion).\",\n",
+    "    \"SELLS\": \"Marks a commercial seller-to-customer relationship for a product or service (markets, distributes, sells).\",\n",
+    "    \"LAUNCHED\": \"Captures the official first release, shipment, or public start of a product, service, or initiative.\",\n",
+    "    \"DEVELOPED\": \"Shows design, R&D, or innovation origin of a technology, product, or capability. Includes 'researched' or 'created'.\",\n",
+    "    \"ADOPTED_BY\": \"Indicates that a technology or product has been taken up, deployed, or implemented by another entity.\",\n",
+    "    \"INVESTS_IN\": \"Represents the flow of capital or resources from one entity into another (equity, funding rounds, strategic investment).\",\n",
+    "    \"COLLABORATES_WITH\": \"Generic partnership, alliance, joint venture, or licensing relationship between entities.\",\n",
+    "    \"SUPPLIES\": \"Captures vendor–client supply-chain links or dependencies (provides to, sources from).\",\n",
+    "    \"HAS_REVENUE\": \"Associates an entity with a revenue amount or metric—actual, reported, or projected.\",\n",
+    "    \"INCREASED\": \"Expresses an upward change in a metric (revenue, market share, output) relative to a prior period or baseline.\",\n",
+    "    \"DECREASED\": \"Expresses a downward change in a metric relative to a prior period or baseline.\",\n",
+    "    \"RESULTED_IN\": \"Captures a causal relationship where one event or factor leads to a specific outcome (positive or negative).\",\n",
+    "    \"TARGETS\": \"Denotes a strategic objective, market segment, or customer group that an entity seeks to reach.\",\n",
+    "    \"PART_OF\": \"Expresses hierarchical membership or subset relationships (division, subsidiary, managed by, belongs to).\",\n",
+    "    \"DISCONTINUED\": \"Indicates official end-of-life, shutdown, or termination of a product, service, or relationship.\",\n",
+    "    \"SECURED\": \"Marks the successful acquisition of funding, contracts, assets, or rights by an entity.\",\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We define several helper functions for the factual QA tool.\n",
+    "\n",
+    "First is `_as_datetime`. This tool is used to coerce the arguments that define the date range to the correct datetime format.\n",
+    "\n",
+    "Next, we introduce two new data models: `PredicateMatching` and `PredicateMatchValidation`. `PredicateMatching` defines the output format for the GPT-4.1-nano call that matches the predicate in the function arguments to valid predicate names. `PredicateMatchValidation` then performs a secondary validation step to assert that this output from GPT-4.1-nano is a valid predicate name, leveraging a Pydantic field validator. This process helps to ensure that the tool runs smoothly and helps to eliminate some of the rare edge cases which would lead to an unsuccessful graph query."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Helper functions and models\n",
+    "from datetime import datetime\n",
+    "\n",
+    "from pydantic import BaseModel, Field, ValidationError, field_validator\n",
+    "\n",
+    "\n",
+    "def _as_datetime(ts) -> datetime | None:\n",
+    "    \"\"\"Helper function to coerce possible timestamp formats to `datetime`.\"\"\"  # noqa: D401\n",
+    "    if ts is None:\n",
+    "        return None\n",
+    "    if isinstance(ts, datetime):\n",
+    "        return ts\n",
+    "    for fmt in (\"%Y-%m-%d\", \"%Y/%m/%d\", \"%Y-%m-%dT%H:%M:%S\"):\n",
+    "        try:\n",
+    "            return datetime.strptime(ts, fmt)\n",
+    "        except ValueError:\n",
+    "            continue\n",
+    "    return None\n",
+    "\n",
+    "class PredicateMatching(BaseModel):\n",
+    "    \"\"\"Class for structured outputs from model to coerce input to correct predicate format.\"\"\"\n",
+    "    reasoning: str = Field(description=\"Use this space to reason about the correct predicate to match.\")\n",
+    "    predicate_match: str = Field(description=\"The predicate that aligns with the dictionary.\")\n",
+    "\n",
+    "\n",
+    "class PredicateMatchValidation(BaseModel):\n",
+    "    \"\"\"Class for validating the outputs from the model that tries to coerce predicate argument to a real predicate.\"\"\"\n",
+    "    predicate: str\n",
+    "\n",
+    "    @field_validator(\"predicate\")\n",
+    "    @classmethod\n",
+    "    def predicate_in_definitions(cls, v):\n",
+    "        \"\"\"Return an error string if the predicate is not in PREDICATE_DEFINITIONS.\"\"\"\n",
+    "        if v not in PREDICATE_DEFINITIONS:\n",
+    "            return f\"Error: '{v}' is not a valid predicate. Must be one of: {list(PREDICATE_DEFINITIONS.keys())}\"\n",
+    "        return v"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Our factual QA tool can be decomposed into four steps.\n",
+    "<ol style=\"margin-left: 1em; line-height: 1.6; padding-left: 0.5em;\">\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Predicate coercion</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      If the provided predicate is not found in the <code>PREDICATE_DEFINITIONS</code> dictionary, this step uses GPT-4.1-nano to coerce it into a valid predicate\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Entity location</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Performs fuzzy matching to identify the corresponding entity nodes within the networkx graph\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Edge collection</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Retrieves both inbound and outbound edges associated with the identified entity nodes\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Response formatting</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Structures the collected information into a well-formatted response that is easy for the orchestrator to consume\n",
+    "    </p>\n",
+    "  </li>\n",
+    "</ol>\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "async def factual_qa(\n",
+    "    entity: str,\n",
+    "    start_date_range: datetime,\n",
+    "    end_date_range: datetime,\n",
+    "    predicate: str\n",
+    ") -> str:\n",
+    "    \"\"\"\n",
+    "    Query the knowledge-graph for relationships attached to *entity* that match\n",
+    "    *predicate* and fall within the requested time-window.\n",
+    "\n",
+    "    The response is rendered as:\n",
+    "\n",
+    "        Subject  –  PREDICATE  –  Object   [Valid-From]\n",
+    "            Statement: \"...\"\n",
+    "            Type: FACT   •   Value: 42\n",
+    "\n",
+    "    If no matches are found (or on error) a human-readable explanation is returned.\n",
+    "    \"\"\"\n",
+    "    # Checks that the date range passed is logical\n",
+    "    if start_date_range > end_date_range:\n",
+    "        return (\n",
+    "            \"You used the `factual_qa` tool incorrectly last time. You provided a \"\n",
+    "            \"`start_date_range` that was more recent than the `end_date_range`. \"\n",
+    "            \"`end_date_range` must be ≥ `start_date_range`.\"\n",
+    "        )\n",
+    "\n",
+    "    # ---- (1) predicate coercion / validation -----------------------\n",
+    "    if predicate not in PREDICATE_DEFINITIONS:\n",
+    "        try:\n",
+    "            predicate_definitions_str = \"\\n\".join(\n",
+    "                f\"- {k}: {v}\" for k, v in PREDICATE_DEFINITIONS.items()\n",
+    "            )\n",
+    "            coercion_prompt = (\n",
+    "                \"You are a helpful assistant that matches predicates to a dictionary of \"\n",
+    "                \"predicate definitions. Return the best-matching predicate **and** your reasoning.\\n\\n\"\n",
+    "                f\"Dictionary:\\n{predicate_definitions_str}\\n\\n\"\n",
+    "                f\"Predicate to match: {predicate}\"\n",
+    "            )\n",
+    "\n",
+    "            completion = await client.beta.chat.completions.parse(\n",
+    "                model=\"gpt-4.1-nano\",\n",
+    "                messages=[{\"role\": \"user\", \"content\": coercion_prompt}],\n",
+    "                response_format=PredicateMatching,\n",
+    "            )\n",
+    "            coerced_predicate = completion.choices[0].message.parsed.predicate_match\n",
+    "\n",
+    "            # Validate against the enum / model we expect\n",
+    "            _ = PredicateMatchValidation(predicate=coerced_predicate)\n",
+    "            predicate = coerced_predicate\n",
+    "        except ValidationError:\n",
+    "            return (\n",
+    "                \"You provided an invalid predicate. \"\n",
+    "                f\"Valid predicates are: {list(PREDICATE_DEFINITIONS.keys())}\"\n",
+    "            )\n",
+    "        except Exception:\n",
+    "            # Coercion failed – fall back to original predicate\n",
+    "            pass\n",
+    "\n",
+    "    predicate_upper = predicate.upper()\n",
+    "    entity_lower = entity.lower()\n",
+    "\n",
+    "    # ---- (2) locate the entity node by fuzzy match -----------------\n",
+    "    try:\n",
+    "        target_node = None\n",
+    "        for node, data in G.nodes(data=True):\n",
+    "            node_name = data.get(\"name\", str(node))\n",
+    "            if entity_lower in node_name.lower() or node_name.lower() in entity_lower:\n",
+    "                target_node = node\n",
+    "                break\n",
+    "        if target_node is None:\n",
+    "            return f\"Entity '{entity}' not found in the knowledge graph.\"\n",
+    "    except Exception as e:\n",
+    "        return f\"Error locating entity '{entity}': {str(e)}\"\n",
+    "\n",
+    "    # ---- (3) collect matching edges (outgoing + incoming) ----------\n",
+    "    matching_edges = []\n",
+    "\n",
+    "    def _edge_ok(edge_data):\n",
+    "        \"\"\"Return True if edge is temporally valid in the requested window.\"\"\"\n",
+    "        valid_at = _as_datetime(edge_data.get(\"valid_at\"))\n",
+    "        invalid_at = _as_datetime(edge_data.get(\"invalid_at\"))\n",
+    "        if valid_at and end_date_range < valid_at:\n",
+    "            return False\n",
+    "        if invalid_at and start_date_range >= invalid_at:\n",
+    "            return False\n",
+    "        return True\n",
+    "\n",
+    "    # Outgoing\n",
+    "    try:\n",
+    "        for _, tgt, _, ed in G.out_edges(target_node, data=True, keys=True):\n",
+    "            pred = ed.get(\"predicate\", \"\").upper()\n",
+    "            if predicate_upper in pred and _edge_ok(ed):\n",
+    "                matching_edges.append(\n",
+    "                    {\n",
+    "                        \"subject\": G.nodes[target_node].get(\"name\", str(target_node)),\n",
+    "                        \"predicate\": pred,\n",
+    "                        \"object\": G.nodes[tgt].get(\"name\", str(tgt)),\n",
+    "                        **ed,\n",
+    "                    }\n",
+    "                )\n",
+    "    except Exception:\n",
+    "        pass\n",
+    "\n",
+    "    # Incoming\n",
+    "    try:\n",
+    "        for src, _, _, ed in G.in_edges(target_node, data=True, keys=True):\n",
+    "            pred = ed.get(\"predicate\", \"\").upper()\n",
+    "            if predicate_upper in pred and _edge_ok(ed):\n",
+    "                matching_edges.append(\n",
+    "                    {\n",
+    "                        \"subject\": G.nodes[src].get(\"name\", str(src)),\n",
+    "                        \"predicate\": pred,\n",
+    "                        \"object\": G.nodes[target_node].get(\"name\", str(target_node)),\n",
+    "                        **ed,\n",
+    "                    }\n",
+    "                )\n",
+    "    except Exception:\n",
+    "        pass\n",
+    "\n",
+    "    # ---- (4) format the response -----------------------------------\n",
+    "    if not matching_edges:\n",
+    "        s = start_date_range.strftime(\"%Y-%m-%d\")\n",
+    "        e = end_date_range.strftime(\"%Y-%m-%d\")\n",
+    "        return (\n",
+    "            f\"No data found for '{entity}' with predicate '{predicate}' \"\n",
+    "            f\"in the specified date range ({s} to {e}).\"\n",
+    "        )\n",
+    "\n",
+    "    lines = [\n",
+    "        f\"Found {len(matching_edges)} relationship\"\n",
+    "        f\"{'s' if len(matching_edges) != 1 else ''} for \"\n",
+    "        f\"'{entity}' with predicate '{predicate}':\",\n",
+    "        \"\"\n",
+    "    ]\n",
+    "\n",
+    "    for idx, edge in enumerate(matching_edges, 1):\n",
+    "        value        = edge.get(\"value\")\n",
+    "        statement    = edge.get(\"statement\")\n",
+    "        statement_tp = edge.get(\"statement_type\")\n",
+    "        valid_from   = edge.get(\"valid_at\")\n",
+    "\n",
+    "        # First line: Subject – PREDICATE – Object\n",
+    "        triplet = f\"{edge['subject']} – {edge['predicate']} – {edge['object']}\"\n",
+    "        if valid_from:\n",
+    "            triplet += f\"  [Valid-from: {valid_from}]\"\n",
+    "        if value is not None:\n",
+    "            triplet += f\"  (Value: {value})\"\n",
+    "        lines.append(f\"{idx}. {triplet}\")\n",
+    "\n",
+    "        # Second line: Statement (truncated to 200 chars) + Type\n",
+    "        if statement:\n",
+    "            snippet = statement if len(statement) <= 200 else statement[:197] + \"…\"\n",
+    "            lines.append(f'   Statement: \"{snippet}\"')\n",
+    "        if statement_tp:\n",
+    "            lines.append(f\"   Type: {statement_tp}\")\n",
+    "\n",
+    "        lines.append(\"\")  # spacer\n",
+    "\n",
+    "    return \"\\n\".join(lines)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "result = await factual_qa(\n",
+    "    entity=\"Amd\",\n",
+    "    start_date_range=datetime(2016, 1, 1),\n",
+    "    end_date_range=datetime(2020, 1, 1),\n",
+    "    predicate=\"launched\"\n",
+    ")\n",
+    "print(result)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "factual_qa_schema = {\n",
+    "  \"type\": \"function\",\n",
+    "  \"name\": \"factual_qa\",\n",
+    "  \"description\": \"Queries the knowledge graph for time-bounded factual relationships involving a given entity and predicate.\",\n",
+    "  \"parameters\": {\n",
+    "    \"type\": \"object\",\n",
+    "    \"properties\": {\n",
+    "      \"entity\": {\n",
+    "        \"type\": \"string\",\n",
+    "        \"description\": \"The name of the entity (e.g., company or organization) whose relationships should be retrieved.\"\n",
+    "      },\n",
+    "      \"start_date_range\": {\n",
+    "        \"type\": \"string\",\n",
+    "        \"format\": \"date\",\n",
+    "        \"description\": \"The start (inclusive) of the date range to filter factual relationships.\"\n",
+    "      },\n",
+    "      \"end_date_range\": {\n",
+    "        \"type\": \"string\",\n",
+    "        \"format\": \"date\",\n",
+    "        \"description\": \"The end (inclusive) of the date range to filter factual relationships.\"\n",
+    "      },\n",
+    "      \"predicate\": {\n",
+    "        \"type\": \"string\",\n",
+    "        \"description\": \"The type of relationship or topic to match against the knowledge graph (e.g., 'invested_in', 'founded').\"\n",
+    "      }\n",
+    "    },\n",
+    "    \"required\": [\n",
+    "      \"entity\",\n",
+    "      \"start_date_range\",\n",
+    "      \"end_date_range\",\n",
+    "      \"predicate\"\n",
+    "    ],\n",
+    "    \"additionalProperties\": False\n",
+    "  }\n",
+    "}\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "##### Trend analysis\n",
+    "The `trend_analysis` tool is designed to compare how specific metrics or signals evolve over time—often across multiple companies and/or topics. It exposes a structured interface that lets the agent specify the time window, subject set, and target metric, then delegates the comparison logic to a specialised agent for handling this analysis. In this case we utilised o4-mini with high reasoning effort as this is a 'harder' anaysis task.\n",
+    "\n",
+    "This allows us to build a highly focused and optimised pipeline for dealing with comparison-style tasks. Whilst this could be built into the core orchestrator itself, it's often more manageable to split this into specialised tools so they can be more easily swapped out or updated later without much concern for impact on the wider system."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import asyncio\n",
+    "from datetime import datetime\n",
+    "\n",
+    "\n",
+    "async def trend_analysis(\n",
+    "    question: str,\n",
+    "    companies: list[str],\n",
+    "    start_date_range: datetime,\n",
+    "    end_date_range: datetime,\n",
+    "    topic_filter: list[str],\n",
+    ") -> str:\n",
+    "    \"\"\"\n",
+    "    Aggregate knowledge-graph facts for multiple companies and topics.\n",
+    "\n",
+    "    For every (company, topic) pair, this calls `factual_qa` with the same\n",
+    "    date window and returns one concatenated, human-readable string.\n",
+    "\n",
+    "    Sections are separated by blank lines and prefixed with:\n",
+    "        === <Company> · <Topic> ===\n",
+    "\n",
+    "    If `factual_qa` raises an exception, an ⚠️  line with the error message\n",
+    "    is included in place of that section.\n",
+    "    \"\"\"\n",
+    "\n",
+    "    # -------- helper ------------------------------------------------------\n",
+    "    async def _fetch(company: str, predicate: str) -> str:\n",
+    "        return await factual_qa(\n",
+    "            entity=company,\n",
+    "            start_date_range=start_date_range,\n",
+    "            end_date_range=end_date_range,\n",
+    "            predicate=predicate,\n",
+    "        )\n",
+    "\n",
+    "    # -------- schedule every call (concurrently) --------------------------\n",
+    "    pairs = [(c, p) for c in companies for p in topic_filter]\n",
+    "    tasks = [asyncio.create_task(_fetch(c, p)) for c, p in pairs]\n",
+    "\n",
+    "    # -------- gather results ---------------------------------------------\n",
+    "    results = await asyncio.gather(*tasks, return_exceptions=True)\n",
+    "\n",
+    "    # -------- assemble final string --------------------------------------\n",
+    "    sections: list[str] = []\n",
+    "    for (company, predicate), res in zip(pairs, results, strict=True):\n",
+    "        header = f\"=== {company} · {predicate} ===\"\n",
+    "        if isinstance(res, Exception):\n",
+    "            sections.append(f\"{header}\\n⚠️  {type(res).__name__}: {res}\")\n",
+    "        else:\n",
+    "            sections.append(f\"{header}\\n{res}\")\n",
+    "\n",
+    "    joined = \"\\n\\n\".join(sections)\n",
+    "\n",
+    "    analysis_user_prompt = (\n",
+    "        \"You are a helpful assistant\"\n",
+    "        \"You specialise in providing in-depth analyses of financial data. \"\n",
+    "        \"You are provided with a detailed dump of data from a knowledge graph that contains data that has been \"\n",
+    "        \"extracted from companies' earnings call transcripts. \\n\"\n",
+    "        \"Please summarise the trends from this, comparing how data has evolved over time in as much detail as possible. \"\n",
+    "        \"Your answer should only contain information that is derived from the data provided, do not lean on your internal \"\n",
+    "        \"knowledge. The knowledge graph contains data in the range 2016-2020. \"\n",
+    "        \"The data provided is: \\n\"\n",
+    "        f\"{joined}\\n\\n\"\n",
+    "        f\"The user question you are summarizing for is: {question}\"\n",
+    "    )\n",
+    "\n",
+    "    analysis = await client.responses.create(\n",
+    "        model=\"o4-mini\",\n",
+    "        input=analysis_user_prompt,\n",
+    "        reasoning={\n",
+    "            \"effort\": \"high\",\n",
+    "            \"summary\": \"auto\"\n",
+    "        }\n",
+    "    )\n",
+    "\n",
+    "    return analysis.output_text\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "result = await trend_analysis(\n",
+    "    question=\"How have AMD's research priorties changed over time?\",\n",
+    "    companies=[\"AMD\"],\n",
+    "    start_date_range=datetime(2016, 1, 1),\n",
+    "    end_date_range=datetime(2020, 1, 1),\n",
+    "    topic_filter=[\"launched\", \"researched\", \"developed\"]\n",
+    ")\n",
+    "print(result)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "trend_analysis_schema = {\n",
+    "  \"type\": \"function\",\n",
+    "  \"name\": \"trend_analysis\",\n",
+    "  \"description\": \"Aggregates and compares knowledge-graph facts for multiple companies and topics over a time range, returning a trend summary.\",\n",
+    "  \"parameters\": {\n",
+    "    \"type\": \"object\",\n",
+    "    \"properties\": {\n",
+    "      \"question\": {\n",
+    "        \"type\": \"string\",\n",
+    "        \"description\": \"A free-text question that guides the trend analysis (e.g., 'How did hiring trends differ between companies?').\"\n",
+    "      },\n",
+    "      \"companies\": {\n",
+    "        \"type\": \"array\",\n",
+    "        \"items\": {\n",
+    "          \"type\": \"string\"\n",
+    "        },\n",
+    "        \"description\": \"List of companies to compare (e.g., ['Apple', 'Microsoft']).\"\n",
+    "      },\n",
+    "      \"start_date_range\": {\n",
+    "        \"type\": \"string\",\n",
+    "        \"format\": \"date\",\n",
+    "        \"description\": \"The start (inclusive) of the date range to filter knowledge-graph facts.\"\n",
+    "      },\n",
+    "      \"end_date_range\": {\n",
+    "        \"type\": \"string\",\n",
+    "        \"format\": \"date\",\n",
+    "        \"description\": \"The end (inclusive) of the date range to filter knowledge-graph facts.\"\n",
+    "      },\n",
+    "      \"topic_filter\": {\n",
+    "        \"type\": \"array\",\n",
+    "        \"items\": {\n",
+    "          \"type\": \"string\"\n",
+    "        },\n",
+    "        \"description\": \"List of predicates (topics) to query for each company (e.g., ['hired_executive', 'launched_product']).\"\n",
+    "      }\n",
+    "    },\n",
+    "    \"required\": [\n",
+    "      \"question\",\n",
+    "      \"companies\",\n",
+    "      \"start_date_range\",\n",
+    "      \"end_date_range\",\n",
+    "      \"topic_filter\"\n",
+    "    ],\n",
+    "    \"additionalProperties\": False\n",
+    "  }\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tools = [\n",
+    "    factual_qa_schema,\n",
+    "    trend_analysis_schema\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 4.1.6. Retriever"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We design a simple retriever containing only a run method which encompasses the planning step and a while loop to execute each tool call that the orchestrator makes before returning a final answer."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "\n",
+    "\n",
+    "class MultiStepRetriever:\n",
+    "    \"\"\"Retrieve information in multiple steps using an OpenAI client.\"\"\"\n",
+    "    def __init__(self, client: AsyncOpenAI):\n",
+    "        self.client = client\n",
+    "        # This helps us simplify our tool calling functionality in run()\n",
+    "        self.function_map = {\n",
+    "            \"factual_qa\": factual_qa,\n",
+    "            \"trend_analysis\": trend_analysis\n",
+    "        }\n",
+    "\n",
+    "    async def run(self, user_question: str) -> tuple[str, dict]:\n",
+    "        \"\"\"Run the multi-step retrieval process for a user question.\"\"\"\n",
+    "        # -------------------------------------------------------\n",
+    "        # Step 1: Generate initial plan\n",
+    "        # -------------------------------------------------------\n",
+    "\n",
+    "        initial_plan = await initial_planner(user_question=user_question)\n",
+    "\n",
+    "        # -------------------------------------------------------\n",
+    "        # Step 2: Make initial model call\n",
+    "        # -------------------------------------------------------\n",
+    "\n",
+    "        retriever_user_prompt = (\n",
+    "            \"You are a helpful assistant. \"\n",
+    "            \"You are provided with a user question: \\n\\n\"\n",
+    "            f\"{user_question} \\n\\n\"\n",
+    "            \"You have access to a set of tools. You may choose to use these tools to retrieve information to \"\n",
+    "            \"help you answer the user's question. These tools allow you to query a knowledge graph that contains \"\n",
+    "            \"information that has been extracted from companies' earnings call transcripts. \"\n",
+    "            \"You should not use your own memory of these companies to answer questions. \"\n",
+    "            \"When returning an answer to the user, all of your content must be derived from the content \"\n",
+    "            \"you have retrieved from the tools used. This is to ensure that is is accurate, as the data in \"\n",
+    "            \"this knowledge graph has been carefully check to ensure its accuracy. The knowledge graph contains \"\n",
+    "            \"data spanning from 2016-2020. \\n\\n\"\n",
+    "            \"You are provided with a plan of action as follows: \\n\"\n",
+    "            f\"{initial_plan} \\n\\n\"\n",
+    "            \"You should generally stick to this plan to help you answer the question, though you may deviate \"\n",
+    "            \"from it should you deem it suitable. You may make more than one tool call.\"\n",
+    "        )\n",
+    "\n",
+    "        input_messages = [\n",
+    "            {\"role\":\"user\", \"content\":retriever_user_prompt}\n",
+    "        ]\n",
+    "\n",
+    "        response = await self.client.responses.create(\n",
+    "            model=\"gpt-4.1\",\n",
+    "            input=input_messages,\n",
+    "            tools=tools,\n",
+    "            parallel_tool_calls=False,\n",
+    "        )\n",
+    "\n",
+    "        # -------------------------------------------------------\n",
+    "        # Step 3: While loop until no more tool calls are made\n",
+    "        # -------------------------------------------------------\n",
+    "\n",
+    "        tools_used = {}\n",
+    "\n",
+    "        while response.output[0].type == \"function_call\":\n",
+    "            tool_call = response.output[0]\n",
+    "            args = json.loads(tool_call.arguments)\n",
+    "            name = tool_call.name\n",
+    "\n",
+    "            if name in self.function_map:\n",
+    "                tool_func = self.function_map[name]\n",
+    "                tool_response_text = await tool_func(**args)\n",
+    "\n",
+    "                input_messages.append(tool_call)\n",
+    "                input_messages.append({\n",
+    "                    \"type\": \"function_call_output\",\n",
+    "                    \"call_id\": tool_call.call_id,\n",
+    "                    \"output\": tool_response_text\n",
+    "                })\n",
+    "\n",
+    "            tools_used[name] = [args, tool_response_text]\n",
+    "\n",
+    "            response = await self.client.responses.create(\n",
+    "                model=\"gpt-4.1\",\n",
+    "                input=input_messages,\n",
+    "                tools=tools,\n",
+    "                parallel_tool_calls=False\n",
+    "            )\n",
+    "\n",
+    "        return response.output_text, tools_used"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can now run our MultiStepRetriever. \n",
+    "\n",
+    "We observe that the answer returned is detailed, and includes a detailed walkthrough of how AMD's research priorities evolved from 2016 to 2020, with references to the underlying quotes that were used to derive these answers."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "retriever = MultiStepRetriever(client=client)\n",
+    "\n",
+    "answer, tools_used = await retriever.run(user_question=\"How have AMD's research & development priorities changed over time?\")\n",
+    "\n",
+    "print(answer)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can also inspect the tools used by our MultiStepRetriever to answer this query."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for key, value in tools_used.items():\n",
+    "    if value:\n",
+    "        print(f\"{key}: {value[0]}\")\n",
+    "    else:\n",
+    "        print(f\"{key}: [empty list]\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[Appendix section A.5. \"Scaling and Productionizing our Retrieval Agent\"](./Appendix.ipynb) outlines some guidelines for how one could take the Retrieval Agent we've built up to production."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 4.1.7. Selecting the right model for Multi-Step Knowledge-Graph Retrieval\n",
+    "\n",
+    "Multi-step retrieval agents need strong reasoning to hop through entities and relations, verify answers, and decide what to do next.  Latency still matters to users, but usually *less* than raw accuracy. Hence, this is one of the domains where OpenAI's o3 and o4-mini reasoning models shine.\n",
+    "\n",
+    "Once again, for development we recommend a “start big, then specialise” ladder:\n",
+    "\n",
+    "1. **Start with o3** – ensure your retrieval logic (chaining, re-ranking, fallback prompts) is sound. o3 may also be the best choice for production if your retrieval system is working with particularly complex data such as pharmaceutical or legal data. You can test this by looking at the severity of performance degradation with smaller models. If the drop off in performance is large, consider sticking with o3\n",
+    "2. **Move to o4-mini**\n",
+    "   * **Prompt enhancement** - optimise your prompts to push the performance of the o4-mini system as close to that of the full o3 model\n",
+    "   * **Reinforcement fine-tuning (RFT)** - [OpenAI's Reinforcement Fine-Tuning](https://platform.openai.com/docs/guides/reinforcement-fine-tuning) offering enables you to fine-tune OpenAI's o-series models to improve their performance on hard reasoning tasks. With as little as ~50 golden answers you can leverage the power of reinforcement learning to fine-tune o4-mini which can help it come close or even exceed the base o3's performance on the same task\n",
+    "4. **Fallback to GPT 4.1 when latency dominates** – for cases when latency is particularly important or you've tuned your prompts well enough that performance drop-off is minimal, consider moving to the GPT 4.1 series\n",
+    "\n",
+    "| Model       | Relative cost | Relative latency | Intelligence | Ideal role in workflow                               |\n",
+    "| ----------- | ------------- | ---------------- | - | ---------------------------------------------------- |\n",
+    "| *o3* | ★★★           | ★★               | ★★★ *(highest)* | Initial prototyping, working with complex data, golden dataset generation |\n",
+    "| *o4-mini*   | ★★            | ★               | ★★ | Main production engine, can push performance with RFT      |\n",
+    "| *GPT 4.1 series*   | ★ *(lowest)*          | ★ *(fastest)* | ★  | Latency-critical or large-scale background scoring   |\n",
+    "\n",
+    "#### Why is Reinforcement Fine-Tuning powerful for long horizon, multi-step retrieval tasks?\n",
+    "RFT has a number of benefits over [Supervised Fine-Tuning](https://platform.openai.com/docs/guides/supervised-fine-tuning) or [Direct Preference Optimization](https://platform.openai.com/docs/guides/direct-preference-optimization) for this use case. \n",
+    "\n",
+    "Firstly, reinforcement fine-tuning can be performed with a far small number of examples, sometimes requiring as little as 50 training examples.\n",
+    "\n",
+    "Additionally, RFT eliminates the necessity of providing labeled step-by-step trajectories. By supplying only the final correct answer, the system learns implicitly how to navigate the knowledge graph effectively. This feature is particularly valuable in real-world contexts where end users typically face time constraints and may struggle to curate the extensive sets of labeled examples (often numbering in the hundreds or thousands) required by traditional SFT methods."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4.2 Evaluating your Retrieval System"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<ol style=\"margin-left: 1em; line-height: 1.6; padding-left: 0.5em;\">\n",
+    "\n",
+    "  <!-- 1. Human-annotated “Golden Answers” -->\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Human-annotated “Golden Answers”</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      The traditional baseline for retrieval evaluation: a curated set of <em>query → gold answer</em> pairs,\n",
+    "      vetted by domain experts.  \n",
+    "      Metrics such as precision@k or recall@k are computed by matching retrieved passages\n",
+    "      against these gold spans.\n",
+    "    </p>\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      <strong>Pros:  </strong> Highest reliability, clear pass/fail thresholds, excellent for regression testing<br />\n",
+    "      <strong>Cons:  </strong> Expensive to create, slow to update, narrow coverage (quickly becomes stale\n",
+    "      when the knowledge base evolves)\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <!-- 2. Synthetically generated answers -->\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Synthetically generated answers</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Use an LLM to generate reference answers or judgments, enabling rapid, low-cost expansion\n",
+    "      of the evaluation set.  Three common pathways:\n",
+    "    </p>\n",
+    "    <ul style=\"list-style: disc; padding-left: 1em; margin-top: 0.25em; margin-bottom: 0.5em;\">\n",
+    "      <li><strong>LLM-as-judge</strong>: Feed the query, retrieved passages, and candidate answer to a\n",
+    "          judge model that outputs a graded score or e.g., “yes / partial / no”</li>\n",
+    "      <li><strong>Tool-use pathway</strong>: For different question types you can either manually or synthetically generate the 'correct' tool-use pathways and score responses against this</li>\n",
+    "    </ul>\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      <strong>Pros: </strong> Fast, infinitely scalable, easier to keep pace with a dynamic application specification<br />\n",
+    "      <strong>Cons: </strong> Judgement quality is typically of lower quality than expert human-annotated solutions\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <!-- 3. Human feedback -->\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Human feedback</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Collect ratings directly from end-users or domain reviewers (thumbs-up/down, five-star scores, pairwise\n",
+    "      comparisons).  Can be <em>in-the-loop</em> (model trains continuously on live feedback) or\n",
+    "      <em>offline</em> (periodic eval rounds).\n",
+    "    </p>\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      <strong>Pros: </strong> Captures real-world utility, surfaces edge-cases synthetic tests miss<br />\n",
+    "      <strong>Cons: </strong> Noisy and subjective; requires thoughtful aggregation (e.g., ELO\n",
+    "      scoring), risk of user biases becoming incorporated in the model\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "</ol>\n",
+    "\n",
+    "### Which is the best evaluation method?\n",
+    "There is no single best method. However, a workflow that we have found that works well on projects is:\n",
+    "1. Start building and iterate synthetic evaluations\n",
+    "2. Test with your golden human set of evaluations before deployment\n",
+    "3. Make it easy for end-users to annotate good and bad answers, and use this feedback to continue to develop your application over time\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 5. Prototype to Production\n",
+    "---"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Transitioning your knowledge graph system from a proof-of-concept to a robust, production-grade pipeline requires you to address several key points:\n",
+    "- **Storing and retrieving high-volume graph data**\n",
+    "- **Mananging and pruning datasets**\n",
+    "- **Implementing concurrency in the ingestion pipeline**\n",
+    "- **Minimizing token cost**\n",
+    "- **Scaling retrieval agents**\n",
+    "- **Safeguards**\n",
+    "\n",
+    "This section serves as a walkthrough of key considerations and best practices to ensure your temporally-aware knowledge graph can operate reliably in a real-world environment. A more detailed [Prototype to Production Appendix section](#a-prototype-to-production) can be found towards the end of this cookbook.\n",
+    "\n",
+    "<ol style=\"margin-left: 1em; line-height: 1.6; padding-left: 0.5em;\">\n",
+    "\n",
+    "<li style=\"margin-bottom: 1.2em;\">\n",
+    "  <strong>Storing and Retrieving High-Volume Graph Data</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "    <a href=\"#a-1-storing-and-retrieving-high-volume-graph-data\">Appendix section A.1. \"Storing and Retrieving High-Volume Graph Data\"</a>\n",
+    "  </p>\n",
+    "  <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "    Manage scalability through thoughtful schema design, sharding, and partitioning. Clearly define entities, relationships, and ensure schema flexibility for future evolution. Use high-cardinality fields like timestamps for efficient data partitioning.\n",
+    "  </p>\n",
+    "</li>\n",
+    "\n",
+    "<li style=\"margin-bottom: 1.2em;\">\n",
+    "  <strong>Temporal Validity & Versioning</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "    <a href=\"#a-1-2-temporal-validity-versioning\">Appendix section A.1.2. \"Temporal Validity & Versioning\"</a>\n",
+    "  </p>\n",
+    "  <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "    Include temporal markers (valid_from, valid_to) for each statement. Maintain historical records non-destructively by marking outdated facts as inactive and indexing temporal fields for efficient queries.\n",
+    "  </p>\n",
+    "</li>\n",
+    "\n",
+    "<li style=\"margin-bottom: 1.2em;\">\n",
+    "  <strong>Indexing & Semantic Search</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "    <a href=\"#a-1-3-indexing-semantic-search\">Appendix section A.1.3. \"Indexing & Semantic Search\"</a>\n",
+    "  </p>\n",
+    "  <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "    Utilize B-tree indexes for efficient temporal querying. Leverage PostgreSQL’s pgvector extension for semantic search with approximate nearest-neighbor algorithms like ivfflat, ivfpq, and hnsw to optimize query speed and memory usage.\n",
+    "  </p>\n",
+    "</li>\n",
+    "\n",
+    "<li style=\"margin-bottom: 1.2em;\">\n",
+    "  <strong>Managing and Pruning Datasets</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "    <a href=\"#a-2-managing-and-pruning-datasets\">Appendix section A.2. \"Managing and Pruning Datasets\"</a>\n",
+    "  </p>\n",
+    "  <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "    Establish TTL and archival policies for data retention based on source reliability and relevance. Implement automated archival tasks and intelligent pruning with relevance scoring to optimize graph size.\n",
+    "  </p>\n",
+    "</li>\n",
+    "\n",
+    "<li style=\"margin-bottom: 1.2em;\">\n",
+    "  <strong>Concurrent Ingestion Pipeline</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "    <a href=\"#a-3-implementing-concurrency-in-the-ingestion-pipeline\">Appendix section A.3. \"Implementing Concurrency in the Ingestion Pipeline\"</a>\n",
+    "  </p>\n",
+    "  <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "    Implement batch processing with separate, scalable pipeline stages for chunking, extraction, invalidation, and entity resolution. Optimize throughput and parallelism to manage ingestion bottlenecks.\n",
+    "  </p>\n",
+    "</li>\n",
+    "\n",
+    "<li style=\"margin-bottom: 1.2em;\">\n",
+    "  <strong>Minimizing Token Costs</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "    <a href=\"#a-4-minimizing-token-cost\">Appendix section A.4. \"Minimizing Token Cost\"</a>\n",
+    "  </p>\n",
+    "  <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "    Use caching strategies to avoid redundant API calls. Adopt service tiers like OpenAI's flex option to reduce costs and replace expensive model queries with efficient embedding and nearest-neighbor search.\n",
+    "  </p>\n",
+    "</li>\n",
+    "\n",
+    "<li style=\"margin-bottom: 1.2em;\">\n",
+    "  <strong>Scaling Retrieval Agents</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "    <a href=\"#a-5-scaling-and-productionizing-our-retrieval-agent\">Appendix section A.5. \"Scaling and Productionizing our Retrieval Agent\"</a>\n",
+    "  </p>\n",
+    "  <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "    Use a controller and traversal workers architecture to handle multi-hop queries. Implement parallel subgraph extraction, dynamic traversal with chained reasoning, caching, and autoscaling for high performance.\n",
+    "  </p>\n",
+    "</li>\n",
+    "\n",
+    "<li style=\"margin-bottom: 1.2em;\">\n",
+    "  <strong>Safeguards & Verification</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "    <a href=\"#a-6-safeguards\">Appendix section A.6. \"Safeguards\"</a>\n",
+    "  </p>\n",
+    "  <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "    Deploy multi-layered output verification, structured logging, and monitoring to ensure data integrity and operational reliability. Track critical metrics and perform regular audits.\n",
+    "  </p>\n",
+    "</li>\n",
+    "\n",
+    "<li style=\"margin-bottom: 1.2em;\">\n",
+    "  <strong>Prompt Optimization</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "    <a href=\"#a-7-prompt-optimization\">Appendix section A.7. \"Prompt Optimization\"</a>\n",
+    "  </p>\n",
+    "  <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "    Optimize LLM interactions with personas, few-shot prompts, chain-of-thought methods, dynamic context management, and automated A/B testing of prompt variations for continuous performance improvement.\n",
+    "  </p>\n",
+    "</li>\n",
+    "\n",
+    "</ol>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Closing thoughts"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This cookbook equips you with foundational techniques and concrete workflows to effectively build and deploy temporally-aware knowledge graphs coupled with powerful multi-hop retrieval capabilities. \n",
+    "\n",
+    "Whether you're starting from a prototype or refining a production system, leveraging structured graph data with OpenAI models can unlock richer, more nuanced interactions with your data. As these technologies evolve rapidly, look out for updates in OpenAI's model lineup and keep experimenting with indexing methods and retrieval strategies to continuously enhance your knowledge-centric AI solutions.\n",
+    "\n",
+    "You can easily adapt the frameworks presented in this cookbook to your respective domain by customizing the provided ontologies and refining the extraction prompts. Swapping in Neo4j as the graph database takes you well on the way to an MVP level application, providing data persistence out of the box. It also opens the door to levelling up your retriever's tools with Cypher queries. \n",
+    "\n",
+    "Iterively develop your solution by making use of synthetic evals, and then test your solution against \"golden\" expert-human annotated solutions. Once in production, you can quickly iterate from human feedback to push your application to new heights. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Contributors\n",
+    "This cookbook serves as a joint collaboration between OpenAI and [Tomoro](https://tomoro.ai/).\n",
+    "\n",
+    "- [Alex Heald](https://www.linkedin.com/in/alexandra-heald/)\n",
+    "- [Douglas Adams](https://www.linkedin.com/in/douglas-adams99/)\n",
+    "- [Rishabh Sagar](https://www.linkedin.com/in/rish-sagar/)\n",
+    "- [Danny Wigg](https://www.linkedin.com/in/dannywigg/)\n",
+    "- [Shikhar Kwatra](https://www.linkedin.com/in/shikharkwatra/)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Appendix\n",
+    "---\n",
+    "\n",
+    "Within this appendix, you'll find a more in-depth *Prototype to Production* section."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3f70ab4a-e04a-44aa-8e75-f9c15be22c5f",
+   "metadata": {},
+   "source": [
+    "## A. Prototype to Production"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b97b1677-7c77-4bad-bdfe-b541901c3b81",
+   "metadata": {},
+   "source": [
+    "### A.1. Storing and Retrieving High-Volume Graph Data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ada5b662-f493-41e3-a5f5-85f92dec61c0",
+   "metadata": {},
+   "source": [
+    "#### A.1.1. Data Volume & Schema Complexity"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8a1009ec-9885-486a-ab69-5d86720389a6",
+   "metadata": {},
+   "source": [
+    "As your dataset scales to millions or even billions of nodes and edges, managing performance and maintainability becomes critical. This requires thoughtful approaches to both schema design and data partitioning:\n",
+    "\n",
+    "<ol style=\"margin-left: 1em; line-height: 1.6; padding-left: 0.5em;\">\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Schema design for growth and change</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Clearly define core entity types (e.g., <code>Person</code>, <code>Organization</code>, <code>Event</code>) and relationships. Design the schema with versioning and flexibility in mind, enabling future schema evolution with minimal downtime.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Sharding &amp; partitioning</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Use high-cardinality fields (such as timestamps or unique entity IDs) for partitioning to preserve query performance as data volume grows. This is particularly important for temporally-aware data. For example:\n",
+    "    </p>\n",
+    "  \n",
+    "  ```sql  \n",
+    "  CREATE TABLE statements (\n",
+    "    statement_id UUID PRIMARY KEY,\n",
+    "    entity_id UUID NOT NULL,\n",
+    "    text TEXT NOT NULL,\n",
+    "    valid_from TIMESTAMP NOT NULL,\n",
+    "    valid_to TIMESTAMP,\n",
+    "    status VARCHAR(16) DEFAULT 'active',\n",
+    "    embedding VECTOR(1536),\n",
+    "    ...\n",
+    "  ) PARTITION BY RANGE (valid_from);\n",
+    "  ```\n",
+    "  </li>\n",
+    "</ol>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f91fa408-9b9c-4fc5-9471-c0ccbc49bbae",
+   "metadata": {},
+   "source": [
+    "#### A.1.2. Temporal Validity & Versioning"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cb172a41-c085-4fc3-b7b4-80d22c3dbabf",
+   "metadata": {},
+   "source": [
+    "In our temporal knowledge graph, each statement includes temporal markers (e.g., `valid_from`, `valid_to`). \n",
+    "\n",
+    "<ol style=\"margin-left: 1em; line-height: 1.6; padding-left: 0.5em;\">\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Preserve history non-destructively</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Avoid deleting or overwriting records. Instead mark outdated facts as inactive by setting a <code>status</code> (e.g., <code>inactive</code>).\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Optimize for temporal access</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Index temporal fields (<code>valid_from</code>, <code>valid_to</code>) to support efficient querying of both current and historical states.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "</ol>\n",
+    "\n",
+    "\n",
+    "#### Example: Non-Destructive Updates\n",
+    "\n",
+    "Rather than removing or overwriting a record, update its status and close its validity window:\n",
+    "\n",
+    "```sql\n",
+    "UPDATE statements\n",
+    "SET status = 'inactive', valid_to = '2025-03-15T00:00:00Z'\n",
+    "WHERE statement_id = '...' AND entity_id = '...';\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "58caf1c8-49ae-46a9-bb16-8c767c21a362",
+   "metadata": {},
+   "source": [
+    "#### A.1.3. Indexing & Semantic Search"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e982b9c7-611c-4e29-9b56-d52fbdc844b1",
+   "metadata": {},
+   "source": [
+    "##### Temporal Indexes\n",
+    "To support efficient temporal queries create B-tree indexes on `valid_from` and `valid_to`. A 'B-tree' index is a tree data structure that keeps data sorted to facilitate fast lookups, range queries, and ordered scans in logarithmic time. It's the default index type in many relational databases. \n",
+    "\n",
+    "```sql\n",
+    "CREATE INDEX ON statements (valid_from);\n",
+    "CREATE INDEX ON statements (valid_to);\n",
+    "```\n",
+    "##### Semantic search with pgvector\n",
+    "Storing vector embeddings in PostgreSQL (via the `pgvector` extension) enables similarity-based retrieval via semantic search. This follows a two-step process:\n",
+    "1. Store high-dimensional vectors that represent the semantic meaning of the text. These can be created with embedding models such as OpenAI's `text-embedding-3-small` and `text-embedding-3-large`\n",
+    "2. Use Approximate Nearest-Neighbour (ANN) for efficient similarity matching at scale\n",
+    "\n",
+    "There are several different indexing options available in pgvector, each with different purposes. These indexing options are described in more detail, along with in-depth implementation steps in the [README on the Github repository for pgvector](https://github.com/pgvector/pgvector/blob/master/README.md).\n",
+    "| <div align=\"center\">Index Type</div> | <div align=\"center\">Build Time</div> | <div align=\"center\">Query Speed</div> | <div align=\"center\">Memory Usage</div> | <div align=\"center\">Accuracy</div> | <div align=\"center\">Recommended Scale</div> | Notes |\n",
+    "|-------------------------------------|--------------------------------------|----------------------------------------|-----------------------------------------|-----------------------------------|----------------------------------------------|-------|\n",
+    "| <div align=\"center\">**flat**</div> | <div align=\"center\">Minimal</div> | <div align=\"center\">Slow<br>(linear scan)</div> | <div align=\"center\">Low</div> | <div align=\"center\">100%<br>(exact)</div> | <div align=\"center\">Very small<br>(&lt; 100 K vectors)</div> | No approximate indexing—scans all vectors. Best for exact recall on small collections |\n",
+    "| <div align=\"center\">**ivfflat**</div> | <div align=\"center\">Moderate</div> | <div align=\"center\">Fast when tuned</div> | <div align=\"center\">Moderate</div> | <div align=\"center\">High<br>(tunable)</div> | <div align=\"center\">Small to Medium<br>(100 K–200 M)</div> | Uses inverted file indexing. Query-time parameters control trade-offs |\n",
+    "| <div align=\"center\">**ivfpq**</div> | <div align=\"center\">High</div> | <div align=\"center\">Very fast</div> | <div align=\"center\">Low<br>(quantized)</div> | <div align=\"center\">Slightly lower<br>than ivfflat</div> | <div align=\"center\">Medium to Large<br>(1 M–500 M)</div> | Combines inverted files with product quantization for lower memory use |\n",
+    "| <div align=\"center\">**hnsw**</div> | <div align=\"center\">Highest</div> | <div align=\"center\">Fastest<br>(esp. at scale)</div> | <div align=\"center\">High<br>(in-memory)</div> | <div align=\"center\">Very high</div> | <div align=\"center\">Large to Very Large<br>(100 M–Billions+)</div> | Builds a hierarchical navigable graph. Ideal for latency-sensitive, high-scale systems |\n",
+    "\n",
+    "\n",
+    "##### Tuning parameters for vector indexing\n",
+    "\n",
+    "`ivfflat`\n",
+    "* `lists`: Number of partitions (e.g., 100)\n",
+    "* `probes`: Number of partitions to scan at query time (e.g., 10-20), controls recall vs. latency\n",
+    "\n",
+    "`ivfpq`\n",
+    "* `subvectors`: Number of blocks to quantize (e.g., 16)\n",
+    "* `bits`: Number of bits per block (e.g., 8)\n",
+    "* `probes`: Same as in `ivfflat`\n",
+    "\n",
+    "`hnsw`\n",
+    "* `M`: Max connections per node (e.g., 16)\n",
+    "* `ef_construction`: Build-time dynamic candidate list size (e.g., 200)\n",
+    "* `ef_search`: Queyr-time candidate pool (e.g., 64-128)\n",
+    "\n",
+    "##### Best practices\n",
+    "- `flat` for debugging or small datasets\n",
+    "- `ivfflat` when you want tunable accuracy with good speed\n",
+    "- `ivfpq` when memory efficieny is critical\n",
+    "- `hnsw` when optimizing for lowest latency on massive collections\n",
+    "\n",
+    "##### Other vector database options in the ecosystem\n",
+    "\n",
+    "| Vector DB    | Key Features                                                 | Pros                                        | Cons                                                            |\n",
+    "| ------------ | ------------------------------------------------------------ | ------------------------------------------- | --------------------------------------------------------------- |\n",
+    "| **Pinecone** | Fully managed, serverless; supports HNSW and SPANN           | Auto-scaling, SLA-backed, easy to integrate | Vendor lock-in; cost escalates at scale                         |\n",
+    "| **Weaviate** | GraphQL API, built-in modules for encoding and vectorization | Hybrid queries (metadata + vector), modular | Production deployment requires Kubernetes                       |\n",
+    "| **Milvus**   | Supports GPU indexing; IVF, HNSW, ANNOY                      | High performance at scale, dynamic indexing | Operational complexity; separate system                         |\n",
+    "| **Qdrant**   | Lightweight, real-time updates, payload filtering            | Simple setup, good hybrid query support     | Lacks native relational joins; eventual consistency in clusters |\n",
+    "| **Vectara**  | Managed with semantic ranking and re-ranking                 | Strong relevance features; easy integration | Proprietary; limited index control                              |\n",
+    "\n",
+    "##### Choosing the Right Vector Store\n",
+    "\n",
+    "| <div align=\"center\">Scale</div> | <div align=\"center\">Recommendation</div> | Details |\n",
+    "|--------------------------------|------------------------------------------|---------|\n",
+    "| <div align=\"center\">**Small to Medium Scale**<br>(less than 100M vectors)</div> | <div align=\"center\">PostgreSQL + pgvector<br>with `ivfflat` index</div> | Often sufficient for moderate workloads. Recommended settings: `lists = 100–200`, `probes = 10–20`. |\n",
+    "| <div align=\"center\">**Large Scale**<br>(100M – 1B+ vectors)</div> | <div align=\"center\">Milvus or Qdrant</div> | Suitable for high-throughput workloads, especially when GPU-accelerated indexing or sub-millisecond latency is needed. |\n",
+    "| <div align=\"center\">**Hybrid Scenarios**</div> | <div align=\"center\">PostgreSQL for metadata<br>+ dedicated vector DB</div> | Use PostgreSQL for entity metadata storage and a vector DB (e.g., Milvus, Qdrant) for similarity search. Synchronize embeddings using CDC pipelines (e.g., Debezium). |\n",
+    "\n",
+    "For more detailed information, check out the [OpenAI cookbook on vector databases](https://cookbook.openai.com/examples/vector_databases/readme).\n",
+    "\n",
+    "##### Durable disk storage and backup\n",
+    "For some cases, especially those requiring high availability or state recovery across restarts, it may be worth persisting state to reliable disk storage and implementing a backup strategy. \n",
+    "\n",
+    "If durability is a concern, consider using persistent disks with regular backups or syncing state to external storage. While not necessary for all deployments, it can provide a valuable safeguard against data loss or operational disruption in environments where consistency and fault tolerance matter."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7e12f78a-eb4f-44ab-9dc1-2fea0e4d7090",
+   "metadata": {},
+   "source": [
+    "### A.2. Managing and Pruning Datasets"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "52acca83-7a99-436f-86ac-5cfe6b93ba86",
+   "metadata": {},
+   "source": [
+    "#### A.2.1. TTL (Time-to-Live) and Archival Policies"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6e6bbf33-4f3e-4536-a806-1b1a7d84add7",
+   "metadata": {},
+   "source": [
+    "Establish clear policies to determine which facts should be retained indefinitely (e.g., legally required records for regulators) and which can be archived after a defined period (e.g., statements sourced from social media more than one year old).\n",
+    "\n",
+    "Key practices to include:\n",
+    "<ol style=\"margin-left: 1em; line-height: 1.6; padding-left: 0.5em;\">\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Automated Archival Jobs</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Set up a background task that periodically queries for records with e.g., <code>valid_to &lt; NOW() - INTERVAL 'X days'</code> and moves them to an archival table for long-term storage.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Source-Specific Retention Policies</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Tailor retention durations by data source or entity type. For example, high-authority sources like government publications may warrant longer retention than less reliable data such as scraped news headlines or user-generated content.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "</ol>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9eefcbf8-8cba-40b3-888f-58b7f723ce5a",
+   "metadata": {},
+   "source": [
+    "#### A.2.2. Relevance Scoring and Intelligent Pruning"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0c6e905c-b91a-48d0-a84b-cff5e8f6dbf1",
+   "metadata": {},
+   "source": [
+    "As your knowledge graph grows, the utility of many facts will decline. To keep the graph focused and maximise performance: \n",
+    "<ol style=\"margin-left: 1em; line-height: 1.6; padding-left: 0.5em;\">\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Index a Relevance Score</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Introduce a numeric <code>relevance_score</code> column (or columns) that incorporate metrics such as recency, source trustworthiness, and production query frequency.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Automated Pruning Logic</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Schedule a routine job to prune or archive facts falling below a predefined relevance threshold.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "</ol>\n",
+    "\n",
+    "\n",
+    "#### Advanced Relevance-Based Graph Reduction\n",
+    "\n",
+    "Efficiently reducing the size of a knowledge graph is important when scaling. [A 2024 survey](https://arxiv.org/pdf/2402.03358) categorizes techniques into **sparsification**, **coarsening**, and **condensation**—all aimed at shrinking the graph while preserving task-critical semantics. These methods offer substantial runtime and memory gains on large-scale KGs.\n",
+    "\n",
+    "Example implementation pattern:\n",
+    "<ol style=\"margin-left: 1em; line-height: 1.6; padding-left: 0.5em;\">\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Score Each Triple</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Compute a composite <code>relevance_score</code>, for example:\n",
+    "    </p>\n",
+    "    <pre style=\"margin-top: 0.5em; margin-bottom: 0.5em; background-color: #f5f5f5; padding: 0.75em; border-radius: 5px;\"><code>relevance_score = β1 * recency_score + β2 * source_trust_score + β3 * retrieval_count</code></pre>\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Where:\n",
+    "    </p>\n",
+    "    <ul style=\"margin-top: 0.5em; margin-bottom: 0.5em; padding-left: 1.2em;\">\n",
+    "      <li><code>recency_score</code>: exponential decay from <code>valid_from</code></li>\n",
+    "      <li><code>source_trust_score</code>: source-domain trust value</li>\n",
+    "      <li><code>retrieval_count</code>: production query frequency</li>\n",
+    "    </ul>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Apply a Reduction Strategy</strong><br />\n",
+    "    <ul style=\"margin-top: 0.5em; margin-bottom: 0.5em; padding-left: 1.2em;\">\n",
+    "      <li><strong>Sparsify</strong>: Select and retain only the most relevant edges or nodes based on criteria like centrality, spectral similarity, or embedding preservation</li>\n",
+    "      <li><strong>Coarsen</strong>: Group low-importance or semantically similar nodes into super-nodes and aggregate their features and connections</li>\n",
+    "      <li><strong>Condense</strong>: Construct a task-optimized mini-graph from scratch</li>\n",
+    "    </ul>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Validate in Shadow Mode</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Log and compare outputs from the pruned vs. original graph before routing production traffic.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Re-Score Regularly</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Recompute relevance (e.g., nightly) to ensure new or frequently accessed facts surface back to the top.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "</ol>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c98d8110-9ac9-4247-bd54-a4dccd3cf61d",
+   "metadata": {},
+   "source": [
+    "### A.3. Implementing Concurrency in the Ingestion Pipeline"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "66e144a0-9837-478a-b112-cfa297eb664a",
+   "metadata": {},
+   "source": [
+    "Moving from prototype to production often requires you to transform your linear processing pipeline into a concurrent, scalable pipeline. Instead of processing documents sequentially (document → chunking → statement extraction → entity extraction → statement invalidation → entity resolution), implement a staged pipeline where each phase can scale independently.\n",
+    "\n",
+    "Design your pipeline with a series of specialized stages, each with its own queue and worker pool. This allows you to scale bottlenecks independently and maintain system reliability under varying loads. \n",
+    "\n",
+    "<ol style=\"margin-left: 1em; line-height: 1.6; padding-left: 0.5em;\">\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Batch Chunking</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Begin by collecting documents in batches of e.g., 100–500 using a job queue like Redis or Amazon SQS. Process these documents in parallel, splitting each into their respective chunks. The chunking stage should often optimize for I/O parallelization as document reading is often the bottleneck. You can then store the chunks and their respective metadata in your <code>chunk_store</code> table, using bulk insert operations to minimize overhead.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Statement and Entity Extraction</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Pull chunks in batches of e.g., 50–100 and send them to your chosen LLM (e.g., GPT-4.1-mini) using parallel API requests. Implement rate limiting with semaphores or other methods to stay safely within OpenAI's API limits whilst maximizing your throughputs. We've covered rate limiting in more detail in our cookbook on <a href=\"https://cookbook.openai.com/examples/how_to_handle_rate_limits\">How to handle rate limits</a>. Once extracted, you can then write these to the relevant table in your database.\n",
+    "    </p>\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      You can then similarly group the statements we've just extracted into batches, and run the entity extraction processes in a similar vein before storing them.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Statement Invalidation</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Group extracted statement IDs by their associated entity clusters (e.g., all statements related to a specific entity like “Acme Corp.”). Send each cluster to your LLM (e.g., GPT-4.1-mini) in parallel to assess which statements are outdated or superseded. Use the model’s output to update the <code>status</code> field in your <code>statements</code> table—e.g., setting <code>status = 'inactive'</code>. Parallelize invalidation jobs for performance and consider scheduling periodic sweeps for consistency.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Entity Resolution</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Take batches of newly extracted entity mentions and compute embeddings using your model’s embedding endpoint. Insert these into your <code>entity_registry</code> table, assigning each a provisional or canonical <code>entity_id</code>. Perform approximate nearest-neighbor (ANN) searches using <code>pgvector</code> to identify near-duplicates or aliases. You can then update the <code>entities</code> table with resolved canonical IDs, ensuring downstream tasks reference unified representations.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "</ol>\n",
+    "\n",
+    "\n",
+    "### Advantages of Batch Processing\n",
+    "* Throughput – Batching reduces the overhead of individual API calls and database transactions.\n",
+    "\n",
+    "* Parallelism – Each stage can horizontally scale: you can run multiple worker processes for chunking, extraction, invalidation, etc., each reading from a queue.\n",
+    "\n",
+    "* Backpressure & Reliability – If one stage becomes slow (e.g., statement invalidation during a sudden data surge), upstream stages can buffer more items in the queue until capacity frees up.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "43cc5595-ae38-47e9-b90f-7b3f1bd004dc",
+   "metadata": {},
+   "source": [
+    "### A.4. Minimizing Token Cost"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "23ff03de-eeed-4bcf-9c1b-18bb8b449353",
+   "metadata": {},
+   "source": [
+    "#### A.4.1. Prompt Caching"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0f5a4127-058a-4cf9-9a35-a928658a99fd",
+   "metadata": {},
+   "source": [
+    "Avoid redundant API calls by memoizing responses to brittle sub-prompts.\n",
+    "\n",
+    "Implementation Strategy:\n",
+    "- **Cache Frequent Queries**: For example, repeated prompts like \"Extract entities from this statement\" on identicial statements\n",
+    "- **Use Hash Keys**: Generate a unique cache key using the MD5 hash of the statement text: `md5(statement_text)`\n",
+    "- **Storage Options**: Redis for scalable persistence or in-memory LRU cache for simplicity and speed\n",
+    "- **Bypass API Calls**: If a statement is found in cache, skip the API call"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "81de3bdc-8cc3-4016-8cd7-01754dd4b04d",
+   "metadata": {},
+   "source": [
+    "#### A.4.2. Service Tier: Flex"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "664765a2-6274-4285-b0c0-b1fb620cdb5a",
+   "metadata": {},
+   "source": [
+    "Utilize the `service_tier=flex` parameter in the OpenAI Responses SDK to enable partial completions and reduce costs.\n",
+    "\n",
+    "API Configuration:\n",
+    "```json\n",
+    "{\n",
+    "  \"model\": \"o4-mini\",\n",
+    "  \"prompt\": \"<your prompt>\",\n",
+    "  \"service_tier\": \"flex\"\n",
+    "}\n",
+    "```\n",
+    "\n",
+    "Cost Benefits:\n",
+    "- Charges only for generated tokens, not prompt tokens\n",
+    "- Can reduce costs by up to 40% for short extractions (e.g., single-sentence entity lists)\n",
+    "\n",
+    "You can learn more about the power of Flex processing and how to utilise it in the [API documentation for Flex processing](https://platform.openai.com/docs/guides/flex-processing?api-mode=responses)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "12c39a74-8e08-4d62-bf09-8603c397b6f2",
+   "metadata": {},
+   "source": [
+    "#### A.4.3. Minimize \"Chattiness\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "05891cac-6f02-40c9-91e8-e19e0fb11e3a",
+   "metadata": {},
+   "source": [
+    "Replace expensive text-generation calls with more efficient alternatives where possible.\n",
+    "\n",
+    "Alternative approach:\n",
+    "- Use embeddings endpoint (cheaper per token) combined with pgvector nearest-neighbor search\n",
+    "- Instead of asking the model \"Which existing statement is most similar?\", compute embeddings once and query directly in Postgres\n",
+    "- This approach is particularly effective for semantic similarity tasks\n",
+    "\n",
+    "**Benefits:**\n",
+    "- Lower cost per operation\n",
+    "- Faster query response times\n",
+    "- Reduced API dependency for similarity searches"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "22affb30-4da1-41aa-9ae4-a285b7f2e060",
+   "metadata": {},
+   "source": [
+    "### A.5. Scaling and Productionizing our Retrieval Agent"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c8fb79ab-d623-4d11-bdff-70af141cf16b",
+   "metadata": {},
+   "source": [
+    "Once your graph is populated, you need a mechanism to answer multi-hop queries at scale. This requires:\n",
+    "\n",
+    "<ol style=\"margin-left: 1em; line-height: 1.6; padding-left: 0.5em;\">\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Agent Architecture</strong><br />\n",
+    "    <ul style=\"margin-top: 0.5em; margin-bottom: 0.5em; padding-left: 1.2em;\">\n",
+    "      <li><strong>Controller Agent (Frontend)</strong>: Receives a user question (e.g., “What events led to Acme Corp.’s IPO?”), then decomposes it into sub-questions or traversal steps.</li>\n",
+    "      <li><strong>Traversal Worker Agents</strong>: Each worker can perform a local graph traversal (e.g., “Find all facts where Acme Corp. has EventType = Acquisition between 2020–2025”), possibly in parallel on different partitions of the graph.</li>\n",
+    "    </ul>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Parallel Subgraph Extraction</strong><br />\n",
+    "    <ul style=\"margin-top: 0.5em; margin-bottom: 0.5em; padding-left: 1.2em;\">\n",
+    "      <li>Partition the graph by entity ID hash (e.g., modulo 16). For a given query, identify which partitions are likely to contain relevant edges, then dispatch traversal tasks in parallel to each worker.</li>\n",
+    "      <li>Workers return partial subgraphs (nodes + edges), and the Controller Agent merges them.</li>\n",
+    "    </ul>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Chained LLM Reasoning</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      For multi-hop questions, the Controller can prompt a model (e.g., GPT-4.1) with the partial subgraph and ask “Which next edge should I traverse?” This allows dynamic, context-aware traversal rather than blind breadth-first search.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Caching and Memoization</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      For frequently asked queries or subgraph patterns, cache the results (e.g., in Redis or a Postgres Materialized View) with a TTL equal to the fact’s <code>valid_to</code> date, so that subsequent requests hit the cache instead of re-traversing.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Load Balancing &amp; Autoscaling</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Deploy the Traversal Worker Agents in a Kubernetes cluster with Horizontal Pod Autoscalers. Use CPU and memory metrics (and average queue length) to scale out during peak usage.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "</ol>\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "28442f85-dfe6-444b-8e19-a9c84e1b23d5",
+   "metadata": {},
+   "source": [
+    "### A.6. Safeguards"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "21583d8e-06e1-4e56-a304-0bf2a4095dc0",
+   "metadata": {},
+   "source": [
+    "#### A.6.1 Multi-Layered Output Verification"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "40f741a4-ff66-4e2d-a3bc-db6ef1f04a26",
+   "metadata": {},
+   "source": [
+    "Run a lightweight validation pipeline to ensure outputs are as desired. Some examples of what can be included in this:\n",
+    "* Check that dates conform to `ISO-8601`\n",
+    "* Verify that entity types match your controlled vocabulary (e.g., if the model outputs an unexpected label, flag for manual review)\n",
+    "* Deploy a \"sanity-check\" function call to a smaller, cheaper model to verify the consistency of outputs (for example, “Does this statement parse correctly as a Fact? Yes/No.”)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1ebdc4fd-bba2-49d2-9e58-18a79c7af467",
+   "metadata": {},
+   "source": [
+    "#### A.6.2. Audit Logging & Monitoring"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5157ecd3-67af-485b-9d0a-a86f5d51d110",
+   "metadata": {},
+   "source": [
+    "- Implement structured logging with configurable verbosity levels (e.g., debug, info, warn, error)\n",
+    "- Store input pre-processing steps, intermediate outputs, and final results with full tracing, such as that offered via [OpenAI's tracing](https://platform.openai.com/traces)\n",
+    "- Track token throughput, latency, and error rates\n",
+    "- Monitor data quality metrics where possible, such as document or statement coverage, temporal resolution rates, and more\n",
+    "- Measure business-related metrics such as user numbers, average message volume, and user satisfaction"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b65f7222-cf56-4b35-a052-a5bf0ab99984",
+   "metadata": {},
+   "source": [
+    "### A.7. Prompt Optimization"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f0dc981e-2a27-4ebe-8917-8eebf725f344",
+   "metadata": {},
+   "source": [
+    "<ol style=\"margin-left: 1em; line-height: 1.6; padding-left: 0.5em;\">\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Personas</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Introducing a persona to the model is an effective way to drive performance. Once you have narrowed down the specialism of the component you are developing the prompt for, you can create a persona in the system prompt that helps to shape the model's behaviour. We used this in our planner model to create a system prompt like this:\n",
+    "    </p>\n",
+    "    <pre style=\"margin-top: 0.5em; margin-bottom: 0.5em; background-color: #f5f5f5; padding: 0.75em; border-radius: 5px;\"><code>initial_planner_system_prompt = (\n",
+    "    \"You work for the leading financial firm, ABC Incorporated, one of the largest financial firms in the world. \"\n",
+    "    \"Due to your long and esteemed tenure at the firm, various equity research teams will often come to you \"\n",
+    "    \"for guidance on research tasks they are performing. Your expertise is particularly strong in the area of \"\n",
+    "    \"ABC Incorporated's proprietary knowledge base of earnings call transcripts. This contains details that have been \"\n",
+    "    \"extracted from the earnings call transcripts of various companies with labelling for when these statements are, or \"\n",
+    "    \"were, valid. You are an expert at providing instructions to teams on how to use this knowledge graph to answer \"\n",
+    "    \"their research queries. \\n\"\n",
+    ")</code></pre>\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Persona prompts can become much more developed and specific than this, but this should provide an insight into what this looks like in practice.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Few-Shot Prompting and Chain-of-Thought</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      For extraction-related tasks, such as statement extraction, a concise few-shot prompt (2–5 examples) will typically deliver higher precision than a zero-shot prompt at a marginal increase in cost.\n",
+    "    </p>\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      For e.g., temporal reconciliation tasks, chain-of-thought methods where you guide the model through comparison logic are more appropriate. This can look like:\n",
+    "    </p>\n",
+    "    <pre style=\"margin-top: 0.5em; margin-bottom: 0.5em; background-color: #f5f5f5; padding: 0.75em; border-radius: 5px;\"><code>Example 1: [Old fact], [New fact] → Invalidate\n",
+    "Example 2: [Old fact], [New fact] → Coexist\n",
+    "Now: [Old fact], [New fact] →</code></pre>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Dynamic Prompting &amp; Context Management</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      You can also lean on other LLMs or more structured methods to prune and prepare material that will be dynamically passed to prompts. We saw an example of this when building the tools for our retriever above, where the <code>timeline_generation</code> tool sorts the retrieved material before passing it back to the central orchestrator.\n",
+    "    </p>\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Steps to clean up the context or compress it mid-run can also be highly effective for longer-running queries.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "\n",
+    "  <li style=\"margin-bottom: 1.2em;\">\n",
+    "    <strong>Template Library &amp; A/B Testing</strong><br />\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Maintain a set of prompt templates in a version-controlled directory (e.g., <code>prompts/statement_extraction.json</code>, <code>prompts/entity_extraction.json</code>) to enable you to audit past changes and revert if necessary. You can utilize OpenAI's reusuable prompts for this. In the OpenAI dashboard, you can develop <a href=\"https://platform.openai.com/docs/guides/text#reusable-prompts\">reusable prompts</a> to use in API requests. This enables you to build and evaluate your prompts, deploying updated and improved versions without ever changing the code.\n",
+    "    </p>\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Automate A/B testing by periodically sampling extracted facts from the pipeline, re-running them through alternative prompts, and comparing performance scores (you can track this in a separate evaluation harness).\n",
+    "    </p>\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      Track key performance indicators (KPIs) such as extraction latency, error rates, and invalidation accuracy.\n",
+    "    </p>\n",
+    "    <p style=\"margin-top: 0.5em; margin-bottom: 0.5em;\">\n",
+    "      If any metric drifts beyond a threshold (e.g., invalidation accuracy drops below 90%), trigger an alert and roll back to a previous prompt version.\n",
+    "    </p>\n",
+    "  </li>\n",
+    "</ol>\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_0.pkl b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_0.pkl
new file mode 100644
index 0000000000..ec45c96265
Binary files /dev/null and b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_0.pkl differ
diff --git a/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_1.pkl b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_1.pkl
new file mode 100644
index 0000000000..81ae4965d4
Binary files /dev/null and b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_1.pkl differ
diff --git a/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_10.pkl b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_10.pkl
new file mode 100644
index 0000000000..db914779ed
Binary files /dev/null and b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_10.pkl differ
diff --git a/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_11.pkl b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_11.pkl
new file mode 100644
index 0000000000..653e08879f
Binary files /dev/null and b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_11.pkl differ
diff --git a/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_12.pkl b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_12.pkl
new file mode 100644
index 0000000000..04a4edad06
Binary files /dev/null and b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_12.pkl differ
diff --git a/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_13.pkl b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_13.pkl
new file mode 100644
index 0000000000..cb3cd27f44
Binary files /dev/null and b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_13.pkl differ
diff --git a/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_14.pkl b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_14.pkl
new file mode 100644
index 0000000000..92d5e2d38b
Binary files /dev/null and b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_14.pkl differ
diff --git a/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_15.pkl b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_15.pkl
new file mode 100644
index 0000000000..0a6785e86b
Binary files /dev/null and b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_15.pkl differ
diff --git a/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_16.pkl b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_16.pkl
new file mode 100644
index 0000000000..2deddeb338
Binary files /dev/null and b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_16.pkl differ
diff --git a/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_17.pkl b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_17.pkl
new file mode 100644
index 0000000000..27cd23117a
Binary files /dev/null and b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_17.pkl differ
diff --git a/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_18.pkl b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_18.pkl
new file mode 100644
index 0000000000..07238dbac9
Binary files /dev/null and b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_18.pkl differ
diff --git a/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_19.pkl b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_19.pkl
new file mode 100644
index 0000000000..d0bdb14241
Binary files /dev/null and b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_19.pkl differ
diff --git a/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_2.pkl b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_2.pkl
new file mode 100644
index 0000000000..d1419389a0
Binary files /dev/null and b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_2.pkl differ
diff --git a/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_20.pkl b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_20.pkl
new file mode 100644
index 0000000000..75b227b5c9
Binary files /dev/null and b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_20.pkl differ
diff --git a/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_21.pkl b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_21.pkl
new file mode 100644
index 0000000000..e5343f80f2
Binary files /dev/null and b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_21.pkl differ
diff --git a/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_22.pkl b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_22.pkl
new file mode 100644
index 0000000000..0b11f748cd
Binary files /dev/null and b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_22.pkl differ
diff --git a/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_23.pkl b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_23.pkl
new file mode 100644
index 0000000000..06655de06d
Binary files /dev/null and b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_23.pkl differ
diff --git a/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_24.pkl b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_24.pkl
new file mode 100644
index 0000000000..3da6afaded
Binary files /dev/null and b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_24.pkl differ
diff --git a/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_25.pkl b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_25.pkl
new file mode 100644
index 0000000000..3eda605459
Binary files /dev/null and b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_25.pkl differ
diff --git a/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_26.pkl b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_26.pkl
new file mode 100644
index 0000000000..969afc54b6
Binary files /dev/null and b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_26.pkl differ
diff --git a/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_27.pkl b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_27.pkl
new file mode 100644
index 0000000000..49f09c1bf1
Binary files /dev/null and b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_27.pkl differ
diff --git a/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_28.pkl b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_28.pkl
new file mode 100644
index 0000000000..d9a025531a
Binary files /dev/null and b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_28.pkl differ
diff --git a/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_29.pkl b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_29.pkl
new file mode 100644
index 0000000000..52c1a35438
Binary files /dev/null and b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_29.pkl differ
diff --git a/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_3.pkl b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_3.pkl
new file mode 100644
index 0000000000..f003305eb1
Binary files /dev/null and b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_3.pkl differ
diff --git a/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_30.pkl b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_30.pkl
new file mode 100644
index 0000000000..7306a6fdee
Binary files /dev/null and b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_30.pkl differ
diff --git a/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_31.pkl b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_31.pkl
new file mode 100644
index 0000000000..0ec0e243a9
Binary files /dev/null and b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_31.pkl differ
diff --git a/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_32.pkl b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_32.pkl
new file mode 100644
index 0000000000..d003a45c86
Binary files /dev/null and b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_32.pkl differ
diff --git a/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_4.pkl b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_4.pkl
new file mode 100644
index 0000000000..7b842afb64
Binary files /dev/null and b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_4.pkl differ
diff --git a/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_5.pkl b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_5.pkl
new file mode 100644
index 0000000000..7d4ae96b34
Binary files /dev/null and b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_5.pkl differ
diff --git a/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_6.pkl b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_6.pkl
new file mode 100644
index 0000000000..65e9bb6c67
Binary files /dev/null and b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_6.pkl differ
diff --git a/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_7.pkl b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_7.pkl
new file mode 100644
index 0000000000..73601b0b2e
Binary files /dev/null and b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_7.pkl differ
diff --git a/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_8.pkl b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_8.pkl
new file mode 100644
index 0000000000..e53a277da5
Binary files /dev/null and b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_8.pkl differ
diff --git a/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_9.pkl b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_9.pkl
new file mode 100644
index 0000000000..b66c40e3da
Binary files /dev/null and b/examples/partners/temporal_agents_with_knowledge_graphs/transcripts/transcript_9.pkl differ
diff --git a/examples/partners/temporal_agents_with_knowledge_graphs/utils.py b/examples/partners/temporal_agents_with_knowledge_graphs/utils.py
new file mode 100644
index 0000000000..fa879da301
--- /dev/null
+++ b/examples/partners/temporal_agents_with_knowledge_graphs/utils.py
@@ -0,0 +1,47 @@
+import re
+from datetime import UTC, datetime
+
+from dateutil.parser import parse
+
+
+def parse_date_str(value: str | datetime | None) -> datetime | None:
+    """Parse a date string into a datetime object.
+
+    If the value is a 4-digit year, it returns January 1 of that year in UTC.
+    Otherwise, it attempts to parse the date string using dateutil.parser.parse.
+    If the resulting datetime has no timezone, it defaults to UTC.
+    """
+    if not value:
+        return None
+
+    if isinstance(value, datetime):
+        return value
+
+    try:
+        # Year Handling
+        if re.fullmatch(r"\d{4}", value.strip()):
+            year = int(value.strip())
+            return datetime(year, 1, 1, tzinfo=UTC)
+
+        #  General Handing
+        dt: datetime = parse(value)
+        if dt.tzinfo is None:
+            dt = dt.replace(tzinfo=UTC)
+        return dt
+
+    except Exception:
+        return None
+
+
+def safe_iso(dt: datetime | None) -> str | None:
+    """Return the ISO format of a datetime object.
+
+    If the datetime is None, it returns None.
+    """
+    if isinstance(dt, str):
+        dt = parse_date_str(dt)
+
+    if isinstance(dt, datetime):
+        return dt.isoformat()
+
+    return None
diff --git a/images/01_benefit_of_temporal_kb.jpg b/images/01_benefit_of_temporal_kb.jpg
new file mode 100644
index 0000000000..aeb10bb27e
Binary files /dev/null and b/images/01_benefit_of_temporal_kb.jpg differ
diff --git a/images/02_question_types_for_temporal_kbs.jpg b/images/02_question_types_for_temporal_kbs.jpg
new file mode 100644
index 0000000000..9f1c4b1e6d
Binary files /dev/null and b/images/02_question_types_for_temporal_kbs.jpg differ
diff --git a/images/03_statement_invalidation.png b/images/03_statement_invalidation.png
new file mode 100644
index 0000000000..ba0bc0ebd3
Binary files /dev/null and b/images/03_statement_invalidation.png differ
diff --git a/images/04_temporal_agent.png b/images/04_temporal_agent.png
new file mode 100644
index 0000000000..8f8c68a3a0
Binary files /dev/null and b/images/04_temporal_agent.png differ
diff --git a/images/05_temporal_agent_arch.png b/images/05_temporal_agent_arch.png
new file mode 100644
index 0000000000..a8840ea538
Binary files /dev/null and b/images/05_temporal_agent_arch.png differ
diff --git a/images/06_temporal_agent_chunker.png b/images/06_temporal_agent_chunker.png
new file mode 100644
index 0000000000..f1322e61f0
Binary files /dev/null and b/images/06_temporal_agent_chunker.png differ
diff --git a/images/07_temporal_agent_class.png b/images/07_temporal_agent_class.png
new file mode 100644
index 0000000000..07edbcdfe6
Binary files /dev/null and b/images/07_temporal_agent_class.png differ
diff --git a/images/08_invalidation_agent.png b/images/08_invalidation_agent.png
new file mode 100644
index 0000000000..fed7b299b5
Binary files /dev/null and b/images/08_invalidation_agent.png differ
diff --git a/images/09_full_pipeline.png b/images/09_full_pipeline.png
new file mode 100644
index 0000000000..6eff3ef2e9
Binary files /dev/null and b/images/09_full_pipeline.png differ
diff --git a/images/10_multi_step_retrieval.png b/images/10_multi_step_retrieval.png
new file mode 100644
index 0000000000..5ac38e332e
Binary files /dev/null and b/images/10_multi_step_retrieval.png differ
diff --git a/images/11_retrieval_agent.png b/images/11_retrieval_agent.png
new file mode 100644
index 0000000000..99126f6255
Binary files /dev/null and b/images/11_retrieval_agent.png differ
diff --git a/images/12_spectrum_of_tools.png b/images/12_spectrum_of_tools.png
new file mode 100644
index 0000000000..af73cb5c73
Binary files /dev/null and b/images/12_spectrum_of_tools.png differ
diff --git a/images/image_optimize_1.png b/images/image_optimize_1.png
new file mode 100644
index 0000000000..3bd7e46b0e
Binary files /dev/null and b/images/image_optimize_1.png differ
diff --git a/images/image_optimize_2.png b/images/image_optimize_2.png
new file mode 100644
index 0000000000..799fd4ef75
Binary files /dev/null and b/images/image_optimize_2.png differ
diff --git a/images/image_optimize_3.png b/images/image_optimize_3.png
new file mode 100644
index 0000000000..c504872864
Binary files /dev/null and b/images/image_optimize_3.png differ
diff --git a/images/image_optimize_4.png b/images/image_optimize_4.png
new file mode 100644
index 0000000000..8087da16cc
Binary files /dev/null and b/images/image_optimize_4.png differ
diff --git a/images/image_optimize_5.png b/images/image_optimize_5.png
new file mode 100644
index 0000000000..a2921d6b8f
Binary files /dev/null and b/images/image_optimize_5.png differ
diff --git a/images/image_optimize_landing.png b/images/image_optimize_landing.png
new file mode 100644
index 0000000000..21e94b2b2a
Binary files /dev/null and b/images/image_optimize_landing.png differ
diff --git a/images/image_optimize_landing_2.png b/images/image_optimize_landing_2.png
new file mode 100644
index 0000000000..aa3bbc7012
Binary files /dev/null and b/images/image_optimize_landing_2.png differ
diff --git a/images/input_image.png b/images/input_image.png
new file mode 100644
index 0000000000..9bc8d56313
Binary files /dev/null and b/images/input_image.png differ
diff --git a/images/login_page.png b/images/login_page.png
new file mode 100644
index 0000000000..0a0f3a1ea2
Binary files /dev/null and b/images/login_page.png differ
diff --git a/images/retro_dark.png b/images/retro_dark.png
new file mode 100644
index 0000000000..4e0af333b1
Binary files /dev/null and b/images/retro_dark.png differ
diff --git a/images/retro_light.png b/images/retro_light.png
new file mode 100644
index 0000000000..d0cf98a9d1
Binary files /dev/null and b/images/retro_light.png differ
diff --git a/images/snake_game.png b/images/snake_game.png
new file mode 100644
index 0000000000..2ff944d260
Binary files /dev/null and b/images/snake_game.png differ
diff --git a/registry.yaml b/registry.yaml
index 78e521ee57..278c35de00 100644
--- a/registry.yaml
+++ b/registry.yaml
@@ -4,15 +4,168 @@
 # should build pages for, and indicates metadata such as tags, creation date and
 # authors for each page.
 
+- title: Verifying gpt-oss implementations
+  path: articles/gpt-oss/verifying-implementations.md
+  date: 2025-08-11
+  authors:
+    - dkundel-openai
+  tags:
+    - gpt-oss
+    - open-models
+
+- title: How to run gpt-oss locally with LM Studio
+  path: articles/gpt-oss/run-locally-lmstudio.md
+  date: 2025-08-07
+  authors:
+    - yagil
+  tags:
+    - gpt-oss
+    - open-models
+- title: GPT-5 Prompt Migration and Improvement Using the New Optimizer
+  path: examples/gpt-5/prompt-optimization-cookbook.ipynb
+  date: 2025-08-07
+  authors:
+    - rajpathak-openai
+    - corwin
+  tags:
+    - gpt-5
+    - responses
+    - reasoning
+    - prompt-optimization
+
+- title: GPT-5 prompting guide
+  path: examples/gpt-5/gpt-5_prompting_guide.ipynb
+  date: 2025-08-07
+  authors:
+    - anoop-openai
+    - julian-openai
+    - ericzakariasson
+    - erinkav-openai
+  tags:
+    - gpt-5
+    - responses
+    - reasoning
+
+- title: Frontend coding with GPT-5
+  path: examples/gpt-5/gpt-5_frontend.ipynb
+  date: 2025-08-07
+  authors:
+    - WJPBProjects
+    - anoop-openai
+  tags:
+    - gpt-5
+    - responses
+    - reasoning
+
+- title: GPT-5 New Params and Tools
+  path: examples/gpt-5/gpt-5_new_params_and_tools.ipynb
+  date: 2025-08-07
+  authors:
+    - msingh-openai
+  tags:
+    - gpt-5
+    - functions
+    - reasoning
+
+- title: How to run gpt-oss-20b on Google Colab
+  path: articles/gpt-oss/run-colab.ipynb
+  date: 2025-08-06
+  authors:
+    - pcuenca
+    - Vaibhavs10
+  tags:
+    - gpt-oss
+    - open-models
+
+- title: Using NVIDIA TensorRT-LLM to run gpt-oss-20b
+  path: articles/run-nvidia.ipynb
+  date: 2025-08-05
+  authors:
+    - jayrodge
+  tags:
+    - gpt-oss
+    - open-models
+
+- title: Fine-tuning with gpt-oss and Hugging Face Transformers
+  path: articles/gpt-oss/fine-tune-transfomers.ipynb
+  date: 2025-08-05
+  authors:
+    - edbeeching
+    - qgallouedec
+    - lewtun
+  tags:
+    - open-models
+    - gpt-oss
+
+- title: How to handle the raw chain of thought in gpt-oss
+  path: articles/gpt-oss/handle-raw-cot.md
+  date: 2025-08-05
+  authors:
+    - dkundel-openai
+  tags:
+    - open-models
+    - gpt-oss
+
+- title: How to run gpt-oss with Transformers
+  path: articles/gpt-oss/run-transformers.md
+  date: 2025-08-05
+  authors:
+    - dkundel-openai
+  tags:
+    - open-models
+    - gpt-oss
+
+- title: How to run gpt-oss with vLLM
+  path: articles/gpt-oss/run-vllm.md
+  date: 2025-08-05
+  authors:
+    - dkundel-openai
+  tags:
+    - open-models
+    - gpt-oss
+
+- title: How to run gpt-oss locally with Ollama
+  path: articles/gpt-oss/run-locally-ollama.md
+  date: 2025-08-05
+  authors:
+    - dkundel-openai
+  tags:
+    - open-models
+    - gpt-oss
+
+- title: OpenAI Harmony Response Format
+  path: articles/openai-harmony.md
+  date: 2025-08-05
+  authors:
+    - dkundel-openai
+  tags:
+    - open-models
+    - gpt-oss
+    - harmony
+
+- title: Temporal Agents with Knowledge Graphs
+  path: examples/partners/temporal_agents_with_knowledge_graphs/temporal_agents_with_knowledge_graphs.ipynb
+  date: 2025-07-22
+  authors:
+    - dwigg-openai
+    - shikhar-cyber
+    - Alex Heald
+    - Douglas Adams
+    - Rishabh Sagar
+  tags:
+    - knowledge-graphs
+    - retrieval
+    - functions
+    - responses
+
 - title: Using Evals API on Image Inputs
   path: examples/evaluation/use-cases/EvalsAPI_Image_Inputs.ipynb
   date: 2025-07-15
   authors:
     - daisyshe-oai
   tags:
-    - evals-api
-    - images
     - evals
+    - images
 
 - title: Optimize Prompts
   path: examples/Optimize_Prompts.ipynb
@@ -211,7 +364,7 @@
   authors:
     - josiah-openai
   tags:
-    - evals-api
+    - evals
     - completions
 
 - title: Evals API Use-case - Bulk model and prompt experimentation
@@ -220,7 +373,7 @@
   authors:
     - josiah-openai
   tags:
-    - evals-api
+    - evals
     - completions
 
 - title: Evals API Use-case - Monitoring stored completions
@@ -229,7 +382,7 @@
   authors:
     - josiah-openai
   tags:
-    - evals-api
+    - evals
     - completions
 
 - title: Evals API Use-case - Responses Evaluation
@@ -238,7 +391,7 @@
   authors:
     - willhath-openai
   tags:
-    - evals-api
+    - evals
     - responses
 
 - title: Multi-Tool Orchestration with RAG approach using OpenAI's Responses API
@@ -2290,7 +2443,7 @@
 
 - title: Generate images with high input fidelity
   path: examples/Generate_Images_With_High_Input_Fidelity.ipynb
-  date: 2025-07-16
+  date: 2025-07-17
   authors:
     - katiagg
   tags:
