Tools for Large Language Model Agents

The venues through which customers have interacted with financial institutions have evolved over the years to include in-branch interactions, banking-by-mail, internet banking, and most recently mobile banking. There is now much public excitement around generative Artificial Intelligence (AI) products. However, federal regulators and management across the financial services industry are mandating a more cautious approach. The main concern centers around controlling “factualness” and reining in “hallucinations,” which are risks with generative AI tools, such as Large Language Models (LLMs), multi-modal models, and agent-based LLMs.

Examples provided herein are directed to tools for Large Language Model agents.

According to one aspect, an example computer system for providing one or more tools for large language model agents can include: one or more processors; and non-transitory computer-readable storage media encoding instructions which, when executed by the one or more processors, causes the computer system to: authenticate a user; provide a description of the one or more tools available for use by the large language model agents; execute the one or more tools upon receipt of a request from the large language model agents; and provide information in response to the request.

According to another aspect, an example method for providing one or more tools for large language model agents, the method comprising: authenticating a user; providing a description of the one or more tools available for use by the large language model agents; executing the one or more tools upon receipt of a request from the large language model agents; and providing information in response to the request.

The details of one or more techniques are set forth in the accompanying drawings and the description below. Other features, objects, and advantages of these techniques will be apparent from the description, drawings, and claims.

This disclosure relates to tools for Large Language Model (LLM) agents.

schematically shows aspects of one example systemprogrammed to provide LLM agents. In this example, the systemcan be a computing environment that includes a plurality of client and server devices. In this instance, the systemincludes client devices,, a server device, and a database. The client devices,can communicate with the server devicethrough a networkand associated application programming interface (API)to accomplish the functionality described herein.

Each of the devices may be implemented as one or more computing devices with at least one processor and memory. Example computing devices include a mobile computer, a desktop computer, a server computer, or other computing device or devices such as a server farm or cloud computing used to generate or receive data.

In some non-limiting examples, the server deviceis owned by a financial institution, such as a bank. The client devices,can be programmed to communicate with the server deviceto perform various tasks, such as financial transactions. Many other configurations are possible, and the disclosure is not limitation to the financial industry.

The example client devices,can be used by customers and/or team members of the financial institution to perform various tasks. For instance, a team member of the financial institution can use the client deviceto perform tasks such as access financial settings and documents, transactional accounts, etc. Similarly, a customer of the financial institution can use the client deviceto perform such tasks.

In some examples, the client devices,execute and/or provide access to one or more chat-based LLMs, such as ChatGPT and Google Bard. More specifically, the client devices,provide LLM-based agents (e.g., see LLM-based agent engineof), as described further below. Many other embodiments are possible.

The example server deviceis programmed to provide financial services functionality. Examples of such functionality include, without limitation, access to financial accounts and information. In addition, the server deviceprovides tools for use by the LLM-based agents of the client devices,, as described further below.

The example databaseis programmed to store data associated with the financial institution that can be accessed by the server device. Such data includes the financial accounts of the customers of the financial institution. The databasecan also store data associated with one or more tools implemented by the system.

The networkprovides a wired and/or wireless connection between the client devices,, and the server device. In some examples, the networkcan be a local area network, a wide area network, the Internet, or a mixture thereof. Many different communication protocols can be used. Although only three devices are shown, the systemcan accommodate hundreds, thousands, or more of computing devices.

In the examples provided herein, the client devices,communicate with the server devicethrough the APIto access one or more tools that can be used by LLM-based agents. These LLM-based agents are programmed as autonomous Artificial Intelligence (AI) agents that can interact with customer's financial accounts on behalf of the customer and make authorized changes as the customer.

As provided herein, an “agent” is an autonomous AI entity that is responsible for deciding the steps to take for a given task. The agent is powered by a LLM (e.g., LLM-based agent engine) and is programmed to receive a prompt. The prompt contains information regarding tools that the agent can use. Such tools can be varied, including examples like calculators, web searching, scripting (e.g., Python code generation and execution), communication tools (e.g., Gmail toolkit), database queries (e.g., SQL database access), custom tools, etc.

In the examples provided below, functions and descriptions are exposed by the APIas “tools” available for the LLM-based agent to use in a secure and efficiency manner. Such tools can cover a wide range of banking and financial service operations that a user would routinely interact with over other banking venues be it in-person or online. LLM-based agents can chain together multiple tools to solve complex problems, possibly over extended periods of time. More specifically, the LLM is used as a reasoning engine to determine which actions to take and in which order. One non-limiting example of a technology that provides such reasoning in the context of LLMs is LangChain from LangChain, Inc., which can be used to define workflows implemented by LLMs. Additional details regarding the LLM-based agents are provided below.

Referring now to, additional details of the server deviceare shown. In this example, the server devicehas various logical modules that assist in providing tools for the LLM-based agents. The server devicecan, in this instance, include an authentication engine, a tools engine, and an execution engine. In other examples, more or fewer engines providing different functionality can be used.

The example authentication engineallows the client devices,to access the server devicethrough the APIin a secure manner. In some examples, the APIcan utilize proprietary or third party services to authenticate the client devices,before access is given. For instance, in one example, a third party service like Plaid by Plaid Inc. is used to authenticate the client devicebefore access is given to financial information stored in the databaseof the system.

In one example that follows, a customer of the financial institution uses the client deviceto request the balance of the customer's checking account. To do so, the client devicemakes the request through an LLM-based agent to the server device.

Preliminarily, the financial institution verifies that the LLM-based agent is acting on behalf of user. The LLM-based agent can be linked to various chatbots that provide AI services, such as Fargo from Wells Fargo Bank, ChatGPT, Google Bard, etc.

Initially, the client devicecan provide bank account credentials to the APIto access the server device. The authentication engineof the server device, either internally or through a third party service provider, authenticates the user. This authentication can be accomplished through various routes, including passwords and multifactor authentication, along with such security mechanisms like POST, OAuth, etc. Upon authentication, the server deviceprovides a client key and permissions in response to the authentication request.

An example response to an authentication request by the client devicethrough the APIfollows, which defines an authentication key (e.g., “123xc321q3”) and various features that are available to the client device, such as the customer settings and a balance for a checking account associated with the customer.

Once authenticated, the client devicecan access a series of tools available from the server device. In one example, the client devicecan query the tools engineof the server deviceto request a list of the tools available to the client device(e.g., specifically available to the LLM-based agent engine). An example response by the tools engineto such a request follows.

In this example, the tools engineprovides two tools for use by the LLM-based agent engineof the client device, including a “ListAccountsTool” that provides a list of all accounts and an “AccountBalanceTool” that provides a present or past balance for a financial account.

The client devicecan use the information about the tools available from the server deviceto request details about one or more of the desired tools. For instance, the client devicecan request additional information about the AccountBalanceTool from the server device. In response, the tools engineprovides the additional detail as follows.

In this example, the tools engineprovides additional details about the AccountBalanceTool, including the fields associated therewith, including an “account_name” field that is the account name (e.g., “Checking Account”) and a “context” field that allows for the definition of a point in time (which defaults to now if left blank).

Having a detailed understanding of the AccountBalanceTool, the LLM-based agent on the client devicecan thereupon make a request to the server devicethrough the API. In one example, this request follows.

The request includes the authentication key (“123xc321q3”), the action identifying the desired tool (“AccountBalanceTool”), and the details associated with the tool (account name (“Checking Account”) and time period (“now”).

The execution engineof the server devicereceives the request from the client devicethrough the API. The execution engineis programmed to engage the desired tool and provide a response, an example of which follows.

The execution engineprovides the result back to the client device. In this example, the result is the current value of the Checking Account (“$9,456.12”) as defined in the request by the client device.

A complete example of an LLM-based agent tool as executed by the execution enginefollows.

Other examples are possible using the examples above.

For instance, the customer may wish to change the monthly payment due date on a credit card account to align with the due date for payment on a mortgage. Using the LLM-based agent engine(see), the client devicecommunicates with the server devicethrough the APIto allow the LLM-based agent on the client deviceto identify the tools that are available and string those tools together in a sequence to allow the desired outcome to occur: (i) use tool to determine the due date for mortgage payments; (ii) use tool to determine the due date for the credit cards payments; (iii) if the two do not match, use tool to request payment due date change for the credit card payments to match the mortgage payments. This can all be accomplished through the LLM-based agent on the client devicecommunicating with the server devicethrough the API.

In yet another example, the customer wants to make a large purchase, such as buying a vehicle. However, the customer is unsure if she could afford the down payment and the loan. The LLM-based agent engineis able to use tools provided by the server deviceto access her typical spending patterns from her banking history through on the server device. The customer's banking history is then used along with information about the loan costs (e.g., interest rates and other loan terms) by the LLM-based agent engineto provide the customer with an understanding of the affordability of the vehicle.

Referring now to, example logical components of the client deviceare shown. In this example, the client deviceincludes the LLM-based agent engineand an approval engine. The client devicecan be similarly configured.

As described in detail above, the LLM-based agent engineis programmed to implement one or more LLM-based agents that access the tools provided by the server device. In some examples, the LLM-based agent engineis executed on the client deviceand/or on another computing device, such as the server deviceor a third party server. Many configurations are possible.

The approval engineof the client deviceis programmed to mitigate some of the risks associated with the use of LLM-based agents, such as the LLM-based agent engine. While the approval engineis shown as being executed by the client device, in alternative embodiments a portion or all of the functionality of the approval enginecan be executed by another computing device, such as the server deviceor a third party server.

In this example, the approval engineis programmed to set limits on the processes initiated by the LLM-based agent engineto mitigate potential issues associated with the use of an LLM-based agent, such as hallucinations (e.g., responses that are nonsensical, factually incorrect, or disconnected form the input prompt). To do so, the approval engineis programmed to intercept calls made by the LLM-based agent engineand potentially require approval before data is obtained by and/or results are reported by the LLM-based agent engine.

In this example, the approval engineintercepts all key input and output calls by the LLM-based agent engineand injects additional behavior (“middleware”) or wholly replaces functionality with appropriate error messages that are then consumed by the LLM-based agent engine.

For example, assume the example above where the customer wishes to align the credit card payment due date with the mortgage payment due date. The LLM-based agent engineaccesses the tools on the server deviceto request the payment due dates and calculate the change to the credit card payment due date. However, before the LLM-based agent engineis allowed to request the modification of the credit card payment due date, the approval engineintercepts the request by the LLM-based agent engineand requires approval by the customer.

In one example, this may include generation of a “pop-up” approval dialog (or other control mechanism) listing details about the potential change to the credit card payment due date:

The customer can then approve or disapprove of the change before the LLM-based agent engineis allowed to proceed with then change. If approved by the customer, the LLM-based agent enginecontinues to use the tools provided by the server deviceto effectuate the change. If not approved by the customer, the LLM-based agent enginegenerates an error indicating that the change cannot be made.

In some examples, the approval engineis programmed to require approval for some actions performed by the LLM-based agent engine, such as those impacting certain aspects of the customer (e.g., requests that involve certain monetary amounts). Other actions that might require approval are those more sensitive in nature (e.g., changes to privacy settings) and/or are known to involve areas where issues can be typical (e.g., hallucinations are known to occur).

In other examples, support personnel can monitor the status of the LLM-based agent enginebased on logs and artifacts it produces. In such a scenario, the LLM-based agent enginemay have limited or no access to write to production databases (e.g., database), but instead produce files (artifacts) that can be consumed by a non-agent-based processes (a normal service running a normal non-agent based programming environment), where the non-agent processes can include various functionality such as controls and checks on the data, notification of human support personnel about the status of the mail, and ultimately even ingestion of the data into a production database if these controls pass.

In addition, human support personnel and/or processes can be brought into the loop to inspect the artifacts produced by the autonomous AI-agent prior to approving the next step in the flow. Before, after, or wholly instead of the human, additional base LLMs or AI-agents could be used to check the output of the main AI-agent (an AI-agent as a “control”). Through the limitations presented to the LLM-based agent engineand the controls built on top and at the end of the execution of the LLM-based agent engine, risks associated with the use of such AI can be mitigated.

As illustrated in the embodiment of, the example server device, which provides the functionality described herein, can include at least one central processing unit (“CPU”), a system memory, and a system busthat couples the system memoryto the CPU. The system memoryincludes a random access memory (“RAM”)and a read-only memory (“ROM”). A basic input/output system containing the basic routines that help transfer information between elements within the server device, such as during startup, is stored in the ROM. The server devicefurther includes a mass storage device. The mass storage devicecan store software instructions and data. A central processing unit, system memory, and mass storage device similar to that shown can also be included in the other computing devices disclosed herein.

The mass storage deviceis connected to the CPUthrough a mass storage controller (not shown) connected to the system bus. The mass storage deviceand its associated computer-readable data storage media provide non-volatile, non-transitory storage for the server device. Although the description of computer-readable data storage media contained herein refers to a mass storage device, such as a hard disk or solid-state disk, it should be appreciated by those skilled in the art that computer-readable data storage media can be any available non-transitory, physical device, or article of manufacture from which the central display station can read data and/or instructions.

Computer-readable data storage media include volatile and non-volatile, removable, and non-removable media implemented in any method or technology for storage of information such as computer-readable software instructions, data structures, program modules, or other data. Example types of computer-readable data storage media include, but are not limited to, RAM, ROM, EPROM, EEPROM, flash memory or other solid-state memory technology, CD-ROMs, digital versatile discs (“DVDs”), other optical storage media, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other medium which can be used to store the desired information and which can be accessed by the server device.

According to various embodiments of the invention, the server devicemay operate in a networked environment using logical connections to remote network devices through network, such as a wireless network, the Internet, or another type of network. The server devicemay connect to networkthrough a network interface unitconnected to the system bus. It should be appreciated that the network interface unitmay also be utilized to connect to other types of networks and remote computing systems. The server devicealso includes an input/output controllerfor receiving and processing input from a number of other devices, including a touch user interface display screen or another type of input device. Similarly, the input/output controllermay provide output to a touch user interface display screen or other output devices.