The agent that helps you finish RFPs faster

How many hours does your team lose each week just trying to fill out RFPs? Today, we're going to show you an RFP agent built on Tray's Merlin Agent Builder for an employee who wants to speed up the process of completing an RFP.

Now, RFPs typically ask for a wide variety of information about your organization, especially technical knowledge. And so, having a good grounding of knowledge is super important. So, let's take a look at this agent in action.

Now my agent here has been configured firstly with an overall agent scopes.

These are kind of the overarching instructions and guidance that I've given the agent. It's also easy for me to configure the model down here, so I can tweak this around as necessary and use different models if I so wish. But most importantly, my agent also has access to a set of agent tools. Now most of the tools here for this RFP agent are going to be grounded in knowledge.

So I've ingested in things like our CAIQ document, previous RFPs, because, of course, there's a wealth of information that exists within those. It also has a tool down here that's ingested in our Tray technical knowledge, so any information around the platform and the functionality from a technical standpoint, so a good knowledge base that it can use for that. Now it's really easy for you to be able to bring in new data sources. So if you want to bring in more data from different systems, you can select the data source, point it at the system that you're using and where that data sits, and start to bring that data into the fold so that your agent can make use of it.

Now, of course, knowledge is just one part of an agent. Where a lot of the power starts to come in is when your agent is able to take action as well. So in the case of an RFP, that might be incorporating in human in the loop, maybe cross checking and pulling information from other systems, or going ahead and maybe creating a ticket for us so that our team can manually review certain questions assigned to them and have visibility that they need to do so. Let's go ahead and test our agent here.

Now I'm going to start with the question, quite a generic one around security. So how does Tray approach security?

Now, of course, I'm testing the agent here in isolation with individual questions, which might be a scenario where if you might have one or two questions, you can ask the questions directly. But I'll also show you in a moment how this agent can ingest in and process a whole RFP document as well. Let's take a look at this question. Let's take a look to see what the response comes back with. And we'll take a look at the format and the information that it's going to pull from to actually come back with a suitable response to quite a generic question.

And so as we see, the response coming back is quite comprehensive. It's given us a great overview of our approach to security. But what's really cool is it's also provided the sources at the bottom. So you can see it actually pulled from several places this information for this response from those knowledge sources, including directly the parts of those CAIQ documents and our technical knowledge base.

Now let's take a look, though, at a scenario where I want to incorporate human in the loop. So I'm going to ask a question around pricing. So what I wanted to happen in this scenario is not come back with any generic pricing. I wanted to create a ticket in our ticketing system assigned to our account team so they can actually put together a tailored pricing proposal for this RFP. So let's take a look to see what the agent does in this scenario.

And so in this case, you can see that it's come back with a response, but it's actually gone ahead and created that ticket for us in our ticketing system. So this is a great example of the agent taking action. It's figured out that this question is about pricing. It doesn't have a suitable response for pricing in its knowledge base.

And so it's gone ahead and taken the action to actually create a ticket, assign it to the relevant team, in this case, our sales team, so that they can manually review this and put together a tailored pricing proposal. So you're starting to see this agent is also able to take action in these systems too. Let's go ahead and take a look at an example of processing a whole RFP document. So I've got my agent also deployed here into Slack.

Now what I'm going to do is I'm going to upload a RFP into the chat here, and I'm going to ask it, "Can you process this RFP, please?" And so in this case, the agent is also going to take action again. In this case, instead of just keeping the RFP here in Slack, it's going to upload that to a collaborative file store, in this case, Google Drive. But that might be something like a SharePoint so that multiple people can access it and collaborate on the completion of that as well.

So you can see it's taken that action and actually provided us a link directly to that RFP that's been uploaded. And what we will see is the questions over on the left hand side for what this RFP includes, and we should see the responses coming through in just a moment because our agent's going to go ahead and process that sequentially with that information in. And so in this case, what we're starting to see is just as before, the agent's coming back with its responses. It's given it a really good grounding set of data that is using pulling from those knowledge sources and just working through these questions, as it sees them and pulls them through in that RFP document directly as as well.

So this is really great. Of course, this is much more applicable maybe to completing a whole RFP, which is awesome. And it will go through in exactly the same way by looking at the question, looking at its knowledge base, kind of provide that response, and, of course, if it needs to bring that human in the loop into that scenario if required as well as it kind of does go through and sequentially processes it. So you can see that it's more or less finished with this RFP processing now, which is fantastic.

Now what's nice is that once it has finished going through, it would also come back and let the user know over in the Slack channel that it's completed. And you can see here that it's also provided that link back so they can go through and click to see that completed RFP. So as you can see, it's really powerful to be able to build out an agent that's, one, grounded in that knowledge, but also, two, when needed, taking that action, whether that's uploading the RFP to a collaborative file store, incorporating in that human in the loop for any of that iterative responses to these RFP questions, and building that altogether with the Merlin Agent Builder functionality.

And this is just one example of what's possible when you build on one platform for every agent.