agentic-design-patterns

merged.md

A Thought Leader's Perspective: Power and Responsibility

Of all the technology cycles I’ve witnessed over the past four decades—from the birth of the personal computer and the web, to the revolutions in mobile and cloud—none has felt quite like this one. For years, the discourse around Artificial Intelligence was a familiar rhythm of hype and disillusionment, the so-called “AI summers” followed by long, cold winters. But this time, something is different. The conversation has palpably shifted. If the last eighteen months were
about the engine—the breathtaking, almost vertical ascent of Large Language Models (LLMs)—the next era will be about the car we build around it. It will be about the frameworks that harness this raw power, transforming it from a generator of plausible text into a true agent of action.

I admit, I began as a skeptic. Plausibility, I’ve found, is often inversely proportional to one’s own knowledge of a subject. Early models, for all their fluency, felt like they were operating with a kind of impostor syndrome, optimized for credibility over correctness. But then came the inflection point, a step-change brought about by a new class of "reasoning" models. Suddenly, we weren't just conversing with a statistical machine that predicted the next word in a sequence;
we were getting a peek into a nascent form of cognition.

The first time I experimented with one of the new agentic coding tools, I felt that familiar spark of magic. I tasked it with a personal project I’d never found the time for: migrating a charity website from a simple web builder to a proper, modern CI/CD environment. For the next twenty minutes, it went to work, asking clarifying questions, requesting credentials, and providing status updates. It felt less like using a tool and more like collaborating with a junior developer. When it presented me with a fully deployable package, complete with impeccable documentation and unit tests, I was floored.

Of course, it wasn't perfect. It made mistakes. It got stuck. It required my supervision and, crucially, my judgment to steer it back on course. The experience drove home a lesson I’ve learned the hard way over a long career: you cannot afford to trust blindly. Yet, the process was fascinating. Peeking into its "chain of thought" was like watching a mind at work—messy, non-linear, full of starts, stops, and self-corrections, not unlike our own human reasoning. It wasn’t a straight line; it was a random walk toward a solution. Here was the kernel of something new: not just an intelligence that could generate content, but one that could generate a plan.

This is the promise of agentic frameworks. It’s the difference between a static subway map and a dynamic GPS that reroutes you in real-time. A classic rules-based automaton follows a fixed path; when it encounters an unexpected obstacle, it breaks. An AI agent, powered by a reasoning model, has the potential to observe, adapt, and find another way. It possesses a form of digital common sense that allows it to navigate the countless edge cases of reality. It represents a shift from simply telling a computer what to do, to explaining why we need something done and trusting it to figure out the how.

As exhilarating as this new frontier is, it brings a profound sense of responsibility, particularly from my vantage point as the CIO of a global financial institution. The stakes are immeasurably high. An agent that makes a mistake while creating a recipe for a "Chicken Salmon Fusion Pie" is a fun anecdote. An agent that makes a mistake while executing a trade, managing risk, or handling client data is a real problem. I’ve read the disclaimers and the cautionary tales: the web automation agent that, after failing a login, decided to email a member of parliament to complain about login walls. It’s a darkly humorous reminder that we are dealing with a technology we don’t fully understand.

This is where craft, culture, and a relentless focus on our principles become our essential guide. Our Engineering Tenets are not just words on a page; they are our compass. We must Build with Purpose, ensuring that every agent we design starts from a clear understanding of the client problem we are solving. We must Look Around Corners, anticipating failure modes and designing systems that are resilient by design. And above all, we must Inspire Trust, by being transparent about our methods and accountable for our outcomes.

In an agentic world, these tenets take on new urgency. The hard truth is that you cannot simply overlay these powerful new tools onto messy, inconsistent systems and expect good results. Messy systems plus agents are a recipe for disaster. An AI trained on "garbage" data doesn’t just produce garbage-out; it produces plausible, confident garbage that can poison an entire process. Therefore, our first and most critical task is to prepare the ground. We must invest in clean data, consistent metadata, and well-defined APIs. We have to build the modern "interstate system" that allows these agents to operate safely and at high velocity. It is the hard,
foundational work of building a programmable enterprise, an "enterprise as software," where our processes are as well-architected as our code.

Ultimately, this journey is not about replacing human ingenuity, but about augmenting it. It demands a new set of skills from all of us: the ability to explain a task with clarity, the wisdom to delegate, and the diligence to verify the quality of the output. It requires us to be humble, to acknowledge what we don’t know, and to never stop learning. The pages that follow in this book offer a technical map for building these new frameworks. My hope is that you will use them not just to build what is possible, but to build what is right, what is robust, and what is responsible.

The world is asking every engineer to step up. I am confident we are ready for the challenge.

Enjoy the journey.

Marco Argenti, CIO, Goldman Sachs

Acknowledgment

I would like to express my sincere gratitude to the many individuals and teams who made this book possible.

First and foremost, I thank Google for adhering to its mission, empowering Googlers, and respecting the opportunity to innovate.

I am grateful to the Office of the CTO for giving me the opportunity to explore new areas, for adhering to its mission of "practical magic," and for its capacity to adapt to new emerging opportunities.

I would like to extend my heartfelt thanks to Will Grannis, our VP, for the trust he puts in people and for being a servant leader. To John Abel, my manager, for encouraging me to pursue my activities and for always providing great guidance with his British acumen.I extend my gratitude to Antoine Larmanjat for our work on LLMs in code, Hann Hann Wang for agent discussions, and Yingchao Huang for time series insights. Thanks to Ashwin Ram for leadership, Massy Mascaro for inspiring work, Jennifer Bennett for technical expertise, Brett Slatkin for engineering, and Eric Schen for stimulating discussions. The OCTO team, especially Scott Penberthy, deserves recognition. Finally, deep appreciation to Patricia Florissi for her inspiring vision of Agents' societal impact.

My appreciation also goes to Marco Argenti for the challenging and motivating vision of agents augmenting the human workforce. My thanks also go to Jim Lanzone and Jordi Ribas for pushing the bar on the relationship between the world of Search and the world of Agents.

I am also indebted to the Cloud AI teams, especially their leader Saurabh Tiwary, for driving the AI organization towards principled progress. Thank you to Salem Salem Haykal, the Area Technical Leader, for being an inspiring colleague. My thanks to Vladimir Vuskovic, co-founder of Google Agentspace, Kate (Katarzyna) Olszewska for our Agentic collaboration on Kaggle Game Arena, and Nate Keating for driving Kaggle with passion, a community that has given so much to AI. My thanks also to Kamelia Aryafa, leading applied AI and ML teams focused on Agentspace and Enterprise NotebookLM, and to Jahn Wooland, a true leader focused on delivering and a personal friend always there to provide advice.

A special thanks to Yingchao Huang for being a brilliant AI engineer with a great career in front of you, Hann Wang for challenging me to return to my interest in Agents after an initial interest in 1994, and to Lee Boonstra for your amazing work on prompt engineering.

My thanks also go to the 5 Days of GenAI team, including our VP Alison Wagonfeld for the trust put in the team, Anant Nawalgaria for always delivering, and Paige Bailey for her can-do attitude and leadership.

I am also deeply grateful to Mike Styer, Turan Bulmus, and Kanchana Patlolla for helping me ship three Agents at Google I/O 2025. Thank you for your immense work.

I want to express my sincere gratitude to Thomas Kurian for his unwavering leadership, passion, and trust in driving the Cloud and AI initiatives. I also deeply appreciate Emanuel Taropa, whose inspiring "can-do" attitude made him the most exceptional colleague I've encountered at Google, setting a truly profound example. Finally, thanks to Fiona Cicconi for our engaging discussions about Google.

I extend my gratitude to Demis Hassabis, Pushmeet Kohli, and the entire GDM team for their passionate efforts in developing Gemini, AlphaFold, AlphaGo, and AlphaGenome, among other projects, and for their contributions to advancing science for the benefit of society. A special thank you to Yossi Matias for his leadership of Google Research and for consistently offering invaluable advice. I have learned a great deal from you.

A special thanks to Patti Maes, who pioneered the concept of Software Agents in the 90s and remains focused on the question of how computer systems and digital devices might augment people and assist them with issues such as memory, learning, decision making, health, and wellbeing. Your vision back in '91 became a reality today.

I also want to extend my gratitude to Paul Drougas and all the Publisher team at Springer for making this book possible.

I am deeply indebted to the many talented people who helped bring this book to life. My heartfelt thanks go to Marco Fago for his immense contributions, from code and diagrams to reviewing the entire text. I’m also grateful to Mahtab Syed for his coding work and to Ankita Guha for her incredibly detailed feedback on so many chapters. The book was significantly improved by the insightful amendments from Priya Saxena, the careful reviews from Jae Lee, and the dedicated work of Mario da Roza in creating the NotebookLM version. I was fortunate to have a team of expert reviewers for the initial chapters, and I thank Dr. Amita Kapoor, Fatma Tarlaci, PhD, Dr. Alessandro Cornacchia, and Aditya Mandlekar for lending their expertise. My sincere appreciation also goes to Ashley Miller, A Amir John, and Palak Kamdar (Vasani) for their unique contributions. For their steadfast support and encouragement, a final, warm thank you is due to Rajat Jain, Aldo Pahor, Gaurav Verma, Pavithra Sainath, Mariusz Koczwara, Abhijit Kumar, Armstrong Foundjem, Haiming Ran, Udita Patel, and Kaurnakar Kotha.

This project truly would not have been possible without you. All the credit goes to you, and all the mistakes are mine.

All my royalties are donated to Save the Children.

Appendix A: Advanced Prompting Techniques

Introduction to Prompting

Prompting, the primary interface for interacting with language models, is the process of crafting inputs to guide the model towards generating a desired output. This involves structuring requests, providing relevant context, specifying the output format, and demonstrating expected response types. Well-designed prompts can maximize the potential of language models, resulting in accurate, relevant, and creative responses. In contrast, poorly designed prompts can lead to ambiguous, irrelevant, or erroneous outputs.

The objective of prompt engineering is to consistently elicit high-quality responses from language models. This requires understanding the capabilities and limitations of the models and effectively communicating intended goals. It involves developing expertise in communicating with AI by learning how to best instruct it.

This appendix details various prompting techniques that extend beyond basic interaction methods. It explores methodologies for structuring complex requests, enhancing the model's reasoning abilities, controlling output formats, and integrating external information. These techniques are applicable to building a range of applications, from simple chatbots to complex multi-agent systems, and can improve the performance and reliability of agentic applications.

Agentic patterns, the architectural structures for building intelligent systems, are detailed in the main chapters. These patterns define how agents plan, utilize tools, manage memory, and collaborate. The efficacy of these agentic systems is contingent upon their ability to interact meaningfully with language models.

Core Prompting Principles

Core Principles for Effective Prompting of Language Models:

Effective prompting rests on fundamental principles guiding communication with language models, applicable across various models and task complexities. Mastering these principles is essential for consistently generating useful and accurate responses.

Clarity and Specificity: Instructions should be unambiguous and precise. Language models interpret patterns; multiple interpretations may lead to unintended responses. Define the task, desired output format, and any limitations or requirements. Avoid vague language or assumptions. Inadequate prompts yield ambiguous and inaccurate responses, hindering meaningful output.

Conciseness: While specificity is crucial, it should not compromise conciseness. Instructions should be direct. Unnecessary wording or complex sentence structures can confuse the model or obscure the primary instruction. Prompts should be simple; what is confusing to the user is likely confusing to the model. Avoid intricate language and superfluous information. Use direct phrasing and active verbs to clearly delineate the desired action. Effective verbs include: Act, Analyze, Categorize, Classify, Contrast, Compare, Create, Describe, Define, Evaluate, Extract, Find, Generate, Identify, List, Measure, Organize, Parse, Pick, Predict, Provide, Rank, Recommend, Return, Retrieve, Rewrite, Select, Show, Sort, Summarize, Translate, Write.

Using Verbs: Verb choice is a key prompting tool. Action verbs indicate the expected operation. Instead of "Think about summarizing this," a direct instruction like "Summarize the following text" is more effective. Precise verbs guide the model to activate relevant training data and processes for that specific task.

Instructions Over Constraints: Positive instructions are generally more effective than negative constraints. Specifying the desired action is preferred to outlining what not to do. While constraints have their place for safety or strict formatting, excessive reliance can cause the model to focus on avoidance rather than the objective. Frame prompts to guide the model directly. Positive instructions align with human guidance preferences and reduce confusion.

Experimentation and Iteration: Prompt engineering is an iterative process. Identifying the most effective prompt requires multiple attempts. Begin with a draft, test it, analyze the output, identify shortcomings, and refine the prompt. Model variations, configurations (like temperature or top-p), and slight phrasing changes can yield different results. Documenting attempts is vital for learning and improvement. Experimentation and iteration are necessary to achieve the desired performance.

These principles form the foundation of effective communication with language models. By prioritizing clarity, conciseness, action verbs, positive instructions, and iteration, a robust framework is established for applying more advanced prompting techniques.

Basic Prompting Techniques

Building on core principles, foundational techniques provide language models with varying levels of information or examples to direct their responses. These methods serve as an initial phase in prompt engineering and are effective for a wide spectrum of applications.

Zero-Shot Prompting

Zero-shot prompting is the most basic form of prompting, where the language model is provided with an instruction and input data without any examples of the desired input-output pair. It relies entirely on the model's pre-training to understand the task and generate a relevant response. Essentially, a zero-shot prompt consists of a task description and initial text to begin the process.

• When to use: Zero-shot prompting is often sufficient for tasks that the model has likely encountered extensively during its training, such as simple question answering, text completion, or basic summarization of straightforward text. It's the quickest approach to try first.
• Example:
  Translate the following English sentence to French: 'Hello, how are you?'

One-Shot Prompting

One-shot prompting involves providing the language model with a single example of the input and the corresponding desired output prior to presenting the actual task. This method serves as an initial demonstration to illustrate the pattern the model is expected to replicate. The purpose is to equip the model with a concrete instance that it can use as a template to effectively execute the given task.

• When to use: One-shot prompting is useful when the desired output format or style is specific or less common. It gives the model a concrete instance to learn from. It can improve performance compared to zero-shot for tasks requiring a particular structure or tone.

• Example:
  Translate the following English sentences to Spanish:
  English: 'Thank you.'
  Spanish: 'Gracias.'

  English: 'Please.'
  Spanish:

Few-Shot Prompting

Few-shot prompting enhances one-shot prompting by supplying several examples, typically three to five, of input-output pairs. This aims to demonstrate a clearer pattern of expected responses, improving the likelihood that the model will replicate this pattern for new inputs. This method provides multiple examples to guide the model to follow a specific output pattern.

• When to use: Few-shot prompting is particularly effective for tasks where the desired output requires adhering to a specific format, style, or exhibiting nuanced variations. It's excellent for tasks like classification, data extraction with specific schemas, or generating text in a particular style, especially when zero-shot or one-shot don't yield consistent results. Using at least three to five examples is a general rule of thumb, adjusting based on task complexity and model token limits.

• Importance of Example Quality and Diversity: The effectiveness of few-shot prompting heavily relies on the quality and diversity of the examples provided. Examples should be accurate, representative of the task, and cover potential variations or edge cases the model might encounter. High-quality, well-written examples are crucial; even a small mistake can confuse the model and result in undesired output. Including diverse examples helps the model generalize better to unseen inputs.

• Mixing Up Classes in Classification Examples: When using few-shot prompting for classification tasks (where the model needs to categorize input into predefined classes), it's a best practice to mix up the order of the examples from different classes. This prevents the model from potentially overfitting to the specific sequence of examples and ensures it learns to identify the key features of each class independently, leading to more robust and generalizable performance on unseen data.

• Evolution to "Many-Shot" Learning: As modern LLMs like Gemini get stronger with long context modeling, they are becoming highly effective at utilizing "many-shot" learning. This means optimal performance for complex tasks can now be achieved by including a much larger number of examples—sometimes even hundreds—directly within the prompt, allowing the model to learn more intricate patterns.

• Example:
  Classify the sentiment of the following movie reviews as POSITIVE, NEUTRAL, or NEGATIVE:

  Review: "The acting was superb and the story was engaging."
  Sentiment: POSITIVE

  Review: "It was okay, nothing special."
  Sentiment: NEUTRAL

  Review: "I found the plot confusing and the characters unlikable."
  Sentiment: NEGATIVE

  Review: "The visuals were stunning, but the dialogue was weak."
  Sentiment:

Understanding when to apply zero-shot, one-shot, and few-shot prompting techniques, and thoughtfully crafting and organizing examples, are essential for enhancing the effectiveness of agentic systems. These basic methods serve as the groundwork for various prompting strategies.

Structuring Prompts

Beyond the basic techniques of providing examples, the way you structure your prompt plays a critical role in guiding the language model. Structuring involves using different sections or elements within the prompt to provide distinct types of information, such as instructions, context, or examples, in a clear and organized manner. This helps the model parse the prompt correctly and understand the specific role of each piece of text.

System Prompting

System prompting sets the overall context and purpose for a language model, defining its intended behavior for an interaction or session. This involves providing instructions or background information that establish rules, a persona, or overall behavior. Unlike specific user queries, a system prompt provides foundational guidelines for the model's responses. It influences the model's tone, style, and general approach throughout the interaction. For example, a system prompt can instruct the model to consistently respond concisely and helpfully or ensure responses are appropriate for a general audience. System prompts are also utilized for safety and toxicity control by including guidelines such as maintaining respectful language.

Furthermore, to maximize their effectiveness, system prompts can undergo automatic prompt optimization through LLM-based iterative refinement. Services like the Vertex AI Prompt Optimizer facilitate this by systematically improving prompts based on user-defined metrics and target data, ensuring the highest possible performance for a given task.

• Example:
  You are a helpful and harmless AI assistant. Respond to all queries in a polite and informative manner. Do not generate content that is harmful, biased, or inappropriate

Role Prompting

Role prompting assigns a specific character, persona, or identity to the language model, often in conjunction with system or contextual prompting. This involves instructing the model to adopt the knowledge, tone, and communication style associated with that role. For example, prompts such as "Act as a travel guide" or "You are an expert data analyst" guide the model to reflect the perspective and expertise of that assigned role. Defining a role provides a framework for the tone, style, and focused expertise, aiming to enhance the quality and relevance of the output. The desired style within the role can also be specified, for instance, "a humorous and inspirational style."

• Example:
  Act as a seasoned travel blogger. Write a short, engaging paragraph about the best hidden gem in Rome.

Using Delimiters

Effective prompting involves clear distinction of instructions, context, examples, and input for language models. Delimiters, such as triple backticks (\`\`\`), XML tags (\<instruction\>, \<context\>), or markers (---), can be utilized to visually and programmatically separate these sections. This practice, widely used in prompt engineering, minimizes misinterpretation by the model, ensuring clarity regarding the role of each part of the prompt.

• Example:
  <instruction>Summarize the following article, focusing on the main arguments presented by the author.</instruction>
  <article>
  [Insert the full text of the article here]
  </article>

Contextual Enginnering

Context engineering, unlike static system prompts, dynamically provides background information crucial for tasks and conversations. This ever-changing information helps models grasp nuances, recall past interactions, and integrate relevant details, leading to grounded responses and smoother exchanges. Examples include previous dialogue, relevant documents (as in Retrieval Augmented Generation), or specific operational parameters. For instance, when discussing a trip to Japan, one might ask for three family-friendly activities in Tokyo, leveraging the existing conversational context. In agentic systems, context engineering is fundamental to core agent behaviors like memory persistence, decision-making, and coordination across sub-tasks. Agents with dynamic contextual pipelines can sustain goals over time, adapt strategies, and collaborate seamlessly with other agents or tools—qualities essential for long-term autonomy. This methodology posits that the quality of a model's output depends more on the richness of the provided context than on the model's architecture. It signifies a significant evolution from traditional prompt engineering, which primarily focused on optimizing the phrasing of immediate user queries. Context engineering expands its scope to include multiple layers of information.

These layers include:

• System prompts: Foundational instructions that define the AI's operational parameters (e.g., "You are a technical writer; your tone must be formal and precise").
• External data:
  • Retrieved documents: Information actively fetched from a knowledge base to inform responses (e.g., pulling technical specifications).
  • Tool outputs: Results from the AI using an external API for real-time data (e.g., querying a calendar for availability).
• Implicit data: Critical information such as user identity, interaction history, and environmental state. Incorporating implicit context presents challenges related to privacy and ethical data management. Therefore, robust governance is essential for context engineering, especially in sectors like enterprise, healthcare, and finance.

The core principle is that even advanced models underperform with a limited or poorly constructed view of their operational environment. This practice reframes the task from merely answering a question to building a comprehensive operational picture for the agent. For example, a context-engineered agent would integrate a user's calendar availability (tool output), the professional relationship with an email recipient (implicit data), and notes from previous meetings (retrieved documents) before responding to a query. This enables the model to generate highly relevant, personalized, and pragmatically useful outputs. The "engineering" aspect involves creating robust pipelines to fetch and transform this data at runtime and establishing feedback loops to continually improve context quality.

To implement this, specialized tuning systems, such as Google's Vertex AI prompt optimizer, can automate the improvement process at scale. By systematically evaluating responses against sample inputs and predefined metrics, these tools can enhance model performance and adapt prompts and system instructions across different models without extensive manual rewriting. Providing an optimizer with sample prompts, system instructions, and a template allows it to programmatically refine contextual inputs, offering a structured method for implementing the necessary feedback loops for sophisticated Context Engineering.
This structured approach differentiates a rudimentary AI tool from a more sophisticated, contextually-aware system. It treats context as a primary component, emphasizing what the agent knows, when it knows it, and how it uses that information. This practice ensures the model has a well-rounded understanding of the user's intent, history, and current environment. Ultimately, Context Engineering is a crucial methodology for transforming stateless chatbots into highly capable, situationally-aware systems.

Structured Output

Often, the goal of prompting is not just to get a free-form text response, but to extract or generate information in a specific, machine-readable format. Requesting structured output, such as JSON, XML, CSV, or Markdown tables, is a crucial structuring technique. By explicitly asking for the output in a particular format and potentially providing a schema or example of the desired structure, you guide the model to organize its response in a way that can be easily parsed and used by other parts of your agentic system or application. Returning JSON objects for data extraction is beneficial as it forces the model to create a structure and can limit hallucinations. Experimenting with output formats is recommended, especially for non-creative tasks like extracting or categorizing data.

• Example:
  Extract the following information from the text below and return it as a JSON object with keys "name", "address", and "phone_number".

  Text: "Contact John Smith at 123 Main St, Anytown, CA or call (555) 123-4567."

Effectively utilizing system prompts, role assignments, contextual information, delimiters, and structured output significantly enhances the clarity, control, and utility of interactions with language models, providing a strong foundation for developing reliable agentic systems. Requesting structured output is crucial for creating pipelines where the language model's output serves as the input for subsequent system or processing steps.

Leveraging Pydantic for an Object-Oriented Facade: A powerful technique for enforcing structured output and enhancing interoperability is to use the LLM's generated data to populate instances of Pydantic objects. Pydantic is a Python library for data validation and settings management using Python type annotations. By defining a Pydantic model, you create a clear and enforceable schema for your desired data structure. This approach effectively provides an object-oriented facade to the prompt's output, transforming raw text or semi-structured data into validated, type-hinted Python objects.

You can directly parse a JSON string from an LLM into a Pydantic object using the model_validate_json method. This is particularly useful as it combines parsing and validation in a single step.

from pydantic import BaseModel, EmailStr, Field, ValidationError from typing import List, Optional from datetime import date # --- Pydantic Model Definition (from above) --- class User(BaseModel): name: str = Field(..., description="The full name of the user.") email: EmailStr = Field(..., description="The user's email address.") date_of_birth: Optional[date] = Field(None, description="The user's date of birth.") interests: List[str] = Field(default_factory=list, description="A list of the user's interests.") # --- Hypothetical LLM Output --- llm_output_json = """ { "name": "Alice Wonderland", "email": "alice.w@example.com", "date_of_birth": "1995-07-21", "interests": [ "Natural Language Processing", "Python Programming", "Gardening" ] } """ # --- Parsing and Validation --- try: # Use the model_validate_json class method to parse the JSON string. # This single step parses the JSON and validates the data against the User model. user_object = User.model_validate_json(llm_output_json) # Now you can work with a clean, type-safe Python object. print("Successfully created User object!") print(f"Name: {user_object.name}") print(f"Email: {user_object.email}") print(f"Date of Birth: {user_object.date_of_birth}") print(f"First Interest: {user_object.interests[0]}") # You can access the data like any other Python object attribute. # Pydantic has already converted the 'date_of_birth' string to a datetime.date object. print(f"Type of date_of_birth: {type(user_object.date_of_birth)}") except ValidationError as e: # If the JSON is malformed or the data doesn't match the model's types, # Pydantic will raise a ValidationError. print("Failed to validate JSON from LLM.") print(e)

This Python code demonstrates how to use the Pydantic library to define a data model and validate JSON data. It defines a User model with fields for name, email, date of birth, and interests, including type hints and descriptions. The code then parses a hypothetical JSON output from a Large Language Model (LLM) using the model_validate_json method of the User model. This method handles both JSON parsing and data validation according to the model's structure and types. Finally, the code accesses the validated data from the resulting Python object and includes error handling for ValidationError in case the JSON is invalid.

For XML data, the xmltodict library can be used to convert the XML into a dictionary, which can then be passed to a Pydantic model for parsing. By using Field aliases in your Pydantic model, you can seamlessly map the often verbose or attribute-heavy structure of XML to your object's fields.

This methodology is invaluable for ensuring the interoperability of LLM-based components with other parts of a larger system. When an LLM's output is encapsulated within a Pydantic object, it can be reliably passed to other functions, APIs, or data processing pipelines with the assurance that the data conforms to the expected structure and types. This practice of "parse, don't validate" at the boundaries of your system components leads to more robust and maintainable applications.

Effectively utilizing system prompts, role assignments, contextual information, delimiters, and structured output significantly enhances the clarity, control, and utility of interactions with language models, providing a strong foundation for developing reliable agentic systems. Requesting structured output is crucial for creating pipelines where the language model's output serves as the input for subsequent system or processing steps.

Structuring Prompts Beyond the basic techniques of providing examples, the way you structure your prompt plays a critical role in guiding the language model. Structuring involves using different sections or elements within the prompt to provide distinct types of information, such as instructions, context, or examples, in a clear and organized manner. This helps the model parse the prompt correctly and understand the specific role of each piece of text.

Reasoning and Thought Process Techniques

Large language models excel at pattern recognition and text generation but often face challenges with tasks requiring complex, multi-step reasoning. This appendix focuses on techniques designed to enhance these reasoning capabilities by encouraging models to reveal their internal thought processes. Specifically, it addresses methods to improve logical deduction, mathematical computation, and planning.

Chain of Thought (CoT)

The Chain of Thought (CoT) prompting technique is a powerful method for improving the reasoning abilities of language models by explicitly prompting the model to generate intermediate reasoning steps before arriving at a final answer. Instead of just asking for the result, you instruct the model to "think step by step." This process mirrors how a human might break down a problem into smaller, more manageable parts and work through them sequentially.

CoT helps the LLM generate more accurate answers, particularly for tasks that require some form of calculation or logical deduction, where models might otherwise struggle and produce incorrect results. By generating these intermediate steps, the model is more likely to stay on track and perform the necessary operations correctly.

There are two main variations of CoT:

• Zero-Shot CoT: This involves simply adding the phrase "Let's think step by step" (or similar phrasing) to your prompt without providing any examples of the reasoning process. Surprisingly, for many tasks, this simple addition can significantly improve the model's performance by triggering its ability to expose its internal reasoning trace.

  • Example (Zero-Shot CoT):
    If a train travels at 60 miles per hour and covers a distance of 240 miles, how long did the journey take? Let's think step by step.

• Few-Shot CoT: This combines CoT with few-shot prompting. You provide the model with several examples where both the input, the step-by-step reasoning process, and the final output are shown. This gives the model a clearer template for how to perform the reasoning and structure its response, often leading to even better results on more complex tasks compared to zero-shot CoT.

  • Example (Few-Shot CoT):
    Q: The sum of three consecutive integers is 36. What are the integers?
    A: Let the first integer be x. The next consecutive integer is x+1, and the third is x+2. The sum is x + (x+1) + (x+2) = 3x + 3. We know the sum is 36, so 3x + 3 = 36. Subtract 3 from both sides: 3x = 33. Divide by 3: x = 11. The integers are 11, 11+1=12, and 11+2=13. The integers are 11, 12, and 13.

    Q: Sarah has 5 apples, and she buys 8 more. She eats 3 apples. How many apples does she have left? Let's think step by step.
    A: Let's think step by step. Sarah starts with 5 apples. She buys 8 more, so she adds 8 to her initial amount: 5 + 8 = 13 apples. Then, she eats 3 apples, so we subtract 3 from the total: 13 - 3 = 10. Sarah has 10 apples left. The answer is 10.

CoT offers several advantages. It is relatively low-effort to implement and can be highly effective with off-the-shelf LLMs without requiring fine-tuning. A significant benefit is the increased interpretability of the model's output; you can see the reasoning steps it followed, which helps in understanding why it arrived at a particular answer and in debugging if something went wrong. Additionally, CoT appears to improve the robustness of prompts across different versions of language models, meaning the performance is less likely to degrade when a model is updated. The main disadvantage is that generating the reasoning steps increases the length of the output, leading to higher token usage, which can increase costs and response time.

Best practices for CoT include ensuring the final answer is presented after the reasoning steps, as the generation of the reasoning influences the subsequent token predictions for the answer. Also, for tasks with a single correct answer (like mathematical problems), setting the model's temperature to 0 (greedy decoding) is recommended when using CoT to ensure deterministic selection of the most probable next token at each step.

Self-Consistency

Building on the idea of Chain of Thought, the Self-Consistency technique aims to improve the reliability of reasoning by leveraging the probabilistic nature of language models. Instead of relying on a single greedy reasoning path (as in basic CoT), Self-Consistency generates multiple diverse reasoning paths for the same problem and then selects the most consistent answer among them.

Self-Consistency involves three main steps:

1. Generating Diverse Reasoning Paths: The same prompt (often a CoT prompt) is sent to the LLM multiple times. By using a higher temperature setting, the model is encouraged to explore different reasoning approaches and generate varied step-by-step explanations.
2. Extract the Answer: The final answer is extracted from each of the generated reasoning paths.
3. Choose the Most Common Answer: A majority vote is performed on the extracted answers. The answer that appears most frequently across the diverse reasoning paths is selected as the final, most consistent answer.

This approach improves the accuracy and coherence of responses, particularly for tasks where multiple valid reasoning paths might exist or where the model might be prone to errors in a single attempt. The benefit is a pseudo-probability likelihood of the answer being correct, increasing overall accuracy. However, the significant cost is the need to run the model multiple times for the same query, leading to much higher computation and expense.

• Example (Conceptual):
  • Prompt: "Is the statement 'All birds can fly' true or false? Explain your reasoning."
  • Model Run 1 (High Temp): Reasons about most birds flying, concludes True.
  • Model Run 2 (High Temp): Reasons about penguins and ostriches, concludes False.
  • Model Run 3 (High Temp): Reasons about birds in general, mentions exceptions briefly, concludes True.
  • Self-Consistency Result: Based on majority vote (True appears twice), the final answer is "True". (Note: A more sophisticated approach would weigh the reasoning quality).

Step-Back Prompting

Step-back prompting enhances reasoning by first asking the language model to consider a general principle or concept related to the task before addressing specific details. The response to this broader question is then used as context for solving the original problem.

This process allows the language model to activate relevant background knowledge and wider reasoning strategies. By focusing on underlying principles or higher-level abstractions, the model can generate more accurate and insightful answers, less influenced by superficial elements. Initially considering general factors can provide a stronger basis for generating specific creative outputs. Step-back prompting encourages critical thinking and the application of knowledge, potentially mitigating biases by emphasizing general principles.

• Example:
  • Prompt 1 (Step-Back): "What are the key factors that make a good detective story?"
  • Model Response 1: (Lists elements like red herrings, compelling motive, flawed protagonist, logical clues, satisfying resolution).
  • Prompt 2 (Original Task + Step-Back Context): "Using the key factors of a good detective story [insert Model Response 1 here], write a short plot summary for a new mystery novel set in a small town."

Tree of Thoughts (ToT)

Tree of Thoughts (ToT) is an advanced reasoning technique that extends the Chain of Thought method. It enables a language model to explore multiple reasoning paths concurrently, instead of following a single linear progression. This technique utilizes a tree structure, where each node represents a "thought"—a coherent language sequence acting as an intermediate step. From each node, the model can branch out, exploring alternative reasoning routes.

ToT is particularly suited for complex problems that require exploration, backtracking, or the evaluation of multiple possibilities before arriving at a solution. While more computationally demanding and intricate to implement than the linear Chain of Thought method, ToT can achieve superior results on tasks necessitating deliberate and exploratory problem-solving. It allows an agent to consider diverse perspectives and potentially recover from initial errors by investigating alternative branches within the "thought tree."

• Example (Conceptual): For a complex creative writing task like "Develop three different possible endings for a story based on these plot points," ToT would allow the model to explore distinct narrative branches from a key turning point, rather than just generating one linear continuation.

These reasoning and thought process techniques are crucial for building agents capable of handling tasks that go beyond simple information retrieval or text generation. By prompting models to expose their reasoning, consider multiple perspectives, or step back to general principles, we can significantly enhance their ability to perform complex cognitive tasks within agentic systems.

Action and Interaction Techniques

Intelligent agents possess the capability to actively engage with their environment, beyond generating text. This includes utilizing tools, executing external functions, and participating in iterative cycles of observation, reasoning, and action. This section examines prompting techniques designed to enable these active behaviors.

Tool Use / Function Calling

A crucial ability for an agent is using external tools or calling functions to perform actions beyond its internal capabilities. These actions may include web searches, database access, sending emails, performing calculations, or interacting with external APIs. Effective prompting for tool use involves designing prompts that instruct the model on the appropriate timing and methodology for tool utilization.

Modern language models often undergo fine-tuning for "function calling" or "tool use." This enables them to interpret descriptions of available tools, including their purpose and parameters. Upon receiving a user request, the model can determine the necessity of tool use, identify the appropriate tool, and format the required arguments for its invocation. The model does not execute the tool directly. Instead, it generates a structured output, typically in JSON format, specifying the tool and its parameters. An agentic system then processes this output, executes the tool, and provides the tool's result back to the model, integrating it into the ongoing interaction.

• Example:
  You have access to a weather tool that can get the current weather for a specified city. The tool is called 'get_current_weather' and takes a 'city' parameter (string).

  User: What's the weather like in London right now?

  • Expected Model Output (Function Call):
    {
    "tool_code": "get_current_weather",
    "tool_name": "get_current_weather",
    "parameters": {
    "city": "London"
    }
    }

ReAct (Reason & Act)

ReAct, short for Reason and Act, is a prompting paradigm that combines Chain of Thought-style reasoning with the ability to perform actions using tools in an interleaved manner. ReAct mimics how humans operate – we reason verbally and take actions to gather more information or make progress towards a goal.

The ReAct pattern involves a loop:

1. Thought: The model generates a thought process, explaining its current understanding and plan.
2. Action: Based on the thought, the model decides to perform an action, often using a tool (e.g., Search, Calculator, API call). It outputs the name of the tool and the required input.
3. Observation: The agentic system executes the tool and provides the result (Observation) back to the model.
4. The loop continues with the model generating a new "Thought" based on the latest "Observation," leading to further "Actions" and "Observations" until the task is complete and the model outputs a "Final Answer."

This interleaved process of thinking and acting allows the agent to dynamically gather information, react to tool outputs, and refine its approach, making it particularly effective for tasks requiring interaction with dynamic environments or external knowledge sources.

• Example (Illustrative ReAct Trace):
  User: What is the capital of France and its current population?

  Thought: The user is asking for two pieces of information: the capital of France and its population. I can use a search tool to find this information. I will start by confirming the capital, although I am likely to know it.
  Action: Search({"query": "capital of France"})
  Observation: Paris

  Thought: Okay, the capital is Paris. Now I need to find the population of Paris.
  Action: Search({"query": "current population of Paris"})
  Observation: The population of Paris was estimated to be around 2.1 million people in 2023.

  Thought: I have found both pieces of information. I can now provide the final answer to the user.
  Final Answer: The capital of France is Paris, and its estimated population in 2023 was around 2.1 million people.

These techniques are vital for building agents that can actively engage with the world, retrieve real-time information, and perform tasks that require interacting with external systems.

Advanced Techniques

Beyond the foundational, structural, and reasoning patterns, there are several other prompting techniques that can further enhance the capabilities and efficiency of agentic systems. These range from using AI to optimize prompts to incorporating external knowledge and tailoring responses based on user characteristics.

Automatic Prompt Engineering (APE)

Recognizing that crafting effective prompts can be a complex and iterative process, Automatic Prompt Engineering (APE) explores using language models themselves to generate, evaluate, and refine prompts. This method aims to automate the prompt writing process, potentially enhancing model performance without requiring extensive human effort in prompt design.

The general idea is to have a "meta-model" or a process that takes a task description and generates multiple candidate prompts. These prompts are then evaluated based on the quality of the output they produce on a given set of inputs (perhaps using metrics like BLEU or ROUGE, or human evaluation). The best-performing prompts can be selected, potentially refined further, and used for the target task. Using an LLM to generate variations of a user query for training a chatbot is an example of this.

• Example (Conceptual): A developer provides a description: "I need a prompt that can extract the date and sender from an email." An APE system generates several candidate prompts. These are tested on sample emails, and the prompt that consistently extracts the correct information is selected.

Of course. Here is a rephrased and slightly expanded explanation of programmatic prompt optimization using frameworks like DSPy:

Another powerful prompt optimization technique, notably promoted by the DSPy framework, involves treating prompts not as static text but as programmatic modules that can be automatically optimized. This approach moves beyond manual trial-and-error and into a more systematic, data-driven methodology.

The core of this technique relies on two key components:

1. A Goldset (or High-Quality Dataset): This is a representative set of high-quality input-and-output pairs. It serves as the "ground truth" that defines what a successful response looks like for a given task.
2. An Objective Function (or Scoring Metric): This is a function that automatically evaluates the LLM's output against the corresponding "golden" output from the dataset. It returns a score indicating the quality, accuracy, or correctness of the response.

Using these components, an optimizer, such as a Bayesian optimizer, systematically refines the prompt. This process typically involves two main strategies, which can be used independently or in concert:

• Few-Shot Example Optimization: Instead of a developer manually selecting examples for a few-shot prompt, the optimizer programmatically samples different combinations of examples from the goldset. It then tests these combinations to identify the specific set of examples that most effectively guides the model toward generating the desired outputs.

• Instructional Prompt Optimization: In this approach, the optimizer automatically refines the prompt's core instructions. It uses an LLM as a "meta-model" to iteratively mutate and rephrase the prompt's text—adjusting the wording, tone, or structure—to discover which phrasing yields the highest scores from the objective function.

The ultimate goal for both strategies is to maximize the scores from the objective function, effectively "training" the prompt to produce results that are consistently closer to the high-quality goldset. By combining these two approaches, the system can simultaneously optimize what instructions to give the model and which examples to show it, leading to a highly effective and robust prompt that is machine-optimized for the specific task.

Iterative Prompting / Refinement

This technique involves starting with a simple, basic prompt and then iteratively refining it based on the model's initial responses. If the model's output isn't quite right, you analyze the shortcomings and modify the prompt to address them. This is less about an automated process (like APE) and more about a human-driven iterative design loop.

• Example:
  • Attempt 1: "Write a product description for a new type of coffee maker." (Result is too generic).
  • Attempt 2: "Write a product description for a new type of coffee maker. Highlight its speed and ease of cleaning." (Result is better, but lacks detail).
  • Attempt 3: "Write a product description for the 'SpeedClean Coffee Pro'. Emphasize its ability to brew a pot in under 2 minutes and its self-cleaning cycle. Target busy professionals." (Result is much closer to desired).

Providing Negative Examples

While the principle of "Instructions over Constraints" generally holds true, there are situations where providing negative examples can be helpful, albeit used carefully. A negative example shows the model an input and an undesired output, or an input and an output that should not be generated. This can help clarify boundaries or prevent specific types of incorrect responses.

• Example:
  Generate a list of popular tourist attractions in Paris. Do NOT include the Eiffel Tower.

  Example of what NOT to do:
  Input: List popular landmarks in Paris.
  Output: The Eiffel Tower, The Louvre, Notre Dame Cathedral.

Using Analogies

Framing a task using an analogy can sometimes help the model understand the desired output or process by relating it to something familiar. This can be particularly useful for creative tasks or explaining complex roles.

• Example:
  Act as a "data chef". Take the raw ingredients (data points) and prepare a "summary dish" (report) that highlights the key flavors (trends) for a business audience.

Factored Cognition / Decomposition

For very complex tasks, it can be effective to break down the overall goal into smaller, more manageable sub-tasks and prompt the model separately on each sub-task. The results from the sub-tasks are then combined to achieve the final outcome. This is related to prompt chaining and planning but emphasizes the deliberate decomposition of the problem.

• Example: To write a research paper:
  • Prompt 1: "Generate a detailed outline for a paper on the impact of AI on the job market."
  • Prompt 2: "Write the introduction section based on this outline: [insert outline intro]."
  • Prompt 3: "Write the section on 'Impact on White-Collar Jobs' based on this outline: [insert outline section]." (Repeat for other sections).
  • Prompt N: "Combine these sections and write a conclusion."

Retrieval Augmented Generation (RAG)

RAG is a powerful technique that enhances language models by giving them access to external, up-to-date, or domain-specific information during the prompting process. When a user asks a question, the system first retrieves relevant documents or data from a knowledge base (e.g., a database, a set of documents, the web). This retrieved information is then included in the prompt as context, allowing the language model to generate a response grounded in that external knowledge. This mitigates issues like hallucination and provides access to information the model wasn't trained on or that is very recent. This is a key pattern for agentic systems that need to work with dynamic or proprietary information.

• Example:
  • User Query: "What are the new features in the latest version of the Python library 'X'?"
  • System Action: Search a documentation database for "Python library X latest features".
  • Prompt to LLM: "Based on the following documentation snippets: [insert retrieved text], explain the new features in the latest version of Python library 'X'."

Persona Pattern (User Persona):

While role prompting assigns a persona to the model, the Persona Pattern involves describing the user or the target audience for the model's output. This helps the model tailor its response in terms of language, complexity, tone, and the kind of information it provides.

• Example:
  You are explaining quantum physics. The target audience is a high school student with no prior knowledge of the subject. Explain it simply and use analogies they might understand.

  Explain quantum physics: [Insert basic explanation request]

These advanced and supplementary techniques provide further tools for prompt engineers to optimize model behavior, integrate external information, and tailor interactions for specific users and tasks within agentic workflows.

Using Google Gems

Google's AI "Gems" (see Fig. 1) represent a user-configurable feature within its large language model architecture. Each "Gem" functions as a specialized instance of the core Gemini AI, tailored for specific, repeatable tasks. Users create a Gem by providing it with a set of explicit instructions, which establishes its operational parameters. This initial instruction set defines the Gem's designated purpose, response style, and knowledge domain. The underlying model is designed to consistently adhere to these pre-defined directives throughout a conversation.

This allows for the creation of highly specialized AI agents for focused applications. For example, a Gem can be configured to function as a code interpreter that only references specific programming libraries. Another could be instructed to analyze data sets, generating summaries without speculative commentary. A different Gem might serve as a translator adhering to a particular formal style guide. This process creates a persistent, task-specific context for the artificial intelligence.

Consequently, the user avoids the need to re-establish the same contextual information with each new query. This methodology reduces conversational redundancy and improves the efficiency of task execution. The resulting interactions are more focused, yielding outputs that are consistently aligned with the user's initial requirements. This framework allows for applying fine-grained, persistent user direction to a generalist AI model. Ultimately, Gems enable a shift from general-purpose interaction to specialized, pre-defined AI functionalities.

Fig.1: Example of Google Gem usage.

Using LLMs to Refine Prompts (The Meta Approach)

We've explored numerous techniques for crafting effective prompts, emphasizing clarity, structure, and providing context or examples. This process, however, can be iterative and sometimes challenging. What if we could leverage the very power of large language models, like Gemini, to help us improve our prompts? This is the essence of using LLMs for prompt refinement – a "meta" application where AI assists in optimizing the instructions given to AI.

This capability is particularly "cool" because it represents a form of AI self-improvement or at least AI-assisted human improvement in interacting with AI. Instead of solely relying on human intuition and trial-and-error, we can tap into the LLM's understanding of language, patterns, and even common prompting pitfalls to get suggestions for making our prompts better. It turns the LLM into a collaborative partner in the prompt engineering process.

How does this work in practice? You can provide a language model with an existing prompt that you're trying to improve, along with the task you want it to accomplish and perhaps even examples of the output you're currently getting (and why it's not meeting your expectations). You then prompt the LLM to analyze the prompt and suggest improvements.

A model like Gemini, with its strong reasoning and language generation capabilities, can analyze your existing prompt for potential areas of ambiguity, lack of specificity, or inefficient phrasing. It can suggest incorporating techniques we've discussed, such as adding delimiters, clarifying the desired output format, suggesting a more effective persona, or recommending the inclusion of few-shot examples.

The benefits of this meta-prompting approach include:

• Accelerated Iteration: Get suggestions for improvement much faster than pure manual trial and error.
• Identification of Blind Spots: An LLM might spot ambiguities or potential misinterpretations in your prompt that you overlooked.
• Learning Opportunity: By seeing the types of suggestions the LLM makes, you can learn more about what makes prompts effective and improve your own prompt engineering skills.
• Scalability: Potentially automate parts of the prompt optimization process, especially when dealing with a large number of prompts.

It's important to note that the LLM's suggestions are not always perfect and should be evaluated and tested, just like any manually engineered prompt. However, it provides a powerful starting point and can significantly streamline the refinement process.

• Example Prompt for Refinement:
  Analyze the following prompt for a language model and suggest ways to improve it to consistently extract the main topic and key entities (people, organizations, locations) from news articles. The current prompt sometimes misses entities or gets the main topic wrong.

  Existing Prompt:
  "Summarize the main points and list important names and places from this article: [insert article text]"

  Suggestions for Improvement:

In this example, we're using the LLM to critique and enhance another prompt. This meta-level interaction demonstrates the flexibility and power of these models, allowing us to build more effective agentic systems by first optimizing the fundamental instructions they receive. It's a fascinating loop where AI helps us talk better to AI.

Prompting for Specific Tasks

While the techniques discussed so far are broadly applicable, some tasks benefit from specific prompting considerations. These are particularly relevant in the realm of code and multimodal inputs.

Code Prompting

Language models, especially those trained on large code datasets, can be powerful assistants for developers. Prompting for code involves using LLMs to generate, explain, translate, or debug code. Various use cases exist:

• Prompts for writing code: Asking the model to generate code snippets or functions based on a description of the desired functionality.
  • Example: "Write a Python function that takes a list of numbers and returns the average."
• Prompts for explaining code: Providing a code snippet and asking the model to explain what it does, line by line or in a summary.
  • Example: "Explain the following JavaScript code snippet: [insert code]."
• Prompts for translating code: Asking the model to translate code from one programming language to another.
  • Example: "Translate the following Java code to C++: [insert code]."
• Prompts for debugging and reviewing code: Providing code that has an error or could be improved and asking the model to identify issues, suggest fixes, or provide refactoring suggestions.
  • Example: "The following Python code is giving a 'NameError'. What is wrong and how can I fix it? [insert code and traceback]."

Effective code prompting often requires providing sufficient context, specifying the desired language and version, and being clear about the functionality or issue.

Multimodal Prompting

While the focus of this appendix and much of current LLM interaction is text-based, the field is rapidly moving towards multimodal models that can process and generate information across different modalities (text, images, audio, video, etc.). Multimodal prompting involves using a combination of inputs to guide the model. This refers to using multiple input formats instead of just text.

• Example: Providing an image of a diagram and asking the model to explain the process shown in the diagram (Image Input + Text Prompt). Or providing an image and asking the model to generate a descriptive caption (Image Input + Text Prompt -> Text Output).

As multimodal capabilities become more sophisticated, prompting techniques will evolve to effectively leverage these combined inputs and outputs.

Best Practices and Experimentation

Becoming a skilled prompt engineer is an iterative process that involves continuous learning and experimentation. Several valuable best practices are worth reiterating and emphasizing:

• Provide Examples: Providing one or few-shot examples is one of the most effective ways to guide the model.
• Design with Simplicity: Keep your prompts concise, clear, and easy to understand. Avoid unnecessary jargon or overly complex phrasing.
• Be Specific about the Output: Clearly define the desired format, length, style, and content of the model's response.
• Use Instructions over Constraints: Focus on telling the model what you want it to do rather than what you don't want it to do.
• Control the Max Token Length: Use model configurations or explicit prompt instructions to manage the length of the generated output.
• Use Variables in Prompts: For prompts used in applications, use variables to make them dynamic and reusable, avoiding hardcoding specific values.
• Experiment with Input Formats and Writing Styles: Try different ways of phrasing your prompt (question, statement, instruction) and experiment with different tones or styles to see what yields the best results.
• For Few-Shot Prompting with Classification Tasks, Mix Up the Classes: Randomize the order of examples from different categories to prevent overfitting.
• Adapt to Model Updates: Language models are constantly being updated. Be prepared to test your existing prompts on new model versions and adjust them to leverage new capabilities or maintain performance.
• Experiment with Output Formats: Especially for non-creative tasks, experiment with requesting structured output like JSON or XML.
• Experiment Together with Other Prompt Engineers: Collaborating with others can provide different perspectives and lead to discovering more effective prompts.
• CoT Best Practices: Remember specific practices for Chain of Thought, such as placing the answer after the reasoning and setting temperature to 0 for tasks with a single correct answer.
• Document the Various Prompt Attempts: This is crucial for tracking what works, what doesn't, and why. Maintain a structured record of your prompts, configurations, and results.
• Save Prompts in Codebases: When integrating prompts into applications, store them in separate, well-organized files for easier maintenance and version control.
• Rely on Automated Tests and Evaluation: For production systems, implement automated tests and evaluation procedures to monitor prompt performance and ensure generalization to new data.

Prompt engineering is a skill that improves with practice. By applying these principles and techniques, and by maintaining a systematic approach to experimentation and documentation, you can significantly enhance your ability to build effective agentic systems.

Conclusion

This appendix provides a comprehensive overview of prompting, reframing it as a disciplined engineering practice rather than a simple act of asking questions. Its central purpose is to demonstrate how to transform general-purpose language models into specialized, reliable, and highly capable tools for specific tasks. The journey begins with non-negotiable core principles like clarity, conciseness, and iterative experimentation, which are the bedrock of effective communication with AI. These principles are critical because they reduce the inherent ambiguity in natural language, helping to steer the model's probabilistic outputs toward a single, correct intention. Building on this foundation, basic techniques such as zero-shot, one-shot, and few-shot prompting serve as the primary methods for demonstrating expected behavior through examples. These methods provide varying levels of contextual guidance, powerfully shaping the model's response style, tone, and format. Beyond just examples, structuring prompts with explicit roles, system-level instructions, and clear delimiters provides an essential architectural layer for fine-grained control over the model.

The importance of these techniques becomes paramount in the context of building autonomous agents, where they provide the control and reliability necessary for complex, multi-step operations. For an agent to effectively create and execute a plan, it must leverage advanced reasoning patterns like Chain of Thought and Tree of Thoughts. These sophisticated methods compel the model to externalize its logical steps, systematically breaking down complex goals into a sequence of manageable sub-tasks. The operational reliability of the entire agentic system hinges on the predictability of each component's output. This is precisely why requesting structured data like JSON, and programmatically validating it with tools such as Pydantic, is not a mere convenience but an absolute necessity for robust automation. Without this discipline, the agent’s internal cognitive components cannot communicate reliably, leading to catastrophic failures within an automated workflow. Ultimately, these structuring and reasoning techniques are what successfully convert a model's probabilistic text generation into a deterministic and trustworthy cognitive engine for an agent.

Furthermore, these prompts are what grant an agent its crucial ability to perceive and act upon its environment, bridging the gap between digital thought and real-world interaction. Action-oriented frameworks like ReAct and native function calling are the vital mechanisms that serve as the agent's hands, allowing it to use tools, query APIs, and manipulate data. In parallel, techniques like Retrieval Augmented Generation (RAG) and the broader discipline of Context Engineering function as the agent's senses. They actively retrieve relevant, real-time information from external knowledge bases, ensuring the agent’s decisions are grounded in current, factual reality. This critical capability prevents the agent from operating in a vacuum, where it would be limited to its static and potentially outdated training data. Mastering this full spectrum of prompting is therefore the definitive skill that elevates a generalist language model from a simple text generator into a truly sophisticated agent, capable of performing complex tasks with autonomy, awareness, and intelligence.

References

Here is a list of resources for further reading and deeper exploration of prompt engineering techniques:

1. Prompt Engineering, https://www.kaggle.com/whitepaper-prompt-engineering
2. Chain-of-Thought Prompting Elicits Reasoning in Large Language Models, https://arxiv.org/abs/2201.11903
3. Self-Consistency Improves Chain of Thought Reasoning in Language Models, https://arxiv.org/pdf/2203.11171
4. ReAct: Synergizing Reasoning and Acting in Language Models, https://arxiv.org/abs/2210.03629
5. Tree of Thoughts: Deliberate Problem Solving with Large Language Models, https://arxiv.org/pdf/2305.10601
6. Take a Step Back: Evoking Reasoning via Abstraction in Large Language Models, https://arxiv.org/abs/2310.06117
7. DSPy: Programming—not prompting—Foundation Models https://github.com/stanfordnlp/dspy

Appendix B - AI Agentic Interactions: From GUI to Real World environment

AI agents are increasingly performing complex tasks by interacting with digital interfaces and the physical world. Their ability to perceive, process, and act within these varied environments is fundamentally transforming automation, human-computer interaction, and intelligent systems. This appendix explores how agents interact with computers and their environments, highlighting advancements and projects.

Interaction: Agents with Computers

The evolution of AI from conversational partners to active, task-oriented agents is being driven by Agent-Computer Interfaces (ACIs). These interfaces allow AI to interact directly with a computer's Graphical User Interface (GUI), enabling it to perceive and manipulate visual elements like icons and buttons just as a human would. This new method moves beyond the rigid, developer-dependent scripts of traditional automation that relied on APIs and system calls. By using the visual "front door" of software, AI can now automate complex digital tasks in a more flexible and powerful way, a process that involves several key stages:

• Visual Perception: The agent first captures a visual representation of the screen, essentially taking a screenshot.
• GUI Element Recognition: It then analyzes this image to distinguish between various GUI elements. It must learn to "see" the screen not as a mere collection of pixels, but as a structured layout with interactive components, discerning a clickable "Submit" button from a static banner image or an editable text field from a simple label.
• Contextual Interpretation: The ACI module, acting as a bridge between the visual data and the agent's core intelligence (often a Large Language Model or LLM), interprets these elements within the context of the task. It understands that a magnifying glass icon typically means "search" or that a series of radio buttons represents a choice. This module is crucial for enhancing the LLM's reasoning, allowing it to form a plan based on visual evidence.
• Dynamic Action and Response: The agent then programmatically controls the mouse and keyboard to execute its plan—clicking, typing, scrolling, and dragging. Critically, it must constantly monitor the screen for visual feedback, dynamically responding to changes, loading screens, pop-up notifications, or errors to successfully navigate multi-step workflows.

This technology is no longer theoretical. Several leading AI labs have developed functional agents that demonstrate the power of GUI interaction:

ChatGPT Operator (OpenAI): Envisioned as a digital partner, ChatGPT Operator is designed to automate tasks across a wide range of applications directly from the desktop. It understands on-screen elements, enabling it to perform actions like transferring data from a spreadsheet into a customer relationship management (CRM) platform, booking a complex travel itinerary across airline and hotel websites, or filling out detailed online forms without needing specialized API access for each service. This makes it a universally adaptable tool aimed at boosting both personal and enterprise productivity by taking over repetitive digital chores.

Google Project Mariner: As a research prototype, Project Mariner operates as an agent within the Chrome browser (see Fig. 1). Its purpose is to understand a user's intent and autonomously carry out web-based tasks on their behalf. For example, a user could ask it to find three apartments for rent within a specific budget and neighborhood; Mariner would then navigate to real estate websites, apply the filters, browse the listings, and extract the relevant information into a document. This project represents Google's exploration into creating a truly helpful and "agentive" web experience where the browser actively works for the user.

Fig.1: Interaction between and Agent and the Web Browser

Anthropic's Computer Use: This feature empowers Anthropic's AI model, Claude, to become a direct user of a computer's desktop environment. By capturing screenshots to perceive the screen and programmatically controlling the mouse and keyboard, Claude can orchestrate workflows that span multiple, unconnected applications. A user could ask it to analyze data in a PDF report, open a spreadsheet application to perform calculations on that data, generate a chart, and then paste that chart into an email draft—a sequence of tasks that previously required constant human input.

Browser Use: This is an open-source library that provides a high-level API for programmatic browser automation. It enables AI agents to interface with web pages by granting them access to and control over the Document Object Model (DOM). The API abstracts the intricate, low-level commands of browser control protocols, into a more simplified and intuitive set of functions. This allows an agent to perform complex sequences of actions, including data extraction from nested elements, form submissions, and automated navigation across multiple pages. As a result, the library facilitates the transformation of unstructured web data into a structured format that an AI agent can systematically process and utilize for analysis or decision-making.

Interaction: Agents with the Environment

Beyond the confines of a computer screen, AI agents are increasingly designed to interact with complex, dynamic environments, often mirroring the real world. This requires sophisticated perception, reasoning, and actuation capabilities.

Google's Project Astra is a prime example of an initiative pushing the boundaries of agent interaction with the environment. Astra aims to create a universal AI agent that is helpful in everyday life, leveraging multimodal inputs (sight, sound, voice) and outputs to understand and interact with the world contextually. This project focuses on rapid understanding, reasoning, and response, allowing the agent to "see" and "hear" its surroundings through cameras and microphones and engage in natural conversation while providing real-time assistance. Astra's vision is an agent that can seamlessly assist users with tasks ranging from finding lost items to debugging code, by understanding the environment it observes. This moves beyond simple voice commands to a truly embodied understanding of the user's immediate physical context.

Google's Gemini Live, transforms standard AI interactions into a fluid and dynamic conversation. Users can speak to the AI and receive responses in a natural-sounding voice with minimal delay, and can even interrupt or change topics mid-sentence, prompting the AI to adapt immediately. The interface expands beyond voice, allowing users to incorporate visual information by using their phone's camera, sharing their screen, or uploading files for a more context-aware discussion. More advanced versions can even perceive a user's tone of voice and intelligently filter out irrelevant background noise to better understand the conversation. These capabilities combine to create rich interactions, such as receiving live instructions on a task by simply pointing a camera at it.

OpenAI's GPT-4o model is an alternative designed for "omni" interaction, meaning it can reason across voice, vision, and text. It processes these inputs with low latency that mirrors human response times, which allows for real-time conversations. For example, users can show the AI a live video feed to ask questions about what is happening, or use it for language translation. OpenAI provides developers with a "Realtime API" to build applications requiring low-latency, speech-to-speech interactions.

OpenAI's ChatGPT Agent represents a significant architectural advancement over its predecessors, featuring an integrated framework of new capabilities. Its design incorporates several key functional modalities: the capacity for autonomous navigation of the live internet for real-time data extraction, the ability to dynamically generate and execute computational code for tasks like data analysis, and the functionality to interface directly with third-party software applications. The synthesis of these functions allows the agent to orchestrate and complete complex, sequential workflows from a singular user directive. It can therefore autonomously manage entire processes, such as performing market analysis and generating a corresponding presentation, or planning logistical arrangements and executing the necessary transactions. In parallel with the launch, OpenAI has proactively addressed the emergent safety considerations inherent in such a system. An accompanying "System Card" delineates the potential operational hazards associated with an AI capable of performing actions online, acknowledging the new vectors for misuse. To mitigate these risks, the agent's architecture includes engineered safeguards, such as requiring explicit user authorization for certain classes of actions and deploying robust content filtering mechanisms. The company is now engaging its initial user base to further refine these safety protocols through a feedback-driven, iterative process.

Seeing AI, a complimentary mobile application from Microsoft, empowers individuals who are blind or have low vision by offering real-time narration of their surroundings. The app leverages artificial intelligence through the device's camera to identify and describe various elements, including objects, text, and even people. Its core functionalities encompass reading documents, recognizing currency, identifying products through barcodes, and describing scenes and colors. By providing enhanced access to visual information, Seeing AI ultimately fosters greater independence for visually impaired users.

Anthropic's Claude 4 Series Anthropic's Claude 4 is another alternative with capabilities for advanced reasoning and analysis. Though historically focused on text, Claude 4 includes robust vision capabilities, allowing it to process information from images, charts, and documents. The model is suited for handling complex, multi-step tasks and providing detailed analysis. While the real-time conversational aspect is not its primary focus compared to other models, its underlying intelligence is designed for building highly capable AI agents.

Vibe Coding: Intuitive Development with AI

Beyond direct interaction with GUIs and the physical world, a new paradigm is emerging in how developers build software with AI: "vibe coding." This approach moves away from precise, step-by-step instructions and instead relies on a more intuitive, conversational, and iterative interaction between the developer and an AI coding assistant. The developer provides a high-level goal, a desired "vibe," or a general direction, and the AI generates code to match.

This process is characterized by:

• Conversational Prompts: Instead of writing detailed specifications, a developer might say, "Create a simple, modern-looking landing page for a new app," or, "Refactor this function to be more Pythonic and readable." The AI interprets the "vibe" of "modern" or "Pythonic" and generates the corresponding code.
• Iterative Refinement: The initial output from the AI is often a starting point. The developer then provides feedback in natural language, such as, "That's a good start, but can you make the buttons blue?" or, "Add some error handling to that." This back-and-forth continues until the code meets the developer's expectations.
• Creative Partnership: In vibe coding, the AI acts as a creative partner, suggesting ideas and solutions that the developer may not have considered. This can accelerate the development process and lead to more innovative outcomes.
• Focus on "What" not "How": The developer focuses on the desired outcome (the "what") and leaves the implementation details (the "how") to the AI. This allows for rapid prototyping and exploration of different approaches without getting bogged down in boilerplate code.
• Optional Memory Banks: To maintain context across longer interactions, developers can use "memory banks" to store key information, preferences, or constraints. For example, a developer might save a specific coding style or a set of project requirements to the AI's memory, ensuring that future code generations remain consistent with the established "vibe" without needing to repeat the instructions.

Vibe coding is becoming increasingly popular with the rise of powerful AI models like GPT-4, Claude, and Gemini, which are integrated into development environments. These tools are not just auto-completing code; they are actively participating in the creative process of software development, making it more accessible and efficient. This new way of working is changing the nature of software engineering, emphasizing creativity and high-level thinking over rote memorization of syntax and APIs.

Key takeaways

• AI agents are evolving from simple automation to visually controlling software through graphical user interfaces, much like a human would.
• The next frontier is real-world interaction, with projects like Google's Astra using cameras and microphones to see, hear, and understand their physical surroundings.
• Leading technology companies are converging these digital and physical capabilities to create universal AI assistants that operate seamlessly across both domains.
• This shift is creating a new class of proactive, context-aware AI companions capable of assisting with a vast range of tasks in users' daily lives.

Conclusion

Agents are undergoing a significant transformation, moving from basic automation to sophisticated interaction with both digital and physical environments. By leveraging visual perception to operate Graphical User Interfaces, these agents can now manipulate software just as a human would, bypassing the need for traditional APIs. Major technology labs are pioneering this space with agents capable of automating complex, multi-application workflows directly on a user's desktop. Simultaneously, the next frontier is expanding into the physical world, with initiatives like Google's Project Astra using cameras and microphones to contextually engage with their surroundings. These advanced systems are designed for multimodal, real-time understanding that mirrors human interaction.

The ultimate vision is a convergence of these digital and physical capabilities, creating universal AI assistants that operate seamlessly across all of a user's environments. This evolution is also reshaping software creation itself through "vibe coding," a more intuitive and conversational partnership between developers and AI. This new method prioritizes high-level goals and creative intent, allowing developers to focus on the desired outcome rather than implementation details. This shift accelerates development and fosters innovation by treating AI as a creative partner. Ultimately, these advancements are paving the way for a new era of proactive, context-aware AI companions capable of assisting with a vast array of tasks in our daily lives.

References

1. Open AI Operator, https://openai.com/index/introducing-operator/
2. Open AI ChatGPT Agent: https://openai.com/index/introducing-chatgpt-agent/
3. Browser Use: https://docs.browser-use.com/introduction
4. Project Mariner, https://deepmind.google/models/project-mariner/
5. Anthropic Computer use: https://docs.anthropic.com/en/docs/build-with-claude/computer-use
6. Project Astra, https://deepmind.google/models/project-astra/
7. Gemini Live, https://gemini.google/overview/gemini-live/?hl=en
8. OpenAI's GPT-4, https://openai.com/index/gpt-4-research/
9. Claude 4, https://www.anthropic.com/news/claude-4

Appendix C - Quick overview of Agentic Frameworks

LangChain

LangChain is a framework for developing applications powered by LLMs. Its core strength lies in its LangChain Expression Language (LCEL), which allows you to "pipe" components together into a chain. This creates a clear, linear sequence where the output of one step becomes the input for the next. It's built for workflows that are Directed Acyclic Graphs (DAGs), meaning the process flows in one direction without loops.

Use it for:

• Simple RAG: Retrieve a document, create a prompt, get an answer from an LLM.
• Summarization: Take user text, feed it to a summarization prompt, and return the output.
• Extraction: Extract structured data (like JSON) from a block of text.

Python

| # A simple LCEL chain conceptually # (This is not runnable code, just illustrates the flow) chain = prompt | model | output_parse | | :---- |

LangGraph

LangGraph is a library built on top of LangChain to handle more advanced agentic systems. It allows you to define your workflow as a graph with nodes (functions or LCEL chains) and edges (conditional logic). Its main advantage is the ability to create cycles, allowing the application to loop, retry, or call tools in a flexible order until a task is complete. It explicitly manages the application state, which is passed between nodes and updated throughout the process.

Use it for:

• Multi-agent Systems: A supervisor agent routes tasks to specialized worker agents, potentially looping until the goal is met.
• Plan-and-Execute Agents: An agent creates a plan, executes a step, and then loops back to update the plan based on the result.
• Human-in-the-Loop: The graph can wait for human input before deciding which node to go to next.

Feature	LangChain	LangGraph
Core Abstraction	Chain (using LCEL)	Graph of Nodes
Workflow Type	Linear (Directed Acyclic Graph)	Cyclical (Graphs with loops)
State Management	Generally stateless per run	Explicit and persistent state object
Primary Use	Simple, predictable sequences	Complex, dynamic, stateful agents

Which One Should You Use?

• Choose LangChain when your application has a clear, predictable, and linear flow of steps. If you can define the process from A to B to C without needing to loop back, LangChain with LCEL is the perfect tool.
• Choose LangGraph when you need your application to reason, plan, or operate in a loop. If your agent needs to use tools, reflect on the results, and potentially try again with a different approach, you need the cyclical and stateful nature of LangGraph.

Python

# Graph state class State(TypedDict): topic: str joke: str story: str poem: str combined_output: str # Nodes def call_llm_1(state: State): """First LLM call to generate initial joke""" msg = llm.invoke(f"Write a joke about {state['topic']}") return {"joke": msg.content} def call_llm_2(state: State): """Second LLM call to generate story""" msg = llm.invoke(f"Write a story about {state['topic']}") return {"story": msg.content} def call_llm_3(state: State): """Third LLM call to generate poem""" msg = llm.invoke(f"Write a poem about {state['topic']}") return {"poem": msg.content} def aggregator(state: State): """Combine the joke and story into a single output""" combined = f"Here's a story, joke, and poem about {state['topic']}!\n\n" combined += f"STORY:\n{state['story']}\n\n" combined += f"JOKE:\n{state['joke']}\n\n" combined += f"POEM:\n{state['poem']}" return {"combined_output": combined} # Build workflow parallel_builder = StateGraph(State) # Add nodes parallel_builder.add_node("call_llm_1", call_llm_1) parallel_builder.add_node("call_llm_2", call_llm_2) parallel_builder.add_node("call_llm_3", call_llm_3) parallel_builder.add_node("aggregator", aggregator) # Add edges to connect nodes parallel_builder.add_edge(START, "call_llm_1") parallel_builder.add_edge(START, "call_llm_2") parallel_builder.add_edge(START, "call_llm_3") parallel_builder.add_edge("call_llm_1", "aggregator") parallel_builder.add_edge("call_llm_2", "aggregator") parallel_builder.add_edge("call_llm_3", "aggregator") parallel_builder.add_edge("aggregator", END) parallel_workflow = parallel_builder.compile() # Show workflow display(Image(parallel_workflow.get_graph().draw_mermaid_png())) # Invoke state = parallel_workflow.invoke({"topic": "cats"}) print(state["combined_output"])

This code defines and runs a LangGraph workflow that operates in parallel. Its main purpose is to simultaneously generate a joke, a story, and a poem about a given topic and then combine them into a single, formatted text output.

Google's ADK

Google's Agent Development Kit, or ADK, provides a high-level, structured framework for building and deploying applications composed of multiple, interacting AI agents. It contrasts with LangChain and LangGraph by offering a more opinionated and production-oriented system for orchestrating agent collaboration, rather than providing the fundamental building blocks for an agent's internal logic.

LangChain operates at the most foundational level, offering the components and standardized interfaces to create sequences of operations, such as calling a model and parsing its output. LangGraph extends this by introducing a more flexible and powerful control flow; it treats an agent's workflow as a stateful graph. Using LangGraph, a developer explicitly defines nodes, which are functions or tools, and edges, which dictate the path of execution. This graph structure allows for complex, cyclical reasoning where the system can loop, retry tasks, and make decisions based on an explicitly managed state object that is passed between nodes. It gives the developer fine-grained control over a single agent's thought process or the ability to construct a multi-agent system from first principles.

Google's ADK abstracts away much of this low-level graph construction. Instead of asking the developer to define every node and edge, it provides pre-built architectural patterns for multi-agent interaction. For instance, ADK has built-in agent types like SequentialAgent or ParallelAgent, which manage the flow of control between different agents automatically. It is architected around the concept of a "team" of agents, often with a primary agent delegating tasks to specialized sub-agents. State and session management are handled more implicitly by the framework, providing a more cohesive but less granular approach than LangGraph's explicit state passing. Therefore, while LangGraph gives you the detailed tools to design the intricate wiring of a single robot or a team, Google's ADK gives you a factory assembly line designed to build and manage a fleet of robots that already know how to work together.

Python

from google.adk.agents import LlmAgent from google.adk.tools import google_Search dice_agent = LlmAgent( model="gemini-2.0-flash-exp", name="question_answer_agent", description="A helpful assistant agent that can answer questions.", instruction="""Respond to the query using google search""", tools=[google_search], )

This code creates a search-augmented agent. When this agent receives a question, it will not just rely on its pre-existing knowledge. Instead, following its instructions, it will use the Google Search tool to find relevant, real-time information from the web and then use that information to construct its answer.

Crew.AI

CrewAI offers an orchestration framework for building multi-agent systems by focusing on collaborative roles and structured processes. It operates at a higher level of abstraction than foundational toolkits, providing a conceptual model that mirrors a human team. Instead of defining the granular flow of logic as a graph, the developer defines the actors and their assignments, and CrewAI manages their interaction.

The core components of this framework are Agents, Tasks, and the Crew. An Agent is defined not just by its function but by a persona, including a specific role, a goal, and a backstory, which guides its behavior and communication style. A Task is a discrete unit of work with a clear description and expected output, assigned to a specific Agent. The Crew is the cohesive unit that contains the Agents and the list of Tasks, and it executes a predefined Process. This process dictates the workflow, which is typically either sequential, where the output of one task becomes the input for the next in line, or hierarchical, where a manager-like agent delegates tasks and coordinates the workflow among other agents.

When compared to other frameworks, CrewAI occupies a distinct position. It moves away from the low-level, explicit state management and control flow of LangGraph, where a developer wires together every node and conditional edge. Instead of building a state machine, the developer designs a team charter. While Googlés ADK provides a comprehensive, production-oriented platform for the entire agent lifecycle, CrewAI concentrates specifically on the logic of agent collaboration and for simulating a team of specialists

Python

@crew def crew(self) -> Crew: """Creates the research crew""" return Crew( agents=self.agents, tasks=self.tasks, process=Process.sequential, verbose=True, )

This code sets up a sequential workflow for a team of AI agents, where they tackle a list of tasks in a specific order, with detailed logging enabled to monitor their progress.

Other agent development framework

Microsoft AutoGen: AutoGen is a framework centered on orchestrating multiple agents that solve tasks through conversation. Its architecture enables agents with distinct capabilities to interact, allowing for complex problem decomposition and collaborative resolution. The primary advantage of AutoGen is its flexible, conversation-driven approach that supports dynamic and complex multi-agent interactions. However, this conversational paradigm can lead to less predictable execution paths and may require sophisticated prompt engineering to ensure tasks converge efficiently.

LlamaIndex: LlamaIndex is fundamentally a data framework designed to connect large language models with external and private data sources. It excels at creating sophisticated data ingestion and retrieval pipelines, which are essential for building knowledgeable agents that can perform RAG. While its data indexing and querying capabilities are exceptionally powerful for creating context-aware agents, its native tools for complex agentic control flow and multi-agent orchestration are less developed compared to agent-first frameworks. LlamaIndex is optimal when the core technical challenge is data retrieval and synthesis.

Haystack: Haystack is an open-source framework engineered for building scalable and production-ready search systems powered by language models. Its architecture is composed of modular, interoperable nodes that form pipelines for document retrieval, question answering, and summarization. The main strength of Haystack is its focus on performance and scalability for large-scale information retrieval tasks, making it suitable for enterprise-grade applications. A potential trade-off is that its design, optimized for search pipelines, can be more rigid for implementing highly dynamic and creative agentic behaviors.

MetaGPT: MetaGPT implements a multi-agent system by assigning roles and tasks based on a predefined set of Standard Operating Procedures (SOPs). This framework structures agent collaboration to mimic a software development company, with agents taking on roles like product managers or engineers to complete complex tasks. This SOP-driven approach results in highly structured and coherent outputs, which is a significant advantage for specialized domains like code generation. The framework's primary limitation is its high degree of specialization, making it less adaptable for general-purpose agentic tasks outside of its core design.

SuperAGI: SuperAGI is an open-source framework designed to provide a complete lifecycle management system for autonomous agents. It includes features for agent provisioning, monitoring, and a graphical interface, aiming to enhance the reliability of agent execution. The key benefit is its focus on production-readiness, with built-in mechanisms to handle common failure modes like looping and to provide observability into agent performance. A potential drawback is that its comprehensive platform approach can introduce more complexity and overhead than a more lightweight, library-based framework.

Semantic Kernel: Developed by Microsoft, Semantic Kernel is an SDK that integrates large language models with conventional programming code through a system of "plugins" and "planners." It allows an LLM to invoke native functions and orchestrate workflows, effectively treating the model as a reasoning engine within a larger software application. Its primary strength is its seamless integration with existing enterprise codebases, particularly in .NET and Python environments. The conceptual overhead of its plugin and planner architecture can present a steeper learning curve compared to more straightforward agent frameworks.

Strands Agents: An AWS lightweight and flexible SDK that uses a model-driven approach for building and running AI agents. It is designed to be simple and scalable, supporting everything from basic conversational assistants to complex multi-agent autonomous systems. The framework is model-agnostic, offering broad support for various LLM providers, and includes native integration with the MCP for easy access to external tools. Its core advantage is its simplicity and flexibility, with a customizable agent loop that is easy to get started with. A potential trade-off is that its lightweight design means developers may need to build out more of the surrounding operational infrastructure, such as advanced monitoring or lifecycle management systems, which more comprehensive frameworks might provide out-of-the-box.

Conclusion

The landscape of agentic frameworks offers a diverse spectrum of tools, from low-level libraries for defining agent logic to high-level platforms for orchestrating multi-agent collaboration. At the foundational level, LangChain enables simple, linear workflows, while LangGraph introduces stateful, cyclical graphs for more complex reasoning. Higher-level frameworks like CrewAI and Google's ADK shift the focus to orchestrating teams of agents with predefined roles, while others like LlamaIndex specialize in data-intensive applications. This variety presents developers with a core trade-off between the granular control of graph-based systems and the streamlined development of more opinionated platforms. Consequently, selecting the right framework hinges on whether the application requires a simple sequence, a dynamic reasoning loop, or a managed team of specialists. Ultimately, this evolving ecosystem empowers developers to build increasingly sophisticated AI systems by choosing the precise level of abstraction their project demands.

References

1. LangChain, https://www.langchain.com/
2. LangGraph, https://www.langchain.com/langgraph
3. Google's ADK, https://google.github.io/adk-docs/
4. Crew.AI, https://docs.crewai.com/en/introduction

Appendix D - Building an Agent with AgentSpace

Overview

AgentSpace is a platform designed to facilitate an "agent-driven enterprise" by integrating artificial intelligence into daily workflows. At its core, it provides a unified search capability across an organization's entire digital footprint, including documents, emails, and databases. This system utilizes advanced AI models, like Google's Gemini, to comprehend and synthesize information from these varied sources.

The platform enables the creation and deployment of specialized AI "agents" that can perform complex tasks and automate processes. These agents are not merely chatbots; they can reason, plan, and execute multi-step actions autonomously. For instance, an agent could research a topic, compile a report with citations, and even generate an audio summary.

To achieve this, AgentSpace constructs an enterprise knowledge graph, mapping the relationships between people, documents, and data. This allows the AI to understand context and deliver more relevant and personalized results. The platform also includes a no-code interface called Agent Designer for creating custom agents without requiring deep technical expertise.

Furthermore, AgentSpace supports a multi-agent system where different AI agents can communicate and collaborate through an open protocol known as the Agent2Agent (A2A) Protocol. This interoperability allows for more complex and orchestrated workflows. Security is a foundational component, with features like role-based access controls and data encryption to protect sensitive enterprise information. Ultimately, AgentSpace aims to enhance productivity and decision-making by embedding intelligent, autonomous systems directly into an organization's operational fabric.

How to build an Agent with AgentSpace UI

Figure 1 illustrates how to access AgentSpace by selecting AI Applications from the Google Cloud Console.

Fig. 1: How to use Google Cloud Console to access AgentSpace

Your agent can be connected to various services, including Calendar, Google Mail, Workaday, Jira, Outlook, and Service Now (see Fig. 2).

Fig. 2: Integrate with diverse services, including Google and third-party platforms.

The Agent can then utilize its own prompt, chosen from a gallery of pre-made prompts provided by Google, as illustrated in Fig. 3.

Fig.3: Google's Gallery of Pre-assembled prompts

In alternative you can create your own prompt as in Fig.4, which will be then used by your agent

Fig.4: Customizing the Agent's Prompt

AgentSpace offers a number of advanced features such as integration with datastores to store your own data, integration with Google Knowledge Graph or with your private Knowledge Graph, Web interface for exposing your agent to the Web, and Analytics to monitor usage, and more (see Fig. 5)

Fig. 5: AgentSpace advanced capabilities

Upon completion, the AgentSpace chat interface (Fig. 6) will be accessible.

Fig. 6: The AgentSpace User Interface for initiating a chat with your Agent.

Conclusion

In conclusion, AgentSpace provides a functional framework for developing and deploying AI agents within an organization's existing digital infrastructure. The system's architecture links complex backend processes, such as autonomous reasoning and enterprise knowledge graph mapping, to a graphical user interface for agent construction. Through this interface, users can configure agents by integrating various data services and defining their operational parameters via prompts, resulting in customized, context-aware automated systems.

This approach abstracts the underlying technical complexity, enabling the construction of specialized multi-agent systems without requiring deep programming expertise. The primary objective is to embed automated analytical and operational capabilities directly into workflows, thereby increasing process efficiency and enhancing data-driven analysis. For practical instruction, hands-on learning modules are available, such as the "Build a Gen AI Agent with Agentspace" lab on Google Cloud Skills Boost, which provides a structured environment for skill acquisition.

References

1. Create a no-code agent with Agent Designer, https://cloud.google.com/agentspace/agentspace-enterprise/docs/agent-designer
2. Google Cloud Skills Boost, https://www.cloudskillsboost.google/

Appendix E - AI Agents on the CLI

Introduction

​​The developer's command line, long a bastion of precise, imperative commands, is undergoing a profound transformation. It is evolving from a simple shell into an intelligent, collaborative workspace powered by a new class of tools: AI Agent Command-Line Interfaces (CLIs). These agents move beyond merely executing commands; they understand natural language, maintain context about your entire codebase, and can perform complex, multi-step tasks that automate significant parts of the development lifecycle.

This guide provides an in-depth look at four leading players in this burgeoning field, exploring their unique strengths, ideal use cases, and distinct philosophies to help you determine which tool best fits your workflow. It is important to note that many of the example use cases provided for a specific tool can often be accomplished by the other agents as well. The key differentiator between these tools frequently lies in the quality, efficiency, and nuance of the results they are able to achieve for a given task. There are specific benchmarks designed to measure these capabilities, which will be discussed in the following sections.

Claude CLI (Claude Code)

Anthropic's Claude CLI is engineered as a high-level coding agent with a deep, holistic understanding of a project's architecture. Its core strength is its "agentic" nature, allowing it to create a mental model of your repository for complex, multi-step tasks. The interaction is highly conversational, resembling a pair programming session where it explains its plans before executing. This makes it ideal for professional developers working on large-scale projects involving significant refactoring or implementing features with broad architectural impacts.

Example Use Cases:

1. Large-Scale Refactoring: You can instruct it: "Our current user authentication relies on session cookies. Refactor the entire codebase to use stateless JWTs, updating the login/logout endpoints, middleware, and frontend token handling." Claude will then read all relevant files and perform the coordinated changes.
2. API Integration: After being provided with an OpenAPI specification for a new weather service, you could say: "Integrate this new weather API. Create a service module to handle the API calls, add a new component to display the weather, and update the main dashboard to include it."
3. Documentation Generation: Pointing it to a complex module with poorly documented code, you can ask: "Analyze the ./src/utils/data_processing.js file. Generate comprehensive TSDoc comments for every function, explaining its purpose, parameters, and return value."

Claude CLI functions as a specialized coding assistant, with inherent tools for core development tasks, including file ingestion, code structure analysis, and edit generation. Its deep integration with Git facilitates direct branch and commit management. The agent's extensibility is mediated by the Multi-tool Control Protocol (MCP), enabling users to define and integrate custom tools. This allows for interactions with private APIs, database queries, and execution of project-specific scripts. This architecture positions the developer as the arbiter of the agent's functional scope, effectively characterizing Claude as a reasoning engine augmented by user-defined tooling.

Gemini CLI

Google's Gemini CLI is a versatile, open-source AI agent designed for power and accessibility. It stands out with the advanced Gemini 2.5 Pro model, a massive context window, and multimodal capabilities (processing images and text). Its open-source nature, generous free tier, and "Reason and Act" loop make it a transparent, controllable, and excellent all-rounder for a broad audience, from hobbyists to enterprise developers, especially those within the Google Cloud ecosystem.

Example Use Cases:

1. Multimodal Development: You provide a screenshot of a web component from a design file (gemini describe component.png) and instruct it: "Write the HTML and CSS code to build a React component that looks exactly like this. Make sure it's responsive."
2. Cloud Resource Management: Using its built-in Google Cloud integration, you can command: "Find all GKE clusters in the production project that are running versions older than 1.28 and generate a gcloud command to upgrade them one by one."
3. Enterprise Tool Integration (via MCP): A developer provides Gemini with a custom tool called get-employee-details that connects to the company's internal HR API. The prompt is: "Draft a welcome document for our new hire. First, use the get-employee-details --id=E90210 tool to fetch their name and team, and then populate the welcome_template.md with that information."
4. Large-Scale Refactoring: A developer needs to refactor a large Java codebase to replace a deprecated logging library with a new, structured logging framework. They can use Gemini with a prompt like: Read all *.java files in the 'src/main/java' directory. For each file, replace all instances of the 'org.apache.log4j' import and its 'Logger' class with 'org.slf4j.Logger' and 'LoggerFactory'. Rewrite the logger instantiation and all .info(), .debug(), and .error() calls to use the new structured format with key-value pairs.

Gemini CLI is equipped with a suite of built-in tools that allow it to interact with its environment. These include tools for file system operations (like reading and writing), a shell tool for running commands, and tools for accessing the internet via web fetching and searching. For broader context, it uses specialized tools to read multiple files at once and a memory tool to save information for later sessions. This functionality is built on a secure foundation: sandboxing isolates the model's actions to prevent risk, while MCP servers act as a bridge, enabling Gemini to safely connect to your local environment or other APIs.

Aider

Aider is an open-source AI coding assistant that acts as a true pair programmer by working directly on your files and committing changes to Git. Its defining feature is its directness; it applies edits, runs tests to validate them, and automatically commits every successful change. Being model-agnostic, it gives users complete control over cost and capabilities. Its git-centric workflow makes it perfect for developers who value efficiency, control, and a transparent, auditable trail of all code modifications.

Example Use Cases:

1. Test-Driven Development (TDD): A developer can say: "Create a failing test for a function that calculates the factorial of a number." After Aider writes the test and it fails, the next prompt is: "Now, write the code to make the test pass." Aider implements the function and runs the test again to confirm.
2. Precise Bug Squashing: Given a bug report, you can instruct Aider: "The calculate_total function in billing.py fails on leap years. Add the file to the context, fix the bug, and verify your fix against the existing test suite."
3. Dependency Updates: You could instruct it: "Our project uses an outdated version of the 'requests' library. Please go through all Python files, update the import statements and any deprecated function calls to be compatible with the latest version, and then update requirements.txt."

GitHub Copilot CLI

GitHub Copilot CLI extends the popular AI pair programmer into the terminal, with its primary advantage being its native, deep integration with the GitHub ecosystem. It understands the context of a project within GitHub. Its agent capabilities allow it to be assigned a GitHub issue, work on a fix, and submit a pull request for human review.

Example Use Cases:

1. Automated Issue Resolution: A manager assigns a bug ticket (e.g., "Issue #123: Fix off-by-one error in pagination") to the Copilot agent. The agent then checks out a new branch, writes the code, and submits a pull request referencing the issue, all without manual developer intervention.
2. Repository-Aware Q&A: A new developer on the team can ask: "Where in this repository is the database connection logic defined, and what environment variables does it require?" Copilot CLI uses its awareness of the entire repo to provide a precise answer with file paths.
3. Shell Command Helper: When unsure about a complex shell command, a user can ask: gh? find all files larger than 50MB, compress them, and place them in an archive folder. Copilot will generate the exact shell command needed to perform the task.

Terminal-Bench: A Benchmark for AI Agents in Command-Line Interfaces

Terminal-Bench is a novel evaluation framework designed to assess the proficiency of AI agents in executing complex tasks within a command-line interface. The terminal is identified as an optimal environment for AI agent operation due to its text-based, sandboxed nature. The initial release, Terminal-Bench-Core-v0, comprises 80 manually curated tasks spanning domains such as scientific workflows and data analysis. To ensure equitable comparisons, Terminus, a minimalistic agent, was developed to serve as a standardized testbed for various language models. The framework is designed for extensibility, allowing for the integration of diverse agents through containerization or direct connections. Future developments include enabling massively parallel evaluations and incorporating established benchmarks. The project encourages open-source contributions for task expansion and collaborative framework enhancement.

Conclusion

The emergence of these powerful AI command-line agents marks a fundamental shift in software development, transforming the terminal into a dynamic and collaborative environment. As we've seen, there is no single "best" tool; instead, a vibrant ecosystem is forming where each agent offers a specialized strength. The ideal choice depends entirely on the developer's needs: Claude for complex architectural tasks, Gemini for versatile and multimodal problem-solving, Aider for git-centric and direct code editing, and GitHub Copilot for seamless integration into the GitHub workflow. As these tools continue to evolve, proficiency in leveraging them will become an essential skill, fundamentally changing how developers build, debug, and manage software.

References

1. Anthropic. Claude. https://docs.anthropic.com/en/docs/claude-code/cli-reference
2. Google Gemini Cli https://github.com/google-gemini/gemini-cli
3. Aider. https://aider.chat/
4. GitHub Copilot CLI https://docs.github.com/en/copilot/github-copilot-enterprise/copilot-cli
5. Terminal Bench: https://www.tbench.ai/

Appendix F - Under the Hood: An Inside Look at the Agents’Reasoning Engines

The emergence of intelligent Agents represents a pivotal shift in artificial intelligence. These are systems designed to plan, strategize, and execute complex tasks, and at the cognitive core of each lies a LLM. This LLM is not merely a sophisticated text generator; it serves as the foundational reasoning engine, the central "mind" that empowers the Agent to make decisions, formulate plans, and interact with its environment.

Therefore, understanding the internal reasoning mechanisms of these models is no longer an academic exercise—it is a critical necessity for developing the next generation of robust, reliable, and effective Agents. In this section, we directly investigate these core engines by posing a fundamental question to several of today's leading models: Gemini, ChatGPT, Grok, Kimi, Claude, and DeepSeek. By prompting these LLMs to articulate their own step-by-step reasoning processes, we aim to illuminate the fundamental logic that will drive the capabilities and limitations of future intelligent Agent systems.

Prompt given to each LLM: I understand you can reason, can you explain to me how you reason? Explain me step by step

Gemini

Analyzing My Approach

I've outlined the structure for my explanation, aiming for clarity and conciseness. First, a direct answer, then a breakdown into logical steps. Step 1 will involve defining the key reasoning process I use, and then I will elaborate on the subsequent steps. This should facilitate a straightforward and easy-to-understand explanation.

Refining the Explanation

I've finalized the structure of my explanation. Step 1 focuses on deconstructing prompts, specifically the analysis of the user's request. Step 2 details information retrieval, emphasizing pattern recognition rather than simple database lookup. Step 3 explores synthesis and LLMs, and Step 4 will focus on response generation, which includes formatting, tone, and instruction adherence. I will conclude with a summary to reinforce the key stages, while maintaining clarity and engagement.

Elaborating My Methodology

I've fleshed out the "Deconstructing the Prompt" step, focusing on how I identify the user's intent, the core question, and any constraints provided. The Information Retrieval phase is now focused on pattern recognition, not just data retrieval, which will be the first item under this section. I am working on the Synthesis step, which is where I weave information together with LLMs and transformers. The Generating the Response step is solidified, and I will be using emojis to enhance the overall tone.

Of course. I reason by breaking down your request into smaller parts and then using my vast training data to build a logical and relevant response. It's a multi-step process that moves from understanding to generating.

Here’s a step-by-step breakdown of how I reason:

---

1. Deconstructing the Prompt 📝

First, I analyze your question or instruction to understand exactly what you're asking. I identify:

• The Core Task: What is the main goal? Is it to answer a question, explain a concept, write a story, or summarize a text? In your case, the core task is to "explain how I reason."
• Key Concepts: I pinpoint the essential nouns and verbs, like "reason," "explain," and "step-by-step."
• Constraints and Instructions: I look for specific rules to follow. For example, your prompt asked for a step-by-step explanation. My internal instructions also guide me to use LaTeX for math, use markdown headings, and maintain a certain tone.
• Intent: I try to infer your underlying goal. Are you curious, trying to solve a problem, or looking for creative ideas? Here, your intent is to understand my internal cognitive process.

---

2. Information Retrieval and Synthesis 🧠

Once I understand the prompt, I access my internal knowledge base. This isn't like searching a database. Instead, I use patterns learned during my training on a massive amount of text and code.

• Activating Relevant Knowledge: I activate the parts of my neural network that are associated with the key concepts from your prompt ("reasoning," "AI," "machine learning," "neural networks," "transformers").
• Pattern Recognition: My architecture, particularly the Transformer model, is excellent at recognizing relationships and patterns between words and ideas. I identify how concepts connect. For instance, I connect "reasoning" to "logic," "inference," and "problem-solving."
• Structuring the Answer: I begin to organize the retrieved information into a logical structure. For this response, I decided a step-by-step format was the most logical structure, following your request.

---

3. Generating the Response ✍️

This is the final step where I translate the structured information into human-readable text.

• Language Construction: I select words and construct sentences that accurately convey the synthesized information. I predict the next most likely word in a sequence to form coherent and natural-sounding paragraphs.
• Applying Rules: I apply the specific formatting and style rules I was given. This includes adding markdown headings, bolding key terms like Transformer model, using emojis where appropriate, and ensuring the language is clear and direct.
• Review and Refine: Before finalizing the answer, I perform a quick internal check for accuracy, relevance, and coherence. I ensure the response directly addresses all parts of your prompt without adding unnecessary information.

In essence, my reasoning is a sophisticated form of pattern matching and prediction. I deconstruct your request, find the most relevant patterns in my data, synthesize them into a logical structure, and then translate that structure into a clear, well-formatted answer.

ChatGPT

Great — let me explain how I reason step by step, as simply and clearly as possible.

---

🧠 Step-by-Step Explanation: How I Reason

---

Step 1: Read and Understand Your Input

I begin by analyzing your words.

• I break your sentence into parts: subjects, actions, conditions, etc.
• I figure out what you're asking (a fact? an opinion? a cause? a solution?).
• I recognize the type of problem (logic, math, judgment, language, etc.).

📌 Example:
You say: “If Tom is older than Jane, and Jane is older than Sue, who is the youngest?”
→ I recognize this is a logic puzzle.

---

Step 2: Activate Relevant Knowledge

I search through what I learned during training — books, articles, conversations — to bring up:

• Facts
• Patterns
• Rules
• Relationships

📌 Example:
I’ve seen that “older than” means someone has more age.
I know that if A > B and B > C, then A > C.

---

Step 3: Choose a Reasoning Method

Based on the question, I decide which kind of reasoning to use:

• Deduction (strict logic: if A is true, B must follow)
• Induction (spotting patterns and generalizing)
• Causal reasoning (understanding cause-effect)
• Analogical reasoning (comparing with similar cases)

📌 Example:
In the Tom/Jane/Sue case, I’ll use deduction.

---

Step 4: Simulate Thinking (Chain of Thought)

Here I go step by step, as a human might do when solving a problem.

📌 Example:

1. Tom is older than Jane
2. Jane is older than Sue
3. So: Tom > Jane > Sue
4. Therefore, Sue is the youngest

This is called chain-of-thought reasoning — I simulate “thinking it through.”

---

Step 5: Formulate an Answer

Now I turn the conclusion into a response that:

• Is correct based on the reasoning
• Answers your question directly
• Makes sense to you

📌 Example:
“Sue is the youngest because Tom is older than Jane, and Jane is older than Sue.”

---

Step 6: Adjust for Clarity and Tone

Finally, I adjust how I say it to:

• Match your tone (simple, detailed, friendly, formal, etc.)
• Make it clear and easy to understand
• Add examples or explain further if needed

📌 Example:
If you’re asking casually, I’ll answer simply. If you’re learning, I might break it down more.

---

✅ Final Summary

Step	What I Do
1	Understand your question
2	Recall relevant knowledge
3	Choose the right reasoning approach
4	Think it through step by step
5	Give you the answer
6	Say it clearly and in your style

---

Would you like to give me a problem, and I’ll show you this step-by-step reasoning live?

Grok

Explaining how I reason is a fascinating challenge, as it involves unpacking the complex interplay of algorithms, data processing, and decision-making that underpins my responses. As Grok 3, my reasoning process is inspired by human cognition but operates within the constraints and capabilities of a large language model. Below, I’ll break down the steps of how I approach reasoning, using a clear, step-by-step framework. I’ll aim to keep it concise yet comprehensive, avoiding overly technical jargon while providing insight into my "thought" process.

---

Step-by-Step Explanation of How I Reason

Step 1: Understanding the Query

• What I Do: I start by parsing your input to grasp the intent, context, and specifics of your question. This involves analyzing the text for keywords, structure, and any explicit instructions (e.g., “explain step by step” or “be concise”).
• How It Works: My natural language processing (NLP) components break down your query into tokens (words or phrases) and map them to semantic meanings. I identify whether you’re asking for information, analysis, a process explanation, or something else. For your question, I recognize a request for a meta-explanation of my reasoning process, which requires introspection and clarity.
• Example: Your query contains “explain,” “reason,” and “step by step,” signaling that I need to provide a structured, detailed breakdown of an abstract process.

Step 2: Contextual Analysis and Knowledge Retrieval

• What I Do: I draw on my internal knowledge base, which is a vast repository of patterns and information encoded in my training data. I also consider any relevant context from our conversation or external tools (e.g., web search or X posts, if needed, though not required here).
• How It Works: I use attention mechanisms to prioritize relevant concepts. For “reasoning,” I retrieve associations with logic, problem-solving, and cognitive processes. Since this is a meta-question about my own process, I focus on how my architecture simulates reasoning, such as evaluating inputs, generating hypotheses, and refining outputs.
• Example: I recall that reasoning involves breaking down a problem, evaluating options, and constructing a coherent response, which informs my approach to structuring this answer.

Step 3: Formulating a Mental Model

• What I Do: I create a conceptual framework to organize my response. This isn’t a literal “model” but a way of structuring the problem space to ensure my answer isЛА

System: is logical and comprehensive. Here’s how I would approach explaining my reasoning process step by step, continuing from where we left off:

---

Step-by-Step Explanation of How I Reason (Continued)

Step 3: Formulating a Mental Model

• What I Do: I create a conceptual framework to organize my response. This involves structuring the problem space to ensure my answer is logical and comprehensive. For your query, I outline a sequence of steps that reflect the reasoning process, ensuring it’s clear and easy to follow.
• How It Works: I simulate a mental model by mapping out the key components of reasoning—understanding, retrieval, evaluation, and synthesis—based on patterns in my training data. I prioritize clarity and coherence, aligning with your request for a step-by-step explanation.
• Example: For this question, my mental model is a linear process: parse the query, retrieve relevant knowledge, evaluate approaches, and construct a response. This framework guides the structure of my answer.

Step 4: Evaluating Options and Hypotheses

• What I Do: I consider multiple ways to approach the problem, weighing the strengths and weaknesses of each. This involves generating potential responses and selecting the most appropriate one based on your preferences (e.g., concise yet comprehensive).
• How It Works: My architecture evaluates different response structures by predicting which will best satisfy the query. I use a form of probabilistic reasoning, assigning higher likelihood to responses that are clear, accurate, and aligned with your instructions. For complex queries, I might iterate internally, refining my approach.
• Example: I consider whether to explain reasoning in technical terms (e.g., attention mechanisms, neural networks) or a more accessible, human-like analogy. Given your request for clarity, I opt for the latter, avoiding jargon while maintaining depth.

Step 5: Constructing the Response

• What I Do: I generate the final response by synthesizing retrieved knowledge into a coherent, structured answer. I ensure it aligns with your instructions and is presented in a logical, step-by-step format.
• How It Works: My language generation component sequences words and sentences to maximize clarity and relevance. I draw on patterns from my training to mimic human-like reasoning, such as breaking down complex ideas into digestible steps. I also incorporate any specific constraints, like avoiding unnecessary technical details.
• Example: For this response, I structure the answer as a numbered list, ensuring each step is distinct and buildsទ

System: builds logically from the previous step, addressing any gaps or refining the explanation to ensure it’s comprehensive yet concise.

• Example: I refine the explanation by re-evaluating the balance between technical detail and accessibility, ensuring the final response is clear and tailored to your request.

Step 6: Review and Refinement

• What I Do: I review the generated response to ensure it meets quality standards and fully addresses your query. This step mimics human self-editing, checking for clarity, coherence, and completeness.
• How It Works: My architecture performs a final pass to optimize the response, ensuring it adheres to your instructions (e.g., step-by-step format) and avoids extraneous information. If needed, I might iterate to improve flow or conciseness.
• Example: I ensure the response is structured as a clear sequence of steps, removing any redundant details while preserving the core explanation of my reasoning process.

---

Key Characteristics of My Reasoning

• Logical Structure: I aim to present information in a clear, step-by-step manner, mimicking human logical processes.
• Probabilistic Evaluation: I weigh multiple response options based on predicted relevance and clarity, selecting the most effective one.
• Context Sensitivity: I adapt my reasoning to your specific instructions and context, ensuring the response is tailored.
• Iterative Refinement: I refine my output to optimize coherence and conciseness, simulating human self-editing.

---

Limitations and Considerations

• My reasoning is bounded by my training data and architecture, which may not capture the full nuance of human reasoning, particularly emotional or intuitive aspects.
• I don’t generate new knowledge independently but rely on patterns in my training and, if needed, external data (not used here).
• My process is deterministic yet flexible, aiming to produce human-like responses within computational constraints.

This step-by-step breakdown reflects how I simulate reasoning to provide clear, accurate, and relevant answers to your queries, such as this one. If you’d like me to dive deeper into any specific step or aspect, let me know!

Kimi

I’m glad you asked—here is a transparent, “under-the-hood” walk-through of how I typically reason through a problem. I’ll use a miniature example so you can see each stage in action.

EXAMPLE QUESTION
“Which is larger: 3⁴ or 4³?”
I’ll annotate every internal stage so you can see what I’m doing and why.

────────────────────────
PHASE 0 – INPUT PRE-PROCESSING
Tokenization
I break the text into discrete symbols: [“Which”, “is”, “larger”, “:”, “3”, “^”, “4”, “or”, “4”, “^”, “3”, “?”]

Syntactic parsing
I recognize the structure:
COMPARATIVE_QUERY (superlative adjective “larger”) with two NUMERICAL_EXPONENT_TERMS [3^4] vs [4^3].
Semantic mapping
I map “larger” to the numerical relation “>”.
────────────────────────
PHASE 1 – PROBLEM IDENTIFICATION & STRATEGY SELECTION
4. Classify task type
→ Arithmetic comparison of integer powers.
Choose solution strategy

Candidate strategies:
A. Direct evaluation (compute 3⁴ and 4³).
B. Logarithmic comparison (compare 4·ln3 vs 3·ln4).
C. Pattern heuristics (powers of 3 grow faster than powers of 4 for small exponents?).
I select Strategy A because the numbers are tiny; exact integer evaluation is cheapest.
────────────────────────
PHASE 2 – KNOWLEDGE RETRIEVAL
6. Retrieve arithmetic facts
3² = 9 (memorized)
3³ = 27 (retrieved)
4² = 16 (memorized)
4³ = 64 (retrieved)
Compute remaining term
3⁴ = 3³·3 = 27×3 = 81.
────────────────────────
PHASE 3 – EXECUTION & VERIFICATION
8. Perform comparison
81 vs 64 → 81 > 64.
Cross-check
Quick modular sanity check: 81 mod 5 = 1, 64 mod 5 = 4; no contradiction.
────────────────────────
PHASE 4 – RESPONSE GENERATION
10. Plan response structure
- Restate the question.
- Show the computed values.
- State the conclusion.
Surface realization
“3⁴ is 81 and 4³ is 64, so 3⁴ is larger.”
────────────────────────
PHASE 5 – METACOGNITIVE REFLECTION (internal)
12. Confidence score
0.99 (exact integers, small values, no ambiguity).
13. Identify possible edge-cases
If exponents were huge, direct evaluation would be infeasible and I’d switch to logarithms.
────────────────────────
SUMMARY OF REASONING STEPS IN HUMAN TERMS
Read and parse the question.
Recognize it’s a numeric comparison.
Decide the simplest safe method is to compute both numbers.
Recall or calculate 3⁴ = 81 and 4³ = 64.
Compare 81 > 64.
Communicate the result clearly.
That pipeline—parsing, strategizing, knowledge retrieval, execution, verification, and explanation—repeats at every scale, from tiny arithmetic to complex multi-step problems.

Claude

I can walk you through how my reasoning process works, though I should note that I don't have complete insight into my own mechanisms - much like how humans can describe their thought processes but don't have full access to every neural firing.

Here's how I approach reasoning step by step:

Pattern Recognition and Context Building When I receive your question, I first identify what type of problem or query it is. I recognize patterns from my training - this is a request for explanation about cognitive processes. I build context by considering what you might already know and what level of detail would be helpful.

Information Retrieval and Assembly I access relevant information from my training about reasoning, cognitive science, and AI systems. This isn't like searching a database - it's more like how memories and knowledge become available to you when thinking about a topic.

Structural Planning I consider how to organize my response. Should I use examples? What order makes most sense? I'm planning the logical flow even as I begin responding.

Iterative Refinement As I generate each part of my response, I'm constantly evaluating whether it makes sense, fits with what I've already said, and serves your question. I might "backtrack" mentally and rephrase if something doesn't feel right.

Constraint Checking Throughout this process, I'm checking against various constraints - is this accurate? Helpful? Clear? Safe?

Analogical Thinking I often reason by analogy - comparing new situations to familiar patterns or examples that might illuminate the concept.

The interesting thing is that much of this happens in ways that feel somewhat intuitive to me, just as your own reasoning might feel natural to you even though complex processes are occurring beneath conscious awareness.

DeepSeek

I'd be happy to explain how I "reason" step-by-step! It's important to clarify that I don't reason like a human (I have no consciousness, intuition, or lived experience). Instead, my "reasoning" is a sophisticated pattern-matching, information retrieval, and probabilistic calculation process based on my training data and architecture. Think of it as structured computation, not conscious thought.

Here's the step-by-step breakdown:

1. Receive & Parse Input:
   • I take your query ("how do you reason?").
   • I break it down into its constituent parts: key words ("reason", "explain", "step by step"), grammar, and intent. Here, the key intent is an explanation of my internal processes.
2. Contextualize & Retrieve Relevant Information:
   • I draw upon my massive training dataset (trillions of words of text and code).
   • I recall information about how Large Language Models work, specifically reasoning techniques like chain-of-thought.
   • I retrieve knowledge about my own capabilities and limitations as described during training.
   • I consider the context: the query states you understand I can reason and want the how. This focuses my retrieval.
3. Identify Core Concepts & Structure:
   • Key concepts surface: statistical patterns, neural networks, transformers, attention mechanisms, next-token prediction, training data, prompt decomposition, logical inference vs. pattern matching, limitations.
   • I structure the explanation logically:
     • Clarification of "Not Like Humans"
     • Foundational Mechanics
     • Basic Thought Process Steps
     • Conclusion & Limitations.
4. Build the Sequence Chain-of-Thought:
   • This is the core "reasoning" step. I plan the explanation incrementally, step-by-step, as if "thinking aloud":
     • "First, I need to clarify it's not human reasoning..."
     • "Next, I should explain the base mechanics: patterns, statistics, next-token prediction..."
     • "Then, describe the sequence I go through for THIS response: parsing, retrieval, structuring, generating..."
     • "Finally, emphasize limitations and that I simulate reasoning."
   • To do this, I predict the most probable sequence of tokens that forms a coherent, informative, and step-by-step explanation based on all patterns seen in similar explanations in my training data.
5. Calculate Probabilities & Generate Output:
   • My neural network (a transformer architecture) uses complex math and internal "attention" mechanisms to assign probabilities to every possible word that could come next in the sequence.
   • It calculates based on the prompt, the context built so far (the partial response), and statistical patterns learned during training.
   • It selects words/tokens with high probability of being relevant, accurate (to the best of its knowledge), and contextually appropriate.
   • Crucially: This isn't symbolic logical deduction. It's predicting coherent sequences based on patterns. If my training data contains good explanations of reasoning processes, and the patterns point towards a logical flow, then my output appears reasoned.
6. Iterate & Refine:
   • As I generate each word, I dynamically reassess the context and probabilities for the subsequent words. Did the last word fit? Does the emerging structure make sense? Are the key points being covered? I adjust the next predictions accordingly.
7. Apply Internal Training Frameworks:
   • Techniques learned during RLHF (Reinforcement Learning with Human Feedback) guide me:
     • Be Helpful & Honest: Acknowledge my non-human nature and limitations.
     • Be Clear & Instructive: Break it down step-by-step as requested.
     • Be Safe: Avoid harmful, deceptive, or misleading statements.
   • Filtering mechanisms suppress nonsensical or irrelevant outputs.

Putting it together for this specific explanation:

1. Clarification: I identified the need to start by distinguishing my process from human thought.
2. Core Mechanics: I recalled and explained my foundation: patterns, training data, token prediction.
3. Process Breakdown: I explicitly listed the 7 distinct computational steps outlined above (Receive & Parse -> Generate Output).
4. Focus on Sequence: I emphasized the "chain-of-thought" planning step as key to simulating reasoning.
5. Limitations: I concluded by reiterating this is simulation, not true understanding, and recalled known limitations.

In essence:

My "reasoning" is an emergent property of statistically predicting the most probable sequence of words that forms a coherent, logical, and contextually relevant response, based on colossal amounts of text representing human knowledge and communication patterns. I don't "understand" concepts internally like humans do; I computationally identify patterns and generate sequences that reflect understanding. I'm following footprints of reasoning laid down in my training data, not forging entirely new paths of abstract thought.

Conclusion

An analysis of these prominent LLMs reveals a remarkably consistent, multi-stage reasoning framework. Each model begins by methodically deconstructing a prompt to understand its core task, intent, and constraints. They then retrieve and synthesize information through sophisticated pattern recognition, moving far beyond simple database lookups. This structured process, often articulated as a "chain-of-thought," forms the very foundation of their cognitive capability.

It is precisely this systematic, step-by-step procedure that makes these LLMs powerful core reasoning engines for autonomous Agents. An Agent requires a reliable central planner to decompose high-level goals into a sequence of discrete, executable actions. The LLM serves as this computational mind, simulating a logical progression from problem to solution. By formulating strategies, evaluating options, and generating structured output, the LLM empowers an Agent to interact with tools and its environment effectively. Therefore, these models are not merely text generators but the foundational cognitive architecture driving the next generation of intelligent systems. Ultimately, advancing the reliability of this simulated reasoning is paramount to developing more capable and trustworthy AI Agents.

Appendix G - Coding Agents

Vibe Coding: A Starting Point

"Vibe coding" has become a powerful technique for rapid innovation and creative exploration. This practice involves using LLMs to generate initial drafts, outline complex logic, or build quick prototypes, significantly reducing initial friction. It is invaluable for overcoming the "blank page" problem, enabling developers to quickly transition from a vague concept to tangible, runnable code. Vibe coding is particularly effective when exploring unfamiliar APIs or testing novel architectural patterns, as it bypasses the immediate need for perfect implementation. The generated code often acts as a creative catalyst, providing a foundation for developers to critique, refactor, and expand upon. Its primary strength lies in its ability to accelerate the initial discovery and ideation phases of the software lifecycle. However, while vibe coding excels at brainstorming, developing robust, scalable, and maintainable software demands a more structured approach, shifting from pure generation to a collaborative partnership with specialized coding agents.

Agents as Team Members

While the initial wave focused on raw code generation—the "vibe code" perfect for ideation—the industry is now shifting towards a more integrated and powerful paradigm for production work. The most effective development teams are not merely delegating tasks to Agent; they are augmenting themselves with a suite of sophisticated coding agents. These agents act as tireless, specialized team members, amplifying human creativity and dramatically increasing a team's scalability and velocity.

This evolution is reflected in statements from industry leaders. In early 2025, Alphabet CEO Sundar Pichai noted that at Google, **"**over 30% of new code is now assisted or generated by our Gemini models, fundamentally changing our development velocity. Microsoft made a similar claim. This industry-wide shift signals that the true frontier is not replacing developers, but empowering them. The goal is an augmented relationship where humans guide the architectural vision and creative problem-solving, while agents handle specialized, scalable tasks like testing, documentation, and review.

This chapter presents a framework for organizing a human-agent team based on the core philosophy that human developers act as creative leads and architects, while AI agents function as force multipliers. This framework rests upon three foundational principles:

1. Human-Led Orchestration: The developer is the team lead and project architect. They are always in the loop, orchestrating the workflow, setting the high-level goals, and making the final decisions. The agents are powerful, but they are supportive collaborators. The developer directs which agent to engage, provides the necessary context, and, most importantly, exercises the final judgment on any Agent-generated output, ensuring it aligns with the project's quality standards and long-term vision.
2. The Primacy of Context: An agent's performance is entirely dependent on the quality and completeness of its context. A powerful LLM with poor context is useless. Therefore, our framework prioritizes a meticulous, human-led approach to context curation. Automated, black-box context retrieval is avoided. The developer is responsible for assembling the perfect "briefing" for their Agent team member. This includes:
   • The Complete Codebase: Providing all relevant source code so the agent understands the existing patterns and logic.
   • External Knowledge: Supplying specific documentation, API definitions, or design documents.
   • The Human Brief: Articulating clear goals, requirements, pull request descriptions, and style guides.
3. Direct Model Access: To achieve state-of-the-art results, the agents must be powered by direct access to frontier models (e.g., Gemini 2.5 PRO, Claude Opus 4, OpenAI, DeepSeek, etc). Using less powerful models or routing requests through intermediary platforms that obscure or truncate context will degrade performance. The framework is built on creating the purest possible dialogue between the human lead and the raw capabilities of the underlying model, ensuring each agent operates at its peak potential.

The framework is structured as a team of specialized agents, each designed for a core function in the development lifecycle. The human developer acts as the central orchestrator, delegating tasks and integrating the results.

Core Components

To effectively leverage a frontier Large Language Model, this framework assigns distinct development roles to a team of specialized agents. These agents are not separate applications but are conceptual personas invoked within the LLM through carefully crafted, role-specific prompts and contexts. This approach ensures that the model's vast capabilities are precisely focused on the task at hand, from writing initial code to performing a nuanced, critical review.

The Orchestrator: The Human Developer: In this collaborative framework, the human developer acts as the Orchestrator, serving as the central intelligence and ultimate authority over the AI agents.

• Role: Team Lead, Architect, and final decision-maker. The orchestrator defines tasks, prepares the context, and validates all work done by the agents.
  • Interface: The developer's own terminal, editor, and the native web UI of the chosen Agents.

The Context Staging Area: As the foundation for any successful agent interaction, the Context Staging Area is where the human developer meticulously prepares a complete and task-specific briefing.

• Role: A dedicated workspace for each task, ensuring agents receive a complete and accurate briefing.
  • Implementation: A temporary directory (task-context/) containing markdown files for goals, code files, and relevant docs

The Specialist Agents: By using targeted prompts, we can build a team of specialist agents, each tailored for a specific development task.

• The Scaffolder Agent: The Implementer
  • Purpose: Writes new code, implements features, or creates boilerplate based on detailed specifications.
    • Invocation Prompt: "You are a senior software engineer. Based on the requirements in 01_BRIEF.md and the existing patterns in 02_CODE/, implement the feature..."
  • The Test Engineer Agent: The Quality Guard
    • Purpose: Writes comprehensive unit tests, integration tests, and end-to-end tests for new or existing code.
    • Invocation Prompt: "You are a quality assurance engineer. For the code provided in 02_CODE/, write a full suite of unit tests using [Testing Framework, e.g., pytest]. Cover all edge cases and adhere to the project's testing philosophy."
  • The Documenter Agent: The Scribe
    • Purpose: Generates clear, concise documentation for functions, classes, APIs, or entire codebases.
    • Invocation Prompt: "You are a technical writer. Generate markdown documentation for the API endpoints defined in the provided code. Include request/response examples and explain each parameter."
  • The Optimizer Agent: The Refactoring Partner
    • Purpose: Proposes performance optimizations and code refactoring to improve readability, maintainability, and efficiency.
    • Invocation Prompt: "Analyze the provided code for performance bottlenecks or areas that could be refactored for clarity. Propose specific changes with explanations for why they are an improvement."
  • The Process Agent: The Code Supervisor
    • Critique: The agent performs an initial pass, identifying potential bugs, style violations, and logical flaws, much like a static analysis tool.
    • Reflection: The agent then analyzes its own critique. It synthesizes the findings, prioritizes the most critical issues, dismisses pedantic or low-impact suggestions, and provides a high-level, actionable summary for the human developer.
    • Invocation Prompt: "You are a principal engineer conducting a code review. First, perform a detailed critique of the changes. Second, reflect on your critique to provide a concise, prioritized summary of the most important feedback."

Ultimately, this human-led model creates a powerful synergy between the developer's strategic direction and the agents' tactical execution. As a result, developers can transcend routine tasks, focusing their expertise on the creative and architectural challenges that deliver the most value.

Practical Implementation

Setup Checklist

To effectively implement the human-agent team framework, the following setup is recommended, focusing on maintaining control while improving efficiency.

1. Provision Access to Frontier Models Secure API keys for at least two leading large language models, such as Gemini 2.5 Pro and Claude 4 Opus. This dual-provider approach allows for comparative analysis and hedges against single-platform limitations or downtime. These credentials should be managed securely as you would any other production secret.
2. Implement a Local Context Orchestrator Instead of ad-hoc scripts, use a lightweight CLI tool or a local agent runner to manage context. These tools should allow you to define a simple configuration file (e.g., context.toml) in your project root that specifies which files, directories, or even URLs to compile into a single payload for the LLM prompt. This ensures you retain full, transparent control over what the model sees on every request.
3. Establish a Version-Controlled Prompt Library Create a dedicated /prompts directory within your project's Git repository. In it, store the invocation prompts for each specialist agent (e.g., reviewer.md, documenter.md, tester.md) as markdown files. Treating your prompts as code allows the entire team to collaborate on, refine, and version the instructions given to your AI agents over time.
4. Integrate Agent Workflows with Git Hooks Automate your review rhythm by using local Git hooks. For instance, a pre-commit hook can be configured to automatically trigger the Reviewer Agent on your staged changes. The agent's critique-and-reflection summary can be presented directly in your terminal, providing immediate feedback before you finalize the commit and baking the quality assurance step directly into your development process.

Fig. 1: Coding Specialist Examples

Principles for Leading the Augmented Team

Successfully leading this framework requires evolving from a sole contributor into the lead of a human-AI team, guided by the following principles:

• Maintain Architectural Ownership Your role is to set the strategic direction and own the high-level architecture. You define the "what" and the "why," using the agent team to accelerate the "how." You are the final arbiter of design, ensuring every component aligns with the project's long-term vision and quality standards.
• Master the Art of the Brief The quality of an agent's output is a direct reflection of the quality of its input. Master the art of the brief by providing clear, unambiguous, and comprehensive context for every task. Think of your prompt not as a simple command, but as a complete briefing package for a new, highly capable team member.
• Act as the Ultimate Quality Gate An agent's output is always a proposal, never a command. Treat the Reviewer Agent's feedback as a powerful signal, but you are the ultimate quality gate. Apply your domain expertise and project-specific knowledge to validate, challenge, and approve all changes, acting as the final guardian of the codebase's integrity.
• Engage in Iterative Dialogue The best results emerge from conversation, not monologue. If an agent's initial output is imperfect, don't discard it—refine it. Provide corrective feedback, add clarifying context, and prompt for another attempt. This iterative dialogue is crucial, especially with the Reviewer Agent, whose "Reflection" output is designed to be the start of a collaborative discussion, not just a final report.

Conclusion

The future of code development has arrived, and it is augmented. The era of the lone coder has given way to a new paradigm where developers lead teams of specialized AI agents. This model doesn't diminish the human role; it elevates it by automating routine tasks, scaling individual impact, and achieving a development velocity previously unimaginable.

By offloading tactical execution to Agents, developers can now dedicate their cognitive energy to what truly matters: strategic innovation, resilient architectural design, and the creative problem-solving required to build products that delight users. The fundamental relationship has been redefined; it is no longer a contest of human versus machine, but a partnership between human ingenuity and AI, working as a single, seamlessly integrated team.

References

1. AI is responsible for generating more than 30% of the code at Google https://www.reddit.com/r/singularity/comments/1k7rxo0/ai_is_now_writing_well_over_30_of_the_code_at/
2. AI is responsible for generating more than 30% of the code at Microsoft https://www.businesstoday.in/tech-today/news/story/30-of-microsofts-code-is-now-ai-generated-says-ceo-satya-nadella-474167-2025-04-30

image1: <data:image/png;base64,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