--- title: "Connect LendingWise to AI Agents: Orchestrate Brokers and Staffing" slug: connect-lendingwise-to-ai-agents-orchestrate-brokers-and-staffing date: 2026-09-04 author: Roopendra Talekar categories: ["AI & Agents"] excerpt: "Learn how to connect LendingWise to AI agents using Truto's unified tools API. Build autonomous workflows for loan origination, broker assignments, and staffing." tldr: "A complete engineering guide to connecting LendingWise to AI agents. Fetch LLM-ready tools, handle API quirks, manage rate limits, and orchestrate complex loan workflows programmatically." canonical: https://truto.one/blog/connect-lendingwise-to-ai-agents-orchestrate-brokers-and-staffing/ --- # Connect LendingWise to AI Agents: Orchestrate Brokers and Staffing You want to connect LendingWise to an AI agent so your system can independently originate loans, assign brokers, update pipeline statuses, and manage back-office staffing. Here is exactly how to do it using Truto's `/tools` endpoint and SDK, bypassing the need to build and maintain a custom Loan Origination System (LOS) integration from scratch. Giving a Large Language Model (LLM) read and write access to your LendingWise instance is an engineering challenge. You either spend weeks building, hosting, and maintaining a custom connector, or you use a managed infrastructure layer that handles the boilerplate for you. If your team uses ChatGPT, check out our guide on [connecting LendingWise to ChatGPT](https://truto.one/connect-lendingwise-to-chatgpt-manage-loans-properties-and-members/), or if you are building on Anthropic's models, read our guide on [connecting LendingWise to Claude](https://truto.one/connect-lendingwise-to-claude-track-pipeline-status-and-loan-files/). For developers building custom autonomous workflows, you need a programmatic way to fetch these tools and bind them to your agent framework. This guide breaks down exactly how to fetch AI-ready tools for LendingWise, bind them natively to an LLM using frameworks like LangChain, LangGraph, CrewAI, or the Vercel AI SDK, and execute complex lending operations workflows. For a deeper look at the architecture behind this approach, refer to our research on [architecting AI agents and the SaaS integration bottleneck](https://truto.one/architecting-ai-agents-langgraph-langchain-and-the-saas-integration-bottleneck/). ## Why a Unified Tool Layer Matters for Agent Safety Before writing a line of integration code, decide what layer your agent talks to. This choice determines how safe your production system will be. Direct API tools (one tool per raw LendingWise endpoint) look convenient, but they push provider quirks into the LLM's context window. The model has to remember that LendingWise requires specific string formats for pipeline statuses, that employee replacements require complete arrays, and that property records have strict primary key rules. Every one of those quirks is a hallucination waiting to happen. Providing your agent with [tools generated directly from Truto's Proxy APIs](https://truto.one/the-best-unified-apis-for-llm-function-calling-ai-agent-tools-2026/) gives you three concrete safety wins: 1. **Smaller attack surface for hallucination.** The LLM only ever chooses from stable [function names with standardized JSON schemas](https://truto.one/what-is-llm-function-calling-for-integrations-2026-guide/). Invalid arguments are rejected before they hit the upstream LOS. 2. **Deterministic data structures.** The unified proxy layer normalizes inputs and outputs, meaning your agent does not need to learn the idiosyncrasies of LendingWise's raw payload structures. 3. **Zero data retention.** Truto operates purely as a pass-through proxy. Your sensitive financial and borrower data is never stored at rest in the integration layer, keeping you compliant with financial regulations. ## The Engineering Reality of the LendingWise API Giving an LLM access to external financial data sounds simple in a prototype. You write a Node.js function that makes a fetch request and wrap it in an `@tool` decorator. In production against complex loan systems, this approach collapses. LendingWise introduces several specific integration challenges that break standard REST assumptions. If you hardcode these interactions into your agent, you will spend your sprints writing defensive integration code instead of improving your model's reasoning. ### The Merge-Patch Mutation Trap When updating a loan file in LendingWise, the API relies on a merge-patch update strategy. Every field in the payload is optional, and the system will only update the fields you explicitly send. While this is efficient for network payloads, it is dangerous for LLMs. If an LLM hallucinates an empty string or null for a critical field like `borrowerName` while trying to update `primaryStatusId`, it could inadvertently wipe out data. By binding strict JSON schemas to your agent via Truto's tools, you enforce parameter constraints, ensuring the agent only sends exactly what is required for the intended state change. ### Multi-Entity Array Replacements Staffing and back-office management in LendingWise is unforgiving. When you want to modify the back-office employees on a loan file, you cannot simply append a new user ID. The API expects a complete replacement of the employee array. If you send an array of IDs and even one ID is invalid, LendingWise rejects the entire request. An AI agent attempting to add an underwriter must first list the existing employees, append the new underwriter to the list in memory, and then send the complete array back to the replacement tool. ### The Reality of Rate Limits No integration platform can magically absorb upstream rate limits without violating consistency or adding unacceptable latency. **Truto does not retry, throttle, or apply backoff on rate limit errors.** When LendingWise returns an HTTP 429 Too Many Requests, Truto passes that error directly to your caller. However, Truto normalizes the upstream rate limit information into standardized IETF headers: `ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`. The caller (your agent framework) is fully responsible for catching these 429s, reading the `ratelimit-reset` header, pausing execution, and retrying. Do not build agents assuming the network layer will save you from excessive loop iterations. ## Building Multi-Step Workflows To build a resilient agent, you need an execution loop that can fetch [tools](https://truto.one/the-best-unified-apis-for-llm-function-calling-ai-agent-tools-2026/), bind them to the LLM, execute calls, and gracefully handle HTTP 429 errors based on standardized headers. Here is how you implement this using LangChain.js and the `truto-langchainjs-toolset` SDK. ```typescript import { ChatOpenAI } from "@langchain/openai"; import { TrutoToolManager } from "truto-langchainjs-toolset"; import { HumanMessage, AIMessage, ToolMessage } from "@langchain/core/messages"; // 1. Initialize the LLM const llm = new ChatOpenAI({ modelName: "gpt-4o", temperature: 0, }); // 2. Initialize Truto Tool Manager for the LendingWise integrated account const toolManager = new TrutoToolManager({ trutoApiKey: process.env.TRUTO_API_KEY, integratedAccountId: process.env.LENDINGWISE_ACCOUNT_ID, }); async function runLendingAgent(prompt: string) { // 3. Fetch tools and bind them to the LLM const tools = await toolManager.getTools(); const llmWithTools = llm.bindTools(tools); let messages = [new HumanMessage(prompt)]; // 4. The Agent Execution Loop while (true) { const response = await llmWithTools.invoke(messages); messages.push(response); if (!response.tool_calls || response.tool_calls.length === 0) { console.log("Agent finished:", response.content); break; } // 5. Execute tools and handle Rate Limits for (const toolCall of response.tool_calls) { try { console.log(`Executing tool: ${toolCall.name}`); const tool = tools.find((t) => t.name === toolCall.name); const toolResult = await tool.invoke(toolCall.args); messages.push(new ToolMessage({ tool_call_id: toolCall.id, content: JSON.stringify(toolResult), })); } catch (error: any) { // Catch 429s and force the agent to wait or fail gracefully if (error.response?.status === 429) { const resetTime = error.response.headers['ratelimit-reset']; const waitSeconds = Math.max(1, parseInt(resetTime) - Math.floor(Date.now() / 1000)); console.warn(`Rate limited. Reset in ${waitSeconds} seconds.`); messages.push(new ToolMessage({ tool_call_id: toolCall.id, content: `Error: 429 Too Many Requests. Wait ${waitSeconds} seconds before retrying.`, })); } else { messages.push(new ToolMessage({ tool_call_id: toolCall.id, content: `Error executing tool: ${error.message}`, })); } } } } } runLendingAgent("List all loans, find the one for borrower ID 89, and assign broker ID 104."); ``` This loop is framework-agnostic in principle. You can port this exact logic to LangGraph for stateful workflows or CrewAI for [multi-agent orchestration](https://truto.one/architecting-ai-agents-langgraph-langchain-and-the-saas-integration-bottleneck/). The sequence looks like this: ```mermaid sequenceDiagram participant User as User participant Agent as AI Agent participant Truto as Truto API participant Upstream as Upstream API (LendingWise) User->>Agent: "Reassign broker to loan 1042" Agent->>Truto: GET /integrated-account//tools Truto-->>Agent: JSON schema of LendingWise tools Agent->>Truto: POST proxy execute (assign_broker) Truto->>Upstream: POST /loans/1042/broker Upstream-->>Truto: 429 Too Many Requests Truto-->>Agent: 429 (ratelimit-reset header) Note over Agent: Agent calculates backoff
and pauses execution Agent->>Truto: POST proxy execute (assign_broker) Truto->>Upstream: POST /loans/1042/broker Upstream-->>Truto: 200 OK Truto-->>Agent: Standardized success JSON Agent-->>User: "Broker reassigned successfully." ``` ## Hero Tools for LendingWise When you call Truto's `/tools` endpoint for LendingWise, you receive a highly targeted list of capabilities. Here are the core tools that enable autonomous loan management. ### Create a LendingWise Loan **Tool Name:** `create_a_lending_wise_loan` This tool allows the agent to originate a new loan file. It requires specific parameters including `branchID`, `fileType`, `loanProgram`, `primaryStatusId`, and a borrower object. This is typically the starting point for autonomous origination workflows. > "Create a new commercial loan file for borrower ID 902. Assign it to branch ID 4, set the file type to 'Commercial', use loan program STCode 'COM-30', and set the initial pipeline status to ID 12." ### Update a LendingWise Loan by ID **Tool Name:** `update_a_lending_wise_loan_by_id` Execute a merge-patch update on an existing loan file by its numeric ID (LMRId). Because every field is optional in the payload, the agent only needs to pass the exact fields it wishes to mutate. This is the primary method for moving a loan through pipeline stages via `primaryStatusId`. > "Move loan file 4492 to pipeline status ID 15 and update the borrower email to newaddress@example.com." ### Add Subject/Collateral Properties **Tool Name:** `lending_wise_loans_add_properties` Allows the agent to attach property records to a loan file. When attaching multiple properties, the agent must mark exactly one property with `isPrimary`. LendingWise automatically mirrors the primary property's address onto the top-level loan record. > "Add two collateral properties to loan 7731. Property 1 is 100 Main St, Austin TX, and should be marked as primary. Property 2 is 200 South St, Austin TX." ### Assign Broker **Tool Name:** `lending_wise_loans_assign_broker` Links an external broker to a specific loan file. This requires the loan ID and the numeric broker ID. This tool returns the full broker profile (first name, last name, email) once assigned, allowing the agent to verify the assignment. > "Assign broker ID 204 to loan 5519 and confirm their preferred communication method from the response." ### Replace Back-Office Employees **Tool Name:** `lending_wise_loans_replace_employees` Overwrites the entire list of back-office employees assigned to a loan file. If the agent needs to add a new underwriter, it must first fetch the current list, append the new ID, and pass the full array to this tool. Sending an empty array removes all assigned staff. > "Update the staffing on loan 6612. Replace the current team with employee IDs 14, 18, and 22." ### List All LendingWise Loans **Tool Name:** `list_all_lending_wise_loans` Retrieves paginated loan-file summaries. Agents use this tool to discover loan IDs by applying optional filters for brokers, borrowers, or loan officers. Max 100 results per page. > "Find all active loan files assigned to loan officer ID 55 created in the last 30 days." For the complete inventory of available tools and their exact JSON schemas, review the [LendingWise integration page](https://truto.one/integrations/detail/lendingwise). ## Workflows in Action Individual tools are useful, but the real power of an AI agent emerges when it chains these tools together to solve complex operational problems. Here are two real-world workflows that IT admins and RevOps teams automate with LendingWise. ### Scenario 1: Underwriting Handoff & Broker Reassignment When a loan application clears initial processing, it needs to be pushed to underwriting, and the assigned broker needs to be updated based on regional availability. > "Loan file 8821 has passed initial processing. Move the pipeline status to 'In Underwriting' (ID 20), assign broker ID 315 to the file, and replace the back-office staff so only employee ID 44 is working on it." **Execution Steps:** 1. The agent calls `update_a_lending_wise_loan_by_id` passing `{ "id": 8821, "primaryStatusId": 20 }`. 2. The agent calls `lending_wise_loans_assign_broker` passing `{ "loan_id": 8821, "brokerId": 315 }`. 3. The agent calls `lending_wise_loans_replace_employees` passing `{ "loan_id": 8821, "employeeIds": [44] }`. The user gets back a summarized confirmation that the loan is now in underwriting, managed by broker ID 315, and staffed exclusively by employee 44. ### Scenario 2: Collateral Setup and Verification During a commercial real estate deal, a processor uploads multiple collateral properties. The agent must attach these properties to the loan file and enforce the primary property constraint. > "We have three properties securing loan 9055. Add them to the file: 500 North Ave (primary), 502 North Ave, and 504 North Ave." **Execution Steps:** 1. The agent calls `lending_wise_loans_add_properties` with the `loan_id` of 9055, passing an array of the three properties, explicitly ensuring `isPrimary: true` is only set on the 500 North Ave object. 2. The agent receives the created property objects and their IDs from the API. The user gets back a confirmation that all three properties were added, with 500 North Ave properly mapped as the primary address on the loan file. ## Strategic Wrap-Up Giving AI agents read and write access to LendingWise transforms your loan origination system from a static database into an autonomous workflow engine. By leaning on Truto's `/tools` endpoint, you strip away the integration boilerplate. You don't have to write custom OpenAPI specs, maintain OAuth tokens, or figure out how to structure payload mutations for complex back-office employee replacements. Your engineering team can focus entirely on prompt engineering, agent orchestration, and business logic, while the infrastructure layer safely handles the API translation and rate limit pass-throughs. > Ready to give your AI agents secure, autonomous access to LendingWise and 200+ other enterprise APIs? Get a demo of Truto today. > > [Talk to us](https://truto.one/book-a-demo/)