Atharv Kulkarni

Language models are increasingly expected to act as agents that use tools, follow user constraints, observe changing environment state, and complete long-horizon tasks. Training and evaluating these agents requires large collections of challenging, verifiable tasks, yet constructing such data at scale remains difficult. Existing synthetic task-generation methods frequently rely on single-pass prompting, producing tasks that are limited in complexity, weakly grounded in executable environments, and difficult to expand while preserving consistency. We introduce Agent Forest, a multi-agent framework for controlled complexity growth that systematically transforms trusted seed tasks into more complex descendants while preserving executability and verification guarantees. Agent Forest uses five specialized agents that increase complementary dimensions of interaction complexity: broader tool use, branching dependencies, long-range memory requirements, partial observability, and task composition. Rather than simply rewriting instructions to create superficial difficulty, these agents reason over available tools and environment state to modify the underlying interaction problem itself. Because transformations can accumulate and be applied in different orders, a single seed task can generate multiple descendants with distinct complexity profiles, forming a forest of task variants that grows both the scale and diversity of trusted agentic datasets. We apply Agent Forest to three agentic environments, τ²-Retail, τ²-Airline, and General-Agent, transforming trusted seed tasks into diverse descendants with varying complexity profiles. As interaction complexity accumulates, the resulting tasks become substantially more challenging for strong solver agents. On τ²-Retail, Qwen 3.5 397B drops from 75.4% Pass@1 on the original seed tasks to 54.7% on fully transformed descendants. On τ²-Airline, Gemma 4 31B drops from 66.0% to 28.6%, while GLM-5.2 drops from 72.0% to 53.6%. On General-Agent, Gemma 4 31B drops from 68.8% to 25.6%. Overall, accumulated complexity growth reduces Pass@1 by 18.4–43.2 percentage points relative to the original seed tasks, demonstrating that Agent Forest can systematically generate more complex agentic tasks while preserving executability and validity.

Large language models (LLMs) are increasingly used as coding assistants, but the programs they generate often fail. Such failures can be addressed by debugging the existing implementation or regenerating a new solution from the problem specification, with existing repair workflows typically defaulting to debugging. We find that the effectiveness of debugging and regeneration depends strongly on initial program quality, suggesting that no single repair strategy is universally optimal. Motivated by this observation, we present PATSSEL (Program-Adaptive Test-guided Repair Strategy Selection), a test-guided repair selection framework that dynamically chooses between debugging and regeneration. Rather than committing to a single repair strategy, PATSSEL generates debugged and regenerated candidates for each buggy program, evaluates them using generated verifier tests, and selects the stronger candidate, leveraging the complementary strengths of debugging and regeneration. Experiments on LeetCodeDataset, LiveCodeBench, and HE+Fix show that PATSSEL achieves average absolute improvements of 2.7% with Qwen3-8B and 3.2% with Llama3-8B over the best single-strategy baselines under the same inference compute budget and routing using gold unit tests. The gains persist across repair models, routing models, and stronger debugger models. Further analysis shows that PATSSEL benefits from the complementary strengths of debugging and regeneration, highlighting the importance of adaptive strategy selection for reliable LLM-based code repair.

In this work, we study the problem of code generation with a large language model (LLM), with a focus on generating SQL queries from natural language questions. We ask: Instead of using supervised fine tuning with text-code pairs, can we tune a model by having it interact with a database engine? We frame this problem as a reinforcement learning problem where the model receives execution-based feedback from the environment in the form of scalar rewards. These rewards penalize execution failures and assign positive values when a query returns a correct answer. We use the rewards within the Group Relative Policy Optimization (GRPO) framework. We use a tabular reasoning benchmark to test and evaluate our findings. We find that with only weak supervision in the form of question-answer pairs, RL-tuning improves the accuracy of model generated SQL code from 31.49 to 49.83 while reducing error percentage from 25.43% to 14.71%. This improvement allowed the model nearly match the performance performance to the larger SQLCoder-70B model. Our work demonstrates the potential of using execution-based feedback to improve symbolic reasoning capabilities of LLMs.

Temporal tabular question answering presents a significant challenge for Large Language Models (LLMs), requiring robust reasoning over structured data—a task where traditional prompting methods often fall short. These methods face challenges such as memorization, sensitivity to table size, and reduced performance on complex queries. To overcome these limitations, we introduce TEMPTABQA-C, a synthetic dataset designed for systematic and controlled evaluations, alongside a symbolic intermediate representation that transforms tables into database schemas. This structured approach allows LLMs to generate and execute SQL queries, enhancing generalization and mitigating biases. By incorporating adaptive few-shot prompting with contextually tailored examples, our method achieves superior robustness, scalability, and performance. Experimental results consistently highlight improvements across key challenges, setting a new benchmark for robust temporal reasoning with LLMs. Code and TEMPTABQA-C dataset: https://coral-lab-asu.github.io/llm_symbolic.