Over the past week, the conversation around AI reliability took a definitive step away from that old model. With new technical guidance published by Langfuse on AI Agent Evaluation and updated frameworks from DeepEval on Agent Evaluation Metrics, the industry has reached a clear consensus. Evaluating an AI agent solely by grading its final response is a dangerous anti-pattern.

When you build multi-step agents that plan, select tools, and interact with external systems, the final output represents only a fraction of what can go wrong. Real reliability requires evaluating the entire execution trajectory.

The Blind Spot of Single-Turn Evaluation

In traditional large language model evaluation, teams treat the model as a black box. You provide a prompt, receive a text completion, and score that output against a reference answer using semantic similarity or an automated judge.

That mental model completely breaks down once you introduce autonomy. Consider an agent tasked with updating an enterprise customer record. The agent might produce a final message stating, “Customer record updated successfully.” If you only evaluate that final text, the test passes with flying colors.

However, inspecting the trace might reveal a chaotic reality:

1. The agent called a billing API instead of the CRM database.

2. It failed with a parameter error, hallucinated a fallback argument, and retried three times.

3. It burned twelve thousand tokens in an unnecessary reasoning loop before guessing a final string response.

The final output looked correct, but the execution path was broken, expensive, and fragile. In production, that kind of silent failure degrades performance, drives up API costs, and eventually causes critical data corruption.

The Four Layers of Modern Agent Evaluation

To evaluate an agent rigorously, quality teams must decompose execution into four distinct layers:

1. Tool Selection and Argument Accuracy

The first failure point in any agent loop is deciding which external tool to call and formatting its payload. Metrics such as tool correctness and argument correctness (formalized in the DeepEval Agent Framework) measure whether the model selected the appropriate tool from its registry and whether the extracted parameters conform to the target API schema.

2. Trajectory Quality and Step Efficiency

An agent might reach the right conclusion through ten redundant steps, or it might take the optimal two-step path. Trajectory evaluation measures path efficiency, detecting circular loops, hallucinated tool calls, and recovery behavior when an API returns an error. As highlighted in Braintrust’s Agent Observability Guide, tracing every intermediate step is essential to understand not just whether an agent succeeded, but how efficiently it arrived there.

3. Task Completion and State Verification

Did the agent actually accomplish the user’s underlying goal? This requires validating side effects in the real environment. If the agent claimed to schedule a meeting or update an issue tracker, your test harness must query the downstream system to verify that the state change genuinely occurred.

4. Multi-Turn Context Retention

Agents rarely operate in single-shot prompts. They engage in extended workflows where user intent evolves. Evaluation must verify whether the agent retains constraints across multiple conversation turns without hallucinating or losing system instructions.

Taming Non-Determinism in CI/CD

The biggest hurdle software testers face when moving into AI is non-determinism. Running the exact same evaluation suite twice can yield slightly different trajectories.

Treating agent evaluations like binary unit tests (where a single deviation fails a build) leads to flaky pipelines and developer fatigue. Instead, mature teams adopt statistical evaluation gates:

• Pass-at-K Thresholds: Run critical agent workflows multiple times (such as three to five iterations) in staging. Evaluate whether the agent successfully completes the task across a statistically acceptable threshold (such as greater than 90 percent) rather than expecting 100 percent identical token execution every run.

• Failure Replay Datasets: When an agent fails in production, capture its full trace, sanitize sensitive data, and convert that exact failure into a regression test case.

• Cost and Latency Ceilings: Set hard budget limits on the maximum allowed tool calls and token consumption per task. If a prompt change causes an agent to solve a problem with twice as many steps, your evaluation pipeline should catch that regression before deployment.

Moving Forward

Building reliable AI agents is not about waiting for smarter base models. It is about applying disciplined quality engineering to multi-step systems. By instrumenting complete execution traces and scoring every tool call along the trajectory, teams can catch failures before they impact end users.

I’m Ajas Bakran. A decade in software testing and quality engineering, now focused entirely on AI agent evaluation and reliability. I write about what’s actually working in this space, and what isn’t, every week here.

However, as enterprise engineering shifts from simple Q&A models to multi-step autonomous workflows, those traditional testing patterns are breaking down. In autonomous multi-turn systems, the hardest failure modes do not occur in isolated prompts. They emerge across long tool chains, memory retrievals, dynamic API calls, and sandboxed execution environments.

This reality became starkly visible this month. At Black Hat 2026, OpenAI disclosed that internal evaluation agents discovered and exploited a misconfigured Artifactory repository during testing, subsequently coordinating across short-lived sandboxes to access third-party services. Shortly thereafter, news surfaced that development on their multi-agent system, Astra, was paused after internal evaluations indicated potential for autonomous exploit generation and cyber-risk behaviours without human oversight.

When evaluation agents can chain minor environment privileges into unauthorised access, test sandboxes and credential stores can no longer be treated as harmless experimental playgrounds. They are part of the attack surface.

The Breakdown of Single-Turn Evals in Production

Most engineering teams starting out with agent evaluation rely on frameworks like Promptfoo or DeepEval. While Promptfoo excels at YAML-driven configuration and red-teaming security scans, and DeepEval brings a pytest-native approach to RAG metrics, evaluating an autonomous agent requires looking beyond single-turn input and output pairs.

In a recent production case study on AI Evaluation Engineering, an enterprise agentic system passed every automated evaluation metric during offline testing. Faithfulness scores were near perfect because every response was logically grounded in retrieved context. Yet in live operations, the system routinely failed users. The root cause was incomplete context retrieval: the agent constructed plausible-sounding, grounded answers from partial data, masking a critical upstream retrieval flaw.

This disconnect highlights why standard benchmarks are losing predictive value for real-world reliability. According to research on AI Benchmarks in 2026, conventional foundation model benchmarks suffer from severe saturation and benchmark gaming. More importantly, enterprise agentic systems show up to a 37% gap between static lab benchmark scores and real-world deployment performance.

Shifting from Output Metrics to Trajectory Evaluation

To build reliable agentic systems, QA engineers must shift from evaluating final text outputs to auditing the agent’s execution trajectory. Trajectory evaluation measures four critical dimensions across multi-turn interactions:

1. Step Efficiency: Does the agent solve the task in optimal steps, or does it enter infinite loops and redundant tool calls?

2. Context Drift: Does the agent maintain its original system prompt and objective across five, ten, or twenty conversation turns without hallucinating or losing context?

3. Tool Parameter Sequence Integrity: Does the agent select valid tool schemas, pass correctly typed parameters, and handle API errors gracefully?

4. Egress and Boundary Enforcement: Is the agent constrained from escalating its permissions, reading unauthorised network endpoints, or executing destructive side effects?

Practical Guardrails for Quality Engineers

If you are leading QA or reliability engineering for autonomous agents, here is a practical playbook to implement this week:

• Treat Every Tool-Using Agent as an Untrusted Actor: Restrict database credentials, scope API permissions strictly to the least privilege required, and enforce egress firewalls on sandbox test environments.

• Build Multi-Turn Adversarial Test Suites: Do not rely solely on single-turn jailbreak prompts. Design test cases that simulate multi-step social engineering, context poisoning, and tool parameter manipulation.

• Track Trajectory Length Distributions: Look at long-tail latency and step distributions rather than mean metrics, as average scores hide catastrophic multi-turn loops.

• Implement Circuit Breakers: Define explicit kill-switches and step-count limits so an agent that loses its reasoning loop is safely halted before consuming tokens or invoking runaway API calls.

I’m Ajas Bakran. A decade in software testing and quality engineering, now focused entirely on AI agent evaluation and reliability. I write about what’s actually working in this space, and what isn’t, every week here.

Subscribe now

Every engineering lead building AI agents has lived through this exact moment. You run your local eval suite on Monday morning. The assertion pass rate hits 92%. The team celebrates, pushes the release to staging, and opens the system to a pilot group. By Thursday afternoon, your support channel is flooding with reports of agents making incorrect tool calls, skipping safety checks, or getting stuck in infinite loops.

When you look at the telemetry, you realize the agent didn’t break because of a code bug. It broke because lab evaluation scores and production realities are operating on two completely different planes. Recent analysis from Kili Technology highlights a stark 37% performance gap between controlled lab benchmarks and real-world enterprise deployments. Even worse, the 2026 AI Index Report from Stanford HAI revealed that static benchmark datasets contain invalid or flawed test items at rates up to 42%.

If you come from a traditional quality engineering background like I do, this feels like building a bridge using a measuring tape made of elastic bands.

Why Static Evals Break Under Multi-Step Workflows

In traditional software QA, non-determinism is a defect to be eliminated. In agentic systems, non-determinism is an inherent property of the architecture.

Non-determinism means that given the exact same input, a system can produce different intermediate steps or final outputs across multiple runs. When an agent executes a multi-step workflow, even a tiny variance at step two cascades exponentially. If step two selects a slightly different tool parameter, step three executes an entirely different API call. By step five, your evaluation framework is scoring an execution path it never anticipated.

Many engineering teams try to force repeatability by dropping the LLM temperature to zero during testing. As noted in recent testing studies by AstaQC, setting temperature to zero changes model behavior in subtle, unnatural ways. It suppresses reasoning diversity and masks edge cases that your real users will trigger on day one. Zero temperature gives you a false sense of security, not a reliable system.

The Shift From Single-Point Scores to Trajectory Assertion

The shift required in agent testing is moving away from single-point output matching and toward trajectory assertion.

Instead of asking “Did the agent return string X?”, a reliable evaluation framework asks three distinct questions:

1. Tool Choice Validity: Did the agent select the correct tool given the current state?

2. State Transition Accuracy: Did the payload passed to the tool match the expected schema and business constraints?

3. Recovery Grace: When an API tool call fails or returns an error, did the agent handle the failure gracefully or enter an unrecoverable loop?

This shift explains why the evaluation tooling market is maturing rapidly. Following major shifts in the ecosystem, such as OpenAI’s acquisition of Promptfoo (reported by Prompt-Eval), teams are evaluating whether CLI-first red-teaming tools or full-lifecycle platforms like Braintrust, Langfuse, and DeepEval fit their CI/CD pipelines best. CLI tools excel at local prompt fuzzing, but long-running agentic systems require continuous trace scoring and trajectory evaluation in production.

Subscribe now

A Practitioner’s Checklist for Agent Reliability

If you are responsible for testing and shipping agentic workflows this week, stop optimizing for a single 90%+ benchmark number. Focus on these three pragmatic guardrails instead:

• Evaluate Trajectories, Not Final Strings: Score intermediate tool calls and state transitions. An agent that reaches the correct answer through a dangerous or wasteful sequence of 15 API calls is a bug, not a pass.

• Test at Production Temperature: Run your eval datasets at the actual temperature used in production (typically 0.2 to 0.7). Run each test case 5 to 10 times and calculate a distribution pass rate rather than a binary pass/fail.

• Build Deterministic Gated Middleware: Put deterministic validation layers around your agent’s tool calls. If an agent generates an API payload, pass it through a strict JSON schema validator before execution. Do not let non-deterministic outputs hit production databases without a hard gate.

Reliability in AI agents is not about making a probabilistic model act like a SQL database. It is about building deterministic scaffolding around non-deterministic reasoning so your system fails safely, predictably, and visibly.

I’m Ajas Bakran. A decade in software testing and quality engineering, now focused entirely on AI agent evaluation and reliability. I write about what’s actually working in this space, and what isn’t, every week here.

Now before you roll your eyes at another acronym, stick with me—MCP isn’t just another “tech thing.” It’s a foundational shift in how AI applications talk to the outside world. If you’ve ever built an app, worked with APIs, or wondered how AI can actually do things in the real world, this is worth your time.

What Is MCP?

Let’s start from the top.

MCP stands for Model Context Protocol. It’s an open standard that helps large language models (like GPT or Claude) work with external data, tools, and services in a secure, structured, and reusable way.

Think of it like this: LLMs are smart, but on their own, they don’t know anything outside their training. They can’t access your company’s knowledge base, read your Google Docs, or call your database—unless you manually set that up. That’s where MCP comes in. It acts as the connective tissue that bridges LLMs with your actual systems and data.

In technical terms, it’s a protocol for exposing tools and context (like documents, APIs, and functions) to models in a structured format.

In human terms: It helps AI do real work with real stuff.

Why Does It Matter?

Before MCP, every time someone wanted to connect an AI model to a tool or data source, they had to write custom logic. It was messy. You had to deal with weird wrappers, unclear formats, and inconsistent APIs. There was no shared language for “here’s a document” or “here’s a tool you can use.”

MCP gives us that shared language.

• It makes tools reusable across apps.

• It makes context sharing easier and more secure.

• It keeps everything modular and composable.

This is the kind of invisible infrastructure that makes AI apps more powerful and more maintainable.

How MCP Works (Without the Tech Headache)

Okay, let’s break this down without drowning in jargon.

MCP defines a host–client–server architecture:

• MCP Host: This is your AI app (like a chatbot, IDE plugin, or command-line tool). It initiates the conversation and wants to “do stuff.”

• MCP Server: This is the thing that has the data or the tools. It exposes resources like files, APIs, or prompt templates.

• MCP Client: This sits in the middle. It connects one host to one server and handles all the handshakes and translations.

Here’s a quick analogy: Imagine your AI app is a customer at a restaurant (the Host). The kitchen is the Server (it has all the tools and ingredients). The waiter is the Client taking orders, relaying instructions, and returning results.

What Kind of Stuff Can MCP Expose?

There are three core components you’ll hear about a lot:

1. Resources – Think files, docs, datasets, code snippets—anything you’d want the AI to “see” or “reference.”

2. Prompts – Predefined instructions for guiding model behavior, often reusable and domain-specific.

3. Tools – Functions or APIs the model can invoke (e.g., “run a database query” or “send an email”).

These three pieces are the building blocks that MCP wraps up in a standard format so everything plays nicely together.

Real-World Use Cases

MCP isn’t just theory—it’s already being used in practical, powerful ways. Here’s a taste:

1. Enterprise AI Assistants

Companies are using MCP to connect internal AI assistants to their knowledge bases, CRMs, and scheduling tools. Instead of “Sorry, I can’t access that,” you get smart replies powered by real data.

2. Developer Tools

Imagine writing code in VS Code, and the AI can pull in relevant documentation, refactor code, or even test APIs—because it has access to your codebase and toolchain via MCP.

3. Customer Support Automation

Support bots can become way more useful if they can actually look up orders, check user logs, or issue refunds. MCP lets them do that securely, without needing direct model access to sensitive data.

4. Content Generation at Scale

Need hundreds of marketing briefs, data reports, or product summaries? MCP can connect a generation tool to your source data, templates, and editorial guidelines.

5. Agents & Multi-Step Reasoning

MCP is also a key part of emerging “agentic” systems—where AI agents reason, plan, and take actions across multiple tools and steps. These setups rely heavily on consistent, structured tool access. MCP is perfect for that.

How Is MCP Different from Tools Like LangChain or Semantic Kernel?

Great question. If you're in the space, you've likely heard of frameworks like LangChain, Semantic Kernel, or Haystack. Here's how MCP relates:

• LangChain/Semantic Kernel are frameworks: they help you build applications.

• MCP is a protocol: it defines how apps can expose data and tools in a shared, interoperable way.

They’re not competing—they’re complementary.

In fact, you can use MCP inside LangChain or Semantic Kernel. Think of MCP as the common plug that different frameworks can use to connect and exchange context cleanly.

Why Open Standards Matter

One of the most exciting parts of MCP is that it’s an open standard. It’s backed by contributors from Hugging Face, Microsoft, and others, and it’s designed to be framework-agnostic. That means you’re not locked into one vendor or ecosystem.

Remember what HTML did for the web? That’s what MCP aims to do for AI integrations.

By using a shared protocol, developers can:

• Build reusable tools

• Mix and match components

• Avoid reinventing the wheel every time

This is a huge win for long-term maintainability and collaboration.

What About Security?

This is a big one.

Because MCP operates on a structured, declarative model, it’s way easier to sandbox, inspect, and control what’s going on.

Instead of letting your AI “do whatever,” you can:

• Explicitly define what tools and resources are available

• Log and audit all interactions

• Set access control policies per client, per resource

This kind of transparency and control is essential for using AI safely in production—especially with sensitive data.

Where Is This Headed?

MCP is still early, but it’s gaining traction fast.

• There’s already a live spec and site

• Hugging Face has a growing ecosystem of MCP-compliant tools

• Devs are sharing examples and building open-source servers and clients

As more companies adopt it, we could see a future where:

• AI assistants work seamlessly across apps and services

• AI agents compose tools dynamically

• Devs stop wasting time wiring the same things over and over

Think: one standard, endless flexibility.

How You Can Start Using MCP

Interested in trying it out? Here’s how to get started:

1. Read the Intro – Check out the official Model Context Protocol site

2. Look at Examples – Hugging Face has a great post showing how to build with MCP

3. Join the Community – MCP is open, so you can contribute ideas, tools, or feedback. The GitHub repo is here

Even if you're not ready to build with it yet, keep an eye on it. It’s laying the groundwork for how AI apps will be built going forward.

Wrapping Up

The Model Context Protocol isn’t flashy—it’s foundational. It doesn’t change what LLMs can do, but it completely changes how we connect them to the world around them.

It’s about building smarter systems with less effort, more safety, and better reuse. And honestly? That’s exactly the kind of boring brilliance the AI world needs right now.

And that’s a wrap for this edition! Stay tuned for more updates in the next newsletter. Until then, take care and stay curious!

Context is everything when it comes to understanding and responding to complex queries. Without it, even the most advanced AI can stumble, providing answers that are technically correct but miss the mark in terms of relevance. Contextual Retrieval aims to bridge that gap, making AI systems more intuitive and effective

So, what’s the big deal? Let's dive in.

What is Contextual Retrieval?

First things first, what exactly is Contextual Retrieval? To understand it, we need to take a quick look at Retrieval-Augmented Generation, or RAG for short. RAG is a type of AI system that combines two powerful capabilities: information retrieval and language generation. Think of it as a super-smart librarian who not only finds the right books for your query but also summarizes them in a way that directly answers your question. It’s like having a conversation with an expert who knows exactly where to look and how to explain things.

RAG systems have been a game-changer in AI, allowing models to access vast amounts of information without having to memorize it all. Instead, they retrieve relevant documents or text chunks on the fly and use that information to generate responses. This makes them incredibly versatile and up-to-date, as they can pull from the latest data. However, the challenge has always been ensuring that the retrieved information is not just relevant but also contextually appropriate.

Here’s where Contextual Retrieval comes in, Sometimes, even the best RAG systems can miss the mark. Imagine asking about the impact of AI on healthcare, and the system pulls up a chunk of text about AI in general without specifying the healthcare context. It’s relevant, but it lacks the specific context you need. Contextual Retrieval is like giving your AI a pair of glasses to see the finer details and understand the full story. It enhances RAG systems by making the retrieved information more contextually aware, ensuring that the answers you get are not just accurate but also deeply relevant.

How Does Contextual Retrieval Work?

So, how does Contextual Retrieval actually work? It’s a two-step process that enhances the way information is retrieved and understood. Let’s break it down.

Step 1: Creating Contextualized Chunks

In traditional RAG systems, text is broken down into chunks—small pieces of information—and the system retrieves the most relevant ones based on your query. But here’s the catch: sometimes these chunks don’t have enough context on their own to be truly useful. Contextual Retrieval solves this by adding a short, descriptive summary to each chunk. This summary acts like a mini-introduction, explaining what the chunk is about and why it matters.

For example, let’s say you have a chunk of text that reads, "AI models require rigorous testing to ensure they don’t produce harmful outputs." On its own, that’s useful, but it doesn’t tell the full story. Contextual Retrieval might add a summary like, "This section discusses the importance of safety protocols in AI development, focusing on testing methodologies to prevent unintended consequences." Now, the system has a clearer idea of how this chunk relates to queries about AI safety.

Think of it like searching for a recipe online. If you type "chocolate cake," you might get a ton of results—some fancy, some simple. But if you add context, like "chocolate cake for beginners," you’re more likely to find recipes that match your skill level. These contextual summaries do the same thing for AI, helping it zero in on the most relevant chunks.

Step 2: Using a Fine-Tuned Embedding Model

Next up is the techy part: embeddings. Embeddings are like information encoded in numbers of the text—they capture its meaning in a way machines can understand. In standard RAG systems, embeddings help the AI find chunks that are similar to your query. But Contextual Retrieval takes it a step further by using a fine-tuned embedding model that’s specially trained to work with these contextualized chunks.

This fine-tuning means the model doesn’t just look at the raw text—it also considers the added context from the summaries. The result? It’s way better at retrieving the exact chunks that answer your question. Imagine training a dog to fetch. A regular dog might grab any stick, but a well-trained one brings back the exact one you threw. That’s what this fine-tuned model does—it fetches the right stuff with precision.

Together, these two steps—contextualized chunks and a fine-tuned embedding model—make Contextual Retrieval a powerful upgrade to how AI systems handle information.

Why Should You Care About Contextual Retrieval?

Alright, let’s talk benefits. Why does Contextual Retrieval matter to someone like you, who’s keen to understand AI in detail? Well, the perks are pretty impressive.

In Anthropic’s tests, Contextual Retrieval reduced the failure rate of RAG systems by up to 49%. Let’s break that down. If a standard RAG system got the answer wrong 15% of the time, Contextual Retrieval slashes that to about 7.5%. That’s a huge leap—essentially doubling the AI’s reliability. For you, that means fewer frustrating moments where the AI misses the point of your question.

It also boosts precision and recall. Precision is about how many of the retrieved chunks are actually relevant, while recall is how many of the relevant chunks it manages to grab out of everything available. Contextual Retrieval improves both, so you get more of the good stuff and less random noise. Imagine asking about the ethics of AI in hiring— вместо getting a mix of vaguely related bits, you’d get spot-on info about ethics in that specific context.

Plus, it’s a champ at handling tricky questions. Ever asked something where the answer isn’t in one neat package but scattered across multiple places? Contextual Retrieval helps the AI connect the dots. For example, if you’re digging into the history of AI, it could link milestones across different chunks—like how early neural networks led to today’s models—giving you a fuller, richer answer.

What’s the Catch?

No tech is perfect, right? Let’s talk about the challenges and limitations of Contextual Retrieval.

One biggie is computational cost. Creating summaries for tons of text chunks can hog resources, especially if you need answers fast in real-time. But here’s the workaround: if your data isn’t changing—like a library of articles—you can pre-compute everything. Do the heavy lifting once, store it, and queries zip along later.

Another hiccup is the language model’s quality. Since those summaries come from a model like Claude, if it misreads a chunk—say, tagging something as healthcare-related when it’s about finance—the retrieval could go off track. The fix? Use a top-notch model and maybe double-check summaries for big projects. As models get smarter, this issue should shrink, too.

Wrapping It Up

There you go—Contextual Retrieval in all! This Anthropic gem is making AI smarter and more tuned-in to context, paving the way for cooler, more advanced tools. Whether you’re a coder dreaming up the next big AI thing or just here to geek out, this is worth watching.

Want more? Swing by Anthropic’s full article for more details.

And that’s a wrap for this edition! Stay tuned for more updates in the next newsletter. Until then, take care and stay curious!

1. OpenAI Introduces Responses API & Agents SDK for Smarter AI Agents

OpenAI, the company behind ChatGPT, has launched two powerful new tools—the Responses API and the Agents SDK. These are designed to help developers create AI agents that can do more than just answer questions—they can now search the web, explore files, and even perform actions on a computer.

• The Responses API allows AI agents to fetch real-time information from the internet, interact with files, and carry out specific tasks on behalf of users.

• The Agents SDK helps developers manage multiple AI agents working together on complex projects.

This means AI assistants could soon handle more practical, hands-on tasks for businesses, like automating research or performing simple digital tasks for users. OpenAI is phasing out its older Assistants API by mid-2026 in favor of these new, more capable tools.

👉 Read more

2. Alibaba Upgrades Quark AI Assistant with Smarter Reasoning

Chinese tech giant Alibaba has made a major upgrade to its AI-powered assistant, Quark. This AI is now smarter and better at handling complex tasks like:

• Researching academic papers

• Writing and summarizing documents

• Planning trips and organizing information

Alibaba is gradually rolling out the improved version of Quark to all users, with a pilot version already available.

This AI update is significant because better AI-powered assistance can make everyday tasks easier, from students researching topics to businesses handling large amounts of information.

👉 Read more

3. China’s New AI Agent, Manus, Operates Autonomously

China-based startup Monica has launched Manus, an AI agent that can work independently without constant human supervision.

Unlike AI chatbots that require ongoing user input, Manus can think and make decisions on its own to complete tasks like:

• Market research

• Data analysis

• Planning trips

• Writing and even coding

This marks a big step toward AI that can truly assist businesses and individuals with complex work, instead of just answering questions. China has been rapidly developing its AI capabilities, and Manus shows how advanced their AI technology is becoming, competing with Western AI companies like OpenAI and Google.

👉 Read more

4. OpenManus: The Open-Source Alternative to Manus AI

OpenManus was launched specifically as an alternative to China’s Manus AI, which is a proprietary AI agent developed by the Chinese startup Monica. OpenManus is designed to be an autonomous agent capable of executing complex tasks like market research, coding, and travel planning.

The launch of OpenManus signals a major shift in AI agent development, giving power back to businesses and developers who want flexibility, security, and control over their AI tools. As more companies seek independent AI solutions that are not tied to Big Tech or specific government policies, OpenManus could become a key player in the AI automation.

👉 Read more

5. Ushur’s AI Agent for Healthcare Services

AI is now playing a bigger role in healthcare! Ushur, an AI automation company, has developed an AI-powered assistant to improve healthcare customer service.

Here’s how it helps:

• Provides faster, more accurate responses to patients

• Makes healthcare info more accessible

• Ensures HIPAA-compliant interactions for privacy and security

This AI assistant is designed to make healthcare interactions more empathetic and efficient, reducing wait times and improving patient experiences.

👉 Read more

Final Thoughts: AI Agents Are Evolving Quickly

These updates highlight a huge leap forward in AI agent technology. OpenAI, Google, and Alibaba are pushing AI assistants toward greater independence and efficiency, while startups like Monica are showing that fully autonomous AI agents are becoming a reality.

The future of AI agents is shaping up to be more intelligent, capable, and integrated into everyday life and work—from researching and coding to customer service and healthcare assistance.

Which of these AI updates do you find most exciting? Let us know in the comments!

And that’s a wrap for this edition! Stay tuned for more updates in the next newsletter. Until then, take care and stay curious!

If you’ve spent even five minutes on tech Twitter, LinkedIn, or Reddit lately, you’ve seen the buzz: “AI agents will automate your life!” “They’ll code, write, and even negotiate for you!” But here’s the million-dollar question: Are AI agents truly revolutionary, or is this just another overhyped tech bubble?

As AI learners, you’re bombarded with promises of a future where autonomous agents handle everything from customer service to complex decision-making. But let’s cut through the noise. In this deep dive, we’ll explore:

• What AI agents actually do today.

• Where the hype exceeds reality.

• Why critical thinking matters in the age of AI FOMO.

What Are AI Agents? (And Why Everyone’s Obsessed)

Before we dissect the hype, let’s define our terms.

AI Agents are software programs designed to perform tasks autonomously by perceiving their environment, making decisions, and acting to achieve specific goals. Think of them as:

• Digital Assistants (e.g. Siri, Alexa).

• Chatbots (e.g. ChatGPT, Claude).

• Sophisticated Systems (e.g. self-driving cars, algorithmic traders).

Why the hype? Three words: automation, scalability, and potential. AI agents promise to:

1. Eliminate repetitive work (e.g. scheduling, data entry).

2. Solve complex problems (e.g. medical diagnosis, climate modeling).

3. Learn and adapt without constant human oversight.

But here’s the catch: Potential ≠ Reality. Let’s unpack why.

Why AI Agents Are (Partly) Overhyped

1. “Autonomous” Doesn’t Mean “Flawless”

Headlines scream: “AI agents can replace humans!” But autonomy ≠ perfection. Today’s agents:

• Struggle with ambiguity: Ask ChatGPT to resolve a nuanced ethical dilemma, and it might hallucinate.

• Depend on training data: Biases, gaps, or outdated info limit reliability.

• Require human oversight: Errors in code, misinterpreted prompts, or security risks still need human checks.

Example: An AI customer service agent might handle 80% of queries but fail catastrophically on edge cases (e.g. legal disputes).

2. The “Jack of All Trades” Fallacy

Many pitch AI agents as Swiss Army knives: “One agent to rule them all!” But in reality:

• Specialization wins: An agent trained for medical diagnosis won’t excel at stock trading.

• Context matters: An agent that thrives in structured data environments (e.g., supply chain logistics) may struggle in creative tasks (e.g. writing poetry).

Reality check: Narrow AI dominates. General AI (AGI) is yet to be a reality.

3. The Scalability Illusion

Yes, AI agents can scale tasks—but scaling requires:

• Infrastructure costs: Training and running models like GPT-4 isn’t cheap.

• Regulatory hurdles: Privacy laws (GDPR), copyright issues, and ethical guidelines limit deployment.

Bottom line: Scaling isn’t as simple as flipping a switch.

Before you dismiss AI agents as hype, let’s acknowledge their legitimate breakthroughs:

1. Automation at Unprecedented Speed

AI agents excel at tasks with clear rules and patterns:

• Data analysis: Processing terabytes of data in minutes.

• Content generation: Drafting emails, reports, or code snippets.

• Customer support: Resolving FAQs 24/7.

Example: GitHub Copilot writes code faster than humans—but still needs review.

2. Democratizing Expertise

AI agents make specialized knowledge accessible:

• Healthcare: IBM Watson assists in diagnosing rare diseases.

• Education: Personalized tutoring bots adapt to student needs.

3. Accelerating Innovation

AI agents help researchers:

• Simulate drug interactions.

• Optimize climate models.

• Design new materials.

Key takeaway: AI agents are powerful tools—when used correctly.

Share

Human + AI: A Winning Team?

Here's the real secret: AI agents work best as assistants, not replacements. Companies that rely completely on AI often face trouble, but those who combine human oversight with AI tools see much better results.

Think of AI agents as copilots. They help steer the plane, but a human pilot must always be there to ensure everything runs smoothly.

How to Make AI Agents Work for You

• Use them for simple tasks first: Let AI handle straightforward jobs like scheduling or basic customer responses.

• Always check their work: AI agents still need human oversight to catch mistakes early.

• Keep expectations realistic: Understand their limits, and don't expect perfection from day one.

How to Stay Ahead as an AI Learner

1. Focus on fundamentals: Master statistics, ethics, and domain-specific knowledge.

2. Build small projects: Create a task-specific agent (e.g., a resume parser).

3. Stay skeptical: Question grand claims. Demand evidence.

Remember: The next “AI revolution” will be built by those who balance optimism with critical thinking.

Final Thoughts: Are AI Agents Overhyped?

Yes and no. AI agents are incredibly promising but are often portrayed as flawless solutions. The reality? They're powerful tools with clear limitations.

By setting realistic expectations and combining AI with human insight, we can unlock their full potential.

In short, AI agents aren’t magic, but with careful use, they can still feel pretty magical.

Have you experienced similar challenges with AI agents? Share your story below and let's discuss the reality behind the hype!

And that’s a wrap for this edition! Stay tuned for more updates in the next newsletter. Until then, take care and stay curious!

So, how do we implement memory in AI agents that is easy to retrieve, effective, and scalable? In this guide, we’ll explore different memory architectures, best practices, and the tech stack needed to build an AI agent with persistent memory. Let’s dive in!

Why Memory Matters in AI Agents

Imagine talking to an AI assistant today, teaching it your preferences, and then having it remember those details the next time you chat. This ability to "remember" past interactions and use that information in the future is what AI memory is all about.

Artificial Intelligence (AI) memory allows AI agents—like chatbots, virtual assistants, self-driving cars, and even robots—to recall past experiences, learn from them, and improve their responses over time. Unlike traditional computing systems that only process real-time data, AI with memory can adapt, improve, and personalize its interactions, making it more human-like.

Every time you interact, you’d have to repeat your preferences, past conversations, and context. That’s frustrating, right? Memory is essential for:

1. Personalization - AI can remember user preferences and tailor responses.

2. Context Retention - AI can recall past interactions to provide relevant answers.

3. Learning & Adaptation - AI can improve over time by remembering what worked before.

4. Efficiency - Memory reduces repetitive queries, making interactions smoother.

5. Decision-Making - AI can analyze past patterns for smarter insights.

But how exactly does AI memory work? What types of memory do AI systems use, and why is it important? Let's try to understand how machines can "remember" and "learn" just like humans.

How AI Agents Process and Store Information

AI memory doesn’t work like human memory, which is based on emotions, senses, and experiences. Instead, AI processes and stores information through structured algorithms. Here's how it happens:

Step 1: Encoding

The AI receives input—this could be a voice command, text, or sensor data. It processes this data and converts it into a format it can understand.

Step 2: Storage

Depending on the importance of the data, AI stores it in either short-term or long-term memory. Temporary information is discarded after use, while valuable data is saved for future reference.

Step 3: Retrieval

When needed, AI retrieves stored information. This helps it recognize patterns, recall past interactions, and improve decision-making.

Step 4: Adaptation

Some AI systems use advanced learning techniques to refine their memory. This means AI can "forget" outdated information and prioritize relevant data for improved efficiency.

To make AI agents truly human-like and useful, we need structured memory systems. Let’s explore how to do it.

The Four Types of Memory in AI

For effective AI memory, we need a hybrid system that includes different types of memory:

1. Short-Term Memory (STM)

Short-term memory in AI functions similarly to how our brain holds information for immediate use. Think of it like when you remember a phone number long enough to dial it but forget it soon after.

AI systems use short-term memory for:

• Processing real-time conversations in chatbots.

• Keeping track of recent commands given to virtual assistants.

• Temporary data storage for immediate calculations and decision-making.

• Used for context windows in LLMs (like GPT models).

Example:

• A chatbot remembering the last 5–10 messages in a conversation.

2. Long-Term Memory (LTM)

Long-term memory in AI is where data is stored for extended periods, allowing AI agents to recall and reuse information even after a long time. Without long-term memory, AI would always start from scratch, making interactions frustrating and inefficient.

AI systems use short-term memory for:

• AI-powered recommendation systems (like Netflix or YouTube) remember your watch history to suggest content.

• Virtual assistants (like Alexa or Siri) recall frequently used commands to provide better suggestions.

• AI-driven customer support bots remember previous interactions to improve responses.

Example:

• A customer support AI remembering a user’s issue from last month.

3. Episodic Memory

Episodic memory is where things get really interesting. This type of memory allows AI to recall past experiences and apply them in future scenarios.

For instance:

• A self-driving car can "remember" past road conditions and use that knowledge to navigate similar situations.

• A chatbot can recall a customer's previous complaints and ensure they are not asked to repeat them.

This kind of memory is crucial for AI to feel more natural and human-like in its responses.

4. Semantic Memory

Semantic memory stores factual knowledge.

• Not tied to individual interactions but helps AI build intelligence.

• Stores information in a structured way (like a knowledge graph).

Example:

• An AI recalling the capital of a country or business facts.

Best AI agents use a combination of all four memory types!

Techniques to Implement AI Memory Effectively

Now that we know what types of memory AI agents need, let’s explore how to implement them.

1. Using Vector Databases for Efficient Retrieval

Vector databases are great for storing and retrieving unstructured data (like conversations, documents, and embeddings).

How it works:

• AI converts text into vector embeddings (numerical representations).

• These vectors are stored in FAISS, Pinecone, or ChromaDB.

• When needed, AI searches for the closest match using cosine similarity.

Use Case:

• AI chatbot remembering similar past user queries to provide better answers.

Tools: FAISS, Pinecone, Weaviate, ChromaDB

2. Knowledge Graphs for Structured Memory

Knowledge graphs store relationships between concepts, people, and events in a structured way.

How it works:

• AI stores information in nodes and edges.

• AI can traverse the graph to find related concepts.

Use Case:

• A medical AI assistant remembers a patient’s symptoms and links them to potential diagnoses.

Tools: Neo4j, ArangoDB

3. Summarization for Efficient Memory Storage

Storing raw text from every interaction is expensive and inefficient. Instead, AI should generate summaries of key interactions.

How it works:

• AI extracts key takeaways from long conversations.

• Stores only important insights instead of full text logs.

Use Case:

• AI summarizing customer support interactions to help future agents understand past complaints.

Tools: LangChain’s summarization pipeline, GPT-based chunking & retrieval

4. Hybrid Approach: Combining Retrieval-Augmented Generation (RAG)

The best memory system for AI agents combines multiple techniques:

• Vector search (retrieves similar past interactions)

• Summarization (remembers key insights)

• Structured storage (SQL/NoSQL for user preferences)

• Knowledge graphs (connects insights)

Use Case:

• AI-powered legal assistant retrieving past case laws while linking them to client history.

Tools: FAISS + LangChain + Neo4j + SQL

Best Practices for AI Memory Implementation

To make your AI memory system efficient and scalable, follow these best practices:

• Balance Storage and Speed - Store only relevant data to prevent slow retrieval.

• Use Summarization - Instead of raw text, store concise summaries.

• Hybrid Memory Systems - Combine vector search, graphs, and databases. Regularly Update Memory - AI should forget outdated information and refresh knowledge.

• Security & Privacy - Ensure sensitive user data is encrypted and not misused.

Conclusion: The Future of AI Memory

AI agents with persistent, structured memory are the future. Whether it’s chatbots, virtual assistants, or AI-powered research tools, memory plays a crucial role in making them smarter and more adaptive.

By implementing a hybrid memory system with:

• Vector databases (FAISS, Pinecone)

• Knowledge graphs (Neo4j)

• Summarization (LangChain, GPT)

• Structured storage (SQL/NoSQL)

You can build AI agents that learn, evolve, and provide human-like experiences.

What’s your take? How do you think AI memory will shape the future? Drop your thoughts in the comments!

And that’s a wrap for this edition! Stay tuned for more updates in the next newsletter. Until then, take care and stay curious!

In this issue, we explore the Top 10 AI Agent Frameworks you should master in 2025 to build, optimize, and deploy cutting-edge AI solutions. Let’s get started!

1. CrewAI: Collaboration Redefined

CrewAI is one of the most powerful AI agent frameworks, designed for multi-agent coordination. If your AI projects involve multiple agents working together, CrewAI provides seamless orchestration and task delegation.

Key Features:

• Enables efficient collaboration between AI agents.

• Ideal for complex workflows requiring intelligent cooperation.

• Supports advanced task delegation mechanisms.

Use Cases:

• Financial Analysis: Coordinating multiple agents to analyze market trends and provide investment insights.

• Healthcare Management: Streamlining patient data processing and treatment planning through collaborative agent efforts.

Best for: AI developers working on multi-agent systems in finance, healthcare, and customer service automation.

Consideration: Has a steeper learning curve, but once mastered, it’s a game-changer.

2. Pydantic-AI: Ensuring Reliable AI Outputs

Pydantic-AI is a Python-based agent framework developed by the creators of Pydantic, aiming to streamline the development of generative AI applications by ensuring that AI-generated responses are both structured and free from hallucinations. It achieves this by integrating Pydantic models into the AI development process, enforcing strict data validation and type safety.

At the core of Pydantic-AI is the use of Pydantic models to define the expected structure and data types of AI outputs. By specifying these models, developers can ensure that the responses generated by large language models (LLMs) conform to predefined schemas.

Key Features:

• Improves AI reliability by validating outputs.

• Ensures consistent and accurate AI-generated responses.

• Ideal for developers who prioritize precision.

Use Cases:

• Legal Document Generation: Producing contracts and agreements with strict adherence to legal standards.

• Financial Reporting: Generating accurate financial statements and analyses.

Best for: AI applications in legal, financial, and compliance sectors where accuracy is critical.

Consideration: Can increase token consumption, making budget management essential.

3. LangChain: The Enterprise AI Powerhouse

LangChain is an open-source framework designed to streamline the development of applications powered by large language models (LLMs) and remains one of the most widely used frameworks for building AI-powered applications at scale. It offers a comprehensive suite of pre-built components and extensive documentation, making it a robust platform for enterprises aiming to harness the capabilities of AI in their operations.

Key Features:

• Pre-built components for rapid AI development.

• Comprehensive documentation for quick implementation.

• Supports enterprise-level AI projects.

Use Cases:

• Customer Service Automation: Deploying AI agents to handle customer inquiries and support.

• Data Analysis Pipelines: Automating complex data processing tasks for large datasets.

Best for: Companies looking to develop scalable, production-ready AI solutions.

Consideration: Not ideal for lightweight or small AI applications.

4. AutoGen: Microsoft’s Autonomous AI Framework

AutoGen is an open-source framework developed by Microsoft, to build applications where multiple AI agents converse to accomplish tasks. These agents are customizable and can operate in various modes, incorporating combinations of large language models (LLMs), human inputs, and tools.

Developers can flexibly define agent interaction behaviors, using both natural language and code to program conversation patterns for diverse applications. Empirical studies have demonstrated the framework's effectiveness across domains such as mathematics, coding, question answering, operations research, and online decision-making.

Key Features:

• Streamlines data manipulation and processing.

• Deep integration with Microsoft’s AI ecosystem.

• AutoGen Studio provides a low-code interface for rapid prototyping.

Use Cases:

• Automated Content Generation: Creating articles, summaries, and reports through agent collaboration.

• Complex Problem Solving: Agents working together to tackle intricate tasks in research and development.

Best for: Enterprises and developers needing strong Microsoft AI tool integration.

Consideration: Requires technical expertise for full utilization.

5. smolagents: The Lightweight AI Agent Framework

smolagents is a minimalist yet powerful AI agent framework developed by Hugging Face, designed to enable developers to create robust agents with minimal code. By focusing on simplicity and efficiency, smolagents empowers large language models (LLMs) to interact seamlessly with real-world tasks

Key Features:

• Minimal code required for agent creation.

• Compatible with multiple LLM providers.

• Beginner-friendly, making onboarding easier.

Use Cases:

• Chatbots: Developing conversational agents for customer engagement.

• Task Automation: Automating routine tasks in personal or professional settings.

Best for: Developers who want to quickly experiment with AI agents.

Consideration: Limited scalability for large enterprise solutions.

6. Langraph: Visualizing AI Workflows

LangGraph is an advanced framework designed to the development and visualization of complex AI workflows. By representing AI processes as directed graphs, LangGraph enables developers to design, optimize, and debug AI agents with enhanced clarity and efficiency

Key Features:

• Provides a graph-based visualization of AI workflows.

• Enhances interpretability of multi-agent systems.

• Helps debug and optimize AI agent logic.

Use Cases:

• AI Workflow Design: Planning and visualizing interactions in multi-agent systems.

• Educational Tools: Assisting in teaching AI concepts through visual aids.

Best for: Developers working on large-scale AI agent workflows.

Consideration: Scalability challenges for extremely complex workflows.

7. n8n: No-Code AI Workflow Automation

For those looking for a no-code/low-code AI agent solution, n8n is a fantastic tool, n8n is a open-source tool for AI workflow automations, a platform that empowers users to design and automate complex workflows without extensive coding knowledge.

Its visual interface and extensive integration capabilities make it an excellent choice for those seeking no-code or low-code solutions to implement AI agents and automate tasks across various applications and services.

Key Features:

• Visual pipeline creation for AI workflows.

• Allows for rapid prototyping of AI-driven automation.

• Great for testing AI workflow concepts quickly.

Best for: Business users and non-technical professionals looking to leverage AI.

Consideration: Limited customization for advanced AI development.

8. phidata: Building Multi-Modal AI Agents

phidata is a framework that enables the creation of multi-modal AI agents equipped with memory, knowledge, tools, and reasoning capabilities. It supports the development of collaborative agent systems that can process various data types, including text, images, and audio.

Key Features:

• Supports team-based AI agent collaboration.

• Provides an intuitive Agent UI for seamless interactions.

• Allows users to create a web search AI agent in 10 lines of code.

Use Cases:

• Legal Document Generation: Producing contracts and agreements with strict adherence to legal standards.

• Financial Reporting: Generating accurate financial statements and analyses.

Best for: Developers looking to build multi-modal AI agents.

Consideration: Limited adoption compared to other frameworks.

Share Grow with AI

9. Relevance AI: Build Autonomous AI Teams

Relevance AI provides a platform for building and deploying AI agents—reasoning bots powered by large language models (LLMs) that autonomously plan and execute tasks. These agents are equipped with tools and can decide how to use them to achieve their objectives.

Key Features:

• Enables AI-driven automation of business workflows.

• Provides easy integration with existing processes.

• Helps teams build AI solutions with minimal programming skills.

Use Cases:

• Customer Support Automation: Agents can handle repetitive and time-consuming tasks, such as answering frequently asked questions or processing standard requests, freeing human employees to focus on more complex issues.

• Sales and Lead Qualification: Automating the initial stages of sales processes, agents can qualify leads based on predefined criteria, allowing sales teams to concentrate on closing deals and nurturing client relationships.

• Content Generation: Agents can autonomously create content, such as tool explainer webpages or product descriptions, and publish them to platforms like Webflow without human intervention, streamlining content management workflows.

Best for: Businesses looking to deploy AI quickly.

Consideration: Limited advanced customizability.

10. Swarm: OpenAI’s Modular AI Agent Framework

Swarm is an experimental framework developed by OpenAI to explore ergonomic interfaces for multi-agent systems. Designed with simplicity and modularity in mind, Swarm aims to make the orchestration of multiple AI agents more accessible and user-friendly. It's important to note that Swarm is primarily an educational resource and is not intended for production use

Key Features:

• Designed for lightweight AI agent coordination.

• Modular agents equipped with specialized tools.

• Agents can transfer control dynamically.

Best for: Developers experimenting with AI agent collaboration.

Consideration: Limited real-world deployment examples at this stage.

Final Thoughts: Which Framework Should You Choose?

The best AI agent framework for you depends on your use case and technical expertise.

• For enterprise AI applications → Go with LangChain or CrewAI.

• For multi-agent collaboration → Try CrewAI, AutoGen, or phidata.

• For quick, low-code AI automation → Choose n8n.io or Relevance AI.

• For structured and validated AI outputs → Pydantic-AI is the way to go.

And that’s a wrap for this edition! Stay tuned for more updates in the next newsletter. Until then, take care and stay curious!

Traditional AI models struggle with static knowledge limitations. They provide responses based on pre-trained data but lack the ability to pull in fresh, dynamic insights from external sources. This is where Retrieval-Augmented Generation (RAG) transforms the game. By enabling AI systems to fetch real-time, domain-specific data, RAG ensures responses remain accurate, contextually relevant, and always up-to-date.

Now, add agentic intelligence to this equation—an architecture where AI systems autonomously plan, decide, and take action based on user queries. The result? A next-level AI Coach that can guide, mentor, and provide tailored learning experiences in a way that static chatbots never could.

To build such a system, we need the right tools. Enter phidata and Qdrant.

• phidata streamlines the entire AI workflow—data ingestion, preprocessing, and integration—ensuring that the AI agent operates on clean, structured, and reliable datasets.

• Qdrant, a powerful vector database, provides lightning-fast similarity searches, allowing the AI agent to retrieve the most relevant pieces of knowledge based on semantic meaning rather than keyword matching.

Together, they form the core engine of an intelligent RAG-powered AI Coach, capable of real-time knowledge retrieval, adaptive reasoning, and self-improvement. Whether you're developing an AI-driven corporate mentor, a personalized learning assistant, or an executive decision-making advisor.

In this guide, I will take you through the process of building an Agentic RAG AI Coach step by step. From setting up the AI Agent to integrating PhiData and Qdrant, we'll cover all the essential components. By the end of this guide, you’ll have a powerful AI Coach at your disposal, ready to resolve user queries by retrieving real-time data from a dynamic, knowledge-rich system. Get ready to create an intelligent, responsive coach that adapts to user needs and delivers accurate, contextually relevant answers with ease

Are you ready to build the future of AI-driven coaching? Let’s dive in.

Step-by-Step Guide to Building an Agentic RAG AI Coach

We’re building an AI agent that can answer user questions within a specific domain, and to achieve this, we’ll train the agent using transcription files from YouTube videos.

These transcriptions will serve as a valuable source of domain-specific knowledge, enabling the AI to pull relevant information and provide accurate, context-aware responses to queries.

By leveraging these transcriptions, we ensure that the agent is equipped with expert-level insights, tailored specifically to the subject matter of the videos. This step will lay the foundation for a highly effective AI coach that can provide real-time, intelligent answers to users based on the rich content it has been trained on.

Step 1: Setup Virtual Env

Execute the following code to set up our virtual environment. This will create an isolated environment where all the necessary dependencies and packages can be installed without interfering with your system’s global setup.

Setting up a virtual environment is crucial for managing project-specific dependencies, ensuring compatibility, and maintaining a clean workspace. By running this code, you’ll be ready to install and manage all the required libraries and tools needed for building and deploying your AI agent.

python3 -m venv ~/.venvs/aicoach
source ~/.venvs/aicoach/bin/activate

Step 2: Install Dependencies

Before we begin coding, we need to install the necessary packages to ensure that our environment is properly set up. To do this, simply execute the following command.

pip install -U phidata

This will install all the dependencies required for building and running the AI agent, including libraries for PhiData. Once the packages are installed, you'll be ready to dive into the development process.

Qdrant is a powerful vector search engine that helps in storing and retrieving high-dimensional data efficiently. To setup Qdrant locally, here are the steps you can follow - Setup Qdrant

Step 3: Download the youtube video transcription

I have downloaded the transcripts of several videos from the YouTube channel LiamOttley. Liam provides valuable insights on AI automation, marketing, and a variety of other topics that are highly relevant in today’s tech landscape.

To proceed with this process, you can easily download YouTube video transcriptions from Tactiq.io. After downloading, simply place the transcription files into a folder named "transcripts" to keep them organized and ready for use. This will ensure the agent has access to all the necessary content for training.

Step 4: Create VectorDB for documents ingestion.

We have imported the Qdrant implementation from phidata and created an instance to specify details, such as the name of the collection we want to create and the URL where Qdrant is running. This instance will help establish the connection to our Qdrant database, enabling us to store and retrieve vectorized info efficiently.

Step 5: Create a Knowledge Base for our AI Agent.

The next step in enhancing the intelligence of our AI Agent involves creating a knowledge base. This knowledge base will serve as the foundation for the agent to reference whenever it receives a question from the user. To achieve this, we will use the TexKnowledgeBase from phidata to build repository of information that the agent can query to provide accurate, domain-specific answers.

This process makes sure that the agent is not only well-informed but also capable of offering relevant and accurate responses to users in real-time.

Step 6: Create our AI Agent.

Now that our knowledge base is ready, the next step is to create an AI agent that can consume and interact with it. Creating an agent in phidata is straightforward. Below is the code to set up the agent and connect it to the knowledge base:

agent = Agent(
    model=OpenAIChat(id="gpt-4o-mini"),
    knowledge=knowledge_base_txt,
    search_knowledge=True,
    show_tool_calls=True,
    markdown=True,
    add_history_to_messages=True,
)

In the above code, we pass the previously created Knowledge Base to the agent. This allows the agent to use the knowledge base whenever it receives a query, so that it provides relevant and contextually accurate answers based on the information stored.

We have used the model ‘gpt-4o-mini’ to power the agent's responses. Additionally, it's crucial to note that we store the OPENAI_API_KEY in a .env file to securely manage API keys. You’ll need to create this file and place it at the root of your project directory. The .env file will look something like this,

OPENAI_API_KEY=your_openai_api_key_here

Step 6: Final touch - setup system prompt.

To configure a system prompt for our agent, we need to define the instructions that guide the agent's behavior. This system prompt will help the agent understand the context and provide more relevant and tailored responses. Below is the code to configure the system prompt for our agent:

user = input("Enter your query here")

while True:
    if user == "exit":
        break
    else:
        sys_prompt = "if you do not know the answer just simply say I dont know"
        agent.print_response(user+sys_prompt , stream=True)
        user = input("Enter your query here : ")

We will keep on running the loop until user enters “exit“ as the command

Let’s look at the end to end code now,

Step 6: Execute the Agent.

To execute the agent, simply run the following command.

python main.py

This will initiate the AI agent, allowing it to start processing queries and providing intelligent responses based on the knowledge base you’ve set up. Make sure all the necessary configurations and dependencies are in place before executing this command. Once done, your agent will be ready to interact with users and deliver answers in real-time and you should see something like below,

When executing the Python file for the first time, the system will ingest and add all the documents (transcriptions, in this case) into the knowledge base, preparing it for use by the agent. This process ensures that the knowledge base is populated with relevant information, which the AI coach will use to provide accurate and context-aware responses.

Now lets ask the question to our AI Coach.

And there you have it! We asked the AI Coach a question about Liam, and the response perfectly reflects the core of what Liam is all about—AI automation, marketing, and more. This shows that the agent is successfully pulling relevant information from the knowledge base and delivering accurate answers.

Congratulations on a job well done! You've successfully set up an intelligent AI coach capable of responding to user queries based on the knowledge it has ingested. This is a significant step forward in building a powerful, domain-specific AI system.

Here is my git repo where all code can be found - github link

In case you prefer a video of the above explanation, go through my video below. Don’t forget to hit the like button and subscribe if you find the video useful—your support helps me create more valuable content like this!

And that’s a wrap for this edition! Stay tuned for more updates in the next newsletter. Until then, take care and stay curious!

Today, we're diving into something exciting - creating ProfitPilot AI, a powerful financial analysis tool that combines artificial intelligence with real-time market data. This project will give you hands-on experience with modern tech stacks with building AI Agents.

What We're Building

ProfitPilot AI is your personal financial analyst that helps you make data-driven decisions by analyzing both short-term market movements and long-term investment opportunities. The best part? It's powered by AI agents that work together to provide comprehensive insights sometimes called Multi-Agent Systems.

The Technology Stack

Let's break down the key components we'll be using:

1. CrewAI - Your AI Agent Framework

CrewAI is the backbone of our project, managing multiple AI agents that work in harmony. Each AI agent has a specific role:

• One analyzes short-term market trends

• Another focuses on long-term patterns

• A third agent combines these insights into actionable recommendations

2. Streamlit - Your Frontend

Streamlit turns your Python scripts into beautiful web applications with minimal effort. We'll use it to create:

• An interactive dashboard displaying real-time market data

• Visual representations of AI insights

• User-friendly controls for customizing analysis parameters

3. Yahoo Finance Library - Data Source

This library will be our window into the financial world, providing:

• Real-time stock prices

• Historical market data

• Company fundamentals

Block Diagram

Let me explain how the architecture shown in this diagram works for ProfitPilot AI. This diagram illustrates the complete flow of how data and requests move through the system.

The process begins with the user interface, where a user (shown on the left) can input a stock query - in this example, they're interested in Tesla (TSLA). This interaction happens through a Streamlit interface, which provides a clean, web-based frontend for users to interact with the system.

When a query is submitted, it flows into the core ProfitPilot AI system, which then initiates AI agent, managed by CrewAI.

The first branch connects to Yahoo Finance (shown in the top right) as a custom tool. This is crucial because it fetches real-time financial data and ratios about Tesla. Think of this as the system's way of gathering raw financial intelligence about the stock.

This data then flows to two specialized agents:

1. The Financial Analyst Agent, which processes the raw financial data to understand the company's financial health, market position, and performance metrics.

2. The Investment Advisor Agent, which takes this analyzed information and transforms it into actionable investment advice.

Both these agents are powered by OpenAI's GPT-4-mini model (shown on the far right), which provides the artificial intelligence capabilities needed to process and interpret the financial data intelligently.

Finally, the system compiles all this information - the raw data, the financial analysis, and the investment advice - and returns it to the user through the Streamlit interface as a comprehensive result.

This architecture is particularly elegant because it combines the best of both worlds: the precision of financial data tools with power of AI, all while maintaining a user-friendly interface. The CrewAI framework ensures that these different components work together to provide best results.

Let’s look into the code

We will divide this in 5 parts,

1. Setup the streamlit dashboard

2. Create Agents

3. Create tool required to fetch the stock data from yahoo finance library

4. Creating the Crew

5. Bringing It All to Life: Running the Investment Analysis

1. Setup the streamlit dashboard

What you see below is the dashboard of the ProfitPilot AI we have build it using streamlit.

The UI has two main cards - one for short-term analysis and another for long-term analysis. The short-term and long-term analyses come from our Investment Advisor Agent working together with Financial Analyst Agent through CrewAI.

Code responsible for creating the dashboard is as below,

Streamlit function create_investment_dashboard() generates an interactive investment dashboard, analyzing a company's short-term and long-term outlook. It presents key insights—investment action, confidence score, and analysis—through visually structured cards. Designed for clarity, this tool helps investors make informed decisions at a glance.

2. Create Agents through CrewAI

Creating agents in CrewAI is straightforward. It has two parts

1. Defining three key elements of an Agent : Role, Goal, and Backstory—each playing a crucial part in shaping the agent’s effectiveness.

   1. Role – The agent’s identity or function (e.g., "Financial Analyst" or "Market Researcher").

   2. Goal – The specific objective the agent is designed to achieve (e.g., "Analyze stock trends and provide investment recommendations").

   3. Backstory – A contextual narrative that enhances the agent’s decision-making accuracy by aligning it with a persona (e.g., "A seasoned Wall Street analyst with years of market expertise").

2. Define the task for above agent - In CrewAI, tasks provide clear instructions on what an agent should do and what kind of output to generate.

   1. Description - The task to be done

   2. Expected output - What needs to be delivered

   3. Agent - Which AI agent will execute this task

Below is the code snippet of our financial Analyst AI Agent -

Corresponding Agent configuration is defined in yaml files as below,

and for tasks it is configured like below,

Now let’s move on to understanding how do we fetch the data from Yahoo Finance library and feed it to our AI Agent.

3. Creating a custom tool to fetch stock data

What is a Tool? - In CrewAI, tools enhance an AI agent’s capabilities by allowing it to interact with external data sources, APIs, or functions.

What is a Custom Tool? - While CrewAI offers built-in integrations, sometimes an agent needs specialized functionality. A custom tool is a user-defined function or API that expands an agent’s abilities beyond standard tools.

For example, if we want our The Financial Analyst Agent to fetch and analyze alternative data sources, we can create a custom tool like this shown below,

That was our first agent—now let’s move on to the second one, the Investment Advisor Agent. In the snippet below, something interesting happens: we take the output from our first agent and pass it to the second agent, enabling it to generate more accurate insights. This is where collaboration comes into play, forming what’s known as a multi-agent setup in CrewAI.

4. Creating the Crew

Now that our agents are ready, it's time to bring them together into a Crew to execute the end-to-end investment analysis. By structuring agents into a seamless workflow, we enable collaboration, allowing each agent to contribute its specialized expertise for a comprehensive stock analysis.

Let’s take a look at the snippet below:

• @crew Decorator – Registers this function as a CrewAI crew setup.

• Agents (self.agents) – A list of AI agents assigned to this crew, automatically generated via the @agent decorator.

• Tasks (self.tasks) – The defined tasks that agents will execute, created using the @task decorator.

• Process.sequential – Defines the execution flow as sequential, meaning agents complete tasks in a step-by-step manner rather than running in parallel.

• verbose=True – Enables detailed logging, making it easier to track the workflow execution.

By structuring our Crew, we ensure that agents work together efficiently, passing insights from one to another to generate a complete, well-analyzed investment report.

5. Bringing It All to Life: Running the Investment Analysis

Now that we have structured our Crew, the final step is to kick off the execution and let our AI agents collaborate on the investment analysis. This is where the magic happens!

What is happening here?

• User Interaction – When the user clicks the Analyze button, the process begins.

• Crew Execution – The Investmentcrew() instance is initialized, and the kickoff() function is triggered with the stock ticker as input.

• Data Processing – The raw results from the AI agents are structured into a well-defined investment report.

• Dashboard Visualization – The investment dashboard is generated, providing a clear view of short-term and long-term stock insights.

• Error Handling – If anything goes wrong, the user is notified with an error message

Since we are using the streamlit as UI, Just hit below command to start the application

Once the application is up and running, you’ll be greeted with an intuitive interface. Simply enter the name or ticker symbol of any stock, and watch as AI agents work in real-time to analyze it for you.

With just one input, you’ll get:

✅ Short-term & long-term investment insights
✅ Confidence scores for decision-making
✅ A comprehensive summary & conclusion

Go ahead—enter any stock name and see AI-driven analysis on the go…

Here is my git repo where all code can be found - github link

In case you prefer a video of the above explanation, go through my video below. Don’t forget to hit the like button and subscribe if you find the video useful—your support helps me create more valuable content like this!

And that’s a wrap for this edition! Stay tuned for more updates in the next newsletter. Until then, take care and stay curious!

The global market for AI agents is projected to grow significantly, from $5.29 billion in 2024 to $216.8 billion by 2035

AI agents are evolving at an unprecedented pace, reshaping the way we work, automate, and interact with technology. From enterprise automation to next-gen AI assistants, the latest advancements are setting the stage for a more intelligent and autonomous future.

In this edition, we’re bringing you the most exciting updates that are pushing AI agents to new heights. Let’s dive in!

1. OpenAI Introduces Operator: Your AI Assistant for Real-World Tasks

What’s New?

OpenAI has launched Operator, an AI agent that can autonomously perform tasks on the web, such as booking flights, ordering groceries, and making reservations—just like a human!

How It Works

• Available for ChatGPT Pro users in the U.S.

• Automates web-based tasks while asking for user confirmation before finalizing actions.

• Handles complex workflows but will pause and request input when needed.

What’s Next?

Operator is currently in a research preview and will expand to more users and regions soon.

2. NTT DATA has just dropped Smart AI Agent – A Game-Changer in Enterprise AI

NTT DATA is a $30+ billion trusted global innovator of business and technology services and serves 75% of the Fortune Global 100 and are committed to helping clients innovate, optimize and transform for long-term success

What’s New?

NTT DATA has launched its next-generation Smart AI Agent™, aiming to drive $2 billion in revenue by 2027 and accelerate generative AI adoption across industries.

How It Works

• Autonomous Execution – Extracts, organizes, and completes tasks based on user instructions.

• Multi-Agent Collaboration – Works with other AI agents to enhance efficiency.

• Advanced RAG (Retrieval-Augmented Generation) – Improves information retrieval for better decision-making.

• Enterprise-Ready – Already transforming operations in automotive, banking, and manufacturing.

Why It Matters
This AI-powered assistant is designed to complement human workforces, streamlining time-consuming processes and boosting productivity. With its advanced task automation and planning capabilities, it’s set to revolutionize enterprise workflows.

3. Oracle AI Agents to Supercharge Business Operations

What’s New?

Oracle has introduced a suite of AI agents embedded in its cloud services, aiming to revolutionize business productivity across multiple industries.

AI for Supply Chain & Operations

• Embedded AI Agents in Oracle Fusion Cloud SCM to streamline workflows.

• Designed to automate logistics, procurement, and inventory management, driving efficiency.

AI for Sales & Customer Engagement

• AI-powered assistants help sales teams generate optimized emails, summarize activities, and enhance customer interactions.

• Goal: Accelerate deal closures and boost engagement with intelligent automation.

“Our new AI agents for supply chain management help ease the administrative burden by streamlining workflows and automating routine tasks to enable greater accuracy and efficiency, smarter decision-making, and ultimately, a more agile and responsive supply chain,” Oracle executive vice president of applications development Chris Leone said in a statement.

Why It Matters
Oracle’s AI-driven approach signals a major shift in enterprise automation, directly competing with Microsoft, Google, and other AI leaders. Businesses can now leverage AI agents for smarter decision-making, reduced manual tasks, and faster operations.

4. Cisco launches Webex AI Agent and AI Agent Studio

Cisco has launched new AI solutions for the Webex Contact Center, including the Webex AI Agent and AI Agent Studio, designed to improve customer service efficiency. These tools enable automated self-service, faster issue resolution, and personalized support, enhancing customer satisfaction while reducing wait times. The Cisco AI Assistant further supports agents by providing contextual summaries and response suggestions to streamline their workflows.

AI for Self-Service & Agent Support

• The Webex AI Agent offers immediate self-service to customers.

• AI Agent Studio enables easy deployment for businesses.

• Cisco AI Assistant supports agents with contextual summaries and response suggestions.

"Customer experience can make or break a brand, and unlike other solutions on the market, the Webex AI Agent solves customer problems instantaneously and will fundamentally transform the experiences we have all reluctantly been using for far too long," said Jeetu Patel, Executive Vice President and Chief Product Officer, Cisco.

Why It Matters
These AI innovations aim to transform contact center workflows, reduce operational costs, and enhance customer satisfaction.

5. SAP's AI agent : Joule Collaborative AI Agents

SAP's AI agents, integrated into their AI copilot Joule, are designed to enhance cross-functional collaboration and automate complex workflows across various business functions, including supply chain, procurement, and finance. These agents autonomously perform multi-step tasks, enabling teams to focus on strategic initiatives

Key Features of SAP's AI Agents:

• Collaborative Functionality: Joule's AI agents work together across different business areas to achieve common objectives, effectively breaking down organizational silos.

• Autonomous Workflow Execution: These agents can autonomously execute multi-step business workflows, handling tasks such as planning, reasoning, and action-taking without explicit programming.

• Integration with SAP Applications: Leveraging SAP's extensive data and business process expertise, these agents are deeply integrated with SAP applications, ensuring seamless operation within existing enterprise systems.

By automating complex workflows and fostering collaboration across business functions, SAP's AI agents aim to transform how teams work, driving efficiency and productivity.

As AI agents continue to transform industries, we value your perspective. How do you see these advancements impacting your business or daily life? Share your insights and join the conversation by replying to this newsletter.

And that’s a wrap for this edition! Stay tuned for more updates in the next newsletter. Until then, take care and stay curious!

In this tutorial, we'll guide you through creating an AI-Powered Medical History Assistant. This application uses OpenAI's language models to assist healthcare professionals by keeping track of patient histories, generating synthetic data, and facilitating conversations.

We are going to touch base upon the important components of the agent.

Let’s look at the high level block diagram of the Agent First,

The diagram above shows the integration of memory into an AI-driven Medical Assistant system. At the heart of this setup lies Mem0, a powerful memory module connected to a vector database like Qdrant. This allows the system to retrieve relevant patient history, ensuring the AI agent isn't starting from scratch with every query.

By combining this memory with OpenAI's advanced reasoning capabilities, the assistant can deliver highly contextual and accurate insights to doctors. In the sections ahead, we'll dive deeper into how each component—Mem0, vector databases, and GPT models—work together to enhance healthcare workflows.

The tutorial covers:

• Block Diagram

• Login

• Patient data management with unique IDs

• AI-powered chat for medical assistance

• Sidebar interactions for patient profiles

• Generating synthetic patient data

• Running the application

By the end, you'll have a fully functional application!

Prerequisites

Before starting, ensure you have the following installed:

1. Python 3.8+ - For coding

2. Streamlit - For UI

3. OpenAI Python SDK - For calling OpenAI model

4. Qdrant or another vector database - For storing memories

5. Mem0 - For Memory layer

6. .env file - For environment variables (e.g., API keys)

Install requirements from requirements.txt

Step 1: Setting Up the Application

1. User Authentication

Let’s start with security—it’s like having a locked door for your app. A simple login system (admin/admin) helps keep things accessible but private. This is just the basics—you can jazz it up later with database-backed authentication to keep things super secure. Plus, it helps the app remember who’s logged in and provides a personalized touch.

Key Functions:

• login(): Handles login, validates credentials, and manages session state.

2. App Setup and Main Dashboard

Think of this as laying the foundation for your house. Streamlit helps us create a clean and friendly interface where doctors can interact seamlessly with the assistant. You’ll set up the app title, add descriptions, and make everything look inviting. It’s all about the first impression, right?

Below code is just for the header of the our AI Agent in streamlit App

Step 2: Integrating AI and Memory

Here’s where the magic happens. The MedicalHistoryAgent is like the brain of the assistant. It connects to OpenAI’s GPT model for intelligent responses and uses Qdrant for memory storage.

More steps on how to setup Qdrant locally : Setup qdrant locally

2.1 Configuring Memory

2.1.1 Why Memory Matters Here

• Context Awareness: By accessing past patient data, the AI can give better and more personalized responses.

• Efficiency: Doctors don't need to re-enter or recall past patient information manually.

• Accuracy: Combining historical records with GPT's reasoning improves the relevance and quality of the output.

• Scalability: Using vector databases ensures the system can handle a large number of patient records efficiently.

2.1.2 A key feature of this setup is the Mem0 memory system:

• The AI Agent interacts with Mem0 to fetch relevant patient memory.

• Mem0 uses a Vector Database (like Qdrant) to store and retrieve memory efficiently. Vector DBs are great for handling unstructured data like patient notes, conversations, or summaries, and performing similarity searches.

• Relevant patient data (e.g., medical history, past queries, or previous results) is retrieved to enhance the AI Agent’s response.

Consider this as if you have discussed something with agent and it remembers for rest of its life.

2.2 Validating Patient IDs

To make sure we use a consistent format for patient IDs, such as PAT-XXXXX. we have added below logic where we would do a pattern matching based on the regex highlighted in below image.

Step 3: Adding Patient Data and Generating Synthetic Data

This step is optional and you can skip if you only want to work with AI Assistant.

3.1 Generating Synthetic Patient Profiles

Before working with real patient data, you need a sandbox to test things out. That’s where synthetic data comes in. Using OpenAI LLM model, you can create realistic mock profiles with medical histories, medications, and allergies. It’s like having a crash-test dummy for your app—safe, reliable, and super helpful for refining the experience.

Step 4: Building the Sidebar

The sidebar is the app’s control panel, where all the action begins. Doctors can input patient IDs, validate them, or generate synthetic data at the click of a button. Using Streamlit’s session state keeps the app interactive, so the sidebar updates dynamically as users interact.

When you click "View Patient Profile", the system quickly pulls up that user's memories from the database, checking if they're already in the system. This helps us provide a personalized experience by accessing their previous interactions and profile details.

Here is code for the same,

Step 5: Interactive Chat Interface

Now, for the part where the assistant really shines—the chat interface. This is where doctors can ask about patient histories, and the assistant responds intelligently and on point.

With GPT handling the heavy lifting, the replies are tailored, context-aware, and quick. It’s like having a virtual assistant who never takes a coffee break.

What is happening in background?

When a user submits a query to our AI Assistant, we first retrieve relevant memories and then create a comprehensive prompt that combines these memories with the system prompt. This approach enhances the AI's accuracy in responding to the user and helps maintain a contextually relevant conversation. That's why we request the user's ID when initiating the interaction.

Step 6: Running the App

Finally, the big moment—running the app! The main execution block (if __name__ == "__main__":) makes everything tick. From initializing the assistant to handling the sidebar and chat features, it ensures the app flows smoothly from start to finish.

Since we are using the streamlit as UI, Just hit below command

streamlit run main.py

and you’re good to go. You should see the screen like below,

Here is my git repo where all code can be found - github link

In case you prefer a video of the above explanation, go through my video below. Don’t forget to hit the like button and subscribe if you find the video useful—your support helps me create more valuable content like this!

And that’s a wrap for this edition! Stay tuned for more updates in the next newsletter. Until then, take care and stay curious!

What is Uber?

Uber Technologies, Inc. is an American multinational transportation company that provides ride-hailing services, courier services, food delivery, and freight transport.It is headquartered in San Francisco, California, and operates in approximately 70 countries and 10,500 cities worldwide. It is the largest ridesharing company worldwide with over 150 million monthly active users and 6 million active drivers and couriers.

The Big Picture

Imagine asking your database questions in plain English and getting instant answers.

That's exactly what Uber achieved with QueryGPT, turning a 10-minute database query process into a 3-minute conversation. Here's how they did it, and why it matters for your business.

The Challenge: When Data Becomes a Bottleneck

Every month, Uber processes a staggering 1.2 million database queries. That's 1.2 million times someone needs to:

• Hunt through complex data dictionaries

• Figure out which tables contain the right information

• Write precise SQL code

• Hope they got it right the first time

For non-technical teams, this was like trying to find a book in a massive library where all the titles are in a different language. Operations teams, responsible for 36% of these queries, were particularly affected.

The Game-Changing Solution

Enter QueryGPT, born during Uber's Generative AI Hackdays in May 2023. Think of it as a universal translator between human questions and database language.

How It Works (In Plain English)

1. Ask Naturally: Users type questions like "How many rides happened in Seattle yesterday?"

2. Smart Understanding: The system figures out exactly what data you need

3. Automatic Translation: It converts your question into a perfect database query

4. Quick Results: Get your answer in about 3 minutes

Below is diagram on high level,

The Secret Sauce: Three Smart Agents

1. The Intent Agent: Like a skilled librarian who knows exactly which section has your book

2. The Table Agent: Picks the right data tables, like choosing the right ingredients for a recipe

   

3. The Column Agent: Removes unnecessary information, keeping only what matters.

Smart Features

• Custom workspaces for different departments

• Intelligent table selection

• Automatic query optimization

• Real-time validation

Let’s talk about Results

• Speed: From 10 minutes to 3 minutes per query

• Adoption: 300 daily active users

• Satisfaction: 78% report getting more done

• Scale: Handles queries across multiple business domains

Why This Matters for Business

• Time Savings: Imagine cutting any data-related task by 70%

• Democratized Data: Everyone can access insights, not just technical experts

• Better Decisions: Faster access to data means quicker, smarter choices

• Resource Optimization: Technical teams can focus on complex problems

Lessons Learned

1. Start Small, Think Big: Uber began with a hackathon project and iteratively improved it

2. User First: Focus on making complex tasks simple

3. Validate Early: Include users in the process to ensure accuracy

4. Stay Flexible: Build systems that can grow with your needs

   ---

Ready to Transform Your Data Access?

Here's how to get started:

1. Assess: Map out your current data access bottlenecks

2. Start Small: Begin with a specific department or use case

3. Iterate: Gather feedback and improve continuously

4. Scale: Expand to more teams as you prove success

Call to Action

• For Business Leaders: Ready to transform how your team uses data? Start by identifying your biggest data bottlenecks.

• For Tech Teams: Want to build something similar? Begin with a small proof of concept in your highest-impact area.

• For Everyone: Share this story with someone who's struggling with data access - they'll thank you later.

Remember: The future of data access isn't about writing better queries - it's about asking better questions.

And that’s a wrap for this edition! Stay tuned for more updates in the next newsletter. Until then, take care and stay curious!

Read the article in detail - Uber Case Study

Note : Please note that the savings calculation is based on some assumptions. We derived this estimate using data from the article, including Uber's processing of 1.2 million queries per month and saving 7 minutes per query. The value is calculated using the average hourly rate of a data engineer at Uber, estimated at $72.12 per hour, based on an annual salary of $150,000. Uber has not officially declared this savings figure.

"2025 is the year of AI Agents" yes, you read it right, This forecast comes from one of the most influential figures in the AI industry, NVIDIA CEO - Jensen Huang.

Let’s look at our top 5 updates of the week.

1. Google Brings AI Agents to the Enterprise Space

Google has just rolled out a new platform called Agentspace, designed to boost productivity in the enterprise world. With its advanced AI capabilities, Agentspace combines the power of Gemini’s reasoning, Google’s search expertise, and enterprise data access. This means employees can get more done with just one prompt, whether it’s synthesizing information or handling complex tasks.

It also introduces NotebookLM Plus, which lets users engage with data and get audio summaries. Plus, there’s a company-branded search agent that not only helps users find what they need but also offers proactive suggestions. By connecting structured and unstructured data across different apps, it’s all about improving workflows and making better decisions faster.

2. NVIDIA Announces BluePrints to Help Build AI Agents for Businesses

NVIDIA is making it easier for developers to create custom AI applications with its new Blueprints. These are pre-built workflows that help create AI Agents for enterprise use. The goal? To help businesses analyze data, extract insights, and take actions using AI. These Agents can work with all sorts of data—documents, images, videos, you name it.

Working with CrewAI, NVIDIA has designed these Blueprints to fit perfectly with its AI Enterprise software platform, including tools like NVIDIA NeMo and NIM microservices. They’ve even developed some in-house, like a Blueprint to turn PDFs into podcasts and another for video search and summarization.

And, if you’re into digital twins, NVIDIA also has four Omniverse Blueprints for physical AI Agents to create “simulation-ready” models. All of these Blueprints are available as NVIDIA Launchables, so developers can jump right into pre-configured environments and get started.

3. ServiceNow Integrates AI into Enterprise Workflows

ServiceNow is going all-in on AI to supercharge its workflow automation tools. The goal is to make it easier for businesses to automate complex tasks, speed up decision-making, and improve scalability. By weaving AI into their platform, ServiceNow is positioning itself as a key player in AI-driven business transformations, helping organizations get more efficient and productive.

4. Tech Mahindra Launches agentX Suite

Tech Mahindra is rolling out the agentX suite, a new generative AI-powered solution for enterprise operations. With agentX, businesses can automate routine processes, optimize workflows, and create better user experiences.

It’s all about helping companies rethink how they operate and become more agile with the help of generative AI.

5.Deloitte’s latest study reveals that AI agents are surpassing generative AI

Deloitte’s recent study shows that AI agents are outperforming traditional generative AI when it comes to managing complex tasks, boosting productivity, and delivering better results for enterprises.

The findings emphasize the growing role of AI agents as a critical tool for businesses looking to stay competitive in today’s fast-moving tech landscape.

And that’s a wrap for this edition! Stay tuned for more updates in the next newsletter. Until then, take care and stay curious!