Update app.py

app.py

@@ -86,24 +86,43 @@ with gr.Blocks() as demo:
     gr.Markdown("""
     # 🧠 Optical Thin-Film Stack AI Agent with Multiple Tool Calls
 
-    This interactive demo showcases an **AI agent that coordinates multiple tool calls** to solve an inverse optics problem.
-    It repeatedly invokes a **physics-based simulator (RCWA)** and a **spectrum comparison tool** to recover the correct material stack.
+    This interactive demo showcases an **AI agent that coordinates multiple tool calls** to solve an inverse optics problem.  
+    Rather than relying on a single inference, the agent repeatedly invokes a **physics-based simulator (RCWA)** and a **spectrum comparison function** to iteratively search for the correct material ordering in a thin-film stack.  
+    It dynamically explores options, evaluates feedback, and stops only when a verifiably accurate match is found.
+
+    ### 🤖 Objective: Reverse-engineer a 4-layer thin-film stack  
+    Given only a target transmission spectrum, the agent must find the **correct material order** that would reproduce it.
+    **Constraints:**  
+    - Materials: `Si`, `Si₃N₄`, `SiO₂`, `AlN` (used once each)  
+    - Terminate when `cosine_similarity > 0.999`
+
+    ## 🔍 What's Happening Under the Hood
+
+    1. A **random 4-layer stack** is generated from a predefined material set (`Si`, `Si₃N₄`, `SiO₂`, `AlN`), with each layer set to 100nm.
+    2. Its **optical transmission spectrum** is computed using **RCWA (Rigorous Coupled-Wave Analysis)** — a high-fidelity physics simulator.
+    3. This target spectrum is handed to an AI **CodeAgent**, powered by GPT-4.1-mini, along with access to callable tools.
+    4. The agent dynamically explores candidate layer permutations by invoking `simulate_spectrum(...)` to generate spectra, and `cosine_similarity(...)` to compare them to the target.
+    5. It loops over permutations, choosing what to simulate next based on feedback — and stops automatically when similarity exceeds a threshold (e.g., `> 0.999`).
+    6. The final output includes the matched material order, a reasoning trace, and optionally a spectrum comparison plot.    
     """)
-
-    gr.Markdown("### 📊 Transmission Spectra of Layer Stack Designs")
+    
+    gr.Markdown("### 📊 Transmission Spectra of Layer Stack Designs for all 24 permutations of material order")
     gr.Image(value="121_resized.png", interactive=False)
-
     gr.Markdown("""
-    ### 🛠️ Tools Available
+
+    ### 🛠️ Tools available to the Agent: 
 
     | Tool               | Description                                | Arguments                              |
     |--------------------|--------------------------------------------|-----------------------------------------|
     | `simulate_spectrum`| Simulates optical spectrum                 | `layer_order`: List of materials        |
     | `cosine_similarity`| Compares predicted vs target spectra       | `vec1`, `vec2`: Lists of floats         |
     | `final_answer`     | Emits final result with justification      | `answer`: any                           |
+
+    > 🧪 This is not a single tool call to the Physics Solver (RCWA) — the agent uses simulation as feedback to drive tool selection and termination.
     """)
 
-    gr.Markdown("### 🧪 Agent Interface")
+
+    gr.Markdown("# 🧪 Optical Spectrum Matching Agent (Streaming UI Style)")
     run_btn = gr.Button("🔁 Run Agent on Random Stack")
     true_order = gr.Textbox(label="True Material Order")
     prompt_box = gr.Textbox(label="Agent Prompt")
@@ -120,8 +139,8 @@ with gr.Blocks() as demo:
             return
 
         prompt = f"""You are an AI agent that uses tools to simulate optical spectra and compare them to a target spectrum.
-Use simulate_spectrum(...) to simulate and cosine_similarity(...) to compare.
-Find a 4-layer permutation from [Si, Si3N4, SiO2, AlN]. Use each material once.
+You must find a 4-layer permutation from this list: [Si, Si3N4, SiO2, AlN]. Use each material only once.
+Use simulate_spectrum(order, thicknesses) to simulate and cosine_similarity(predicted, target) to compare.
 Stop when similarity > 0.999. Report number of permutations tried.
 Target spectrum: {target_val}
 """