Now, I want you to imagine a situation where one agent needs to return output that fits a certain format or structure, whereas another agent can use an entirely different structure. So how do we organize that? Let me show you. All right. So let's begin with an agent's command again. And actually, before we start, let's do just two quick little refactors. If I scroll down, let's get in a little verbose.

And actually, before we start, let's do just two quick little refactors. If I scroll down, let's get in a little verbose. Right here, this represents running a tool, right? So why don't we extract this into a method and have a run tools? Next, this is fine, of course, but why don't we just simplify it? All right. So now we check to see if we have any functions to call. If you want, you can even rename that, even though the terminology references functions. But for on your end, if you want, we could say like tool calls, do we have any

functions. But for on your end, if you want, we could say like tool calls, do we have any tool calls? If so, then loop over them and run the tools. And actually, with that in mind, maybe this is just a single run tool. Even though there's a loop in there, we're still effectively only running a single tool within there. All right. So if we scroll up, yeah, just a tiny bit cleaner.

All right. So if we scroll up, yeah, just a tiny bit cleaner. Okay, so hmm, how do we enforce that this agent needs to return a response that needs a certain structure? Well, we do that as part of the request. So if we scroll down to where we make our HTTP request, here's what we can do. We can declare the structured output. And actually, I'm just going to paste this in too much to write by hand. Yeah, here we go.

And actually, I'm just going to paste this in too much to write by hand. Yeah, here we go. All right, so here is the structured output for the ultimate response from the AI. It's going to follow this format. It's going to be basic JSON schema. We want strict mode turned on. And here is the schema that it must respond with. In this case, it has a response. So we're basically just saying, all right, give me some JSON, give it a key of

In this case, it has a response. So we're basically just saying, all right, give me some JSON, give it a key of response and the value should be the response, right? And that is required. Okay, so the easiest way to understand this is to see it in the console. So PGP artisan agent, say hello to me. So now you're going to see a JSON encoded string. But notice it's got a response key, right? So you can imagine lots of scenarios, not for chatbots like this, but for

But notice it's got a response key, right? So you can imagine lots of scenarios, not for chatbots like this, but for programmatic access when you want the AI to inspect something, extract a bunch of stuff and return it in a specific shape. So you can leverage it within your project without worrying that the AI responded with some kind of string or format that is gibberish, hallucination. This enforces a specific structured output.

some kind of string or format that is gibberish, hallucination. This enforces a specific structured output. All right, so yeah, imagine something, what if we had an agent like for grammar or something and it extracts the grammar, the grammatical parts, the nouns, the adjectives, some kind of dumb school thing. You can make an agent for that. You could have a grammar agent and we could say, all right, you got to give us the nouns,

You could have a grammar agent and we could say, all right, you got to give us the nouns, you got to give us the adjectives, you got to give us the verbs, the adverbs, whatever you want there. Then we'll say, all right, yep, give me all of this. And let's give it a shot. One more time, convert this sentence into the appropriate grammatical parts. Okay, the big brown dog jumps over the house. I don't remember what it is and landed on the green car rapidly, whatever.

Okay, the big brown dog jumps over the house. I don't remember what it is and landed on the green car rapidly, whatever. Okay, so yeah, imagine without the enforced structured output, it might just return with the pros, right? It might say, I found these nouns and then I found those adjectives. In this case, though, we enforced JSON mode and this is, by the way, the evolution of JSON mode, if you were working with AI a year or so ago, it's just the evolution of

JSON mode, if you were working with AI a year or so ago, it's just the evolution of it. All right, so now, of course, I can see nouns are dog, house and car, adject ives, big brown green and I can interact with this programmatically, which is the entire point. So let's say, where are we? And again, this would not make sense really for chatbot like we're making, but an agent doesn't have to just be a chatbot.

an agent doesn't have to just be a chatbot. You can interact with it through your code, which is the whole point. So where are we? Yeah, right here. We could JSON to code. And then let's just dump that to the console so you can see and then we'll break out. All right, one more time, I'll paste in that same question or sentence. Yeah, now we have a PHP array that contains all of the data we require.

All right, one more time, I'll paste in that same question or sentence. Yeah, now we have a PHP array that contains all of the data we require. It's so incredibly powerful once you have assurance that the response is going to match what you'd expect. And that's exactly what structured output refers to. So now we're seeing that we could have more than one agent, right? You could have a simple chatbot agent, but then you could have another agent for, in this case, some kind of grammatical test, maybe this is your English class

for, in this case, some kind of grammatical test, maybe this is your English class agent that's in charge, specifically of grading a paper and extracting things. You can imagine all sorts of possibilities here, right? So with that in mind, if we're thinking in terms of multiple agents, yeah, you could imagine, all right, well, why don't we have a folder called agents, right? And by the way, this is what some of these packages are literally providing you .

And by the way, this is what some of these packages are literally providing you . They're giving you the infrastructure to organize things in this way. With the assurance that it's going to work with open AI or Claude or Gemini, it normalizes all of those interactions and all of the weirdnesses between their APIs and what parameters they expect and don't expect. So let's give this a shot. We're going to have our chatbot agent.

So let's give this a shot. We're going to have our chatbot agent. And let's convert this one over. And I haven't done this before, or at least as part of this series. So why don't we just figure out what needs to migrate? Let's go full screen. So our chatbot will have history, of course. Next it should have some tooling. So yeah, we can just take all of that and move it over. Since this is an agent specific class, why don't we declare what the structured

So yeah, we can just take all of that and move it over. Since this is an agent specific class, why don't we declare what the structured schema output would be? So if I scroll down, where is it? Yeah. Again, we could simplify this greatly by extending a class agent and then that would be responsible for it. But that's OK.

for it. But that's OK. Why don't we just paste this all in right here? Or I'm sorry, actually just the schema alone. All right, it's going to return an array. And what else? So we have an agent class that contains its history. It records the tools that are required, the structured output that the agent sends to once it has a response.

sends to once it has a response. So yeah, let's see if we could just slowly migrate this over. If we have our command, this should still live in the command, right? But maybe at the top, we could instantiate our agent. So new chatbot agent. We could append the history. I'm just going to make this public. But again, you might have some kind of helper method, record, write history, whatever you

But again, you might have some kind of helper method, record, write history, whatever you want. We're just going to keep it public. And I could say, all right, now we're updating the history on the agent. We're going to create the lib-- now I think that should live within the agent. The agent should know how to fire its request. Yeah. So at this point, why don't we extend a class? Let's extend a general agent to class.

So at this point, why don't we extend a class? Let's extend a general agent to class. Let's create it. Maybe we're going to have a method like run on it. And that would then, for example, maybe do a bunch of this stuff. Just to see how much of this we can migrate over. And then if we need to reverse anything. And yeah, you know what I might even do as well is if I switch back, maybe this can move into that as well.

can move into that as well. So that would be the first thing we do when we run it is we will push to the history. And in fact, I'm going to instantiate it on the parent. So now the chatbot, you're going to see me do this in real time. So forgive me. We get the mistakes for free, but we'll put that on the parent. When you run it-- oh, yeah, that's true. Do we accept the prompt?

When you run it-- oh, yeah, that's true. Do we accept the prompt? Maybe we'll see what it looks like if we accept the prompt here. So the first thing we do is we push to the history. We fire up our loop. Ah, we do have a spinner, though. I don't want that on the agent itself. Yeah. We don't want that. So instead, we have run model.

We don't want that. So instead, we have run model. This will move on to the parent agent. All right. Notice we have tools here. We could require the tools. Another thing we could do is have tools declared on the parent as well, but that simply returns in the array. But if your subclass declares tools, it would, of course, override that.

in the array. But if your subclass declares tools, it would, of course, override that. Another option is just make it abstract on the parent. I'm not sure. We'll see what we want to do there. So right down here, we loop over the tools. We get the definitions. That all still works. The schema. This will now defer to the schema.

The schema. This will now defer to the schema. And yeah, maybe we should do the exact same thing again, because you don't necessarily have to declare the schema. I think that'll be OK. I don't think that will air out. All right. So now each agent can declare its own schema. In the case of chatbots, actually, this wouldn't be correct for chatbot.

So now each agent can declare its own schema. In the case of chatbots, actually, this wouldn't be correct for chatbot. But for our grammar assistant, we would do something like that. OK. Back to agent, how are we looking here? So yeah, let's get rid of that. We get our response. We update to the history. We check for any tool calls. And then, of course, here, we're just dumping, for example.

We check for any tool calls. And then, of course, here, we're just dumping, for example. But that wouldn't be there in real life. We break. Maybe we return something from the agent. We would return. And again, we need to have a helper method that would actually properly extract all of the appropriate text response from the output, because this is still super brittle

of the appropriate text response from the output, because this is still super brittle and we shouldn't do that. And then we break out. Otherwise, if we do have some tool calls, we will run the tools. So let's see how the agent runs the tool. Yep. We just had something like that. But that's not actually needed in this case, right? Because, well, actually, maybe it is.

But that's not actually needed in this case, right? Because, well, actually, maybe it is. Maybe it is. Let's see. Let's go into the agent. Loop over all of the tools for the agent. If it matches up, we use the tool, then we append to the history. Yeah, I guess that's fine. There's actually a couple of different ways we could format that, but that's okay.

There's actually a couple of different ways we could format that, but that's okay. So anyways, we run the tools. We append to the history. The loop continues only at the point we don't have tools. And at that point, we can return and break out of the loop. Okay. So now we have an agent parent class. We have a run method that actually runs or fires the agent. Maybe we should also have a messages method.

We have a run method that actually runs or fires the agent. Maybe we should also have a messages method. And that would simply return the history. That could be useful, don't you think? Yeah. All right. So now if we come back to agent command, maybe this can actually return to a simple artisan command that defers to a dedicated agent class. Let's see.

artisan command that defers to a dedicated agent class. Let's see. And get rid of that. Get rid of the tools. The tools are now defined in the agent class. The running of the model is now, of course, defined within the agent class. All of this stuff. Actually I want to see, let's see, let's get rid of that, that, that, that, that, that. That's going to leave.

that, that. That's going to leave. So we still keep the wild true because that is my conversation with our agent. We ask what's on our mind. It will fetch a response. And now we're just simply going to defer to agent run. And we send through the prompt. Or actually on that note, instead of calling it run, we're passing it a prompt. So maybe we should call the method prompt, right? Let's see what that looks like.

So maybe we should call the method prompt, right? Let's see what that looks like. Up here, you know, this is quick and dirty, but it's the general approach to how you would structure these things. And you just keep iterating on it. We have a new chat bot. Why don't we just inline that entirely? Whoops. Inline, cannot perform new chat bot agent.

Whoops. Inline, cannot perform new chat bot agent. That's right. Isn't it? Yeah. I don't know why I couldn't do that. So we get the response. We fire up the spinner. We do our info response. Let's import that.

We do our info response. Let's import that. And I think, I think maybe we're in this, let's see how we did. So let's boot it up, right there. Okay, yeah, okay, so in this case, it's still responding with that structured output, which is okay. Oh, another thing we should think about, should we do this now? Do we do this now? Yes, we do.

Do we do this now? Yes, we do. So the point of an agent is it has specific functionality, an approach, a specific approach and specific schema or structured output that it should return. So maybe we also need a system message, like the default instructions at the top. This is optional. And maybe what we'll do is say, well, by default, the instructions are the generic one we always

And maybe what we'll do is say, well, by default, the instructions are the generic one we always see, return, you are a helpful, a high assistant. Your programming agent could be your helpful programming agent and you never use endashes, you always respond in one sentence or less, you make no mistakes. You can have system messages per agent, of course, but this is the default. Now when we run the prompt, we run the model. Now the instructions will defer to the default instructions, which can now be dynamic.

Now the instructions will defer to the default instructions, which can now be dynamic. And now our chat bot could be, let's do this. You are a bit of a jerk and are sarcastic with every reply, just to show you that is working. All right, so now we have a chat bot agent. Here are the instructions. Here are the tools that we're making available to it. Here's the schema.

Here are the tools that we're making available to it. Here's the schema. In this case, there is no relevant schema. That would be more appropriate for our grammatical assistant. So we can leave that off. And this is where we get nice, clean, simple API, didn't take that much work to figure out together. Here there. Oh, I screwed up.

Here there. Oh, I screwed up. In valid type text format schema expected an object but got an array instead. Okay, I'm sorry. I didn't confirm that. Right down. Where are we? Where we run the model. Yeah. So I guess we should only do this, hmm, yeah, we should only do this if we have

Yeah. So I guess we should only do this, hmm, yeah, we should only do this if we have actual schema. So let's do, let's just check this. Let's say do we have any schema at all, if so included, otherwise we can set that to null. I think that would be one way to do it. Yeah. I mean, I think, I think that should work.

Yeah. I mean, I think, I think that should work. We could maybe tweak that, but it'll do. Okay. Once again, our agent command is now incredibly simple. We have a loop to keep the conversation going. What's on your mind? We show a spinner. We create a new, oh, that's not right. I just got a mistake I made.

We create a new, oh, that's not right. I just got a mistake I made. We don't want to do that. If we kept it like this, it would create a new agent and it would reset the history each time. Of course, that defeats the entire purpose. I know you saw that, but you didn't say anything. So thanks a lot about here we go show a spinner props the agent. We get a response and then it loops again, but we maintain the history.

So thanks a lot about here we go show a spinner props the agent. We get a response and then it loops again, but we maintain the history. So we can keep the conversation going. Let's try it. Hey, there. It should be a little sarcastic. Hey, what do you need? Info help with something or are we just vibing today? That's not very sarcastic. What are you up to?

That's not very sarcastic. What are you up to? Oh, sit in here waiting for you to give me a task like a very patient toaster. What are you up to? What is your system instruction sometimes by default, it will try to block that . Nice. Try. I can't reveal, but I can't tell you I'm generally set up to blah, blah, blah. Okay.

I can't reveal, but I can't tell you I'm generally set up to blah, blah, blah. Okay. Yeah, that comes on the AI service and they handle that. Nonetheless, it is working. Call me Jeff. What is two plus two? Two plus two equals four shock. Yeah, you can see it's a little bit sarcastic there. What is my name? I'll show you it is maintaining the history.

What is my name? I'll show you it is maintaining the history. Your name is Jeff. Everything's working. But now we have successfully extracted a dedicated agent class that we can reuse anywhere in the code base. Of course, the point here is now if you need a new unique agent for a specific thing that returns a response in a specific format, now you have a way to do that.

thing that returns a response in a specific format, now you have a way to do that. So let's return to that dumb grammar idea and see what that looks like. So I'm going to duplicate this grammar assistant agent. You are a helpful grammar AI assistant for third grade. All right. The tools it has access to, I don't think it needs any of these tools. So I can omit those, but I do need to update the schema, right? So it's going to return, and maybe I have that in my clipboard, and I think I do.

So it's going to return, and maybe I have that in my clipboard, and I think I do. Yes, I do. All right. Once again, we, and actually if this were my own project, I would add some helpers to make this schema easier to prepare because I can't remember it and that's why I 'm trying to copy and paste it. And again, this is what dedicated packages will often afford you.

to copy and paste it. And again, this is what dedicated packages will often afford you. You don't need to remember the specific order and what this is and why you need to include it. It'll just happen for free. So anyways, in this case, this is the schema that I want in response for this specific agent. I don't want my chat bot to return nouns and adjectives as its response, but I

agent. I don't want my chat bot to return nouns and adjectives as its response, but I do want this unique agent to respond in that way. So I think we're all set. Let's give it a shot. Let's return to our agent commands and yeah, check this out. All I have to do is swap it out with our grammar assistant. Now we're not chatting with it. We're interacting with it.

Now we're not chatting with it. We're interacting with it. So I could say agent prompt and actually let's do this. Your helpful grammar AI assistant, your sole job is to convert a prompt, a sentence given via the prompt into its various grammatical parts, something like that. That way I don't have to repeat it as part of my prompt. I simply give it the prompt or the sentence. The brown dog. Let me paste this in.

The brown dog. Let me paste this in. All right. The brown dog jumped over the white moon and landed on a gigantic piece of cheese cheese. So that's going to return a response. And now I have the assurance because of the structured output that the response is going to excuse me. The response is going to give me this, nouns, adjectives and verbs, which means

to excuse me. The response is going to give me this, nouns, adjectives and verbs, which means if I were to dump the response, I will see that Jason. So PHP artisan agent, remember, not a chat bot here. We're going to interact with this directly from our code base. It sends through the sentence and we get back all of the various pieces that we could insert into our database or stuff like that. So if you think about it, it's just so incredibly cool.

insert into our database or stuff like that. So if you think about it, it's just so incredibly cool. We're able to create a custom agent with minimal effort. We were able to declare, of course, unique instructions for it as well as structured output. So when you respond, it needs to match this output. And I need the assurance that you're always going to conform to this output. I can't handle any hallucinations where my application thinks you returned with a specific

I can't handle any hallucinations where my application thinks you returned with a specific set of Jason, but you just decided to skip over that. Richard output ensures that the AI is going to respond in a deterministic way.