Committee

arXiv:2603.02081v1 Announce Type: cross Abstract: Traditional query processing relies on engines that are carefully optimized and engineered by many experts. However, new techniques and user requirements evolve rapidly, and existing systems often cannot keep pace. At the same time, these systems are difficult to extend due to their internal complexity, and developing new systems requires substantial engineering effort and cost. In this paper, we argue that recent advances in Large Language Models (LLMs) are starting to shape the next generation of query processing systems. We propose using LLMs to synthesize execution code for each incoming query, instead of continuously building, extending, and maintaining complex query processing engines. As a proof of concept, we present GenDB, an LLM-powered agentic system that generates instance-optimized and customized query execution code tailored to specific data, workloads, and hardware resources. We implemented an early prototype of GenDB that uses Claude Code Agent as the underlying component in the multi-agent system, and we evaluate it on OLAP workloads. We use queries from the well-known TPC-H benchmark and also construct a new benchmark designed to reduce potential data leakage from LLM training data. We compare GenDB with state-of-the-art query engines, including DuckDB, Umbra, MonetDB, ClickHouse, and PostgreSQL. GenDB achieves significantly better performance than these systems. Finally, we discuss the current limitations of GenDB and outline future extensions and related research challenges.

arXiv:2602.23388v1 Announce Type: new Abstract: The rising demand for inclusive speech technologies amplifies the need for multilingual datasets for Natural Language Processing (NLP) research. However, limited awareness of existing task-specific resources in low-resource languages hinders research. This challenge is especially acute in linguistically diverse countries, such as India. Cross-task profiling of existing Indian speech datasets can alleviate the data scarcity challenge. This involves investigating the utility of datasets across multiple downstream tasks rather than focusing on a single task. Prior surveys typically catalogue datasets for a single task, leaving comprehensive cross-task profiling as an open opportunity. Therefore, we propose Task-Lens, a cross-task survey that assesses the readiness of 50 Indian speech datasets spanning 26 languages for nine downstream speech tasks. First, we analyze which datasets contain metadata and properties suitable for specific tasks. Next, we propose task-aligned enhancements to unlock datasets to their full downstream potential. Finally, we identify tasks and Indian languages that are critically underserved by current resources. Our findings reveal that many Indian speech datasets contain untapped metadata that can support multiple downstream tasks. By uncovering cross-task linkages and gaps, Task-Lens enables researchers to explore the broader applicability of existing datasets and to prioritize dataset creation for underserved tasks and languages.

Document digitization has long been a multi-stage problem: first detect the layout, then extract the text, and finally try to reconstruct the structure. For Large Vision-Language Models (LVLMs), this often leads to ‘structural hallucinations’—disordered rows, invented formulas, or unclosed syntax. The FireRedTeam has released FireRed-OCR-2B, a flagship model designed to treat document parsing as a structural engineering task rather than ‘impressionist’ text generation. Built on the Qwen3-VL-2B-Instruct architecture, this model establishes a new State-of-the-Art (SOTA) for end-to-end solutions, achieving an overall score of 92.94% on the OmniDocBench v1.5 benchmark. Shifting the Paradigm: Structural Engineering vs. Text Generation Devs often find that even the most powerful general VLMs struggle with the dense spatial logic of a technical PDF. When a model ‘sees’ a complex table or a multi-line LaTeX equation, it frequently fails to maintain the hierarchical relationship between elements. FireRed-OCR-2B addresses this through a specialized Progressive Training Pipeline consisting of three distinct stages: Multi-task Pre-alignment: This stage establishes spatial grounding by training the model on detection, region recognition, and layout-to-markdown tasks. Specialized SFT (Supervised Fine-Tuning): The model is fine-tuned on a high-quality, standardized Markdown dataset to ensure logical consistency and hierarchical expression. Format-Constrained GRPO: The final stage uses reinforcement learning to enforce syntactic validity. The Core Innovation: Format-Constrained GRPO The most significant technical differentiator for FireRed-OCR is its use of Format-Constrained Group Relative Policy Optimization (GRPO). While traditional fine-tuning focuses on character accuracy, GRPO introduces a reinforcement learning loop that rewards the model for specific structural traits: Formula Syntax: Ensuring LaTeX equations are mathematically valid. Table Integrity: Maintaining consistent row/column counts and proper HTML/Markdown tagging. Hierarchical Closure: Verifying that all opened structural tags (like lists or headers) are correctly closed. Text Accuracy: Reducing character-level errors in dense text blocks. By eliminating the need for a separate ‘critic’ model—a key benefit of the GRPO algorithm—FireRedTeam has optimized the training process to focus specifically on the high-friction areas of document parsing. Solving the Long-Tail Layout Problem The ‘long-tail’ of document layouts (e.g., non-standard legal forms, academic papers with overlapping figures, or handwritten annotations) is where most OCR pipelines break. FireRed-OCR utilizes a ‘Geometry + Semantics’ Data Factory. This novel approach uses geometric feature clustering and multi-dimensional tagging to synthesize balanced datasets. By combining geometric awareness with semantic understanding, the model maintains ‘In-the-Wild Robustness,’ outperforming traditional pipeline systems like PaddleOCR on complex, non-standard layouts (benchmarked on the FireRedBench dataset). Performance Benchmarks In head-to-head comparisons on OmniDocBench v1.5, FireRed-OCR-2B (92.94%) significantly outperforms other end-to-end models, including: DeepSeek-OCR 2: 91.09% Gemini-3.0 Pro: 90.33% Qwen3-VL-235B: 89.15% While some ‘pipeline’ solutions (which use separate models for detection and recognition) achieve slightly higher scores, FireRed-OCR-2B represents the leading performance for a single-model, end-to-end approach. This is particularly relevant for devs looking to reduce system complexity and inference latency in production RAG (Retrieval-Augmented Generation) environments. Key Takeaways I have summarized the technical significance and performance metrics of the FireRed-OCR-2B release into five key takeaways for AI engineers and data scientists. 5 Key Takeaways: FireRed-OCR-2B New End-to-End SOTA Performance: FireRed-OCR-2B has achieved a state-of-the-art (SOTA) score of 92.94% on the OmniDocBench v1.5 benchmark. This makes it the leading single-model solution for document parsing, outperforming significantly larger models like Qwen2-VL-72B and Gemini-1.5-Pro in structural accuracy. Architectural Foundation: Built on the Qwen2-VL-2B-Instruct (or the updated 2026 iteration) base, the model utilizes a Vision-Language-Model (VLM) approach. It replaces traditional multi-stage pipelines (separate detection, cropping, and OCR steps) with a unified, end-to-end transformer architecture that outputs structured Markdown directly. Structural Integrity via GRPO: A major technical differentiator is the use of Format-Constrained GRPO (Group Relative Policy Optimization). This reinforcement learning technique rewards the model for maintaining syntactic validity—specifically ensuring that LaTeX formulas, table tags, and Markdown hierarchies are logically closed and mathematically consistent. ‘Geometry + Semantics’ Data Factory: To solve the problem of complex ‘in-the-wild’ layouts, the FireRedTeam developed a specialized data engine. This ‘factory’ synthesizes datasets by balancing geometric layout features with semantic content, enabling the model to handle overlapping figures, multi-column academic papers, and non-standard forms more reliably than previous iterations. Check out the Model Weight and Repo. Also, feel free to follow us on Twitter and don’t forget to join our 120k+ ML SubReddit and Subscribe to our Newsletter. Wait! are you on telegram? now you can join us on telegram as well. The post FireRedTeam Releases FireRed-OCR-2B Utilizing GRPO to Solve Structural Hallucinations in Tables and LaTeX for Software Developers appeared first on MarkTechPost.

In this tutorial, we build an advanced explainable AI analysis pipeline using SHAP-IQ to understand both feature importance and interaction effects directly inside our Python environment. We load a real-world dataset, train a high-performance Random Forest model, and then apply the SHAP-IQ interaction index to compute precise, theoretically grounded explanations of model predictions. We extract main effects, pairwise interaction effects, and decision breakdown contributions, and we present them through structured terminal outputs and interactive Plotly visualizations. Also, we move beyond basic explainability and gain deep insight into how individual features and their interactions influence model decisions at both the local and global levels. Copy CodeCopiedUse a different Browser import sys, subprocess, textwrap, numpy as np, pandas as pd def _pip(*pkgs): subprocess.run([sys.executable, “-m”, “pip”, “install”, “-q”, *pkgs], check=False) _pip(“shapiq”, “plotly”, “pandas”, “numpy”, “scikit-learn”) import plotly.express as px import plotly.graph_objects as go import plotly.io as pio import shapiq from sklearn.ensemble import RandomForestRegressor from sklearn.model_selection import train_test_split try: pio.renderers.default = “colab” except Exception: pass RANDOM_STATE = 42 INDEX = “SII” MAX_ORDER = 2 BUDGET_LOCAL = 512 TOP_K = 10 INSTANCE_I = 24 GLOBAL_ON = True GLOBAL_N = 40 BUDGET_GLOBAL = 256 We install and import all the required libraries, including shapiq, Plotly, pandas, NumPy, and scikit-learn, ensuring our environment is fully prepared for explainable AI analysis. We configure Plotly to render visualizations directly in the notebook or terminal so we can view results without needing any external dashboard. We also define global configuration parameters, such as the interaction index, explanation budget, and global analysis settings, to control the depth, accuracy, and performance of our explainability pipeline. Copy CodeCopiedUse a different Browser def extract_main_effects(iv, feature_names): d = iv.dict_values vals = [float(d.get((i,), 0.0)) for i in range(len(feature_names))] return pd.Series(vals, index=list(feature_names), name=”main_effect”) def extract_pair_matrix(iv, feature_names): d = iv.dict_values n = len(feature_names) M = np.zeros((n, n), dtype=float) for k, v in d.items(): if isinstance(k, tuple) and len(k) == 2: i, j = k M[i, j] = float(v) M[j, i] = float(v) return pd.DataFrame(M, index=list(feature_names), columns=list(feature_names)) def ascii_bar(series, width=28, top_k=10): s = series.abs().sort_values(ascending=False).head(top_k) m = float(s.max()) if len(s) else 1.0 lines = [] for name, val in s.items(): n = int((abs(val) / m) * width) if m > 0 else 0 lines.append(f”{name:>18} | {‘█’*n}{‘ ‘*(width-n)} | {val:+.6f}”) return “n”.join(lines) We implement utility functions that extract the main effects and pairwise interaction effects from the SHAP-IQ InteractionValues object. We convert the raw explanation output into structured Pandas objects, allowing us to analyze feature contributions in a clear, organized manner. We also create an ASCII visualization function that lets us interpret feature importance directly in the terminal without relying on graphical interfaces. Copy CodeCopiedUse a different Browser def plot_local_feature_bar(main_effects, top_k): df = main_effects.abs().sort_values(ascending=False).head(top_k).reset_index() df.columns = [“feature”, “abs_main_effect”] fig = px.bar(df, x=”abs_main_effect”, y=”feature”, orientation=”h”, title=”Local Feature Importance (|Main Effects|)”) fig.update_layout(yaxis={“categoryorder”: “total ascending”}) return fig def plot_local_interaction_heatmap(pair_df, top_features): sub = pair_df.loc[top_features, top_features] fig = px.imshow(sub.values, x=sub.columns, y=sub.index, aspect=”auto”, title=”Local Pairwise Interaction Importance (values)”) return fig def plot_waterfall(baseline, main_effects, top_k): contrib = main_effects.copy() top = contrib.reindex(contrib.abs().sort_values(ascending=False).head(top_k).index) remainder = float(contrib.sum() – top.sum()) labels = [“baseline”] + list(top.index) + ([“others”] if abs(remainder) > 1e-12 else []) + [“prediction”] measures = [“absolute”] + [“relative”] * len(top) + ([“relative”] if abs(remainder) > 1e-12 else []) + [“total”] y = [0.0] + [float(v) for v in top.values] + ([float(remainder)] if abs(remainder) > 1e-12 else []) + [0.0] fig = go.Figure(go.Waterfall(x=labels, y=y, measure=measures, orientation=”v”, connector={“line”: {“width”: 1}})) fig.update_layout(title=”Decision Breakdown (Baseline → Prediction via Main Effects)”, showlegend=False) return fig We use Plotly to visualize feature importance, interaction strength, and decision breakdown. We create a bar chart to visualize feature importance, a heatmap to show pairwise interaction effects, and a waterfall plot to illustrate how individual features contribute to the final prediction. These visualizations allow us to transform raw explainability data into intuitive graphical insights that make model behavior easier to understand. Copy CodeCopiedUse a different Browser def global_summaries(explainer, X_samples, feature_names, budget, seed=123): main_abs = np.zeros(len(feature_names), dtype=float) pair_abs = np.zeros((len(feature_names), len(feature_names)), dtype=float) for t, x in enumerate(X_samples): iv = explainer.explain(x, budget=int(budget), random_state=int(seed + t)) main = extract_main_effects(iv, feature_names).values pair = extract_pair_matrix(iv, feature_names).values main_abs += np.abs(main) pair_abs += np.abs(pair) main_abs /= max(1, len(X_samples)) pair_abs /= max(1, len(X_samples)) main_df = pd.DataFrame({“feature”: feature_names, “mean_abs_main_effect”: main_abs}).sort_values(“mean_abs_main_effect”, ascending=False) pair_df = pd.DataFrame(pair_abs, index=feature_names, columns=feature_names) return main_df, pair_df X, y = shapiq.load_california_housing() feature_names = list(X_train.columns) n_features = len(feature_names) model = RandomForestRegressor( n_estimators=400, max_depth=max(3, n_features), max_features=2/3, max_samples=2/3, random_state=RANDOM_STATE, n_jobs=-1 ) model.fit(X_train.values, y_train.values) explainer = shapiq.TabularExplainer( model=model.predict, data=X_train.values, index=INDEX, max_order=int(MAX_ORDER), ) We define a global explainability function that aggregates feature importance and interaction strength across multiple samples to identify overall model behavior. We load the dataset, split it into training and testing sets, and train a Random Forest model to serve as the predictive system we want to explain. We then initialize the SHAP-IQ explainer, which enables us to compute precise, theoretically grounded explanations for the model’s predictions. Copy CodeCopiedUse a different Browser INSTANCE_I = int(np.clip(INSTANCE_I, 0, len(X_test)-1)) x = X_test.iloc[INSTANCE_I].values y_true = float(y_test.iloc[INSTANCE_I]) pred = float(model.predict([x])[0]) iv = explainer.explain(x, budget=int(BUDGET_LOCAL), random_state=0) baseline = float(getattr(iv, “baseline_value”, 0.0)) main_effects = extract_main_effects(iv, feature_names) pair_df = extract_pair_matrix(iv, feature_names) print(“n” + “=”*90) print(“LOCAL EXPLANATION (single test instance)”) print(“=”*90) print(f”Index={INDEX} | max_order={MAX_ORDER} | budget={BUDGET_LOCAL} | instance={INSTANCE_I}”) print(f”Prediction: {pred:.6f} | True: {y_true:.6f} | Baseline (if available): {baseline:.6f}”) print(“nTop main effects (signed):”) display(main_effects.reindex(main_effects.abs().sort_values(ascending=False).head(TOP_K).index).to_frame()) print(“nASCII view (signed main effects, top-k):”) print(ascii_bar(main_effects, top_k=TOP_K)) print(“nTop pairwise interactions by |value| (local):”) pairs = [] for i in range(n_features): for j in range(i+1, n_features): v = float(pair_df.iat[i, j]) pairs.append((feature_names[i], feature_names[j], v, abs(v))) pairs_df = pd.DataFrame(pairs, columns=[“feature_i”, “feature_j”, “interaction”, “abs_interaction”]).sort_values(“abs_interaction”, ascending=False).head(min(25, len(pairs))) display(pairs_df) fig1 = plot_local_feature_bar(main_effects, TOP_K) fig2 = plot_local_interaction_heatmap(pair_df, list(main_effects.abs().sort_values(ascending=False).head(TOP_K).index)) fig3 = plot_waterfall(baseline, main_effects, TOP_K) fig1.show() fig2.show() fig3.show() if GLOBAL_ON: print(“n” + “=”*90) print(“GLOBAL SUMMARIES (sampled over multiple test points)”) print(“=”*90) GLOBAL_N = int(np.clip(GLOBAL_N, 5, len(X_test))) sample = X_test.sample(n=GLOBAL_N, random_state=1).values global_main, global_pair = global_summaries( explainer=explainer, X_samples=sample, feature_names=feature_names, budget=int(BUDGET_GLOBAL), seed=123, ) print(f”Samples={GLOBAL_N} | budget/sample={BUDGET_GLOBAL}”) print(“nGlobal feature importance (mean |main effect|):”) display(global_main.head(TOP_K)) top_feats_global = list(global_main[“feature”].head(TOP_K).values) sub = global_pair.loc[top_feats_global, top_feats_global] figg1 = px.bar(global_main.head(TOP_K), x=”mean_abs_main_effect”, y=”feature”, orientation=”h”, title=”Global Feature Importance (mean |main effect|, sampled)”) figg1.update_layout(yaxis={“categoryorder”: “total ascending”}) figg2 = px.imshow(sub.values, x=sub.columns, y=sub.index, aspect=”auto”, title=”Global Pairwise

arXiv:2512.13352v3 Announce Type: replace-cross Abstract: Large Language Models (LLMs) are prone to memorizing training data, which poses serious privacy risks. Two of the most prominent concerns are training data extraction and Membership Inference Attacks (MIAs). Prior research has shown that these threats are interconnected: adversaries can extract training data from an LLM by querying the model to generate a large volume of text and subsequently applying MIAs to verify whether a particular data point was included in the training set. In this study, we integrate multiple MIA techniques into the data extraction pipeline to systematically benchmark their effectiveness. We then compare their performance in this integrated setting against results from conventional MIA benchmarks, allowing us to evaluate their practical utility in real-world extraction scenarios.

arXiv:2602.00477v2 Announce Type: replace Abstract: Large Language Models (LLMs) have achieved impressive capabilities in various context-based text generation tasks, such as summarization and reasoning; however, their applications in intention-based generation tasks remain underexplored. One such example is revision generation, which requires the generated text to explicitly reflect the writer’s actual intentions. Identifying intentions and generating desirable revisions are challenging due to their complex and diverse nature. Although prior work has employed LLMs to generate revisions with few-shot learning, they struggle with handling entangled multi-intent scenarios. While fine-tuning LLMs using intention-based instructions appears promising, it demands large amounts of annotated data, which is expensive and scarce in the revision community. To address these challenges, we propose Intention-Tuning, an intention-adaptive layer-wise LLM fine-tuning framework that dynamically selects a subset of LLM layers to learn the intentions and subsequently transfers their representations to revision generation. Experimental results suggest that Intention-Tuning is effective and efficient on small revision corpora, outperforming several PEFT baselines.

In this tutorial, we build a hierarchical planner agent using an open-source instruct model. We design a structured multi-agent architecture comprising a planner agent, an executor agent, and an aggregator agent, where each component plays a specialized role in solving complex tasks. We use the planner agent to decompose high-level goals into actionable steps, the executor agent to execute those steps using reasoning or Python tool execution, and the aggregator agent to synthesize results into a coherent final response. By integrating tool usage, structured planning, and iterative execution, we create a fully autonomous agent system that demonstrates how modern AI agents reason, plan, and act in a scalable and modular manner. Copy CodeCopiedUse a different Browser !pip -q install -U transformers accelerate bitsandbytes sentencepiece import json import re import io import contextlib from dataclasses import dataclass from typing import Any, Dict, List, Optional import torch from transformers import AutoTokenizer, AutoModelForCausalLM MODEL_ID = “Qwen/Qwen2.5-1.5B-Instruct” DEVICE = “cuda” if torch.cuda.is_available() else “cpu” print(“Device:”, DEVICE) tokenizer = AutoTokenizer.from_pretrained(MODEL_ID, use_fast=True) model = None if DEVICE == “cuda”: try: model = AutoModelForCausalLM.from_pretrained( MODEL_ID, device_map=”auto”, torch_dtype=”auto”, load_in_4bit=True, ) print(“Loaded model in 4-bit.”) except Exception as e: print(“4-bit load failed, falling back to normal load:”, str(e)[:200]) model = AutoModelForCausalLM.from_pretrained( MODEL_ID, device_map=”auto”, torch_dtype=”auto”, ) else: model = AutoModelForCausalLM.from_pretrained( MODEL_ID, torch_dtype=torch.float32, ).to(DEVICE) model.eval() We install the required libraries and import all the modules necessary to build our hierarchical agent system. We load the open-source Qwen instruct model and configure it to run efficiently on a GPU using 4-bit quantization when available. We initialize the tokenizer and model, ensuring that our agent has the language understanding and reasoning capabilities needed to plan and execute tasks. Copy CodeCopiedUse a different Browser def llm_chat(system: str, user: str, max_new_tokens: int = 500, temperature: float = 0.3) -> str: messages = [ {“role”: “system”, “content”: system.strip()}, {“role”: “user”, “content”: user.strip()}, ] prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True) inputs = tokenizer(prompt, return_tensors=”pt”).to(model.device) with torch.no_grad(): out = model.generate( **inputs, max_new_tokens=max_new_tokens, do_sample=True if temperature > 0 else False, temperature=temperature, top_p=0.9, repetition_penalty=1.05, eos_token_id=tokenizer.eos_token_id, ) text = tokenizer.decode(out[0], skip_special_tokens=True) return text.split(user.strip())[-1].strip() def run_python(code: str) -> Dict[str, Any]: buf = io.StringIO() env: Dict[str, Any] = {“__builtins__”: __builtins__} try: with contextlib.redirect_stdout(buf): exec(code, env, env) return {“ok”: True, “stdout”: buf.getvalue(), “error”: None} except Exception as e: return {“ok”: False, “stdout”: buf.getvalue(), “error”: repr(e)} We define the core interaction function that allows us to communicate with the language model using a structured system and user prompts. We generate responses from the model using controlled sampling parameters to ensure stable, coherent reasoning. We also implement a Python execution tool that allows our agent to dynamically execute generated code and capture its output safely. Copy CodeCopiedUse a different Browser def extract_json_block(text: str) -> Optional[Any]: fenced = re.search(r”“`jsons*(.*?)s*“`”, text, flags=re.DOTALL | re.IGNORECASE) if fenced: cand = fenced.group(1).strip() try: return json.loads(cand) except: pass start_obj = text.find(“{“) start_arr = text.find(“[“) starts = [i for i in [start_obj, start_arr] if i != -1] if not starts: return None start = min(starts) s = text[start:] stack = [] end = None for i, ch in enumerate(s): if ch in “{[“: stack.append(ch) elif ch in “}]”: if not stack: continue op = stack.pop() if (op == “{” and ch != “}”) or (op == “[” and ch != “]”): return None if not stack: end = i + 1 break if end is None: return None cand = s[:end].strip() try: return json.loads(cand) except: return None We implement a robust JSON extraction mechanism that allows us to reliably parse structured plans generated by the planner agent. We handle multiple formats, including fenced JSON blocks and inline JSON, to ensure resilience against imperfect model outputs. We ensure that our agent can consistently convert raw language model outputs into structured data for downstream execution. Copy CodeCopiedUse a different Browser PLANNER_SYSTEM = “”” You are a Hierarchical Planner Agent. You break down the user’s task into 3-8 clear steps. You MUST output ONLY valid JSON (no extra text). Schema: { “goal”: “string”, “assumptions”: [“string”, …], “steps”: [ { “id”: 1, “title”: “short title”, “instruction”: “what to do”, “tool”: “none|llm|python”, “expected_output”: “what we should get” } ] } Guidelines: – Use tool=”python” only if calculation / data processing / simulation helps. – Keep steps independent and executable. “”” EXECUTOR_SYSTEM = “”” You are an Executor Agent. Given a step and the current context, you produce the result for that step. If the step tool is “python”, output ONLY Python code (no backticks). If the step tool is “llm” or “none”, output a concise result, and reference any prior step outputs when relevant. “”” AGGREGATOR_SYSTEM = “”” You are an Aggregator Agent. You combine step outputs into a final, polished response to the original task. Be structured, correct, and practical. If the task asks for an actionable plan, include bullet points and clear next actions. “”” @dataclass class StepResult: step_id: int title: str tool: str output: str def planner_agent(task: str) -> Dict[str, Any]: raw = llm_chat(PLANNER_SYSTEM, f”Task:n{task}nnReturn JSON only.”, max_new_tokens=650, temperature=0.2) plan = extract_json_block(raw) if plan is None or “steps” not in plan: raw2 = llm_chat( PLANNER_SYSTEM, f”Your last output was invalid. Task:n{task}nReturn ONLY valid JSON matching the schema.”, max_new_tokens=650, temperature=0.0, ) plan = extract_json_block(raw2) if plan is None: plan = { “goal”: task, “assumptions”: [], “steps”: [ {“id”: 1, “title”: “Analyze”, “instruction”: “Analyze the task and outline an approach.”, “tool”: “llm”, “expected_output”: “Approach”}, {“id”: 2, “title”: “Execute”, “instruction”: “Produce the main solution.”, “tool”: “llm”, “expected_output”: “Solution”}, {“id”: 3, “title”: “Refine”, “instruction”: “Improve clarity and add next actions.”, “tool”: “llm”, “expected_output”: “Polished final”}, ], } return plan We define the prompts for the planner, executor, and aggregator agent system that establishes the hierarchical reasoning architecture. We create a planner agent function that decomposes complex tasks into structured steps, using defined tools and expected outputs. We also define the StepResult structure to store execution outputs in a structured, reusable format for subsequent reasoning. Copy CodeCopiedUse a different Browser def executor_agent(step: Dict[str, Any], context: Dict[str, Any]) -> StepResult: step_id = int(step.get(“id”, 0)) title = step.get(“title”, f”Step {step_id}”) tool =