Leveraging AI

210 | Your Next Hire Is an AI Agent: Building Agent Teams That Actually Work with Jake George

• Isar Meitis, Jake George • Season 1 • Episode 210

Share episode

👉 Learn more about the AI Business Transformation Course starting August 11 — spots are limited - http://multiplai.ai/ai-course/

Are AI agents just overhyped chatbots — or the future of business operations?

With every platform from Salesforce to ChatGPT touting “agents,” it’s easy to get lost in the jargon. But building agents that actually work — ones that can execute tasks, coordinate like a real team, and drive real ROI — is a different story.

In this episode, we cut through the noise. You’ll discover how to build orchestrated AI agent systems that not only think and act, but also talk to each other like a high-performing business team.

Our guest, Jake George — founder of Agentic Brain — brings his rare blend of COO-level business ops insight and cutting-edge AI development to walk us through exactly how he designs and deploys AI agents that make a measurable impact.

In this session, you’ll discover:

  • The key differences between a traditional LLM and a true AI agent (and why most tools misuse the term)
  • What agent orchestration actually means — and why you need it to scale your AI strategy
  • How Jake builds multi-agent systems using Slack and N8N to automate real-world business workflows
  • The anatomy of a powerful agent prompt — from roles and rules to tool descriptions and strategic reasoning
  • Why “your AI is your intern” is the smartest way to think about performance and iteration
  • How to balance autonomy vs. structure when designing AI workflows
  • What business leaders must know before hiring an AI agency or building agents in-house

Jake George is the founder of Agentic Brain, a custom AI solutions agency focused on developing real-world AI agent systems for businesses. With a background as a COO, Jake blends strategic business thinking with hands-on AI expertise to create agent teams that act more like high-functioning departments than clunky bots.

About Leveraging AI

If you’ve enjoyed or benefited from some of the insights of this episode, leave us a five-star review on your favorite podcast platform, and let us know what you learned, found helpful, or liked most about this show!

Isar Meitis:

Hello, and welcome to another episode of the Leveraging AI Podcast, the podcast that shares practical, ethical ways to leverage AI to improve efficiency, grow your business, and advance your career. This is Isar Metis, your host, and probably the biggest buzzword of AI in 2025 is AI agents. It feel like agents are taking over everything in the AI conversation. Multiple platforms are now allowing you to develop AI agents. Salesforce is focusing now on Agent Force and even Chachi PT just released their agent tool. And so multiple platforms, multiple people, everybody's talking about AI agents, but the reality is that most people don't even understand what the hell's the difference between agents and traditional large language models, how they work, how to differentiate them from other stuff that's happening. And to be fair, it's not easy because everybody calls everything agents, even when it isn't, because it's a big buzzword and everybody wants to say that, that their tool includes agents. What are agents and how can you build them is exactly what we're going to focus on in this episode. So we are going to demystify this whole concept for you. We're gonna talk about what agents are and what they're not and how you can actually build them. But more importantly, how you can build several different agents that talk to one another in a similar way that a team works in your company. So an orchestration of several agents that can achieve, actually perform business goals and do specific business tasks. And do it consistently and effectively, which is what everybody wants. And so if that's not exciting to you, I'm not sure what will, but it's definitely really exciting to me. Now, our guest today in his early career was a COO of a company, which means he has a deep and solid understanding of business operations. And in this past year, he founded Agentic Brain, which is an AI solution agency that's focusing on developing custom AI solutions for companies, a lot of it surrounding agents. So he has this unique combination of understanding business processes together with his personal technical skills, together with the things he's developing for his clients, which makes him understand what actually is needed in a business, makes him the perfect person to walk us through this process. So I'm personally, truly excited and humbled to welcome Jake to the show. Jake, welcome to leveraging ai.

Jake George:

Hey Isar, thanks for having me. And yeah, great, great intro there. And I think that you, you know, are already touched on a lot of like very important points of like, you know, understanding the difference between just typical LLMs and agents. And there's, it's definitely a huge buzzword and a lot of people will sort of like use them interchangeably. Like to them everything is an agent and then it's like when you actually look at it, it's really not. And then there's also a lot of, you know, sort of like a strategy and architecture and building effective agents, which is what a lot of people like. Yes, anyone can go and, you know, like. Build an agent. There's tons of like really cool workflow builders and to be honest, like just using standard like the latest, you know, LLMs behind the scenes, they do, they are quite smart even on just on a base level. But really there's like a lot of skill and strategy that goes into like actually making them effective and then actually making them, like you said, consistently handle, uh, large or complex tasks, which is, you know, really what I wanna get into today. Because that's something that, when you, when you see people, they build something for like YouTube, it's like very simple, easy to explain. It's like a 15 minute build. And I mean, that's great for people that are just getting started and learning, you know, at a base level. But a lot of times, you know, people kinda like will hype that up and be like, oh you know this, you can sell this for$10,000 to a company. I built it in 20 minutes. And that's just completely, it's just not true. You know, it's like something you build in 10 minutes is typically not gonna be that effective. It's a great starting point, but there's so much more that goes into it. So I'm super excited to share.

Isar Meitis:

I'm, I'm really excited myself. I say one thing, I literally just came back from lunch with a good friend of mine. He's a technical person, very knowledgeable person, and he told me, you know, he knows obviously what I do. And he said, well, you know, I think this whole thing is hyped. I try different things and yes, I can see the demo and I can see how it's cool, but when I actually try to make it to do the work day to day consistently, it just doesn't work. And I'm like, you're right. If you don't really know what you're doing and you don't invest the time to learn this deeply and troubleshoot it and build it properly or have somebody else do it for you, that's perfectly fine as well. But don't expect magic like you can do magic. Demos with AI doing magic work just doesn't happen. And it requires, it's still highly efficient, but it's not gonna happen in five or 10 minutes. It's gonna happen in two or three days or sometimes a week, but then you're gonna have a solution that you can use every single day in your business consistently moving forward. And so let's, let's dive right in. Let's start with what the hell are agents and what are the differences between an agent in a large language model?

Jake George:

Sure. Yeah, great question. And in a nutshell, it's like, um, very, very basic nutshell. Uh, an LLM is sort of like a question answer, um, sort of AI model. Um, it's think back to the old days of chat GBT before it had tools because, excuse me, given. Now, as you said, uh, ChatGPT is becoming quite agentic. They actually have agent mode. It just by default will search the web run code, whatever. So it's like, technically that is an agent because an agent would be like an LLM that can call tools at the very most basic form. So a lot of times why people will confuse them, it's like they have an AI tool. And so what it does is it's essentially a workflow that maybe it helps you write, like let's say marketing copy or something like that. And so you write, Hey, this is my company. I want an email that says this, this, and that. You click run and they say, oh, our agent writes it for you. It's not an agent, it's just you're putting an LLM on a step in there that takes the input, it mixes it with their system prompt and then gives you some sort of hopefully desirable output. But it's not actually like thinking, planning between tool calls, reasoning, you know, it doesn't have memory. You know, there's, there's a lot of, uh, aspects as I'll go into that go into an agent. But at its core, it's just an LLM that can use tools intelligently, and that's what makes it agentic.

Isar Meitis:

Awesome. So I, I will try to summarize, because you touched on a few very important points that are the biggest differences. One, it thinks on its own right? An agent is not a step-by-step process that you define, but it can decide how to address a problem, right? So it has its own thinking ability. Uh, you give it a goal and then it figures out the steps on how to get there in the most effective way. So this is one. Two, it can use tools so it can decide when to search, when to do deep research, when to write code, when to, uh, summarize things, when to do math. Like it can decide on the different things that needs to do, and you can give it. Access to different tools. And tools can be software that you have in your company, which leads to the third thing. It can use memory, it can use its own memory to remember things through the process. And it can use, I'll call it third party memory, meaning it can pull data from other sources. It can pull data from your CRM, it can pull data from your, uh, ERP system. It can pull data from a spreadsheet, like whatever it is that you wanted to pull data from. And then you can use its own memory and make sense in all of that. and the last thing that I will say is that a large language model is a flat one level thing, and an agent environment can be a multi-layer with an orchestrator and multi-level of tools, which doesn't happen in a large language model. So these are the, like, the key, main things that you touched on, on one word here, one word there. but really, let's dive in. Let's start looking at the actual thing and, and I think looking through an example and then diving in on how it's built or probably is gonna be, uh, very helpful for everybody to underst.

Jake George:

Absolutely. Yeah. Let me just pull it up and share my screen here. gimme one

Isar Meitis:

second. Now we are going to show you how to do this in a tool called N eight N. So the letter n, the number eight, and then letter N, again, it's a tool that really took off completely in the last year and a half, but it's in its essence, in its original essence. It is very similar to Zapier and make, it's a process automation tool. It's just open source. Uh, and it's really flexible because of that. But about, I don't know, a year ago, a little less, probably nine months, they, they, they gave the option to build agents within there, which made it extremely powerful and hence, uh, drove the attractiveness on this tool to a lot of people. I'll say one thing, it's a little more technical than learning how to use make, but once you master that, the options are literally endless. So it's probably worth a steeper learning curve.

Jake George:

Absolutely. And that's one of the reasons that we love it. You can get very technical with it, and we've yet to find a problem, an agent that we haven't been able to use to, uh, and any to end to use to solve that problem. So it, you can really get very deep with it. Um, let me know if you can see my screen here. I can. So this, just to give you kind of like the broad overview of what we'll be looking at, we call this one, we built this for an insurance client that we have, and they wanted, essentially they call it like the CEO agent, but more of like, let's say like ex executive, assistant agent, um, to handle a lot of backend tasks. So we're not going to get into all of them because like I was saying, that could make this like six to eight hours. Um, but we will get into some of the basic ones here. So at the top we have the level one, uh, manager agent. So. This is kinda like the architecture of like how we will build agents behind the scene. So to the client, they just think, they just, I mean, they know it's a team of agents, but they just really interact with one agent for the most part. But that agent has these sub-agents that can go and perform tasks, and underneath the sub-agents we have tools and workflows. So that's really how we will start off. And it's a good way to go about it. Just sort of like building from the ground up rather than building everything from a high level to begin with if it doesn't need to be. Because another, uh, large misconception is that everyone thinks that like everything should be solved by agents. And so they, you know. Try to sometimes like cut corners and then they'll be like, okay, here's the agent, here's the tool. Okay, now, um, do all of my work for me every day. And like you were saying about your friend, it's like, it just doesn't usually end up being quite effective. So it's like you need to build some, a lot of things are better solved by workflows and maybe workflows with, uh, LLM steps in them. And there's nothing wrong with that. And there are also some, something that's just like. It won't always consistently do, uh, the task correctly that you want it to when you just slap an agent on it. So we always start with the tools, like let's build the tool and the workflow, and if it should be a workflow, we'll build a workflow to solve this part of what they want done. And then we give those different workflows and tools to a subagent. So then for example, you know, we find it best that it's like each subagent focuses on one area of what they want done. So this one, for example, manages their CRM. And then we have one over here that is sort of like the email manager agent. So these are very specific areas that they're focusing on. And under each of these, they have like the email writing, uh, agent, these are more of like workflows. Um. But they'll have like tools and workflows within here. But sometimes the workflow will also have agentic parts. So there's like many different levels to it. But essentially, so the, then we let the CEO agent or the manager agent really focus on like overseeing the task. It knows what all the other agents do, and it doesn't really focus on actually executing actions itself. It's more of like, okay, which agents do I tell to do which parts in which order? And then based on what they return to it, then it decides the next steps. So that's from like a, high level how this whole system works. I'll pause you just for one

Isar Meitis:

second because you touched on a few very important things. One, those of you are not watching the screen. I'm gonna tell you what's on the screen at any given point. This is just a static flow chart. This wasn't the actual agent tool. And so when you come to design these things, you gotta think about, okay, what does it need to do? What does it need to achieve? What tools that need the access to? And you first of all, design the architecture before you start creating the actual tool. Number two is. There's this really important difference that we touched on earlier, but now kinda like reading between the lines with what Jake was saying is important to understand. A workflow is a step-by-step process that you define. Versus an agent that has a level of autonomy and there's pros and cons in each and every one of these approaches. A step-by-step process is awesome if it's exactly the same step-by-step process every single time. And so whenever you need one of those things, you can build a process as a tool that the agent can use. And then when it gets into that situation, it will follow the same exact thing every single time, which is important when you need flexibility, meaning you needed to think, you needed to be more creative, you needed to figure out what to do next, then an agent is more effective. And learning how to mix and match these is what drives what we started with when I did the introduction. Effective consistent results, which without it, you can't actually use it. And so this is a great introduction. So let's dive into the actual tool itself.

Jake George:

Yeah, absolutely. That's a, a great recap there. And that's that's the reason why sometimes you wanna use workflows.'cause if you think about it as a company, there's processes that you always want done the same way. You don't want someone to guess every single time on how to do it. But then there's sometimes that you want those processes done in a more dynamic way. You might want someone to write me an email. You might want them to go check your CRM and see what leads haven't been talked to in the past three months and have a policy renewal within a month. And then go and pull all their past conversations and call recordings and then write a contextual based email follow up to them. A lot more complex. But at its core, there are, you know, I think a lot of times people will use AI because it's like they don't want to think or they don't wanna decide and they want the AI to figure it out for them. And that's just the wrong way to go about it. Like, you don't want AI making all the decisions, you leave it too broad and typically you see those unfavorable outcomes. So it's best to have some things that are like hard coded, you might say, of just like this process. We always want it done the same way. But you can call these different processes done in the same way, in a dynamic way to achieve different outcomes and goals. So, um, perfect. Yeah. great. Um, recap there. Um, let me see. Sorry, I can't see which screen I'm sharing here. I gotta, I see a list

Isar Meitis:

of agents in any 10 or a list of workflows. Okay.

Jake George:

So you are seeing NAN Okay, cool. So we'll switch automatically, sorry. Now the screen won't go away. There we go. Okay, so let's start with the main, um, manager agent here, and I can kind of like break it down of how this works. So, this is already, I mean, this is just like the base level of the agent that calls the other agents. And you can see it's, um, a little bit more complex than what you'd usually see on YouTube, which would usually just be like this part and then a few tools. Um, and so the reason for that is that there's a lot of, typically with any like real world deliverable, there's gonna be like. A lot of these sort of like data processing and cleaning up steps and just making it like function properly to get the input and output, in there correctly. Um, so that's what a lot of these are. We use mainly for communications with agents. We do all of that through Slack. It's a great platform to use it on. Obviously Salesforce is using that for their agent force and it just, it works very well. There's a lot that you can do with it and it makes for a great user experience. And then also notion for any sort of like dashboard, uh, user facing database, uh. Parts of the agent, uh, it allows them to easily like, update things that they might wanna change and sort of see like, you know, any output logs they might wanna see, so on and so forth. So what we do is we start off with, the user. We just essentially message through Slack. Uh, we just filter it out to make sure it's, you know, that user's message. Um, we get their user data. And then for this one, because this agent will sometimes have what we call like long running tasks that may take multiple minutes to accomplish, we have it just send a response right away just saying like, Hey, I got your message and you know, let me process a task and get back with you. And this is again, something that you might not think about until you have someone using it. But it's just like, if the task might take three minutes, people are, and they don't get a response back before that three minutes. People are just gonna keep spamming it and sending all these requests and then in three minutes they get like, and they're like, oh goodness. And it does the task like 18 times. uh, we just do a little bit, you know, sort of like notify them. Hey, got your message. Right here what we're doing is we're looking for any files. So you can see like JPEGs, PNGs, uh, and then just the regular text from the Slack message CSVs. So what we do with that is if the user sends any message, because they will sometimes use this for, um, adding like leads to their cm. So they might snap a picture of a business card and then we just have it, you know, get the image used, OpenAI to sort of like pull whatever the image is and then turn that into a normal text, which we can then pass to the CEO agent. and then this part we're kind of, it has a lot of different inputs here. so this is for, this one is specifically for long running tasks. So what we're, and we're still building this as well, we've, you know, been working on this agent maybe like three or four months for this client. And they're, you know, looking long term with ai. So like we're always adding things onto it. So. Because of that. Sometimes it'll have these, we call, like I was saying, the long running tasks. So what it does is it essentially says, okay, it will output at its first turn and say like, Hey, this is gonna be a long running task. And it actually will then message the user back right here and just say, Hey, this is gonna be a long task. I'll get back to you when it's done. And then it re-triggers itself with the task so it can message and then go and complete the task so the user kinda can understand it, will actually tell it the steps. It'll like, Hey, this is a long task. Here are the 10 steps that I have to do to complete this. This might take a few minutes and it will trigger itself. So that's what this is right here. It's essentially so the agent can re-trigger itself. This one right here is from our reminder workflow. This is super important and pretty much every client wants this. It's another thing a lot of people don't consider that it's like. AI agents are not like alive perceiving time like you and I. It doesn't just sit here all day waiting for something to do. It activates when it's triggered. So if you just go specifically to an LLM and just say, Hey, remind me in two days to do this sort of thing, it will say, okay, but it will not do that. It'll just say, yeah, sure, I'll do that. But it doesn't have any perception of time after that. It doesn't know when two days has passed. So what we created, um, and this is we, this is one that we put in, almost every, agent for a client because they will pretty much always want it, is it can actually set reminders for itself. So it says when it should be due and what the actual task is. So when it, uh, becomes due, it will actually go through this workflow and trigger itself and say, Hey, you set a reminder for this time to do this action. Go ahead and do it now. It's the right time to do it. Um, super important there. Um, this one comes from their Zoho. And so what the, because it's insurance. They wanna know when clients are coming up on their, uh, 30, 60, and 90 days from their policy renewal. Because that's really when there's the sort of like sales cycle will kind of like restart for that client. They wanna go find them better deals and they wanna keep in touch with that client to ensure that they will renew with them. Uh, so it's super important. Zoho has its own, like internal, as most CRMs do, like triggers and timers and workflows and stuff like that. However, they're workflows I really don't like, and they're hard to use, but, um, they, we can have it trigger there. So then essentially that triggers the agent as well. So these are sort of like external triggers that aren't direct messages from the user, but they are important for the agent to receive and then take action upon those. Then for the outputs, this is another thing is, you know, when you're using ai, it pretty, like, if you send it a message, it messages you back. Um, and we don't always want that, especially if it's something where it's like a background task. We don't want it to necessarily send a message. Sometimes we just want it to take an action. Like if it's 30 days from a policy renewal, we want it to get all that client's data and write them an email saying, Hey, we're looking for better policy options for you, but we don't really, you know, we want then the email agent to message us of like, Hey, this is the email, here's the email I'm going to send. So we give it the option to actually continue with, um, no response here. If it's like a sort of background task. That's another thing is that some agents, you know, will only act like when you ask them to do something. And, or some they can also operate just in the background as well, but we don't want it to necessarily message the client every background operation it does because it just gets annoying and spammy and they'll see the action is completed. They don't need to see it and be told. Um, and then right here, so we already went over the long task so it could say, Hey, this is a long task. And then what we do here is we have it either send or update messages. This is another cool thing that you could do with Slack. And it makes it just like a cleaner user experience. So it will say, Hey, I'm right here. Hey, I'm getting started. I got your message. Uh, let me get started on the task. And then over here it takes that same message and updates it to just say, Hey, here's the completion of the task, or here's the results that I got back. so I I I

Isar Meitis:

wanna pause you just for one second. yeah.'cause there are. Really three main key components. And we touched on two of them even though it was a very long detailed one. Uh, one of them is inputs, like the agent gets inputs, right? It gets, and in this particular case, you touched on a lot of inputs. Some of it is our inputs that in this case are coming in through Slack. I want you to do 1, 2, 3, 4. Some of them are inputs from different systems such as CRM, some of them are inputs from the output of the agent. And that sounds a little meta, but that's the way it is. Like the agent did something. It's like, oh, uh, this triggers something else. So go and. Put this as another input to the agent. So these are the inputs, the outputs could be anything you want. The output could be a message back to the user. It could be taking action in a system, could be updating another agent, could be many different things. So the output could be either a task or a message or an update of a different platform. And in the middle, which is the part that we're gonna get to right now, is the actual agent itself. Meaning what does the agent do to take the data from the various inputs that it gets and turn it into the outputs that we need. And so let's dive into, I assume I'm, I don't wanna, I'm not trying to lead you here. I assume that's the next step.

Jake George:

Yep. Yeah, no, you're, you're spot on. Yeah. Great recap there. That's, yeah. There, there's a lot of different ways that they can be input to and output. And also, you know, one of the kind of like challenges is sort of like making them think like a human, like having stuff like memory, knowing when to do stuff, setting tasks for themselves because like as humans, that's just like normal, you know? It's like you don't really think about, oh, I'm setting a task for myself to do on Tuesday. You just think on Tuesday I have to. Take my dog to the groom or whatever. so now we can get into this, and you can see this is quite a long and detailed prompt, so I won't, you know, necessarily read, uh, every single word of it. Um, and I can just explain more at a conceptual level. But there's, this is another very important thing that people quite often overlook. Typically, you'll see someone's prompt is like this long, okay? And it's like two sentences and just a very broad, vague description of kind of what they want it to do. And so there's some really important, uh, parts that you should have in your prompt. And this is actually, like, this is all backed up by like, research, by like anthropic, opening eye Google. Like this is just a good way to prompt, an agent. And it makes sense because it's like you wanna write things out clearly and break them up into different sections. So how we do this is we write things in markdown. Uh, we use different delimiters so it can understand the different parts of the prompt because if you just mash everything together and you just write like. Usually we try to avoid sections like these, but I will put it in roll in objectives because this is just like a high level overview of what it's doing, but it's best to, like, we use like bulleted lists and let's see if we have any step by step. Yeah. Like uh, numbered processes as well. So it's like these are all very important. So what we start off with is roll in objectives. So this is kind of like a high level, level overview of like. This is what you typically should be doing. This is the type of actions that you perform. This is why you're doing them. This is the outcome that we want. So very high level overview. Usually people stop at this and think that that's enough and it just is not like AI can do a million things, but it only does exactly what it's told. Like it tries to do exactly what you say. It's like if you're talking to someone and they take everything you say literally, and you're like, oh, that's so annoying. Like, come on, use your skills and infer stuff. Ai, it's getting better at that for sure. But it will still try to do what you say kind of literally. So you have to describe things like you have to be exact, and that's one of the things that we see people are not very good with. Especially when we start with clients. They'll be like, oh, well I just kinda, you know, I want it to like write me marketing emails. You are like, okay, but like, what's your process? Who do they go to? What should they, what should be the content? Where do you get the content? Who writes these? What's your strategy to write them what, you know, the, there's a million little details that go into it, but a lot of times people are not so good at like breaking down and you know, being specific on what they actually want. So from role and objectives, now we have, a subsection under here about the core capabilities. And this is sort of like, this is how it does the task delegation. It leads the team of other agents. Uh, one of them is the CRM manager. One of them handles emails. Um, it can also do cross platform research to read emails and CRM data to make decisions, uh, goes into the decision decision making. And then user alignment as well just to kind of say like, Hey, before you do like irreversible actions or like add or update leads or something, check with the user always. This is another thing that is very important to add. We never just let an agent loose into a company on the first go. We always add human in the loop and then a testing period. And we try to make it as transparent as possible, which is why we love using Slack.'cause if they're already in Slack and they say. See that the agent is like, Hey, I'm gonna do this. Hey, I noticed this, so therefore I'm going to do this. And they become more comfortable, uh, to the point where, you know, after a couple months of that, typically, then they'll be like, okay, put the, at least these parts on autopilot. Like, I know it's gonna do those, it always does'em right. You know, I have confidence in it. But that's very important to, let clients know, like, what is actually going on. And yeah, just let them have their input on it as well.'cause it won't always get everything right on the first go.

Isar Meitis:

I wanna pause you just for one second because this iss a very important point. Mm-hmm. The, when you're developing these things, the expectation should be, it is not going to work properly the first time or the second time or the fifth time. Uh, on the 20th time, it's gonna work okay. 90% of the time, which for some of the tasks is fine and for some of the tasks it's unacceptable. It just depends what the task is. And the way to solve this is by testing it with live environments, meaning. Letting it run on actual data and then seeing what it actually does. Now to make sure, like Jake said, it's not creating havoc and trashing your best clients, is to put a stop point that lets a human check what they're about to do. And you could do this in Slack. Uh, I'm doing this as well with like tasks. So you can open a task in Notion or in Jira, Asana, click up Monday, whatever, whatever it is that you're using for task management, you can open a task and until the user closes the task or confirms the well, like whatever the thing is that it needs to do until that the, the agent will move forward and that's your way to increase your level of control and understanding of what the agent actually does, then you go and fix it. You do it again, you go fix it, you do it again, uh, like Jake said, until you get to the point like, okay, I don't need to check this thing. It's correct every single time. You're just wasting my time. Uh, the other thing that it does, doing it in Slack or in your task management platform is that it's just another. Person on the team, right? That tells you what they're doing and updating you regularly. And what I tell people all the time is that building an agent, or in general using these models is like having the best intern on the planet. It is going to do exactly what you tell them. However, if you don't give them all the information and you don't explain to them exactly how to do the thing you, you want them to do, don't expect them to do the task properly because they're. Still an intern. And so this is the approach, right? If you're gonna break it down step by step and give them all the information, just we would give a person to do the task. When they don't know anything about the company or you, or the process or the project or the tools or whatever, give them the time, the resources that you would've given a person. They will do the task amazingly well, and they take feedback amazingly well. And so, uh, so let's continue. So I, I, I, sorry, I, I broke you up, but this was a very important point. So you said, uh, if you can scroll up, we started with, uh, a general, kinda like task setup. So that was, you called it roll in objectives, roll in. The second thing was your core capabilities. So these are the things that you can do with a bullet point that describes each and every one of the things. What is the third component?

Jake George:

So then the third component is we have for this one goal, and these are not, I want to go into like, these are not. We don't always start with like, oh, you must have goal, you must have role and objective, so on and so forth. We really, like every prompt is built differently and it should extend based on how complex the task is, and it should be a very iterative process. So it's like sometimes I'll put goal in role and objective. Sometimes that doesn't need to be clarified, but when we're doing something like the manager agent, as you can imagine, has the most extensive prompt and then the subagents are a little bit less, and then the agents within workflows or tools and stuff are even less and more specific. So these are not like hard set things of like. You must have this or the prompt will not work. You really build the prompt around the task in doing it in sort of like an iterative testing phase. And this is what a lot of people get wrong. They use AI for it. And not that AI couldn't write a good prompt, but there's a one specific reason why AI is typically not as good at writing prompts as humans is because it doesn't go and test them. It just says, Hey, here's a whole bunch of fluff. Here's like 18 paragraphs going over everything that it could do. And when you do something like that and you paste it in, you don't really know what's working and what's not working, and you also don't know how to change it because you don't know at what point it started to go off track. So it's really best to start with like just the very basic things, like just give it like a. One sentence roll when you start, and then like a one sentence goal. And then rules. I always just add as it does things wrong. Like that's the reason I add rules unless I know like, this is something that AI always gets wrong, or just some like rule of thumb, best things to add in there. I just add these as it makes mistakes, I write all of my prompts by hand, like I write each word in them. Sometimes when I'm done with it, it might be like maybe a little messy, so I might send it to AI and just say, Hey, format this better for me. But the most I ever put in from AI is maybe like one line. Like let's say I try to explain something that. It's kind of a simple concept, but maybe when I write it out, it comes about this long because you know, when people write, they're just like writing as they think. And I go, can you make this more concise and clear? And then if I read it back, I'm like, that's good. I might paste it in. But what I never do is be like, write this entire section.'cause it's just guessing on what it should do, what might go wrong, what the rules should be. So I highly recommend that, you don't use AI to prompt, especially if you're, you know, if you're like an absolute master at it and you've built your own agent to write prompts, just how you'd write them and so on and so forth. Sure. I'm sure that there are people that are really that good, but it's like I write all but by hand and I recommend people do it too. It's a good thinking exercise and it's a good learning exercise. And if you always use AI to do it, you just won't get better at it. And that's why a lot of people struggle at these sorts of things because they never actually learn. They're just, oh, ai do it for me. They don't know what's good about it, bad about it. Anyways. The next step is rules. And then I break these down into subsections. So again, rules, uh, bulleted list. And a lot of times these are, like I said, they're written because it messes up. And then I say, okay, you know, do this because it's screwed up on that. So that's the reasoning for rules. I break them down into subsections based on like, you know, oh, the workflow, communication emails, how to use tools. I think that there's one. Planning and reflection, um, reasoning strategy as well. So I guess this is under workflow processes. Um, but this is another thing. So then when we have exact processes,'cause the cool thing, um, we were kind of talking about it before. When you have hard set workflows, sometimes you want things always done a certain way. When you use an agent, it's almost like an AI build your own workflow.'cause it has all these tools, depending on which order it's using them. Every time you run it, it can build its own workflow. That's what's really cool and useful about it and makes it more similar to a human. However, there are some times that it's like you wanna tell it, like always do these things in these order. Like don't go and send an email before looking up data about the client, because then you'll have no context on them. You would think that's obvious. It's obvious to a human. It's not obvious to an AI unless you specifically tell it exactly what you wanna do. Also explaining reasoning strategy. Things like plan extensively before each function or tool call, take a moment to outline the steps. Um, and then always like think between using tool steps.'cause sometimes another thing a lot of people don't think about it will just run tool after tool and not really think about the return inputs and try and do all the thinking at the end. You can actually change this by telling it, like think between the tool steps and then make the next decision. Um, these are actually outlined in, uh, in OpenAI. Paper about the 4.1 models because it will follow prompts a little bit more literally than the previous models, which would kind of try to infer more and they, you can actually get a 20% better result when you explain the reasoning steps and use this part here. and then there's another part at the end here just telling it you are an agent. Keep going until the user's query is completely resolved or, uh, before ending your turn and yielding back to the user by using this. And then a reasoning step. Um, and then there's also one other one, which I don't think was, uh, necessary in here about like reviewing data. or it may actually be in tool usage. Um, but using those you'll just naturally get about a 20% better, uh, result from it just by reminding it of these sorts of things. Um, and so it's really interesting'cause a lot of people don't, you know, they wouldn't think deep enough to think I need to explain a reasoning thinking process to get it to think like me and do things like me, but it really significantly improves the result. next we have steps. So this is still under workflow processes, so steps for researching a person, um, CRM and email. So again, we want them to always look in the CRM, we want them to search, want it to search for recent emails. Um, and then we want it to review these. And then see another thing that it does in the background is look for any missing data on that person. And if it can find that missing data, like their, uh, email or their address, or their LinkedIn or something, if it can find it in an email from them, it will actually go in, um, autonomously. Add that to the CRM. Um, then it compiles a summary. So this is also important. a lot of things if, if. You pro, I'm sure that you've heard of it, maybe not a lot of other people have, uh, depending on how much they build agents, but the sort of like context engineering of like, you can't just, there's usually two sides. People give it like a one sentence instruction and it's not very clear or they just dump everything they can possibly imagine into it. And either of those is a great strategy. If you overload its context window, they just naturally like, yes, it might have a million, token context window. That doesn't mean it will process all of that properly. It, AI tends to skip over a lot of parts. So you wanna only give it the really the necessary data. So, uh, when we do, especially in subagents, we kinda have it like summarize, uh, the data and then pass it onwards. It helps preserve its context window. Next we go into the tool section. This is very important to explain. We give in here like a broad overview of what they do, and then it's best for structure to explain more in here, which I don't know if this one, yeah, so this one is pretty good. So this has like a more detailed explanation of how to use the tool, what the tool can do. Sometimes when to use it depending on the tool. Well, I wanna pause just

Isar Meitis:

for one second. For the people who are not watching the screen. Uh Sure. Yep. For each of the agents in every. Tool you use, it doesn't matter which, where they're using NA 10 or something else to build the agent. The agent had a section of the tools it has access to. You're literally connecting a line, uh, and giving it access to different tools. A tool could be A-C-R-M-A tool could be something you build. So a, a process that you build. It's something that the agent can use to achieve the goal that it was given. And so what Jake is showing right now, he's saying that on the high level agent, in the actual prompt of the agent, when it's describing to the agent what it can and cannot do, it's giving it a short description of the tool. Inside the tool itself. There's a much longer description of the tool, which makes. Perfect sense, right? Because you want the, it's, think about it, just like Jake mentioned, think about the CEO. The CEO doesn't necessarily need to know exactly how to do each function in the company. It needs to know the function exists, it needs to know what the function does. It doesn't need to know how to do the thing. But the, uh, the guy that creates the reports from the ERP to the inventory manager needs to know very, very well how to do this. One very specific thing where you're gonna define that tool in much more detail. In this particular case, this could be a Zoho CRM, data query, which is what we're seeing right now. So that part has to be very, very detailed. But on the high level agent, the CEO agent, the orchestrator agent, you just tell it that it has that functionality.

Jake George:

Exactly. Yeah, you summed it up very well. And it, and kind of like a way to think about it in sort of a human level is think if you're given, you, you just, you, you're an intern, you just joined the company. They give you this long list. Here's all the things that you do. Here's the processes. They have it all documented. You're not gonna, every time you go to do a task, read the entire thing and remember each step and whatever you're gonna look for that section, oh, I gotta update the CRM, let me find that section. Okay. I need to use this tool. Let me go read how to use the tool. And that's kind of in a nutshell. AI doesn't think exactly like humans, but kind of like it pays attention to different parts depending on what it's doing. So that's why the structure of the prompt is extremely important and it, it will pay attention to different parts of it, depending on what it's doing. So you wanna break it down granularly and you, yeah, you hit it right, nail right on the head that, you know, you give it a very brief explanation of how the tool works. And then. The prompt. And it's also important to keep the naming the same. So don't call this one like Zoho tool. And then it's just the other one is like CRM managing workflow or something like that. Like I always will name them this sort of way and then reflect the name exactly within the prompt so it knows it, you know, be very specific and exact when you're speaking to an ai. So very high level, low review when you go into the tool makes more sense. Give all the details there because it doesn't necessarily necessarily need all the steps, use it every time. If it's doing an email managing task, it doesn't need to know all the steps that it's, uh, the Zoho, uh, managing agent does in here. Lastly, uh, we have vector stores. So this is if you have, uh, external databases, uh, vector stores, anything like that that I might need to reference, kind of just tell it. We just tell it like this is what's contained in here. And a really cool thing that we've done well, we do for a lot of managing agents, but this one as well, is that it actually has like a shared memory, um, where all the agents will output to a database and super base and they'll kind of like write down like, here's what the input was. Uh, sometimes it's reasoning steps and then the output. So this makes it like a whole unified team because if they each have their own separate memory, they won't always know like. What was actually done. They just know user input, output. That's it. And that's a lot of times not enough context, especially in multi-agent systems. So by giving them like a shared memory, it's like having a group chat. Imagine like if you're trying to coordinate something with your team at work, if it's all one-on-one conversations, no one knows what's going on. If you do it all in the group chat, everyone kind of stays on board and they're like, oh. And if they don't know what's going on, just go and check. So we do that here. you can always, you can also use this as like more of like a, a structured query database rather than like rag. Um, which is, you know, depends on what the use case is, but there's different ways to query this. But that is essentially like the gist behind why we do that.

Isar Meitis:

I'm gonna pause then at the end just for one second. For the people who get diarrhea when they hear the word database or superb base, sorry, store. Uh, so you don't have to worry about it. Like it's, it sounds very technical, but the reality is the tools today became really, really simple. Like literally, if you go to superb base, which is one of the most commonly used tools, uh, in these worlds, uh, it's a database tool and you can set up a new database and give it a name, and that's more or less everything you need to know. And from that moment on, uh, the agent or in this particular case, all the agents can call that database, which is just a storage. It's a container of information where they can all save information to, and you tell them what information to save. So when you take an action, a announce it to the database, when you post something to the CRM, put it in the database, like you tell them what to save. And it's called a vector store because these AI. Databases are built on vector information. So basically it's like a length and a direction, but again, you don't need to know all of that. You just need to know there's a container that saves information and saves data that all the tools have, that all the agents and all the tools have access to, and that's their way to collaborate and have a unified knowledge of what's going on across the different processes.

Jake George:

Absolutely. And there's, in a nutshell, there's two ways that, uh, databases are commonly used for agents and one is just their like chat memory. So like maybe the past 10 things that were said. And then the other one would be the vector database. And usually that's when people say, I trained an AI to do something. Usually what they mean is they uploaded all this information to a vector database and it's just like, imagine having like a user manual for something. You can go in there and look up any data when you want to. So there's like chat memory and then here's all the data that you can look up if you need it. And that's how those two will typically operate and why they're a little bit different there. Um, then at the end here, uh, this is super effective and important. The, uh, AI models will pay attention to the things that they top and bottom the most, and I believe bottom a little bit more than top. Um, so. When you have a very long prompt that it might kind of like skip over things on, it's really good to give it a recap. And again, I do this iteratively of like the things that it might forget or is not doing well, that you're like, it's in the prompt, it's just not doing it. Just restate it at the end because the more times that it appears in the prompt, the more that it will adhere to the instruction. And also if it's at the end, it pays more attention to the end and it just makes it that much more effective. For this one, it follows the instructions very well, largely because they're, you know, well written, well structured and everything. The thing I put at the end is from the open AI paper about, you know, how it's an agent and keep going until the user's task is complete. Um. The AI models, they just understand what agents and agentic frameworks are. And so then it just thinks more like an agent rather than like a, you know, you send me a question, I send you an answer sort of thing. It just makes it perform better. so that in, yeah, that is how this, uh, main agent works here. I can definitely go into, um, maybe a subagent now, or I could even show like, sort of how the outputs look like in a user experience sort of way from Slack.

Isar Meitis:

So I, I we're, we're short on time. I want us to do two things very quickly. Sure. One, let's open just one of the subagent, just as people see what it looks like. And basically, if you think about it, a subagent is kinda like a tool for the main agent, and then you can go as many layers deep as you want, or a process could be a tool for an agent and so on. So you can see now that Jake opened a subagent, it has a lot less stuff. So let's just go over the. Components that this is connected to so people understand. Uh, and then maybe we'll look at one run and see how the output looks like. And I think that's gonna be awesome.

Jake George:

Sure, yeah. For this one. Um, so yeah, it is much simpler and one of the reasons for that is because it's input is just directly, it's just a natural language string from the manager agent. We don't have to worry about processing the data from Slack, having a reply, so on and so forth. Um, so what this one does, we actually use some different, um, MCP servers here. These ones are more of like workflow ones that we had to build, uh, different steps into. These ones are more like direct actions of like getting deals, leads many deals, many leads, accounts and contacts from their, um, CRM. And then it also has, so the, uh, Postgres chat memory here is the database, like I was saying, where it's just the chat memory, like it has, you know, this many messages that happened helps keep it on track a lot more. And then as you can see, for the prompt it's structured. Very much, uh, similarly to the other one. Um, we have like more step-by-step processes in here, explain all the different tools, so on and so forth, um, and how to do, uh, different processes in here. Um, but yeah, this one is mainly focused because it doesn't need to know all the instructions of everything. It's really just focused on like, it's how you complete the queries that will go to you. Here's the tools that you have available, here's how you would use them. Um, also using the think tool is quite useful as well. It's, you know, allows it to kind of have like a sort of like a scratch pad where it can just like put down thoughts and kind of like reason through them. And it just, it helps it think better through a longer or more complex tasks that might take many different steps. so that is, I'll add one

Isar Meitis:

small thing. First of all, great recap of what the subagents do. You touched. For on MCP servers, MCP servers are the ultimate AI connectors, and they basically are built either by the companies themselves or by third parties, and they're exposing the functionality of a tool. In this particular case, Zoho, but this could have been Salesforce, ERP email platforms, knowledge graphs, social media network, like whatever has an API that connects to it. It exposes it to an AI in a very, very simple way. So instead of having to develop APIs for weeks with a team of 10 people, you write four to 10 lines of code and you have access to everything that the tool has to offer. So when, uh, Jake is saying, I connected MCP servers to provide me information or take actions in Zoho, what he means is that they've connected specific functionality from that. Into this agent, which again, sounds really, really complicated, but it's a lot easier than you think because that's what MCP does. It makes it very easily accessible. And then in simple English, you can tell the agent, Hey, I need you to go and do this. And it knows how to go and grab that function from the MCP and then it knows how to call in this particular particular case, Zoho and say, Hey, I need to know all the new leads that came in in the last 24 hours. And then it just works without you having to figure out what's actually happening in the backend.

Jake George:

Yeah. it makes it, it makes these things very quick and easy to develop too. You just simply go, you make your MCP server, you throw all the tools in it, and it yeah, makes it very easy to, uh, spin these things up very quickly. one more I can show sort of like a demonstration. See, let's see how this

Isar Meitis:

looks like on the Slack channel. Uh, yeah. So people understand what the output looks like after all this, uh, detailed work. Let

Jake George:

me go into here. Okay. Slack. Okay. Do you see Slack now? Yes. So. What we have here, this is kind of like the, uh, this is another one that we're working on, but this is kind of like a manager agent here, uh, that has a whole bunch of different subagents. Uh, Joe named it Jarvis for this one. Um, but these are sort of like the functions of how the different agents would interact, uh, with the user. For example, he says, Hey, can you look for information on himself? So it's going to go ahead and look through the CRM. It says, Hey, here's the CRM summary. I also look for all the emails from, uh, him as well, and then ask the user what they would like it to do next. So for sometimes we use structured. Another really cool thing that you can do is use slack blocks, which I'll give a visual demonstration of in a second. A lot of times some agents we use like unstructured texts like this because it can be so dynamic. But other ones that are focused on a very specific task, uh, this one for example. So this one is the email managing agent, which is under the subagent. So again, like I was saying, sometimes if it just like, Hey, I know that I should write an email to this person, we don't need. Jarvis to tell us, and then the email agent to tell us, it's just duplicate. So then Jarvis would choose, Hey, email, uh, agent has it, I don't need to respond. Um, then the email agent would send this. So it's just like, Hey, um, this is the email that came in and then here's the new one that I'm going to send based on that. So then we have it referencing past emails so it knows exactly how to write those, knows what's going on. And then to make it very easy, because it's like you can have sometimes to keep it better on track, especially for clients because it's like in your mind you might know exactly all the 8,000 things that this agent does, but a client does not. So sometimes it just makes it easier to just like, these are your four options, and just give them some buttons because it's like they either want to send it, draft it, uh, to be rewritten or just decline it in general. So it's very useful to kind of just give them those direct options. Yeah, for you can do this using Slack box. When

Isar Meitis:

you do this, you build, and again, now we're getting way too technical, but you build a Slack tool that has these functions that then connects in the backend to the functions in the AI agents. So that's how these two universes interact. Jake, this was fantastic. very detailed and I wanna do a very quick recap and then I want to let people know where they can find you. So. Agents are awesome, especially when you're combine them with structured processes and the right data sources and the right tools, and that's the way to actually make them work. And what Jake showed you literally openly, which is incredible because it's work he actually does for his clients, is how to think about it. So how to create the architecture, how to build the layers of the different things, what kind of tools you need to think about how to connect them, and what are the actual prompt structures of a master agent and then the sub smaller. Tools level or specific operations level agents. and then we showed you a very quick example on how that can work while connecting it into Slack as the way to communicate, as the, if you want, the front end, the user interface for these agents. So the users don't need to know any of this. The end user just sees a Slack channel and they talk to the Slack just like it's a person and they can, uh, communicate back and forth. So again, incredible, incredible work. This is extremely helpful for people. Uh, by the way, I don't expect anybody after listening to this podcast to be, uh, an agent Ninja, but it gives you a very good idea of what it takes to actually develop an agent. And then you can call somebody like Jake to actually build it for you, but you will have a much easier work of explaining what you actually need, which is a big, uh, important part. So, Jake, if people wanna learn more about your work, uh, work with you, follow you, see your content, what are the best ways to do that?

Jake George:

Yeah, so definitely I can connect with me on my LinkedIn. Hopefully you can just drop a link in the description or you can just search for me by name and then also at my website, which is just ag agentic brain.com, which is spelled right here.

Isar Meitis:

Awesome. Really, really great. I really appreciate you, appreciate what you're doing, appreciate the content you're sharing, uh, and keep on doing the hard work. And for everybody listening, if you wanna learn more about agents, we have several other episodes on several other platforms that are not NA 10, so they can broaden your horizons, but they all follow the same exact concept that Jake, beautifully laid in front of us. So thanks again, Jake. Uh, I'll see you around. Thanks everybody for listening.

Jake George:

Thanks for having me.

People on this episode

Head Shot

Isar Meitis

Host