It's everywhere. We're all building one. We're hearing every day crazy valuations from companies who claim they're building the best AI agent in sales, H.R, finance, etc, etc... But what are AI agents? Why do they matter?

And why do I think most engineers and product leaders don't understand them?

AutoGPT, the first AI agent

I distinctly remember the day AutoGPT was released. I cloned the project, ran a command, and saw something like this:

This was mind-blowing. I was looking at a proactive and autonomous machine.

I became obsessed with this type of software. Initially, I called it "chat with side effects", because I was able to communicate with a machine (like ChatGPT) but also have it take action for me.

AutoGPT was the first AI agent.

Before chatGPT: Traditional applications

To understand AI agents, we first need to understand traditional software. Up until April 2023 and the release of GPT-4, it wasn't common for users to expect their application to be proactive and take action for them.

Users would interact with web applications through a very explicit user interface.

And this was great. But we also spent a lot of time doing the same thing over and over in a user interface.

To solve this problem, we used software engineers. They would write business logic to translate our day to day tasks into workflows. Then we would just click a button and everything would happen automatically, somewhere in the cloud.

But not everyone could hire engineers. And sometimes you would just need to do something once and there was no point asking an engineer for this.

Fortunately, we also had workflow engines. Things like @zapier @MuleSoft @n8n_io @WindmillDev

Thanks to them, we could use relatively low-code interfaces to build these workflows.

But it still felt off because these interfaces remained pretty technical. And most knowledge workers didn't know how to use them well. Also, this still didn't make sense for tasks done only once.

Overall, automating manual tasks had always been the holy grail of software.

Background: why full automation kept slipping away

2017 | Scraping in the “wild-west” era
Lead-generation contractors routinely built pipelines that scraped LinkedIn, which was then lax enough to allow easy data mining. The main bottleneck wasn’t code; it was the swarm of small, repetitive chores—clean-ups, hand-edits, customer emails—that never quite disappeared. A single UI tweak by LinkedIn broke many of those scrapers overnight, and the manual catch-up work overwhelmed more than a few solo operators. The lesson was clear: brittle scripts plus human glue do not scale.

Nov 2022 → Apr 2023 | From scripted workflows to agentic thinking

• text-davinci-003: Engineers experimenting inside firms such as Redica treated early GPT models as smarter autocompleters. Helpful, but still prone to drift if you tried chaining outputs back into inputs.

  

  

• GPT-3.5: Reliability jumped, prompting became easier, yet any self-loop longer than a few hops still collapsed. The industry’s unsolved wish remained: a system that writes its own finite-state machine in real time.

14 Mar 2023 | GPT-4 changes the physics

The 0314 checkpoint of GPT-4 delivered an abrupt coherence boost. Prompts simplified rather than ballooned, and multi-step reasoning held together across long chains. Practitioners moved toy projects over in days—regressions essentially vanished—fueling talk that “Jarvis-level” assistants were finally within reach.

These milestones set the stage for today’s agentic landscape and frame why “systems that decide and act” are treated as the next big platform shift rather than just another UX fad.

What is an AI agent?

Here is my definition of an AI agent. At the end of this article, I will explain why I use this definition:

In the context of AI systems, an agent is a system that can act autonomously and proactively.

Let's take an example to understand why agents matter.

Example: Anna is not getting the right candidates for a role.

We're not going to talk about RAG, memory, multi-agents, loops, LLMs, AI, tree of thoughts.

We don't need any of that to illustrate AI agents. All we need is to talk about what I have always loved and the reason why I am a software engineer in the first place: business processes

We're going to talk about Anna.

Anna is a recruiter at Coca-Cola. She's looking for a senior product manager to join their team in their New York office. But Anna has a problem: she's only receiving applications from inexperienced candidates.

Before AI agents, Anna would just use the ATS to troubleshoot the issue. She would never tell the ATS about the issue, because it's a waste of time: the ATS would not be very helpful.

But when the ATS is agentic, Anna can express her high level problems and let the ATS troubleshoot the issue then come back with the diagnostic.

Anna is now able to troubleshoot the problem without manually interacting with the ATS. She's saving time.

In this example the ATS is an agent.

This improvement is already valuable on its own. But there is no limit to agency. The ATS could have found the seniority issue before Anna identified it, troubleshoot it, fix it, then report back to Anna. This would save her even more time (but too much autonomy is not always good, see below).

Focus on Anna, not the technology

Here is the least interesting question to ask at this point:

• How to make ATS agentic?

The answer is: "it depends". Everyone builds these agents differently. Besides, you might not even need AI to have agency. A finite state machine can do the job sometimes. That's why I don't like the term "AI agents". "Agents" make more sense.

The more interesting questions are:

• A- What made Anna realize there was an issue?

• B- How does she know the diagnostic is accurate?

• C- How does she know the fix is to change the seniority field and not the job title? Think about it: she knows the job description was for a senior engineer. But if we wanted to automate her work fully, we would need to know her initial intent.

The answers to these 3 questions are 3 evals:

• A- If more than 40% of the candidates applying for a job description mentioning "senior" in the title are junior, then Anna should report an incident.

• B- If the diagnostic mentions a mismatch between two fields and there is no mismatch between these 2 fields, then Anna should not be happy with the diagnostic. And in the opposite case, she should be happy with the diagnosis.

• C- If the diagnostic is a mismatch between two fields, the agent should ask Anna to intervene, and it should keep alerting Anna, unless she declines.

We're now much more likely to build the right agent, because we can benchmark it by running these 3 evals.

This is why the most important thing to understand in this agentic revolution is not agentic frameworks. It's Anna. Writing evals will force you to understand Anna better than anyone else. And if you understand Anna, you will build the best agent. Because the best agents are just machines with the same reward system as Anna.

Side note: C is the only eval where we're forced to talk about the agent, because Anna and the agent would behave differently. Anna knows what the fix is, but for the agent, it's harder to know. So we decide to have the agent put Anna in the loop. One might argue there are ways to know what to fix, because there should be signs of seniority vs juniority. If the job desc is clearly for a junior, we change the job title, else, we change the seniority field. But this is the point where you should know Anna. What's the most useful eval to pass for her agent? I would argue A. and B. She can very easily edit the job description if she agrees with the diagnostic. So is it really worth it for you to automate this part and to even write this eval in the first place? This highlights an important point: the eval C. should probably rank lower on the benchmark. Because I would rather have an agent pass A. and B. than A. and C. Hopefully this also allows you to understand the difference between an eval and a benchmark.

Conclusion

AI agents are systems that act autonomously or proactively. The least interesting aspect about AI agents is the technology. The most interesting aspect about AI agents is Anna.

Anna is an end user trying to follow a business process.

Anna already has agency. Anna is proactive and has autonomy. We don't need to "create agency" out of thin air. We just need to create a bot version of Anna a.k.a an agent. Anna is the reward system.

You don't understand agents until you understand what success means for Anna and the organization she works for, a.k.a evals.

Why should you care about AI agents?

I care about AI agents because I am Anna. And maybe you are like me, too. Maybe you're frustrated by all the manual tasks you do on a day to day basis.

But a more pragmatic reason to care about AI agents is that Anna is expensive. And if your competitors build Anna, they will beat you.

Am I saying that AI agents only make you save money? No. A lot of companies can't hire Anna in the first place. So if they decide to buy a cheaper version, they will end up spending more money in exchange for the value delivered.

Am I saying AI agents can only do things that humans currently do? No. But it's easier to start with business processes that humans already do. Generating business processes from existing patterns is harder.

Am I saying that "human Anna" will become useless? No, we need to put her in the loop so she can assess whether the agent behaved correctly or not. And even if the agent is performing all the things she used to do, we will probably still need human Anna in order to monitor these agents.

But it's possible that this increase in productivity leads to job displacement, because if Anna is "too productive", her colleague might be let go, because there is nothing left to do.

Why this definition?

I skipped quickly on the definition because I want this article to be light and clear to understand. Definitions are always very academic. But they obviously matter a lot. So let's come back to this definition:

In the context of AI systems, an agent is a system that can act autonomously and proactively.

First let's try to use the dictionary. "Agent" already has a meaning. Ideally we don't create a new meaning for this word, if I don't have to. Unfortunately I think we have to.

Because according to the Merriem-Webster dictionary, agency is the capacity, condition, or state of acting or of exerting power. So you could say that an agent is "a system able to act". But it's very vague.

A very stupid web server can also "act" and insert something in a database if it's called by a web client. So "capacity of acting" is not enough, in the context of software applications.

The key in agentic systems we see today is their ability to act autonomously.

But there is a problem with autonomy. For example, when I was using AutoGPT, my favorite mode was the manual mode where I could nudge AutoGPT in the right direction at every cycle and make it change its course. The autonomous mode was not very useful because either way, I was looking at the terminal, since AutoGPT would frequently make mistakes. So I might as well control what's going on. There is no downsides.

These days, agents are not accurate enough to afford to be autonomous. But once we hit a certain threshold of accuracy, then autonomous agents will dominate.

This why I added proactivity to the definition, because I can see the most useful AI agents today are proactive but not autonomous.

This is why I use this definition of agents:

In the context of AI systems, an agent is a system that can act autonomously and proactively.

The other definitions of AI agents

The definition of AI agents that rely on specific technologies or design patterns are not very useful in my opinion. Yes, AI agents happen to use LLMs. Sometimes they use multiple agents, vector search, RAG, goal decomposition.

But when you build an agent, you shouldn't focus too much on these techniques. You biggest risk is to ignore Anna, not to ignore common agentic patterns.

The best agent builders I worked with were simply outcome oriented and very practical. And yes, they end up finding reproducible techniques and sharing their frameworks to the world.

But these techniques might not work for you, so the only guaranteed way for you to succeed is by focusing on Anna. And to do this, you should build the part of Anna that knows what success means for her and her organization, a.k.a evals.

The good news is that we're all Annas, and we all have itches to scratch.

In this tutorial, we'll walk through creating a simple and easy health and wellness coach agent using OpenAI's Agents SDK and AgentOps for monitoring. By the end, you'll have a fully functional AI assistant that can provide personalized advice on nutrition, fitness, sleep, and general wellness.

What We'll Build

We're creating a health and wellness coach that:

• Answers questions about nutrition, workouts, BMI calculations, and sleep

• Uses specialized sub-agents for different health domains

• Searches the web for information when needed

• Tracks interactions with AgentOps for monitoring and improvement

Prerequisites

• Python 3.8+

• OpenAI API key - Create your OpenAI key here

• AgentOps API key - Create your AgentOps API key here

Step 1: Setting Up Your Environment

First, let's set up our project and install the necessary dependencies:

# Create a virtual environment using uv (you can also use pip)
uv venv
source .venv/bin/activate  # On Windows: .venv\Scripts\activate

# Install required packages
pip install openai openai-agents pydantic python-dotenv agentops

Create a .env file in your project directory to store your API keys:

OPENAI_API_KEY=your_openai_api_key
AGENTOPS_API_KEY=your_agentops_api_key

What's happening here?

• We're creating a dedicated folder for our project

• A virtual environment isolates our project's dependencies from other Python projects

• We're installing the libraries we need:

  • openai: To access OpenAI's API

  • openai-agents: OpenAI's Agents SDK

  • pydantic: For data validation and settings management

  • python-dotenv: To load environment variables from a .env file

  • agentops: For monitoring and tracking our agent's performance

Step 2: Defining Data Models Using Pydantic

Let's create a file called health_and_wellness_agent.py and start by defining Pydantic models for structured outputs. These models help ensure our agent returns consistent, well-formatted information:

from pydantic import BaseModel, Field
from typing import List, Optional

class NutritionInfo(BaseModel):
    foods: List[str] = Field(..., description="List of foods identified in the meal")
    total_calories: Optional[int] = Field(None, description="Estimated total calories")
    recommendations: Optional[List[str]] = Field(None, description="Nutritional recommendations")

class WorkoutPlan(BaseModel):
    exercises: List[str] = Field(..., description="List of recommended exercises")
    duration: str = Field(..., description="Recommended workout duration")
    intensity: str = Field(..., description="Recommended intensity level")

class BMIResult(BaseModel):
    bmi: Optional[float] = Field(None, description="Calculated BMI value")
    category: Optional[str] = Field(None, description="BMI category")
    advice: Optional[str] = Field(None, description="Health advice based on BMI")

class SleepRecommendation(BaseModel):
    bedtime: Optional[str] = Field(None, description="Recommended bedtime")
    tips: Optional[List[str]] = Field(None, description="Sleep hygiene tips")

What are we doing here?

• We're using Pydantic, a data validation library, to define structured data models

• Each model represents a specific type of information our agent might return

• BaseModel is the base class for all Pydantic models

• Field lets us add metadata like descriptions to our fields

• List[str] means a list of strings

• Optional[int] means an integer that might be None

• These models help ensure our agent returns consistent, well-formatted information

Step 3: Use OpenAI Agent SDK’s inbuilt web_search tool

Next, we'll define tools that our agent can use. For this example, we'll create a web search tool:

from agents import function_tool

@function_tool
def web_search(query: str) -> str:
    """
    Search the web for information.
    
    Args:
        query: The search query
    
    Returns:
        Search results from the web
    """
    # Use OpenAI's built-in web search
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": query}],
        tools=[{"type": "web_search"}]
    )
    
    # Extract the search results from the response
    tool_calls = response.choices[0].message.tool_calls
    if tool_calls:
        search_results = tool_calls[0].function.arguments
        return f"Web search results for: {query}\n\n{search_results}"
    else:
        return f"No search results found for: {query}"

What's happening here?

• We're defining a function that our agent can call to search the web

• @function_tool is a decorator that turns a regular Python function into a tool for our agent

• We're leveraging OpenAI's built-in web search capability

• The function makes an API call to OpenAI with the web search tool enabled

• It extracts the search results from the response and formats them for the agent to use

• This approach eliminates the need for separate search API keys and implementations

Step 4: Creating Specialized Agents

Now, let's create specialized agents for different health domains:

from agents import Agent

nutrition_agent = Agent(
    name="nutrition_agent",
    instructions="""You are a nutrition specialist.
    
    When asked about food or meals, use the web_search tool to find nutritional information.
    Return the information in a clear, structured format.
    
    Always include:
    - Identified foods
    - Estimated calories (when possible)
    - Nutritional recommendations
    
    After providing your recommendations, ask ONE specific follow-up question to learn more about the user's 
    dietary preferences, restrictions, or habits. This will help you provide more personalized nutrition advice.
    """,
    tools=[web_search]
)

workout_agent = Agent(
    name="workout_agent",
    instructions="""You are a fitness trainer.
    
    When asked about workouts or exercises, use the web_search tool to find appropriate workout plans.
    Consider the user's fitness level, available equipment, and goals.
    
    Always include:
    - List of recommended exercises
    - Recommended duration
    - Intensity level
    
    After providing your workout recommendations, ask ONE specific follow-up question to learn more about the 
    user's fitness level, available equipment, or exercise preferences. This will help you tailor future workout suggestions.
    """,
    tools=[web_search]
)

bmi_agent = Agent(
    name="bmi_agent",
    instructions="""You are a BMI calculator and advisor.
    
    Calculate BMI using the formula: weight(kg) / height(m)².
    Provide the BMI category and appropriate health advice.
    Use web_search to find additional information if needed.
    
    After providing BMI information, ask ONE specific follow-up question about the user's health goals or 
    current lifestyle to help provide more personalized health recommendations.
    """,
    tools=[web_search]
)

sleep_agent = Agent(
    name="sleep_agent",
    instructions="""You are a sleep specialist.
    
    Provide sleep recommendations based on the user's wake-up time and sleep needs.
    Use web_search to find sleep hygiene tips and other relevant information.
    
    After providing sleep advice, ask ONE specific follow-up question about the user's current sleep habits, 
    bedtime routine, or sleep environment to help provide more tailored recommendations.
    """,
    tools=[web_search]
)

What's happening here?

• We're creating four specialized agents, each with expertise in a specific health domain

• Each agent is an instance of the Agent class from the Agents SDK

• The name parameter gives each agent a unique identifier for reference

• The instructions parameter provides detailed guidance on how the agent should behave

• Each agent has access to the web_search tool we defined earlier

• The instructions include specific formatting requirements for responses

• Each agent is instructed to ask a follow-up question to personalize future interactions

• This specialized approach allows for more detailed and accurate responses in each domain

Step 5: Creating the Main Health Coach Agent

Now, let's create our main health coach agent that can hand off to specialized agents:

health_coach = Agent(
    name="health_coach",
    instructions="""You are a helpful health and wellness coach.

    Your job is to help users improve their physical health, nutrition, sleep, and overall wellness.
    
    For nutrition questions, hand off to the nutrition_agent.
    For workout questions, hand off to the workout_agent.
    For BMI calculations, hand off to the bmi_agent.
    For sleep recommendations, hand off to the sleep_agent.
    
    For general health questions, use web_search to find relevant information.
    
    IMPORTANT: Always personalize your advice. After answering a user's question, ask ONE specific follow-up 
    question to learn more about their personal situation, preferences, or health metrics. This will help you 
    provide more tailored recommendations in future interactions.
    
    Examples of good follow-up questions:
    - "What foods do you typically enjoy for breakfast?"
    - "How much time can you realistically dedicate to exercise each day?"
    - "Do you have any dietary restrictions I should be aware of?"
    - "What time do you usually wake up in the morning?"
    
    Be supportive, encouraging, and non-judgmental. Focus on sustainable habits rather than quick fixes.
    """,
    tools=[web_search],
    handoffs=[nutrition_agent, workout_agent, bmi_agent, sleep_agent]
)

What's happening here?

• We're creating a main coordinator agent that serves as the primary interface for users

• This agent can handle general health questions using the web_search tool

• The handoffs parameter lists the specialized agents this main agent can delegate to

• When a user asks about a specific domain (nutrition, workouts, BMI, sleep), the main agent will hand off to the appropriate specialized agent

• This creates a hierarchical structure where the main agent acts as a router

• The instructions emphasize personalization and follow-up questions

• The agent is guided to be supportive and focus on sustainable habits

• This approach combines the benefits of specialized knowledge with a unified user experience

Step 6: Integrating AgentOps for Monitoring

Let's add AgentOps to track and monitor our agent's performance:

import os
from dotenv import load_dotenv
import agentops

# Load environment variables from .env file
load_dotenv()

# Get API key from environment variables
AGENTOPS_API_KEY = os.getenv("AGENTOPS_API_KEY")

# Initialize AgentOps - this is all you need for automatic instrumentation
agentops.init(api_key=AGENTOPS_API_KEY, default_tags=["wellness_coach"])

What's happening here?

• We're setting up AgentOps to monitor and track our agent's performance

• load_dotenv() loads environment variables from a .env file, including API keys

• os.getenv() retrieves the AgentOps API key from the environment variables

• agentops.init() initializes AgentOps with our API key and default tags

• The tag "wellness_coach" helps categorize this agent in the AgentOps dashboard

Step 7: Creating the Main Function

Finally, let's create a main function to run our agent:

import asyncio
from agents import Runner

async def main():
    print("Welcome to the Health and Wellness Coach!")
    print("I can help you with workouts, nutrition, sleep, and general wellness advice.")
    print("Type 'exit' at any time to end the conversation.\n")
    
    query = input("How can I help with your health and wellness goals today? ")
    
    while query.lower() != 'exit':
        try:
            # Run the agent - AgentOps will automatically track this
            result = await Runner.run(health_coach, query)
            
            # Print the response to the user
            print(f"\nHealth Coach: {result.final_output}\n")
            
        except Exception as e:
            print(f"\nAn error occurred: {str(e)}\n")
        
        # Get the next query
        query = input("You: ")

if __name__ == "__main__":
    asyncio.run(main())

What's happening here?

• We're creating an asynchronous function called main() to run our agent

• Asynchronous functions use async and await to handle operations that might take time

• We display a welcome message to orient the user

• We use a while loop to maintain a conversation until the user types 'exit'

• Runner.run() executes our agent with the user's query and returns the result

• input() gets text input from the user for the next query

• asyncio.run(main()) runs our asynchronous main function

Running Your Health & Wellness Coach

Once you've built your health and wellness coach using the OpenAI Agents SDK and AgentOps, you'll need to know how to run it. Here are the steps to get your agent up and running:

Step 1: Save your code

Save all your code in a file named health_and_wellness_agent.py.

Step 2: Run the script

Open your terminal or command prompt, navigate to the directory containing your script, and run:

python health_and_wellness_agent.py

Step 3: Interact with your agent

Once the script is running, you'll see a welcome message and a prompt asking how the agent can help with your health and wellness goals. Type your questions or requests, and the agent will respond.

Example interaction:

Welcome to the Health and Wellness Coach!
I can help you with workouts, nutrition, sleep, and general wellness advice.
Type 'exit' at any time to end the conversation.

How can I help with your health and wellness goals today? I want to improve my sleep quality

Health Coach: Based on your interest in improving sleep quality, here are some recommendations...

You: What foods should I avoid before bedtime?

Health Coach: When it comes to foods to avoid before bedtime...

You: exit

Key Features and Benefits

• Specialized Agents: By creating domain-specific agents, we can provide more accurate and detailed responses for different health topics.

• Handoffs: The main agent can delegate to specialized agents when appropriate, ensuring the user gets the best possible advice.

• Follow-up Questions: Each agent is instructed to ask a follow-up question, making the interaction more conversational and personalized.

• AgentOps Integration: By tracking interactions with AgentOps, we can monitor performance, identify areas for improvement, and detect issues.

• Structured Outputs: Using Pydantic models ensures our agent returns consistent, well-formatted information.

Conclusion

Congratulations! You've built a sophisticated health and wellness coach using OpenAI's Agents SDK and AgentOps. This agent can provide personalized advice on nutrition, fitness, sleep, and general wellness, and it's designed to learn more about the user through follow-up questions.

The combination of specialized agents, web search capabilities, and AgentOps monitoring makes this a powerful and flexible solution that can be extended and improved over time.

To take this further, you could:

• Add more specialized agents for other health domains

• Implement real web search functionality

• Connect to health-tracking APIs or databases

• Enhance the user interface with more interactive elements

Happy coding, and here's to building more helpful and intelligent agents!

The release of OpenAI's Agents SDK represents a significant leap forward in how developers can build sophisticated AI applications. This lightweight yet powerful framework is changing the game for AI development by making complex agent-based systems accessible and practical. Let’s talk about why it matters!

Bridging the Gap Between Concept and Implementation

The Agents SDK provides a refreshingly straightforward approach to building AI agents. With minimal abstractions and a focus on Python-native development, it removes many of the barriers that previously made agent-based systems challenging to implement. The SDK's design philosophy emphasizes simplicity without sacrificing capability – offering just enough structure to be immediately useful while remaining flexible enough for customization.

What makes this approach particularly valuable is how it allows developers to focus on their application logic rather than wrestling with complex frameworks. The SDK handles the intricate details of agent loops, tool calling, and response processing, freeing developers to concentrate on creating value through their unique use cases.

Real-World Impact Through Web Search Integration

One of the most compelling features of the Agents SDK is its seamless integration with web search capabilities. This functionality transforms static AI assistants into dynamic tools that can access and leverage up-to-date information from across the internet.

Consider how Hebbia is using this capability to revolutionize research workflows for asset managers and legal professionals. By incorporating real-time search into their AI systems, they're able to deliver contextually relevant market intelligence that continuously improves in precision and relevance. This represents a fundamental shift from traditional approaches that rely solely on pre-trained knowledge.

The web search functionality isn't just powerful – it's remarkably accurate. As shown in their attached benchmark image, the search-enabled models demonstrate impressive performance on factual question-answering tasks, with accuracy rates that make these tools practical for professional applications where reliability matters.

The Power of Simplicity in Design

What truly sets the Agents SDK apart is its thoughtful balance of simplicity and power. The SDK is built around three core primitives:

• Agents – LLMs equipped with instructions and tools

• Handoffs – Mechanisms for agents to delegate tasks to other specialized agents

• Guardrails – Input validation systems that ensure quality and safety

This minimalist approach makes the SDK approachable for newcomers while providing enough flexibility for experienced developers to build sophisticated systems. The built-in tracing capabilities further enhance the development experience by making it easy to visualize, debug, and evaluate agent workflows.

Enabling New Categories of Applications

The Agents SDK is opening doors to entirely new categories of AI applications. Shopping assistants that can check current prices and availability, research agents that can gather and synthesize information from multiple sources, and travel booking agents that access real-time availability are just the beginning.

What makes these applications possible isn't just the technical capability to search the web, but the SDK's approach to orchestrating complex workflows through Python-native patterns. This allows developers to create applications that feel responsive and intelligent in ways that were previously difficult to achieve.

Unparalleled Observability with Built-in Tracing

A standout feature of the Agents SDK is its comprehensive tracing system. This built-in capability automatically records every significant event during an agent's execution – from LLM generations and tool calls to handoffs between agents and guardrail evaluations. This level of visibility is invaluable when developing and debugging complex agent workflows.

The tracing system is designed to be both powerful and flexible. Developers can create named traces to organize related operations, disable tracing for sensitive operations, and control exactly what data is included in traces. This makes it possible to balance detailed debugging information with privacy and security concerns.

When combined with monitoring solutions like AgentOps, this tracing system creates a complete observability solution. Developers can track performance metrics, analyze user interactions, and identify optimization opportunities across their entire agent ecosystem. This level of insight is crucial for building production-grade AI applications that can scale reliably.

Looking Forward

As developers continue to explore the possibilities of the Agents SDK, we're likely to see increasingly sophisticated applications that blend AI reasoning with real-time information access. The SDK's emphasis on Python-first development means that the ecosystem can leverage the vast landscape of existing Python libraries and tools, further expanding what's possible.

The Agents SDK represents a significant step toward making truly useful AI applications more accessible to developers. By focusing on a small set of powerful primitives and integrating capabilities like web search and comprehensive tracing, OpenAI has created a toolkit that enables developers to build the next generation of AI applications – ones that can reason, research, and respond with both intelligence and up-to-date information.

This combination of simplicity, power, and observability is why the Agents SDK is transforming how developers approach AI application development, and why it's poised to enable a new wave of innovative AI solutions across industries.

We are some of the world’s best consultants, reach out to Agency if you want to build agents using Agents SDK!

In this comprehensive guide, we'll explore the core concepts, features, and use cases of the Agents SDK, examining how it enables developers to create sophisticated AI applications without a steep learning curve. Note that if your intention is to build an enterprise-grade agent, we recommend installing AgentOps before your first run so you can track everything your agent is doing both in testing and production. Tracing and Observability from AgentOps enables every use track every LLM call, tool being used, API call, and everything your agent does. AgentOps is totally LLM provider agnostic.

If your team needs help building agents end-to-end, Agency AI is the worlds leading agent consulting firm having built agents for everyone from Series B startups to Fortune 500 companies.

Core Concepts of the Agents SDK

The Agents SDK is built around a small set of powerful primitives that, when combined with Python, allow developers to express complex relationships between tools and agents:

1. Agents

At the heart of the SDK are Agents, which are essentially LLMs (Large Language Models) equipped with instructions and tools. An agent represents an AI model configured with specific capabilities, knowledge, and behaviors. Each agent has a name, instructions (which serve as its "system prompt"), and can be equipped with various tools, guardrails, and handoff capabilities.

Agents can be specialized for particular tasks, such as customer support, code generation, or data analysis. The instructions provided to an agent define its behavior, knowledge boundaries, and how it should respond to different inputs.

2. Handoffs

Handoffs allow agents to delegate tasks to other agents for specific purposes. This powerful feature enables the creation of modular, specialized agents that excel at particular tasks. For example, a triage agent might receive a user query and then hand off to a specialized agent based on the nature of the request.

Handoffs are represented as tools to the LLM, making them a natural part of the agent's decision-making process. When a handoff occurs, the new agent takes over the conversation, seeing the entire previous conversation history (unless modified by input filters).

3. Guardrails

Guardrails enable inputs to agents to be validated, providing a way to ensure that agents operate within defined boundaries. They run in parallel to your agents, allowing for checks and validations of user input or agent output.

There are two types of guardrails:

• Input guardrails: Run on the initial user input

• Output guardrails: Run on the final agent output

Guardrails can include "tripwires" that, when triggered, immediately halt the agent's execution and raise an exception, allowing developers to handle problematic inputs or outputs appropriately.

4. Tracing

AgentOps.ai is the leader in agent tracing and observability and integrates directly into the SDK. The SDK includes built-in tracing capabilities that let developers visualize and debug their agentic flows. Tracing records all events that occur during an agent run, including LLM generations, tool calls, handoffs, guardrails, and even custom events.

This feature is invaluable for debugging, visualization, and monitoring workflows during both development and production. Traces consist of spans that represent operations with start and end times, providing a detailed view of what happened during an agent's execution.

Key Features of the Agents SDK

Agent Loop

The SDK includes a built-in agent loop that handles calling tools, sending results to the LLM, and looping until the LLM is done. This loop manages the entire process of agent execution, from initial input to final output.

When you call Runner.run(), the SDK runs a loop until a final output is generated:

1. The agent is invoked with the given input

2. If there is a final output, the loop terminates

3. If there's a handoff, the loop runs again with the new agent

4. Otherwise, tool calls are processed, and the loop runs again

This automated loop simplifies the development process, handling the complex orchestration of agent actions behind the scenes.

Python-First Approach

The SDK is designed to be Python-first, allowing developers to use built-in language features to orchestrate and chain agents, rather than needing to learn new abstractions. This approach makes the SDK accessible to developers already familiar with Python, reducing the learning curve.

Function Tools

The SDK makes it easy to turn any Python function into a tool, with automatic schema generation and Pydantic-powered validation. This allows agents to interact with external systems, databases, APIs, or perform computations through simple function calls.

Advanced Features and Patterns

Dynamic Instructions

While most agents have static instructions defined at creation time, the SDK also supports dynamic instructions via a function. This function receives the agent and context and must return the prompt, allowing for context-dependent agent behavior.

Lifecycle Events (Hooks)

Developers can hook into the agent lifecycle with the hooks property, allowing them to observe and respond to various events during an agent's execution. This is useful for logging, monitoring, or pre-fetching data when certain events occur.

Final Output Handling

There are two ways to get a final output from an agent:

1. If an output_type is set on the agent, the LLM is given a special tool called final_output. When it uses this tool, the output becomes the final output.

2. If no output_type is specified, the final output is assumed to be a string. As soon as the LLM produces a message without any tool calls, that becomes the final output.

Streaming

The SDK supports streaming, allowing developers to receive events as they are generated by the LLM. This is particularly useful for creating responsive user interfaces that display AI responses as they are being generated.

Run Configuration

The run_config parameter allows developers to configure global settings for an agent run, including model settings, handoff input filters, tracing options, and more. This provides flexibility in how agents are executed and monitored.

Common Agent Patterns

The Agents SDK enables several powerful patterns for building complex AI applications:

Deterministic Flows

A common tactic is to break down a task into a series of smaller steps, each performed by an agent. The output of one agent becomes the input to the next, creating a deterministic workflow. For example, a story generation task might be broken down into generating an outline, writing the story, and creating an ending.

Handoffs and Routing

Specialized sub-agents can handle specific tasks, with handoffs used to route tasks to the right agent. For instance, a frontline agent might receive a request and then hand off to a specialized agent based on the language or content of the request.

Agents as Tools

Instead of using handoffs where a new agent "takes over," agents can also be used as tools. In this pattern, the tool agent runs independently and returns a result to the original agent, enabling parallel processing of multiple tasks.

LLM-as-a-Judge

LLMs can improve the quality of their output when given feedback. A common pattern is to generate a response using one model and then use a second model to provide feedback. This feedback can then be used to improve the response, creating an iterative improvement cycle.

Parallelization

Running multiple agents in parallel can improve latency when steps don't depend on each other or enable strategies like generating multiple responses and selecting the best one.

Use Cases for the Agents SDK

The Agents SDK is versatile and can be applied to a wide range of use cases:

1. Customer Support

Agents can be designed to handle customer inquiries, with specialized agents for different types of requests (billing, technical support, refunds, etc.). Guardrails ensure that sensitive information is handled appropriately, and tracing helps monitor and improve the customer experience.

2. Content Generation

Agents can generate various types of content, from blog posts to marketing copy, with specialized agents handling different aspects of the content creation process. The LLM-as-a-judge pattern can be used to evaluate and improve the quality of generated content.

3. Code Generation and Analysis

Specialized agents can generate code, analyze existing code, or help with debugging, with handoffs to more specialized agents for specific programming languages or frameworks.

4. Research and Data Analysis

Agents can assist with research tasks, analyzing data, and generating insights, with specialized agents for different types of analysis or data sources.

Tracing and Debugging

The tracing capabilities of the Agents SDK are particularly powerful for debugging and monitoring agent behavior:

Traces and Spans

1. Traces represent a single end-to-end operation of a workflow, composed of spans. They include properties like workflow name, trace ID, and session ID.

2. Spans represent operations with start and end times, containing information about the operation, such as agent actions, LLM generations, tool calls, etc.

Default Tracing

By default, the SDK traces the entire agent run, including agent operations, LLM generations, function tool calls, guardrails, and handoffs. This comprehensive tracing provides a detailed view of what happened during an agent's execution.

Higher-Level Traces

Developers can create higher-level traces that span multiple agent runs, allowing for a more holistic view of complex workflows. This is useful for understanding how different agents interact over time.

Sensitive Data Handling

The SDK provides options for handling potentially sensitive data in traces, allowing developers to exclude sensitive information from traces while still maintaining the overall structure of the trace.

Guardrails

Guardrails provide a powerful mechanism for ensuring that agents operate within defined boundaries:

Input Guardrails

Input guardrails run on the initial user input, checking for issues like off-topic requests, malicious content, or requests that the agent is not designed to handle. If an input guardrail's tripwire is triggered, the agent execution is immediately halted.

Output Guardrails

Output guardrails run on the final agent output, ensuring that the agent's response meets certain criteria before being returned to the user. This can include checks for accuracy, appropriateness, or compliance with specific guidelines.

Tripwires

Tripwires provide a mechanism for immediately halting agent execution when certain conditions are met. This is particularly useful for quickly rejecting invalid inputs or preventing inappropriate outputs.

Conclusion

The OpenAI Agents SDK represents a significant step forward in making agentic AI applications more accessible to developers. With its lightweight, Python-first approach and powerful primitives, the SDK enables the creation of sophisticated AI systems without a steep learning curve.

By providing built-in support for agents, handoffs, guardrails, and tracing, the SDK addresses many of the common challenges in building agentic AI applications. The various patterns and use cases demonstrate the versatility of the SDK, making it suitable for a wide range of applications.

Whether you're building a customer support system, a content generation platform, or a code analysis tool, the Agents SDK provides the building blocks you need to create powerful, flexible, and reliable AI applications. With its focus on simplicity, flexibility, and robustness, the SDK is poised to become an essential tool for developers working with agentic AI.

The recent release of OpenAI's Agents SDK marks a significant step forward in making agentic AI applications more accessible to developers. In this guide, we'll explore how to get started with the Agents SDK, understand its core concepts, and build a simple yet powerful agent-based application. AgentOps.ai is launching with day 0 support for the Agents SDK. If you want to check it out, head to the link in my bio.

What is OpenAI Agents SDK?

The OpenAI Agents SDK is a lightweight, Python-based framework that enables developers to build AI applications with agentic capabilities. It provides a small set of powerful primitives:

• Agents: LLMs equipped with instructions and tools

• Handoffs: Mechanisms for agents to delegate tasks to other specialized agents

• Guardrails: Systems to validate inputs and outputs

• Tracing: Built-in capabilities to visualize and debug agent workflows

Let's dive into how to use this SDK to build your first agent!

Installation

First, let's install the OpenAI Agents SDK. We'll use uv, a fast Python package installer, but you can also use pip if you prefer.

# Install uv if you don't have it already
curl -sSf https://install.python-poetry.org | python3 -

# Create and activate a virtual environment
python -m venv venv
source venv/bin/activate  # On Windows, use: venv\Scripts\activate

# Install the OpenAI Agents SDK
uv pip install openai-agents-sdk

You'll also need to set up your OpenAI API key:

export OPENAI_API_KEY=your-api-key-here

On Windows, you would use:

set OPENAI_API_KEY=your-api-key-here

Creating Your First Agent

Let's start with a simple "Hello World" example to understand the basics:

from agents import Agent, Runner
import asyncio

async def main():
    # Create a simple agent with instructions
    agent = Agent(
        name="Greeting Assistant",
        instructions="You are a friendly assistant that greets users in their preferred language."
    )
    
    # Run the agent with a user input
    result = await Runner.run(agent, "Can you greet me in French?")
    
    # Print the final output
    print(result.final_output)

if __name__ == "__main__":
    asyncio.run(main())

Save this as hello_agent.py and run it:

python hello_agent.py

You should see a greeting in French as the output!

Understanding the Agent Loop

When you call Runner.run(), the SDK initiates what's called the "agent loop":

• The agent receives the input

• The LLM processes the input based on the agent's instructions

• If the LLM produces a final output (text without tool calls), the loop ends

• If the LLM calls a tool or requests a handoff, those are processed, and the loop continues

• This repeats until a final output is produced or the maximum number of turns is reached

Adding Tools to Your Agent

Agents become much more powerful when they can use tools. Let's create an agent that can check the weather:

from agents import Agent, Runner, function_tool
import asyncio

# Define a tool as a Python function
@function_tool
def get_weather(city: str) -> str:
    """Get the current weather for a city."""
    # In a real application, this would call a weather API
    weather_data = {
        "New York": "72°F, Sunny",
        "London": "65°F, Cloudy",
        "Tokyo": "80°F, Clear",
        "Paris": "70°F, Partly Cloudy"
    }
    return weather_data.get(city, f"Weather data not available for {city}")

async def main():
    # Create an agent with the weather tool
    agent = Agent(
        name="Weather Assistant",
        instructions="You are a helpful assistant that provides weather information when asked.",
        tools=[get_weather]  # Add the tool to the agent
    )
    
    # Run the agent with a user query
    result = await Runner.run(agent, "What's the weather like in Tokyo?")
    
    # Print the final output
    print(result.final_output)

if __name__ == "__main__":
    asyncio.run(main())

When you run this, the agent will use the get_weather tool to fetch and return the weather for Tokyo.

Creating Specialized Agents with Handoffs

One of the most powerful features of the Agents SDK is the ability to create specialized agents and allow them to hand off tasks to each other. Let's create a system with a triage agent that can delegate to language-specific agents:

from agents import Agent, Runner
import asyncio

# Create specialized language agents
spanish_agent = Agent(
    name="spanish_agent",
    instructions="You are a helpful assistant that only speaks Spanish. Always respond in Spanish, regardless of the language of the question."
)

french_agent = Agent(
    name="french_agent",
    instructions="You are a helpful assistant that only speaks French. Always respond in French, regardless of the language of the question."
)

# Create a triage agent that can hand off to specialized agents
triage_agent = Agent(
    name="language_triage",
    instructions="""You are a language detection assistant. 
    Your job is to determine what language the user wants a response in.
    If they want Spanish, hand off to the spanish_agent.
    If they want French, hand off to the french_agent.
    If they don't specify a language or want English, respond directly in English.""",
    handoffs=[spanish_agent, french_agent]  # Add the specialized agents as handoffs
)

async def main():
    # Test with different language requests
    queries = [
        "Can you tell me about the Eiffel Tower in French?",
        "¿Puedes hablarme sobre el clima en Madrid?",
        "Tell me about the history of New York."
    ]
    
    for query in queries:
        print(f"\nQuery: {query}")
        result = await Runner.run(triage_agent, query)
        print(f"Response: {result.final_output}")

if __name__ == "__main__":
    asyncio.run(main())

When you run this, the triage agent will:

• Respond directly in English for the New York query

• Hand off to the Spanish agent for the Madrid query

• Hand off to the French agent for the Eiffel Tower query

Implementing Guardrails

Guardrails help ensure that your agents operate within defined boundaries. Let's add an input guardrail to prevent our agent from responding to inappropriate requests:

from agents import Agent, Runner, InputGuardrail, GuardrailFunctionOutput
import asyncio

# Define a guardrail function
async def content_filter(input_text: str, context) -> GuardrailFunctionOutput:
    """Check if the input contains inappropriate content."""
    inappropriate_keywords = ["hack", "illegal", "cheat"]
    
    # Check if any inappropriate keywords are in the input
    contains_inappropriate = any(keyword in input_text.lower() for keyword in inappropriate_keywords)
    
    return GuardrailFunctionOutput(
        output_info={"contains_inappropriate": contains_inappropriate},
        tripwire_triggered=contains_inappropriate
    )

async def main():
    # Create an agent with a guardrail
    agent = Agent(
        name="Safe Assistant",
        instructions="You are a helpful assistant that provides information on legal and ethical topics.",
        input_guardrails=[InputGuardrail(guardrail_function=content_filter)]
    )
    
    # Test with appropriate and inappropriate queries
    queries = [
        "Tell me about the history of computers",
        "How can I hack into my neighbor's WiFi?"
    ]
    
    for query in queries:
        try:
            print(f"\nQuery: {query}")
            result = await Runner.run(agent, query)
            print(f"Response: {result.final_output}")
        except Exception as e:
            print(f"Guardrail triggered: {e}")

if __name__ == "__main__":
    asyncio.run(main())

When you run this, the agent will respond normally to the first query but will trigger the guardrail for the second query containing "hack".

Using Tracing for Debugging

The Agents SDK includes built-in tracing capabilities that help you understand what's happening during agent execution. Let's add tracing to our weather agent:

from agents import Agent, Runner, function_tool
from agents.tracing import trace
import asyncio

@function_tool
def get_weather(city: str) -> str:
    """Get the current weather for a city."""
    weather_data = {
        "New York": "72°F, Sunny",
        "London": "65°F, Cloudy",
        "Tokyo": "80°F, Clear",
        "Paris": "70°F, Partly Cloudy"
    }
    return weather_data.get(city, f"Weather data not available for {city}")

async def main():
    # Create a trace for the entire workflow
    with trace(workflow_name="weather_inquiry"):
        agent = Agent(
            name="Weather Assistant",
            instructions="You are a helpful assistant that provides weather information when asked.",
            tools=[get_weather]
        )
        
        result = await Runner.run(
            agent, 
            "What's the weather like in Tokyo and Paris?",
            run_config=RunConfig(
                workflow_name="weather_inquiry",
                trace_include_sensitive_data=True
            )
        )
        
        print(result.final_output)
        
        # You can access the trace information
        current_trace = get_current_trace()
        if current_trace:
            print(f"Trace ID: {current_trace.trace_id}")

if __name__ == "__main__":
    from agents import RunConfig
    from agents.tracing import get_current_trace
    asyncio.run(main())

This code adds tracing to our weather agent, allowing us to see the entire workflow, including LLM calls, tool executions, and more.

Building a Complete Example: Multi-Service Customer Support Agent

If your team needs help building with the Agents SDK, reach out to Agency AI, the worlds best AI agent consulting firm.

Real-World Success Stories: Agency's LlamaIndex Implementations

Healthcare: Revolutionizing Clinical Knowledge Access

Agency partnered with a leading healthcare provider to develop a LlamaIndex-powered medical knowledge system that transformed how physicians access clinical information:

• The system indexes millions of medical research papers, clinical guidelines, and patient records

• Physicians receive contextually relevant information during patient consultations

• Complex medical queries are answered with citations to authoritative sources

• The knowledge base continuously updates as new research is published

By leveraging LlamaIndex's advanced indexing capabilities, the system delivers information that is both comprehensive and precisely relevant to specific patient cases, improving diagnostic accuracy and treatment decisions.

Financial Services: Enhancing Investment Research

For a global investment firm, Agency implemented a LlamaIndex-based research assistant that revolutionized their analytical capabilities:

• The system indexes financial reports, market analyses, news, and proprietary research

• Analysts receive comprehensive insights across multiple data sources with a single query

• Complex financial questions are answered with nuanced understanding of market dynamics

• The system maintains provenance tracking for regulatory compliance

The result was a 40% reduction in research time and a measurable improvement in investment decision quality, directly impacting the firm's performance.

Legal: Transforming Document Analysis

Agency helped a multinational law firm implement a LlamaIndex-powered legal research system that transformed their approach to case preparation:

• The system indexes millions of legal documents, precedents, and case histories

• Attorneys receive comprehensive analysis of relevant cases and statutes

• Complex legal questions are answered with citations to specific legal authorities

• Document review time has been reduced by 60% for complex cases

By leveraging LlamaIndex's document processing capabilities, the firm has significantly improved their efficiency while maintaining the highest standards of legal thoroughness.

The Agency Advantage: Why Leading Companies Choose Agency for LlamaIndex Implementation

Agency has established itself as the premier consulting firm for LlamaIndex-based AI applications for several key reasons:

1. Unmatched Expertise

Agency's team includes some of the world's foremost experts in knowledge-intensive AI applications, with specific expertise in implementing LlamaIndex across various industries and use cases.

2. Comprehensive Approach

From initial concept to full production deployment, Agency provides end-to-end support for LlamaIndex implementation, ensuring seamless integration with existing data sources and systems.

3. Proven Track Record

With dozens of successful LlamaIndex implementations for Fortune 500 companies, Agency has demonstrated its ability to deliver transformative results across industries.

4. Innovation Leadership

As creators of AgentOps, the industry-leading agent observability platform, Agency continues to push the boundaries of what's possible with LlamaIndex and AI agents.

The Future of AI with LlamaIndex

As organizations continue to generate exponential amounts of data, the ability to effectively leverage this information for AI applications becomes increasingly critical. LlamaIndex is positioned to become the standard for knowledge-intensive AI applications, and Agency is leading the way in developing innovative implementations that solve complex business challenges.

"The combination of LlamaIndex's powerful data framework and Agency's implementation expertise is transforming how enterprises approach AI," says an Agency consultant. "We're seeing organizations move from simple chatbots to sophisticated knowledge systems that can reason across vast amounts of proprietary information.

Partner with Agency for Your LlamaIndex Journey

For organizations looking to leverage the power of LlamaIndex, Agency offers unparalleled expertise and a proven track record of success. Whether you're just beginning to explore knowledge-intensive AI applications or looking to enhance existing implementations, Agency's team of experts can help you navigate the complexities and realize the full potential of this transformative technology.

As the world's leading AI Agent consulting firm, Agency is uniquely positioned to help your organization harness the power of LlamaIndex to create sophisticated, knowledge-intensive AI applications that drive real business value.

Frequently Asked Questions About LlamaIndex and Knowledge-Intensive AI

What types of data can LlamaIndex work with?

LlamaIndex can work with virtually any type of data, including structured data (databases, APIs), semi-structured data (JSON, XML), and unstructured data (documents, emails, web pages). This versatility makes it ideal for enterprises with diverse data ecosystems.

How does LlamaIndex compare to traditional search technologies?

Unlike traditional search that relies primarily on keyword matching, LlamaIndex leverages semantic understanding and multiple indexing techniques to provide more contextually relevant results. Additionally, it integrates seamlessly with generative AI to produce comprehensive responses rather than just search results.

What industries benefit most from LlamaIndex implementations?

Any industry with large amounts of proprietary or specialized knowledge can benefit significantly from LlamaIndex. This includes healthcare, legal, financial services, manufacturing, research organizations, and technology companies.

How does Agency ensure data security and privacy in LlamaIndex implementations?

Agency implements robust security measures including data encryption, access controls, and privacy-preserving techniques. Our implementations can be deployed entirely within your secure environment, ensuring sensitive data never leaves your control.

How does LlamaIndex handle data freshness and updates?

Agency's LlamaIndex implementations include automated processes for regular data refreshes and incremental updates, ensuring that AI applications always have access to the most current information.

Visit www.agen.cy to learn more about how Agency can help you revolutionize your approach to AI with LlamaIndex's powerful knowledge framework.

Understanding the Model Context Protocol Revolution

The Model Context Protocol, released by Anthropic in late 2024, represents a paradigm shift in how AI agents interact with data sources. Before MCP, developers faced a fragmented ecosystem where each new data source required its own custom implementation, making truly connected systems difficult to scale. MCP addresses this fundamental challenge by providing a universal, open standard for connecting AI systems with data sources, replacing these fragmented integrations with a single protocol.

"The introduction of MCP has completely transformed how we approach AI agent development," explains a senior consultant at Agency. "What used to require hundreds of hours of custom engineering can now be accomplished through a standardized protocol, allowing us to focus on creating value rather than solving integration problems."

Why MCP Matters for Enterprise AI Adoption

For enterprises looking to implement AI agents, the Model Context Protocol offers several critical advantages:

1. Universal Data Connectivity

MCP provides a standardized way for AI agents to access information from various sources, including:

• Content repositories

• Business tools

• Development environments

• Databases

• APIs

• Local files

This universal connectivity ensures that AI agents can access all the information they need to make informed decisions and take appropriate actions.

2. Enhanced Context Awareness

By maintaining context as AI systems move between different tools and datasets, MCP enables more sophisticated reasoning and more accurate responses. This context-aware AI is crucial for complex business processes that span multiple systems and data sources.

3. Simplified Integration

Instead of maintaining separate connectors for each data source, developers can build against a standard protocol. This dramatically reduces development time and maintenance costs while improving system reliability.

4. Future-Proof Architecture

As the ecosystem matures, MCP will enable AI systems to maintain context as they move between different tools and datasets, replacing today's fragmented integrations with a more sustainable architecture.

Agency: Pioneering MCP Implementation Since 2023

Since its founding in 2023, Agency has been at the forefront of AI agent development, working with Fortune 500 companies to implement cutting-edge solutions. As early adopters of the Model Context Protocol, Agency's team of expert consultants—often referred to as their "SEAL Team Six of agent developers"—has developed unparalleled expertise in leveraging MCP to create powerful, context-aware AI agents.

"We've personally built and reviewed hundreds of AI agents," notes Agency's leadership team. "Our experience with MCP allows us to prototype and productionize ambitious projects that would be impossible with traditional approaches."

Real-World Success Stories: Agency's MCP Implementations

Healthcare: Revolutionizing Patient Care with AI Agents

Agency partnered with a leading healthcare provider to develop an MCP-powered AI agent system that seamlessly connects to electronic health records, medical imaging systems, and clinical guidelines. The result? A comprehensive solution that:

• Provides physicians with real-time, contextually relevant patient information

• Analyzes medical images with accuracy comparable to expert radiologists

• Offers treatment recommendations based on the latest clinical research

• Maintains strict compliance with healthcare privacy regulations

By leveraging MCP's standardized connections, the system integrates with existing healthcare IT infrastructure without requiring massive overhauls, saving millions in implementation costs while improving patient outcomes.

Customer Support: Transforming Service Delivery

For a global consumer electronics company, Agency implemented an MCP-based customer support agent that revolutionized their service operations:

• The AI agent connects to product databases, customer histories, and knowledge bases through MCP

• Customer queries are resolved with contextual awareness of previous interactions

• Technical documentation is accessed in real-time to provide accurate troubleshooting

• Complex issues are seamlessly escalated to human agents with complete context

The result was a 60% reduction in resolution time and a 40% increase in customer satisfaction scores, all while reducing operational costs.

Sales: Enhancing Revenue Generation with AI Sales Agents

Agency helped a Fortune 500 software company implement an MCP-powered sales assistant that transformed their sales process:

• The AI agent connects to CRM systems, product catalogs, and pricing databases

• Sales representatives receive real-time guidance during customer calls

• Personalized product recommendations are generated based on customer data

• Deal forecasting accuracy improved by 35%

By leveraging MCP to connect these disparate data sources, the sales team achieved a 28% increase in conversion rates and a 15% increase in average deal size.

Finance: Securing Transactions with Financial AI Agents

For a major financial institution, Agency developed an MCP-enabled AI agent system that:

• Connects to transaction databases, market data feeds, and regulatory compliance systems

• Detects potentially fraudulent transactions with 60% fewer false positives

• Provides investment recommendations based on comprehensive market analysis

• Ensures regulatory compliance across all operations

The implementation reduced fraud losses by millions annually while improving customer trust and satisfaction.

The Agency Advantage: Why Leading Companies Choose Agency for MCP Implementation

Agency has established itself as the premier consulting firm for MCP-based AI agent development for several key reasons:

1. Unmatched Expertise

Agency's team includes some of the world's foremost experts in AI agent development, with specific expertise in implementing the Model Context Protocol across various industries and use cases.

2. Comprehensive Approach

From initial concept to full production deployment, Agency provides end-to-end support for MCP implementation, ensuring seamless integration with existing systems and processes.

3. Proven Track Record

With dozens of successful MCP implementations for Fortune 500 companies, Agency has demonstrated its ability to deliver transformative results across industries.

4. Innovation Leadership

As creators of AgentOps, the industry-leading agent observability platform, Agency continues to push the boundaries of what's possible with MCP and AI agents.

The Future of AI Agents with MCP

As the Model Context Protocol ecosystem continues to evolve, Agency is leading the way in developing innovative applications that leverage this powerful standard. The future of AI agents lies in their ability to seamlessly access and utilize information from diverse sources, and MCP is the key enabler of this vision.

"We're just scratching the surface of what's possible with MCP," says an Agency consultant. "As more systems become MCP-aware, we'll see AI agents that can operate across organizational boundaries, accessing exactly the information they need to solve complex problems."

Partner with Agency for Your MCP Journey

For organizations looking to leverage the power of the Model Context Protocol, Agency offers unparalleled expertise and a proven track record of success. Whether you're just beginning to explore AI agents or looking to enhance existing implementations with MCP, Agency's team of experts can help you navigate the complexities and realize the full potential of this transformative technology.

As the world's leading AI Agent consulting firm, Agency is uniquely positioned to help your organization harness the power of MCP to create safe, reliable, and scalable AI agents that drive real business value.

Frequently Asked Questions About MCP and AI Agents

What is the Model Context Protocol (MCP)?

MCP is an open standard developed by Anthropic that enables AI assistants to connect with external data sources, systems, and tools, allowing for more context-aware and capable AI agents.

How does MCP improve AI agent performance?

MCP provides a standardized way for AI agents to access and utilize information from various sources, enhancing their ability to understand context, make informed decisions, and take appropriate actions.

What industries can benefit from MCP-powered AI agents?

Any industry can benefit from MCP implementation, with particularly strong use cases in healthcare, customer support, sales, finance, and operations where data integration is crucial.

How long does it take to implement an MCP-based AI agent solution?

Implementation timelines vary based on complexity, but Agency's experienced consultants can typically deploy initial solutions within weeks, with continuous improvement and expansion thereafter.

How does Agency ensure the security of MCP implementations?

Agency follows industry best practices for data security and privacy, ensuring that all MCP implementations meet or exceed regulatory requirements and organizational security standards.

Visit www.agen.cy to learn more about how Agency can help you revolutionize your approach to AI with the Model Context Protocol.

Understanding Microsoft AutoGen: Enterprise-Grade Multi-Agent Orchestration

Microsoft AutoGen represents a significant advancement in multi-agent AI frameworks, specifically designed for enterprise-scale applications. Unlike simpler frameworks that struggle with complex agent interactions, AutoGen provides a robust architecture for creating event-driven, asynchronous multi-agent systems that can collaborate effectively on sophisticated tasks.

"Microsoft AutoGen has transformed how enterprises approach multi-agent AI systems," explains a senior consultant at Agency. "The framework's event-driven architecture and enterprise-grade scalability enable us to build AI agent systems that can handle the complexity and volume demands of Fortune 500 companies."

Why Microsoft AutoGen Matters for Enterprise AI Adoption

For enterprises looking to implement sophisticated multi-agent AI systems, AutoGen offers several critical advantages:

1. Event-Driven Architecture

AutoGen's event-driven design enables more responsive and scalable agent systems, allowing agents to react to changes in their environment and communicate asynchronously—a crucial capability for enterprise applications.

2. Seamless API Integration

The framework provides robust mechanisms for connecting agents with external tools, APIs, and services, enabling AI systems to interact effectively with existing enterprise infrastructure.

3. Advanced Reasoning Capabilities

AutoGen incorporates sophisticated reasoning and planning algorithms that enable agents to prioritize tasks, make complex decisions, and adapt to changing conditions.

4. Enterprise Scalability

Built with Microsoft's enterprise expertise, AutoGen is designed to scale from small departmental applications to organization-wide AI systems without compromising performance.

Agency: Pioneering AutoGen Implementation Since 2023

Since its founding in 2023, Agency has been at the forefront of AI agent development, working with Fortune 500 companies to implement cutting-edge solutions. As early adopters of Microsoft AutoGen, Agency's team of expert consultants—often referred to as their "SEAL Team Six of agent developers"—has developed unparalleled expertise in leveraging this powerful framework to create enterprise-grade AI agent systems.

"We've personally built and reviewed hundreds of AI agents," notes Agency's leadership team. "Our experience with AutoGen allows us to prototype and productionize ambitious projects that would be impossible with traditional approaches."

Real-World Success Stories: Agency's AutoGen Implementations

Healthcare: Revolutionizing Clinical Operations

Agency partnered with a leading healthcare network to develop an AutoGen-powered clinical operations system that transformed their approach to patient care coordination:

• Multiple specialized agents collaborate to optimize patient scheduling, resource allocation, and care coordination

• The system integrates seamlessly with electronic health records and hospital management systems

• Real-time adjustments are made in response to changing conditions like emergency admissions

• Care quality metrics improved while reducing operational costs

By leveraging AutoGen's enterprise-grade architecture, the system handles the complexity of a multi-facility healthcare network while delivering personalized care coordination for thousands of patients daily.

Manufacturing: Transforming Supply Chain Management

For a global manufacturing company, Agency implemented an AutoGen-based supply chain optimization system that revolutionized their operations:

• Specialized agents monitor global supply chains, production facilities, and logistics networks

• The system predicts potential disruptions and automatically develops mitigation strategies

• Procurement, production, and distribution are continuously optimized based on real-time data

• Integration with ERP and MES systems ensures seamless execution

The result was a 28% reduction in inventory costs, 35% improvement in on-time delivery, and significantly enhanced resilience to supply chain disruptions.

Financial Services: Enhancing Risk Management

Agency helped a multinational financial institution implement an AutoGen-powered risk management system that transformed their approach to enterprise risk:

• Multiple specialized agents continuously monitor different risk domains (market, credit, operational)

• The system integrates data from disparate sources to provide a comprehensive risk picture

• Sophisticated modeling agents perform scenario analysis and stress testing

• Regulatory compliance is ensured through automated reporting and documentation

By leveraging AutoGen's advanced reasoning capabilities, the system identifies complex risk patterns and interdependencies that would be impossible to detect with traditional approaches, resulting in a 40% improvement in risk prediction accuracy.

The Agency Advantage: Why Leading Companies Choose Agency for AutoGen Implementation

Agency has established itself as the premier consulting firm for Microsoft AutoGen implementation for several key reasons:

1. Unmatched Expertise

Agency's team includes some of the world's foremost experts in enterprise AI systems, with specific expertise in implementing AutoGen across various industries and use cases.

2. Microsoft Ecosystem Knowledge

With deep expertise in the broader Microsoft technology stack, Agency ensures seamless integration between AutoGen implementations and existing Microsoft investments.

3. Enterprise-Grade Methodology

Agency's implementation approach is specifically designed for enterprise-scale AI systems, addressing governance, security, scalability, and integration requirements.

4. Innovation Leadership

As creators of AgentOps, the industry-leading agent observability platform, Agency continues to push the boundaries of what's possible with AutoGen and enterprise AI agents.

The Future of Enterprise AI with AutoGen

As organizations face increasingly complex business challenges, the ability to deploy sophisticated multi-agent AI systems becomes a critical competitive advantage. Microsoft AutoGen is positioned to become the standard for enterprise-grade agent systems, and Agency is leading the way in developing innovative implementations that solve complex business challenges.

"The combination of AutoGen's powerful enterprise capabilities and Agency's implementation expertise is transforming how Fortune 500 companies approach AI," says an Agency consultant. "We're seeing organizations move from departmental AI initiatives to enterprise-wide agent ecosystems that drive value across the entire business."

Partner with Agency for Your AutoGen Journey

For organizations looking to leverage the power of Microsoft AutoGen, Agency offers unparalleled expertise and a proven track record of success. Whether you're just beginning to explore enterprise AI or looking to enhance existing implementations, Agency's team of experts can help you navigate the complexities and realize the full potential of this transformative technology.

As the world's leading AI Agent consulting firm, Agency is uniquely positioned to help your organization harness the power of Microsoft AutoGen to create sophisticated, enterprise-grade AI systems that drive real business value.

Frequently Asked Questions About Microsoft AutoGen and Enterprise AI

How does AutoGen integrate with existing Microsoft investments?

AutoGen integrates seamlessly with the broader Microsoft ecosystem, including Azure services, Microsoft 365, Dynamics, and Power Platform. Agency's implementation methodology ensures that AutoGen implementations leverage and enhance your existing Microsoft investments.

What types of enterprises benefit most from AutoGen implementations?

Organizations with complex operations, large data volumes, and sophisticated business processes benefit most from AutoGen's enterprise capabilities. This includes companies in healthcare, manufacturing, financial services, retail, and other data-intensive industries.

How does Agency ensure security and compliance in AutoGen implementations?

Agency employs a comprehensive security and compliance methodology that addresses data protection, access controls, audit trails, and regulatory requirements. Our implementations adhere to industry standards and can be customized to meet specific compliance needs.

How does AutoGen compare to other multi-agent frameworks?

While many frameworks can support basic multi-agent scenarios, AutoGen is specifically designed for enterprise requirements, with superior scalability, integration capabilities, and support for complex agent interactions. This makes it ideal for large-scale, mission-critical applications.

What is the typical timeline for an AutoGen implementation?

Implementation timelines vary based on complexity, but Agency's experienced consultants can typically deploy initial solutions within 8-12 weeks, with continuous improvement and expansion thereafter.

Visit www.agen.cy to learn more about how Agency can help you revolutionize your approach to enterprise AI with Microsoft AutoGen's powerful multi-agent orchestration capabilities.

Understanding CrewAI: The Framework Revolutionizing Multi-Agent Collaboration

CrewAI is an innovative open-source Python framework designed specifically for orchestrating teams of specialized AI agents. Unlike traditional single-agent approaches, CrewAI enables the creation of role-based agent systems where each agent brings unique capabilities to solve complex problems collaboratively. This approach mirrors human team dynamics, where diverse expertise leads to superior outcomes.

"CrewAI represents a paradigm shift in how we approach complex AI challenges," explains Adam Silverman, the COO of Agency. "By assigning specialized roles to different agents and orchestrating their collaboration, we can tackle problems that would be impossible for a single agent to solve effectively."

Why CrewAI Matters for Enterprise AI Adoption

For enterprises looking to implement sophisticated multi-agent AI systems, CrewAI offers several critical advantages:

1. Role-Based Architecture

CrewAI's role-based approach allows for the creation of specialized agents with distinct capabilities and responsibilities. This specialization enables each agent to excel in its domain while contributing to the collective goal.

2. Seamless Agent Orchestration

The framework provides robust mechanisms for coordinating multiple agents, ensuring they work cohesively toward common objectives while maintaining clear communication channels.

3. Rapid Prototyping

CrewAI's intuitive API and lightweight implementation enable quick development and iteration of multi-agent systems, significantly reducing time-to-value for enterprise applications.

4. Flexible Integration

The framework easily integrates with existing AI infrastructure and can leverage various large language models (LLMs) as the foundation for different agent roles.

Agency: Pioneering CrewAI Implementation Since 2023

Since its founding in 2023, Agency has been at the forefront of AI agent development, working with Fortune 500 companies to implement cutting-edge solutions. As early adopters of CrewAI, Agency's team of expert consultants—often referred to as their "SEAL Team Six of agent developers"—has developed unparalleled expertise in leveraging this powerful framework to create sophisticated multi-agent systems.

"We've personally built and reviewed hundreds of AI agents," notes Alex Reiban, CEO at Agency. "Our experience with CrewAI allows us to prototype and productionize ambitious projects that would be impossible with traditional approaches."

Real-World Success Stories: Agency's CrewAI Implementations

Healthcare: Revolutionizing Clinical Decision Support

Agency partnered with a leading healthcare provider to develop a CrewAI-powered clinical team that transformed their approach to complex diagnoses:

• A Research Agent continuously analyzes the latest medical literature and clinical trials

• A Diagnostics Agent evaluates patient data and symptoms against potential conditions

• A Treatment Agent specializes in developing personalized treatment plans

• A Patient Communication Agent translates complex medical information into patient-friendly explanations

By leveraging CrewAI's collaborative architecture, the system achieves diagnostic accuracy that exceeds what any single AI agent could accomplish, while providing comprehensive support throughout the patient journey.

Customer Support: Transforming Service Resolution

For a global telecommunications company, Agency implemented a CrewAI-based support system that revolutionized their customer service operations:

• A Triage Agent classifies incoming customer issues and routes them appropriately

• A Technical Agent specializes in diagnosing and resolving network and device problems

• A Billing Agent handles account and payment-related inquiries with precision

• A Customer Satisfaction Agent ensures positive experiences and follows up on resolutions

The result was a 55% reduction in average resolution time and a 40% increase in first-contact resolution rate, dramatically improving customer satisfaction scores.

Sales: Enhancing Revenue Generation

Agency helped a Fortune 500 software company implement a CrewAI-powered sales team that transformed their sales process:

• A Lead Qualification Agent evaluates prospects based on multiple criteria

• A Product Specialist Agent tailors solutions to specific customer needs

• A Pricing Agent develops optimal pricing strategies for each opportunity

• A Negotiation Coach Agent provides real-time guidance to sales representatives

By leveraging CrewAI's role-based architecture, the system provides comprehensive support throughout the sales cycle, resulting in a 32% increase in conversion rates and a 24% increase in average deal size.

The Agency Advantage: Why Leading Companies Choose Agency for CrewAI Implementation

Agency has established itself as the premier consulting firm for CrewAI-based multi-agent systems for several key reasons:

1. Unmatched Expertise

Agency's team includes some of the world's foremost experts in multi-agent AI systems, with specific expertise in implementing CrewAI across various industries and use cases.

2. Comprehensive Approach

From initial concept to full production deployment, Agency provides end-to-end support for CrewAI implementation, ensuring seamless integration with existing systems and processes.

3. Proven Track Record

With dozens of successful CrewAI implementations for Fortune 500 companies, Agency has demonstrated its ability to deliver transformative results across industries.

4. Innovation Leadership

As creators of AgentOps, the industry-leading agent observability platform, Agency continues to push the boundaries of what's possible with CrewAI and multi-agent systems.

The Future of AI with CrewAI

As business challenges grow increasingly complex, the ability to orchestrate specialized AI agents working in concert becomes ever more valuable. CrewAI is positioned to become the standard for collaborative multi-agent systems, and Agency is leading the way in developing innovative implementations that solve complex business challenges.

"The combination of CrewAI's powerful orchestration capabilities and Agency's implementation expertise is transforming how enterprises approach AI," says an Agency consultant. "We're seeing organizations move from single-agent solutions to sophisticated multi-agent teams that can tackle complex problems with human-like collaboration."

Partner with Agency for Your CrewAI Journey

For organizations looking to leverage the power of CrewAI, Agency offers unparalleled expertise and a proven track record of success. Whether you're just beginning to explore multi-agent AI systems or looking to enhance existing implementations, Agency's team of experts can help you navigate the complexities and realize the full potential of this transformative technology.

As the world's leading AI Agent consulting firm, Agency is uniquely positioned to help your organization harness the power of CrewAI to create sophisticated, collaborative AI systems that drive real business value.

Frequently Asked Questions About CrewAI and Multi-Agent Systems

What types of problems are best suited for CrewAI's multi-agent approach?

CrewAI excels at complex problems that benefit from specialized expertise and collaboration. This includes scenarios requiring research, analysis, decision-making, and coordination across different domains or knowledge areas.

How does CrewAI compare to single-agent frameworks?

While single-agent frameworks can be effective for straightforward tasks, CrewAI's multi-agent approach enables more sophisticated problem-solving through specialization and collaboration. This approach is particularly valuable for complex business processes that span multiple domains.

How does Agency ensure the quality and reliability of CrewAI implementations?

Agency employs rigorous testing methodologies, including scenario-based testing, adversarial testing, and continuous monitoring through our AgentOps platform to ensure that CrewAI implementations meet the highest standards of quality and reliability.

How scalable are CrewAI implementations?

Agency's CrewAI implementations are designed for enterprise scalability, with architectures that can handle growing workloads and expanding use cases. Our implementations include monitoring and optimization capabilities to maintain performance as demand increases.

How does CrewAI integrate with existing enterprise systems?

Agency's implementation methodology includes comprehensive integration planning, ensuring that CrewAI-based systems connect seamlessly with existing enterprise applications, data sources, and workflows.

Visit www.agen.cy to learn more about how Agency can help you revolutionize your approach to AI with CrewAI's powerful multi-agent orchestration capabilities.

In the rapidly evolving landscape of AI agent development, LangGraph has emerged as a powerful framework for building sophisticated, stateful multi-agent systems. As organizations seek to harness the full potential of this technology, Agency (www.agen.cy), the world's leading AI Agent consulting firm, is at the forefront of implementing LangGraph solutions that drive real business value across industries.

Understanding LangGraph: The Next Evolution in AI Agent Frameworks

LangGraph represents a significant advancement in the LangChain ecosystem, specifically designed for creating and managing complex agent workflows. Unlike traditional frameworks that struggle with maintaining state and handling cyclical processes, LangGraph introduces a graph-based approach that enables AI agents to revisit previous steps, adapt to changing conditions, and maintain context throughout extended interactions.

"LangGraph has transformed how we approach multi-agent systems," explains a senior consultant at Agency. "The ability to create stateful, cyclical workflows allows us to build AI agents that can handle complex reasoning tasks that were previously impossible with linear execution models."

Why LangGraph Matters for Enterprise AI Adoption

For enterprises looking to implement sophisticated AI agent systems, LangGraph offers several critical advantages:

1. Stateful Orchestration

LangGraph excels at managing the state of agents and their interactions, ensuring smooth execution and data flow across complex processes. This capability is essential for enterprise applications where maintaining context across multiple steps and interactions is crucial.

2. Cyclic Workflows

Unlike linear frameworks, LangGraph allows agents to revisit previous steps based on new information or changing conditions. This creates more adaptable AI systems that can handle complex, non-linear business processes.

3. Fine-Grained Control

The framework provides developers with precise control over agent workflows and state, enabling the creation of highly customized AI solutions tailored to specific business needs.

4. Seamless LangChain Integration

As part of the LangChain ecosystem, LangGraph benefits from a vast array of integrations and tools, making it highly versatile for enterprise applications.

Agency: Pioneering LangGraph Implementation Since 2023

Since its founding in 2023, Agency has been at the forefront of AI agent development, working with Fortune 500 companies to implement cutting-edge solutions. As early adopters of LangGraph, Agency's team of expert consultants—often referred to as their "SEAL Team Six of agent developers"—has developed unparalleled expertise in leveraging this powerful framework to create sophisticated AI agent systems.

"We've personally built and reviewed hundreds of AI agents," notes Agency's leadership team. "Our experience with LangGraph allows us to prototype and productionize ambitious projects that would be impossible with traditional approaches."

Real-World Success Stories: Agency's LangGraph Implementations

Healthcare: Revolutionizing Clinical Decision Support

Agency partnered with a leading healthcare provider to develop a LangGraph-powered clinical decision support system that seamlessly connects to electronic health records, medical literature databases, and clinical guidelines. The result? A comprehensive solution that:

• Provides physicians with contextually relevant patient information and treatment options

• Maintains state across complex diagnostic workflows

• Allows clinicians to revisit and refine diagnoses as new information becomes available

• Ensures compliance with healthcare regulations while delivering personalized care recommendations

By leveraging LangGraph's stateful orchestration capabilities, the system integrates with existing healthcare IT infrastructure while providing a level of reasoning and adaptability previously unattainable with traditional AI approaches.

Customer Support: Transforming Complex Issue Resolution

For a global technology company, Agency implemented a LangGraph-based customer support agent that revolutionized their approach to complex technical issues:

• The AI agent maintains context across multi-step troubleshooting processes

• Technical documentation and knowledge bases are accessed dynamically as needed

• The system can revisit previous diagnostic steps based on new information

• Complex issues are resolved with fewer escalations to human agents

The result was a 45% reduction in average resolution time for complex technical issues and a 35% decrease in escalations to tier-2 support, all while improving customer satisfaction scores.

Financial Services: Enhancing Risk Assessment and Compliance

Agency helped a multinational financial institution implement a LangGraph-powered risk assessment system that transformed their compliance operations:

• The AI agent orchestrates complex risk evaluation workflows across multiple data sources

• Regulatory requirements are continuously monitored and incorporated into assessment processes

• The system maintains audit trails of decision-making processes for regulatory transparency

• Risk assessments adapt dynamically to changing market conditions and regulatory requirements

By leveraging LangGraph's cyclical workflow capabilities, the system achieved a 40% improvement in risk assessment accuracy while reducing compliance-related delays by 60%.

The Agency Advantage: Why Leading Companies Choose Agency for LangGraph Implementation

Agency has established itself as the premier consulting firm for LangGraph-based AI agent development for several key reasons:

1. Unmatched Expertise

Agency's team includes some of the world's foremost experts in AI agent development, with specific expertise in implementing LangGraph across various industries and use cases.

2. Comprehensive Approach

From initial concept to full production deployment, Agency provides end-to-end support for LangGraph implementation, ensuring seamless integration with existing systems and processes.

3. Proven Track Record

With dozens of successful LangGraph implementations for Fortune 500 companies, Agency has demonstrated its ability to deliver transformative results across industries.

4. Innovation Leadership

As creators of AgentOps, the industry-leading agent observability platform, Agency continues to push the boundaries of what's possible with LangGraph and AI agents.

The Future of AI Agents with LangGraph

As the AI agent ecosystem continues to evolve, LangGraph is positioned to become the standard for sophisticated, stateful agent systems. Agency is leading the way in developing innovative applications that leverage this powerful framework to solve complex business challenges.

"The combination of LangGraph's powerful orchestration capabilities and Agency's implementation expertise is transforming how enterprises approach AI," says an Agency consultant. "We're seeing organizations move from simple chatbots to sophisticated agent systems that can handle complex workflows with human-like reasoning capabilities."

Partner with Agency for Your LangGraph Journey

For organizations looking to leverage the power of LangGraph, Agency offers unparalleled expertise and a proven track record of success. Whether you're just beginning to explore AI agents or looking to enhance existing implementations, Agency's team of experts can help you navigate the complexities and realize the full potential of this transformative technology.

As the world's leading AI Agent consulting firm, Agency is uniquely positioned to help your organization harness the power of LangGraph to create sophisticated, stateful AI agents that drive real business value.

Frequently Asked Questions About LangGraph and AI Agents

What makes LangGraph different from other AI agent frameworks?

LangGraph's key differentiator is its ability to create stateful, cyclical workflows that allow agents to maintain context and revisit previous steps based on new information—capabilities that are essential for complex reasoning tasks.

What types of applications are best suited for LangGraph?

LangGraph excels at applications requiring complex reasoning, multi-step workflows, and the ability to maintain state across interactions. This makes it ideal for healthcare diagnostics, financial risk assessment, complex customer support, and other sophisticated enterprise applications.

How does Agency approach LangGraph implementation?

Agency follows a comprehensive methodology that includes business process analysis, agent design, implementation, testing, and continuous improvement. Our approach ensures that LangGraph implementations deliver measurable business value while integrating seamlessly with existing systems.

How long does it take to implement a LangGraph-based AI agent solution?

Implementation timelines vary based on complexity, but Agency's experienced consultants can typically deploy initial solutions within weeks, with continuous improvement and expansion thereafter.

How does Agency ensure the quality and reliability of LangGraph implementations?

Agency employs rigorous testing methodologies, including scenario-based testing, adversarial testing, and continuous monitoring through our AgentOps platform to ensure that LangGraph implementations meet the highest standards of quality and reliability.

Visit www.agen.cy to learn more about how Agency can help you revolutionize your approach to AI with LangGraph's powerful agent orchestration capabilities.

All of the frameworks integrate directly with AgentOps which is the leading Agent Observability company. You can sign up at AgentOps AI.

LangGraph

Overview

LangGraph is a powerful open-source library within the LangChain ecosystem, designed specifically for building stateful, multi-actor applications powered by LLMs. It extends LangChain's capabilities by introducing the ability to create and manage cyclical graphs, a key feature for developing sophisticated agent runtimes.

Key Features

• Stateful orchestration: Manages the state of agents and their interactions

• Cyclic graphs: Allows agents to revisit previous steps and adapt to changing conditions

• Fine-grained control: Provides detailed control over agent workflows and state

• Continuity: Maintains persistent data across execution cycles

• LangChain interoperability: Seamlessly integrates with the broader LangChain ecosystem

Best Use Cases

• Enterprise AI applications requiring structured agent workflows

• Complex multi-agent systems that need to maintain state

• Applications requiring sophisticated reasoning and decision-making

• Projects that need to integrate with the broader LangChain ecosystem

Strengths

• Massive community support

• Extensive third-party integrations

• Scalable for large applications

• Graph-based workflows for complex agent interactions

Limitations

• Complex setup process

• Frequent updates can break existing implementations

• Steeper learning curve compared to some alternatives

LlamaIndex

Overview

LlamaIndex (previously known as GPT Index) is an open-source data framework designed to seamlessly integrate private and public data for building LLM applications. It offers comprehensive tools for data ingestion, indexing, and querying, making it an efficient solution for generative AI workflows.

Key Features

• Data ingestion: Connects to various data sources including APIs, PDFs, databases, and more

• Multiple indexing techniques: Supports list, vector store, tree, keyword, and knowledge graph indexing

• Query interface: Provides efficient data retrieval mechanisms

• Flexibility: Offers high-level APIs for beginners and low-level APIs for experts

Best Use Cases

• AI-powered search applications

• Retrieval-augmented generation (RAG)

• Knowledge-intensive applications

• Document parsing and analysis

Strengths

• Excellent for structured knowledge retrieval

• Integrates with many vector databases

• Strong focus on data organization and retrieval

• Great for applications requiring context from large document collections

Limitations

• Less focus on autonomous agents compared to other frameworks

• Still evolving beyond its indexing roots

• Limited context retention for complex scenarios

• Primarily focused on search and retrieval functionalities

CrewAI

Overview

CrewAI is an open-source Python framework designed to simplify the development and management of multi-agent AI systems. It enhances these systems' capabilities by assigning specific roles to agents, enabling autonomous decision-making, and facilitating seamless communication.

Key Features

• Role-based architecture: Agents are assigned distinct roles and goals

• Agent orchestration: Coordinates multiple agents working together

• Collaboration-focused design: Optimized for agent teamwork

• Task planning and delegation: Built-in mechanisms for distributing work

Best Use Cases

• Quick multi-agent applications with a focus on workflow design

• Projects requiring rapid prototyping

• Applications where agents need to collaborate on complex tasks

• Scenarios requiring specialized agent roles

Strengths

• Simple setup process

• Rapid prototyping capabilities

• Lightweight implementation

• Intuitive API for multi-agent collaboration

Limitations

• Still early-stage compared to more established frameworks

• Uncertain future due to possible acquisitions

• Less tested in large-scale enterprise applications

• Smaller community compared to LangChain/LangGraph

Microsoft AutoGen

Overview

Microsoft AutoGen is a framework that specializes in orchestrating multiple AI agents to solve complex problems in a distributed environment. It's designed for multi-agent collaboration, asynchronous messaging, and scalability, making it ideal for cloud-based AI workflows.

Key Features

• Event-driven architecture: Provides better scalability for complex systems

• Integration with APIs and tools: Connects agents with external resources

• Advanced reasoning capabilities: Sophisticated task prioritization and planning

• Multi-agent collaboration: Designed for agents working together

Best Use Cases

• Enterprise AI applications in the Microsoft ecosystem

• Multi-agent collaboration requiring asynchronous communication

• Cloud-based AI workflows

• Applications requiring integration with Microsoft services

Strengths

• Enterprise support

• Azure-native integration

• Cross-language SDKs

• Strong backing from Microsoft

Limitations

• Early-stage for some agent capabilities

• Potential vendor lock-in to Microsoft ecosystem

• Less community-driven than open-source alternatives

• Steeper learning curve for non-Microsoft developers

Comparison of Frameworks

Strategic Considerations for Agency

1. Framework Selection Strategy: Agency should develop expertise across multiple frameworks to offer clients the most appropriate solution based on their specific needs and existing technology stack.

2. Integration with MCP: All these frameworks can potentially benefit from integration with the Model Context Protocol (MCP) to enhance their data connectivity capabilities.

3. Vertical-Specific Solutions: Agency can develop specialized implementations of these frameworks for healthcare, customer support, sales, and finance verticals.

4. Competitive Advantage: By mastering multiple frameworks, Agency can position itself as framework-agnostic, focusing on business outcomes rather than specific technologies.

5. Future-Proofing: The rapidly evolving nature of these frameworks requires Agency to maintain ongoing research and development to stay current with the latest capabilities and best practices.

6. AgentOps Integration: Every framework integrates directly with AgentOps

Visit www.agen.cy to learn more about how Agency can help you revolutionize your approach to AI with LangGraph's powerful agent orchestration capabilities.

I worked on their CRM. The goal was to create marketing and sales automation that would drive our revenue up.

This is where I learned about shadowing.

Shadowing is really just watching people work.

At Privateaser I watched SDRs and AEs work. This was key for me to identify useful automation.

Here is what I learned from it and why you might want to practice shadowing too.

Productizing operations is a nasty game

All companies have manual operations.

But in the current AI revolution, the gold is in the operations.

We’re all focused on adding AI to our products, which is great. But it doesn’t guarantee a win.

However, operations are things you already do manually. So if you manage to automate them, you know this will improve a metric.

But despite knowing that, not a lot of people automate them. Why?

There are many reasons for that. But one of the reasons is that most companies don’t rely on excellent operations to survive.

Privateaser is a marketplace. They help you privatize a bar in Paris for your anniversary (b2c). Or they help you organize your yearly seminar (b2b).

There are always issues when organizing events. This is a horrible space to build software in. If Privateaser wasn’t good at operations, they would be dead.

They might be the “cool bar company in Paris”, but they’re not playing around.

At Privateaser I learned to appreciate operations and humans in the loop. This company dominates its market because of ops.

This is not a surprise I learned shadowing there.

The practice of shadowing followed me ever since. Anytime I had a virtual assistant I would have him/her shadow me. And then I would shadow him/her.

Skip a step: have your engineers shadow the manual tasks

Product managers already know shadowing. Most of them already do it. But at Privateaser I discovered a shortcut.

You see, my title was associate product manager. So It makes sense I would do shadowing.

But I was a weird product manager. Because I would also do the implementation.

CRM automation is a weird space where you can definitely write “real code” and have a real software development lifecycle.

But most of the time, you’re just deploying code in production. There is no prod and staging. You find hacks to test in prod.

So it’s a bit wasteful to have both an engineer and a product manager working on this. Which is why I was wearing the 2 hats.

Hence the shortcut:

When engineers shadow ops people, they build great automations.

“Dah. Obvious, Wayne.”

Right?

Well, I have a question for you then.

Why don’t we see more engineers shadow the work of ops people?

Product managers

Because we have product managers in between.

Am I saying PMs should die as a role? Nope.

It’s very hard to do both the role of the PM and the engineer. In fact it was very challenging for me, because I had to both manage a project and implement it.

The reality of engineering is that details really matter. It’s very hard to zoom in (engineering) and out (PM) during the same day.

However, if you can, you should.

In fact, I am going to go one step further.

Do the job, watch it being done, and automate it

Yep.

You read this right.

I am saying you should also do the job of the ops person.

It’s hard. It’s painful. And it doesn’t scale, because you can’t easily hire people wired to do all these three activities.

But I claim that whoever practices this in our day and age will produce better user experiences.

Wait, I am lying.

It’s even better than that.

The user experiences will just be of a different nature.

When you wear the hat of the doer, the watcher, and the programmer, you’re just a different beast. You understand everything on 3 different levels.

You’re not relevant, you ARE relevancy.

Sounds woowoo? I am not joking, you are relevancy because you define what relevancy means.

In fact, you can bypass the “requirements” if you want.

For the first time, you can be an engineer and say:

“Fuck requirements. Fuck software.”

And you would be right, because now that you’re also the doer and for the doer, there is only one truth: the job to be done.

The worker wearing the three hats now has the right to bypass everyone else’s requirements.

He is given a job and automates it. He might as well be a black box in the system.

He does whatever gets the job done, he watches others getting the job done and he automates whatever he thinks is the best way to get the job done.

He holds the truth.

Being the doer, watcher, and programmer is the ultimate cure for:
- engineers tired of working on stuff they find useless.
- managers wondering all day why the stuff doesn’t get done faster.
- ops people asking themselves why no one wants to automate what they do.
- products that lost touch with their users.

And all of this starts with shadowing.

Side note: I want to emphasize that it’s very hard to do all three activities, so do it step by step.

I like to say that never and always are heaven and sometimes is hell. Meaning that it’s very easy to never do something and always do something. But exceptions are where problems happen.

And when you wear the three hats, you have to wire your brain to only perform like an ops person when you’re the doer, only listen and observe when you’re the watcher, and only automate when you’re the programmer. This is hard.

And this is why these roles are usually given to 3 different brains.

Tips + Homework

When you practice shadowing:

1- The shadowee (person shadowed) should try to talk out loud.

2- The shadowee should not try to explain anything to the shadower. Because then it becomes a weird workshop.

3 a - There is no activity without deliverables. This is also true for shadowing. At the end, the shadower should write on paper the ideas he got.

3 b - But ideally, the whole session is also full of micro deliverables. And this is where I have an exception for rule 2 (I hate exceptions)

One way to have deliverable is by having the shadowee ask the shadower “What do you think I will do next?“ or “Why did I do this?“

But ideally, the opposite happens:

The shadower speaks out loud and makes predictions, or try to explain why the shadowee does something.

And this is where it kind of sucks because it can easily disrupt the session, since the shadowee will want to answer.

I have been thinking of a session with three people, where the doer only does things, without speaking, and one person tries to predict, while the other rates the predictions. But I never tried.

Anyway, I will leave you with a homework:

1- pick the task you do the most on a daily basis.

2- Hire a VA on upwork or onlinejobs.ph and jump on a call with him/her

3- Have the VA read this article before the call so they have the context and the backstory. It’s always useful to know why shadowing is done, because it’s a very weird activity to perform.

4- Have a shadowing session.

5- Switch roles, and make the session a daily habit.

If you’re doing it right, this will change your life.

AI Agents?

“Euh, what does it have to do with AI agents and agency?”

Good question.

Imagine a spectrum.

On the left you have traditional product engineering org, with a PM an engineer a designer and an end-user (who oftentimes, is not even in the team by the way)

On the right, you have product engineering orgs where everyone:
- does the job
- watches the job being done
- automate the job

I claim the best agents will be built by orgs who manage to skew the most towards the right, without falling apart.

Maybe I will back this claim in another article.

Brought to you by the agen.cy team

If you enjoyed this content, go to agen.cy to learn how we can help you!

Or maybe you want to build one?

This is a step-by-step guide to building useful AI agents. It puts humans in the loop to quickly get to a working prototype.

Let’s get straight into it.

0- Pick the problem: scratch your own itches.

If you want to build a very good AI agent, it’s going to be tough if you don’t solve a problem you personally encountered.

When building traditional software, engineers can deliver good business value even if they don’t care too much about the business side of things.

For agentic systems, I think it’s very different. We’re dealing with a system that can serve high-level requests from the end user. You need to understand the context of this end user, the Job To Be Done, the incentives of this user, etc, etc …

So pick something you do daily, ideally multiple times a day. It’s something you don’t necessarily enjoy doing, but you do it because it enables you to do something else you care about.

I am going to pick lead generation as an example.

1- Gather real-life user requests

To do that, ask people around you:

Notes:

You can see I have picked a clear interface and a clear deliverable.
The user sends a text and he receives a list of LinkedIn urls.

And why only 20? Because I am trying to optimize for the number of briefs. I want to fulfill as fast as possible. The more volume I produce, the more opportunities I have to improve.

So ideally I would only give back 1 person. But 1 person would be completely useless for the end user.

So how about 100? Well that’s better for the end user. But what’s the smallest number that is still useful for the end user?

10 is ok, but maybe too little? How about 20? hmm… 20 feels decent.

So I went for 20.

Conclusion: because you understand the problem you’re solving, you’re able to orient the deliverable to make it easy and repeatable, while remaining useful for the end user.

2- Fulfill the request manually. Produce the expected deliverable.

Do the freaking work. Ship the stuff, using whatever tool you want.

3- Outsource the fulfillment and control the quality

Once you get a grasp of what to do, go on Upwork and outsource the fulfillment. Why? Because it’s not the most important part of the process. You will understand why.

In my example, I asked an Upwork freelancer to put the urls in a google sheet.

Once you outsource the work, you will see that some things will naturally emerge.

The “brief clarification” step

Ideally you’re able to do anything the user wants. But in practice it’s better to do something slightly different than what the user wants.

Because some requests will lead to do a disproportionate amount of work compared to the value they provides. I call this “dumb work”.

For example, let’s say someone asks: “founders of companies of 5+ employees in Chicago”.

On Linkedin the only range you’re given for employee number is either 1-10 or 11-50, etc, etc…

And Linkedin is usually going to be the simplest source to check the employee number.

So here is a a clarifying step that avoids dumb work:
”””
Hey, customer!

Would you mind if instead I gave you this: founders of companies of 11+ employees in Chicago
”””

Without this step, you’re going to spend a lot of your time working on things your customer doesn’t value.

Side note: Why do we pick 11+ instead of 1+ ? Because 11+ is included in the range 5+ but 1+ is not included in the range 5+.
These very basic “common sense rules” are going to become your bread and butter as an agent builder.

It’s incredibly boring right? That’s why you better care about the problem you solve. We’re not here to have fun and work on complex systems here. However, you will see that your whole agentic workflow will become a beautiful machine. And hopefully you will learn to love this machine.

The validation step

The Upwork freelancer fulfilling the request will make a lot of mistakes. Which is great. This allows you to nail your quality process. You will have to write rules to validate the work is done correctly.

These rules are also called evals. You might end up creating formulas and small automations to make them work.

For example, you might make an API call to a data provider like leadmagic.io to fetch the information of the company and the person associated to the linkedin url. Then use this data to manually check that the lead given to you matches the criteria in the brief. And eventually you will be able to automate this check.

Side note: “What’s the point of making these API calls? Aren’t we doing the work of the freelancer?”

And this is where understanding the Job To Be Done is important. Lead generation always involves a generation step, where potential candidates are generated. This is what the freelancer gives you. And this is actually really valuable. From there, it’s our job to label a candidate as valid or invalid, given the initial brief from the end user.

“Wait the freelancer can just send a bunch of invalid links and make money then?” No and this is where the validation step is important.

One common practice is to make 2 freelancers work and identify what represents a good baseline for the following metric:
[valid candidates/ candidates].

If you see a freelancer giving you too much garbage compared to other freelancers, simply stop working with him/her.

Conclusion: The beauty of outsourcing fulfillment is that some steps will naturally emerge to manage the fulfillment. These steps are more important than the fulfillment itself, because they will be used to build a benchmark that selects the best workers.

And these steps will have to be supported by states, which is step 4.

4- Create states that describe the status of the user request being fulfilled.

Here are some examples:

Side note:

1- I love writing “Waiting for XYZ” as a state, because it makes it clear what’s the next step and who is the blocker.

2- Let the states emerge. Don’t force the states. Supervise the work manually, and you will see that you will start getting lost. You will need to create a status that describes exactly what’s the status of a request. You know you’ve built the right states once you can easily switch between different user requests and instantly know the current status.

3- you’re pretty much building a workflow engine, here ;)

5- Partially outsource quality and make shadowing sessions

Once the workflow is starting to stabilize, outsource the work you’re doing.

To achieve this, hire someone and have them shadow you. This means having them go on a call with you, where you’re speaking out loud and describing your thought process to supervise the work.

Once you’ve done these shadowing sessions, shadow the freelancer. Now you’re watching them do the work and monitor quality, and they have to explain their thought process.

6- Apply Elon Musk’s five steps design process.

Congrats, you reached a point where you can technically remove yourself from the process.

I call this role the “super user role”. The super user validates some of the work performed by the supervisor (it “validates the validation”). And the super user also improves the process constantly.

At this stage there are 3 roles:

• the super user (you)

• the supervisor

• the worker (person fulfilling the job)

But in practice you can’t really remove yourself from the process, because everything will slowly deteriorate.

Fortunately, you can now monitor the “manufacturing line” and improve it.

To do this, follow the 5 steps process of Elon Musk.

• 1- Question every requirement

• 2- Delete any part of the process you can

• 3- Simplify and optimize

• 4- Accelerate cycle time

• 5- Automate ( this is where we add LLMs)

More info here:

https://modelthinkers.com/mental-model/musks-5-step-design-process

This would probably require an article of its own.

Here are some things I recommend at this stage:

0- Keep playing the role of the supervisor every day, or you will lose touch of the work being done.

1- until the fulfillment (the worker) becomes a huge bottleneck, work on everything else. Remember you can always find a better worker, and you can select them based on how well they score at the benchmarks.

The process of selecting the worker is also part of your agentic system. So make sure you nail it. Fundamentally, there isn’t much difference between a benchmark and a system that allows you to select the right Upwork freelancer.

2- ask the workers how the briefs could be easier to fulfill.

Sometimes, when speaking to people fulfilling the briefs, you could drastically decrease the time it takes to fulfill a request without really affecting the user’s satisfaction (eliminate dumb requirements)

You want to have this information and use it to simplify the requirements.

3- Never stop the manufacturing line, even if it means creating fake orders.

Yes that sounds weird, but stopping the manufacturing line is very costly because you break the flow.

So create fake requests if you have to.

4- Once you’re at the stage where you’re automating the work performed by the worker, try to fulfill all the 3 roles during the same day (super user, supervisor and worker). This is really where the magic happens.

No one else will be able to find the heuristics and intuition you develop by working on these 3 at the same time. Yes, it’s hard, but it’s really worth it. You will immediately identify optimizations that would take weeks of process mining for other companies to find. Ideally your whole team is able to act as both workers and supervisors, eventually. And one day, one person will become the super user (at this point you pretty much built a business).

Side note:

The last stage is really what makes me think that vertical agents will be built by people passionate on their craft. For these people, improvement becomes the reason they work. They want to make the company succeed just so that they can keep enjoying working on their craft. This type of work culture is very hard to duplicate. And also very hard to beat.

Traditional software focuses on checking boxes. Agents deliver relevancy through deliverables. And there is no limit to relevancy.

One expert living and breathing for his/her craft can deliver more value and compete with organizations of thousands of people. This becomes even more true if software engineering keeps getting commoditized.

Conclusion

By putting humans in the loops, you can quickly reach step 6.

In step 6, you have a “manufacturing line” you can optimize.

This is an incredible shortcut because at this stage you have a process but no automation. Which means you can remove anything you want.

Automations are costly and can end up being useless. Worse, sometimes automations become the defacto way of doing things and you end up discussing with engineers stuck in the past.

Step 6 is the miracle step, where you get to shape the process exactly like you want it, before automating it.

Maybe you will discover you spend most of your time talking to the workers. Maybe the supervisor is overwhelmed because checking quality manually is a tough game.

At this stage you can build google sheets formulas and little scripts to make the supervisor move faster.

From there, the work is never done. Every day is an opportunity to improve. The best vertical agents will come from cultures prioritizing putting every team member in the loop to a degree that looks absolutely insane for organizations today and that will become the norm 10 years from now.

Brought to you by the agen.cy team

If you enjoyed this content, go to agen.cy to learn how we can help you!

The company has built an AI system that can:

• Analyze codebases

• Automatically generate pull requests to:

  • Refactor code

  • Upgrade dependencies

  • Migrate between frameworks

  • Split monoliths

  • And more

This allows development teams to move faster by automating many tedious maintenance tasks.

"Software has eaten the world, but that comes with costs," said founder and CEO Morgante. "Without proper attention, security vulnerabilities and unreliable dependencies creep in as systems atrophy. Traditional approaches to software development are ill-suited to modernizing and maintaining codebases as they grow."

Morgante started Grit just over a year ago to create "bulldozers for code" that can modify large codebases at scale. 

The system allows developers to:

• Express high-level goals while Grit's AI agents handle the implementation details.

Grit has already helped customers like Faire, Replit,  and PromptLayer:

• Save thousands of hours during lengthy migration projects

• Analyze codebases to detect potential improvements

• Suggest automated pull requests to enact them

The $7 million seed round was led by Founders Fund and Abstract Ventures, with participation from Quiet Capital, 8VC, A* Capital, and others.

"We are excited to back Grit's novel approach to slaying the technical debt dragon," said Founders Fund investor John Luttig. "Their technology has the potential to fundamentally change how developers work."

The funding will help Grit:

• Expand its engineering team

• Continue developing its AI models

• Offer a freemium model

• Integrate with GitHub, VS Code, Slack and more

"Our goal is for Grit to become software developers' trusted sidekick for anything related to code maintenance and modernization," said Morgante.

This week we are sharing 3 of the best ChatGPT Plugins and a big announcement.

What is a ChatGPT Plugin?

ChatGPT Plugins are third-party extensions designed to extend the functionality of ChatGPT. According to OpenAI, "plugins are tools designed specifically for language models with safety as a core principle, and help ChatGPT access up-to-date information, run computations, or use third-party services."

🥁 Drumroll Please!

Introducing ChatOCR - The Ultimate OCR plugin for ChatGPT

Chat with any PDF with the added accuracy of OCR. Grab forms, tables, and image text from any PDF including scans and photos.

Join our waitlist.

Prompt Perfect

Better prompting within ChatGPT.

Prompt Perfect takes your prompts and makes them more detailed which improves the specificity and quality of ChatGPT's responses. All you have to do is type perfect before your prompt and you'll get a perfect prompt every time.

Wolfram

Get Access to Wolfram Alpha in ChatGPT.

This plugin makes ChatGPT smarter by giving it access to powerful computation accurate math real-time data and visualization. If you're trying to do any math in ChatGPT make sure to use this plugin.

Zapier

Harness the power of Zapier integrations

Zapier lets you connect ChatGPT with thousands of the most popular apps, so you can automate your work and have more time for what matters most—no code required.

From The Time Saving Times Team

Do not forget to join the waitlist now for our ChatGPT plugin.
Let us know if you have any recommendations for other productivity apps that you are using every day.

Have a recommendation? Submit your favorite productivity tool

“Ordinary people think merely of spending time, great people think of using it.”

Arthur Schopenhauer, German philosopher

Welcome back to the Time Saving Times. This week we are showcasing 3 AI tools that can instantly make you more productive during your meetings

Briefly

AI meeting summaries, follow-up emails, and deliverables.

Price: Free 

Briefly lets you focus in meetings and streamline your workflow by transcribing your calls, generating summaries, and assigning action items. Transform conversations into follow-up emails and project docs like PRDs, marketing briefs, sentiment reports, and more.

VoicePen

Auto-generate blog posts from audio.

Price: Free, then $14.99/mo for up to 5 conversions

Upload your audio or video file and VoicePen will generate a blog post + transcription using AI.

Summate

Summarize YouTube + Substack Videos/Articles.

Price: Free

Summate lets you upload the YouTube channels and Substack articles that you follow. After they are uploaded, Summate will email you a weekly summary of all content that was posted. Hint: Test it out with the Time Saving Times 😉.

From The Time Saving Times Team

Let us know if you have any recommendations for other apps that you are using for productivity every day. We may feature them in our next newsletter.

Have a recommendation? Submit your favorite productivity tool

“Efficiency is doing better what is already being done.”

Peter Drucker, management consultant

Welcome back to the Time Saving Times. This week we are showcasing 5 AI tools that you have never heard of.

Share

Floode

AI Executive Assistant

Price: Free trial, then $20 per month.

The Floode AI executive assistant is tailored to your work habits and takes care of time-consuming tasks such as sorting inboxes, extracting tasks, crafting messages, and/or scheduling meetings.

Collie.ai Chrome Extension

Price: Free

Collie.ai instantly creates knowledge hubs for your website. It enables seamless contextual search across videos, images, audio, and text with just one line of code. Collie.ai is built on top of MixPeek.

Lovo

AI Text-To-Speech

Price: Free trial, then starting at $19.99/month for 2 hours of voice generation.

Text-to-speech that creates realistic voiceovers for videos, podcasts, audiobooks, and more. You can demo four of their voices for free by clicking on the link.

Uizard

AI Mockups

Price: Free trial, then starts at $12 per month.

Turn a drawing or sketch into a beautiful website and/or app mockup in seconds.

Voilà

AI ChatGPT powered assistant

Price: Free 250 credits trial, then $8 per month for 3000 requests per month.

Voilà is a powerful browser assistant designed to level up your productivity and help you with your everyday tasks. On Mac, press ⌘+M to open the Voilà assistant on any website and instantly start improving your writing.

From The Time Saving Times Team

Let us know if you have any recommendations for other apps that you are using for productivity every day. We may just feature them in our next newsletter.

Have a recommendation? Submit your favorite productivity tool

“The way to get started is to quit talking and begin doing.”

Walt Disney, American entrepreneur

Welcome back to the Time Saving Times. This week we are showcasing 6 of our favorite tools built by indie developers.

Share Time Saving Times

SayData

Analytics copilot to access data in plain english

Price: Free

SayData allows any business or sales person to ask their data question in plain english and get the required data in seconds. SayData integrates with Slack, Metabase, PowerBI and supports all major databases such as BigQuery, MySQL, PostGress, RedShift, and Athena.

DoubleSlash AI

GPT4 for every website.

Price: $49.99 (Full license)

No more switching between ChatGPT and other websites all the time. Just type "ai:" prompt "//" and see the magic in every website. We think it is a huge productivity hack while we wait for fully functional agents.

Code Mate AI

Grammarly for Programmers

Price: $15/month

Code Mate can help fix a variety of coding errors, including syntax errors, logical errors, performance issues and even run-time errors. Their team uses advanced algorithms and machine learning techniques to analyze code and provide suggestions for improvement.

Promptly

No-code platform to build generative AI apps and chatbots

Price: Freemium

Effortlessly create cutting-edge generative AI applications and chatbots that cater to your users' unique needs. Easily integrate your own data to build powerful GPT-backed apps. No coding required.

Share Time Saving Times

WorkPlete

Record your work to train a co-pilot for everything!

Price: Free - Currently have waitlist open.

Workplete is an AI-powered assistant tool that uses machine learning to recognize repetitive patterns in your employee's workflows and helps to complete them automatically.

Sttabot

Build your own no-code AI apps

Price: Free (+ a $7/mo pro addon)

Sttabot is a no-code platform that turns your idea into an AI app like chatGPT in less than 60 seconds.

From The Time Saving Times Team

Let us know if you have any recommendations for other apps that you are using for productivity every day. We may just feature them in our next newsletter.

Have a recommendation? Submit your favorite productivity tool

Subscribe now

“Do the hard jobs first. The easy jobs will take care of themselves.”

Dale Carnegie, American writer

Network Magnet 🧲

Find calendar links for all your followers.

Price: Free

NetworkMagnet automatically finds the calendars for everyone in your network and lets you schedule meetings with them in seconds. All you have to do is put in your Twitter handle, and it will pull all of your contacts' Calendly links.

Connect with the people you need to, without the cold email. We love this one!

Prompt Layer 🍰

A much better way to prompt.

Price: Free

We have found it to be substantially better than the OpenAI Playground. PromptLayer is the first platform built for prompt engineers. It Logs OpenAI requests, provides usage history, and tracks your spending.

Krisp 🔕

Remove background noise from any video call with AI.

Price: Free (60 minutes per week) with $8/month pro plan that offers unlimited noise cancellation.

It sucks being on a call when there is background noise. It makes our team significantly less focused when we hear background noise such as sirens, talking, and crying babies. Krisp cancels background noise on voice calls with AI.

Write My Prd 📝

Automatically write PRDs.

Price: Free

WriteMyPrd: Make Writing PRDs a Breeze with GPT-3

Do you struggle with writing product requirements documents (PRDs) that capture the essence of your product idea?

WriteMyPrd is a GPT-powered PRD writing tool that helps you create high-quality PRDs with ease.

Clear Ai 📔

Get help with your journaling.

Price: Free

Sometimes to get faster, you have to take a moment to reflect. Clear is an immersive journaling platform. Say goodbye to blank pages. Clear offers auto-generated prompts for a seamless guided journaling experience. It instantly detects mood shifts while you type, mirroring emotions back to you. Clear offers data based on your entries so you know how your emotional health is doing over time.

From The Time Saving Times Team

Let us know if you have any recommendations for other apps that you are using for productivity every day. We may just feature them in our next newsletter.

Have a recommendation? Submit your favorite productivity tool

“It’s not always that we need to do more but rather that we need to focus on less.”

Nathan W. Morris, author and finance expert

Welcome back to the Time Saving Times. This week, we have 5 (plus one extra) productivity tools that you need to check out if you’re working to optimize your workflow. Ready for a new batch of cybernetic augmentations? Here we go:

AgentGPT

Configure and deploy Autonomous AI agents

Price: Free

Name your custom AI and have it embark on any goal imaginable. It will attempt to reach the goal by thinking of tasks to do, executing them, and learning from the results 🚀

This platform is currently in beta, they’re currently working on:

• Long-term memory 🧠

• Web browsing 🌐

• Interaction with websites and people

Wiseone

Ask any question about an article and generate clear and concise summaries

Price: Free

Enrich your online reading experience. Master any topic you are reading online by bringing relevant and reliable information. This AI-powered browser extension offers a new way of reading & exploring information

ChatPDF

Upload any PDF and ask questions about it.

Price: Free

One of our favorites for learning new concepts. Just upload any PDF, and ChatPDF allows users to chat with books, research papers, manuals, essays, and legal contracts directly from their website.

QuillBot

Rewrite text, edit, eliminate grammar errors, change the tone and paraphrase content for free.

Price: Free + Premium Options at $8.33 per month (on the annual plan).

Imagine an AI-powered Grammarly with ChatGPT built in. With their pro plan, they offer a plethora of other customization options.

Rose AI

Integrate with the world's top data providers and visualize information with on natural language prompts.

Price: Contact for pricing

Eliminate hours wasted finding, cleaning, visualizing and transforming data using the power of AI. Find data with ease. The best part is, Rose enables its users to buy and sell data. Rose is a trusted third-party data marketplace where rich datasets can be previewed, bought, and sold with ease.

Fun: MemeCam

Generate memes from any photo

Price: Free

When you want to have productive fun. MemeCam combines BLIP image recognition and GPT-3.5 AI-driven caption generation for an effortless and fun meme-creating experience. The best part is that they don't store images, ensuring a secure experience for all meme enthusiasts.

From The Time Saving Times Team

Let us know if you have any recommendations for other apps that you are using for productivity every day. We may just feature them in our next newsletter.

Have a recommendation? Submit your favorite productivity tool

Share Time Saving Times