LLM Agents with Reflection, Multi agent collab, Planning & Tool Use

[manisnesan]

Jay Alammar Building LLM Agent with tool use - YouTube

• Tool use is a method whichs allows developers to connect Cohere's Command models to external tools like search engines, APIs, databases, and other software tools.

• Just like how Retrieval-Augmented Generation (RAG) allows a model to use an external data source to improve factual generation, tool use is a capability that allows retrieving data from multiple sources.

• But it goes beyond simply retrieving information and is able to use software tools to execute code, or even create entries in a CRM system.

• In this video, we'll see how we can use two tools to create a simple data analyst agent that is able to search the web and run code in a python interpreter.

• This agent uses Cohere's Command R+ mode and Langchain.

[manisnesan]

AI agents looping vs planning

1. Predict necessary tools given a request using a recommendation system.

2. Generate an execution plan (DAG) based on the request, retrieved tools, and their descriptions. Iteratively refine the plan through conversation.

3. Fine-tune models to predict the final plan from inputs and tools, using examples of successfully running plans and implementing individual edges as needed.

The goal is to create a probabilistic plan construction process separate from its deterministic execution, producing artifacts for retrieval and few-shot examples, ultimately enabling single-shot output prediction.

Source: Jason Liu post

[manisnesan]

From Andrew ng post on Reflection as design pattern for Agentic workflows

Original

Last week, I described four design patterns for AI agentic workflows that I believe will drive significant progress this year: Reflection, Tool use, Planning and Multi-agent collaboration. Instead of having an LLM generate its final output directly, an agentic workflow prompts the LLM multiple times, giving it opportunities to build step by step to higher-quality output. Here, I'd like to discuss Reflection. For a design pattern that’s relatively quick to implement, I've seen it lead to surprising performance gains.

You may have had the experience of prompting ChatGPT/Claude/Gemini, receiving unsatisfactory output, delivering critical feedback to help the LLM improve its response, and then getting a better response. What if you automate the step of delivering critical feedback, so the model automatically criticizes its own output and improves its response? This is the crux of Reflection.

Take the task of asking an LLM to write code. We can prompt it to generate the desired code directly to carry out some task X. After that, we can prompt it to reflect on its own output, perhaps as follows:

Here’s code intended for task X:
[previously generated code]
Check the code carefully for correctness, style, and efficiency, and give constructive criticism for how to improve it.

Sometimes this causes the LLM to spot problems and come up with constructive suggestions. Next, we can prompt the LLM with context including (i) the previously generated code and (ii) the constructive feedback, and ask it to use the feedback to rewrite the code. This can lead to a better response. Repeating the criticism/rewrite process might yield further improvements. This self-reflection process allows the LLM to spot gaps and improve its output on a variety of tasks including producing code, writing text, and answering questions.

And we can go beyond self-reflection by giving the LLM tools that help evaluate its output; for example, running its code through a few unit tests to check whether it generates correct results on test cases or searching the web to double-check text output. Then it can reflect on any errors it found and come up with ideas for improvement.

Further, we can implement Reflection using a multi-agent framework. I've found it convenient to create two different agents, one prompted to generate good outputs and the other prompted to give constructive criticism of the first agent's output. The resulting discussion between the two agents leads to improved responses.

Reflection is a relatively basic type of agentic workflow, but I've been delighted by how much it improved my applications’ results in a few cases. I hope you will try it in your own work. If you’re interested in learning more about reflection, I recommend these papers:

• Self-Refine: Iterative Refinement with Self-Feedback, by Madaan et al. (2023)
• Reflexion: Language Agents with Verbal Reinforcement Learning, by Shinn et al. (2023)
• CRITIC: Large Language Models Can Self-Correct with Tool-Interactive Critiquing, by Gou et al. (2024)

I’ll discuss the other agentic design patterns as well in the future.

[Original text: deeplearning.ai/the-batch/issu… ]

[manisnesan]

Self-Refine: Iterative Refinement with Self-Feedback,” Madaan et al. (2023)
“Reflexion: Language Agents with Verbal Reinforcement Learning,” Shinn et al. (2023)
“CRITIC: Large Language Models Can Self-Correct with Tool-Interactive Critiquing,” Gou et al. (2024)

[manisnesan]

Agent Design Patterns : Tool Use

Related

Gorilla: Large Language Model Connected with Massive APIs,” Patil et al. (2023)
“MM-REACT: Prompting ChatGPT for Multimodal Reasoning and Action,” Yang et al. (2023)
“Efficient Tool Use with Chain-of-Abstraction Reasoning,” Gao et al. (2024)

“If I invest $100 at compound 7% interest for 12 years, what do I have at the end?”, rather than trying to generate the answer directly using a transformer network — which is unlikely to result in the right answer — the LLM might use a code execution tool to run a Python command to compute 100 * (1+0.07)**12 to get the right answer. The LLM might generate a string like this: {tool: python-interpreter, code: "100 * (1+0.07)**12"}.

[manisnesan]

Agent Design Pattern - Planning

• For example, if we ask an agent to do online research on a given topic, we might use an LLM to break down the objective into smaller subtasks, such as researching specific subtopics, synthesizing findings, and compiling a report

• Many tasks can’t be done in a single step or with a single tool invocation, but an agent can decide what steps to take

Related

• Chain-of-Thought Prompting Elicits Reasoning in Large Language Models,” Wei et al. (2022)
• HuggingGPT: Solving AI Tasks with ChatGPT and its Friends in Hugging Face,” Shen et al. (2023)
• “Understanding the planning of LLM agents: A survey,” by Huang et al. (2024)

[manisnesan]

Agentic AI via Armand Ruiz - LinkedIn

• Components (Core, Memory, Tool use and Planning)
• Capabilities : self reflection, and improvement, advanced planning, tool utilization and collaborative multiagent framework

[manisnesan]

[manisnesan]

Agent Frameworks: Jerry Liu from llamaindex previewed upcoming agent architectures for 2025, focusing on customizability for domains like report generation and customer support.

via X post

[manisnesan]

Contributions, Takeaways, and Key Insights from the Devin Experiment

via Thoughts on a month with Davin from answerai

Contributions

1. Task Automation: Devin succeeded in automating straightforward tasks, such as integrating Notion and Google Sheets and creating a planet tracker, showcasing potential for handling “glue code” tasks.

2. Polished User Experience: The Slack-based interface and autonomous setup of computing environments demonstrated a polished, user-friendly experience.

3. Asynchronous Workflow: Devin’s ability to operate autonomously offered glimpses of potential productivity benefits, such as multitasking during meetings.

Takeaways

1. Limited Task Reliability: Out of 20 tasks attempted, only 3 were successful, with 14 failures and 3 inconclusive results. The success rate was too low for consistent utility.

2. Unpredictability: Devin’s performance was inconsistent, even with tasks similar to its early successes, making it hard to trust or plan its use.

3. Overcomplication: Devin frequently produced unnecessarily complex code (“code soup” or “spaghetti code”), making it harder to debug or use effectively.

4. Failure to Recognize Blockers: Devin spent time pursuing impossible tasks (e.g., deploying multiple apps to a single Railway deployment) without identifying fundamental limitations.

5. Contextual Challenges: Tasks involving existing codebases or research (e.g., debugging, security reviews) revealed Devin’s inability to adapt to specific contexts or established patterns.

Key Insights

1. Autonomy as a Liability: Devin’s autonomous nature often led to inefficiencies, such as pursuing dead ends or hallucinating solutions. Tools requiring human-driven iteration (e.g., Cursor) proved more reliable.

2. Documentation Navigation Strength: Devin excelled in guiding users through complex API documentation and credential setup, saving time on mundane steps.

3. Mismatch Between Hype and Reality: Despite impressive early demos and industry buzz, Devin’s real-world utility was far below expectations, reflecting a gap between AI promises and practical application.

Conclusion

Devin represents an ambitious vision for autonomous AI software engineering, but its inconsistent performance, lack of reliability, and inefficiencies make it unsuitable for most real-world tasks. While its polished interface and ability to handle small, well-defined problems hint at potential, its struggles with complex or undefined tasks highlight the importance of human-driven workflows in AI-assisted development. For now, tools that complement human efforts rather than attempt full autonomy offer more practical value.

[manisnesan]

Agents

via Chip Huyen Blogpost

Table of Contents

Agent Overview

Tools

• Knowledge augmentation
• Capability extension
• Write actions

Planning

Planning overview
Foundation models as planners
Plan generation
Function calling
Planning granularity
Complex plans
Reflection and error correction
Tool selection

Agent Failure Modes and Evaluation

Planning failures
Tool failures
Efficiency

Conclusion

[manisnesan]

via Agent Systems - Lilian Weng

via Think Agents https://arxiv.org/pdf/2411.13239

[manisnesan]

Agents at Work 9: Agents from First principles w/ Johno Whitaker

Podcast Episode

Triggered thought

• Agents are good at asking the questions, planning, synthesizing and reasoning
• Human defining the task clearly, curating the context, reviewing and annotating for alignment