---
title: "Connect Lone Wolf Back Office to Claude: Track Agents & Commissions"
slug: connect-lone-wolf-back-office-to-claude-track-agents-commissions
date: 2026-11-13
author: Uday Gajavalli
categories: ["AI & Agents"]
excerpt: "Learn how to connect Lone Wolf Back Office to Claude using a managed MCP server. Track transactions, audit commissions, and automate real estate workflows."
tldr: "Connect Lone Wolf Back Office to Claude via a managed MCP server to automate real estate workflows. This guide covers server generation, configuration, hero tools, and real-world agentic workflows."
canonical: https://truto.one/blog/connect-lone-wolf-back-office-to-claude-track-agents-commissions/
---

# Connect Lone Wolf Back Office to Claude: Track Agents & Commissions


If your team needs to connect Lone Wolf Back Office to Claude to automate real estate transaction tracking, audit agent commissions, or oversee escrow deposits, you need a [Model Context Protocol (MCP) server](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/). This server acts as the secure translation layer between Claude's function-calling capabilities and Lone Wolf's REST APIs. You can either build, host, and maintain this infrastructure entirely in-house, or use a [managed integration platform like Truto](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/) to dynamically generate a [secure, authenticated MCP server URL](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/). If your team uses ChatGPT, check out our guide on [connecting Lone Wolf Back Office to ChatGPT](https://truto.one/connect-lone-wolf-back-office-to-chatgpt-manage-transactions-staff/) or explore our [broader architectural overview on syncing property and deal data](https://truto.one/connect-lone-wolf-back-office-to-ai-agents-sync-property-deal-data/).

Giving a Large Language Model (LLM) read and write access to a specialized, compliance-heavy real estate back office system like Lone Wolf is an engineering hurdle. You have to securely manage client credentials, map highly normalized financial schemas into LLM-friendly tool descriptions, and build resilient HTTP transport layers. Every time the underlying API introduces a breaking change or alters a payload structure, your custom MCP server breaks. 

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Lone Wolf Back Office, connect it natively to Claude, and execute complex real estate back-office workflows using natural language.

> Want to give your AI agents secure, authenticated access to Lone Wolf Back Office and 100+ other SaaS APIs? Let's talk about managed MCP architecture.
>
> [Talk to us](https://truto.one/book-a-demo/)

## The Engineering Reality of the Lone Wolf Back Office API

A custom MCP server is essentially a [self-hosted integration layer](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/). While the open MCP standard provides a predictable way for models to discover tools, the reality of implementing it against specialized B2B APIs is painful. Lone Wolf Back Office manages the financial and operational lifeblood of real estate brokerages. Its API is built for strict data integrity, which introduces several unique integration challenges.

If you decide to build a custom Lone Wolf MCP server, here are the specific integration hurdles you will face:

**Fragmented Entity Relationships (Deals vs. Commissions vs. Deposits)**
In Lone Wolf Back Office, a real estate deal is not a single flat object. The API forces you to interact with a highly fragmented entity model. You cannot pull a "Deal" and get its commission structure and escrow deposits in one go. You must first fetch the transaction, extract the ID, then query the commission endpoint (`get_single_lone_wolf_back_office_commission_by_id`), and separately query the deposit endpoint. If you pass this raw schema directly to an LLM, the model will frequently hallucinate the relationships. A managed MCP server auto-generates explicitly described tools derived from API documentation, instructing the LLM exactly how to chain these lookups together.

**Strict Pagination Limits**
Fetching bulk data - like listing all employees, offices, or historical transactions - requires precise handling of limit and offset parameters. Lone Wolf strictly caps these at a maximum of 100 records per page. An LLM inherently struggles with stateful pagination loops. If your MCP server does not expose clear, deterministic tools with `limit` and `next_cursor` inputs (along with explicit instructions to the LLM to pass cursors back exactly as received), the model will drop records or enter infinite polling loops.

**Unforgiving Rate Limits (429s)**
Unlike consumer APIs, financial and operational SaaS platforms strictly throttle aggressive polling. When you hit a rate limit, the API returns an HTTP 429 error. Truto's architectural philosophy is strict transparency: Truto does *not* retry, throttle, or apply backoff on rate limit errors. If the upstream Lone Wolf API returns a 429, Truto passes that error directly to the caller. However, Truto normalizes the upstream rate limit information into standardized IETF headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`). The caller (your LLM client or agent loop) is entirely responsible for reading these headers and executing the appropriate retry/backoff logic. Do not expect the integration layer to magically absorb rate limit errors.

## Generating the MCP Server for Lone Wolf Back Office

Truto's MCP server generation is dynamic and documentation-driven. Rather than hand-coding tool definitions, Truto derives them from the integration's defined resources and documentation records. Every MCP server is scoped to a single integrated account (a specific customer's connected instance) and authenticated via a cryptographic token in the URL.

You can generate the MCP server using either the Truto Dashboard UI or programmatically via the Truto API.

### Method 1: Via the Truto UI

For internal testing or one-off agent setups, the UI provides a fast configuration path.

1. Log into your Truto dashboard and navigate to the **Integrated Accounts** page.
2. Select your connected Lone Wolf Back Office account.
3. Click the **MCP Servers** tab.
4. Click **Create MCP Server**.
5. Select your desired configuration (e.g., restrict to `read` methods only, or filter by specific tags).
6. Copy the generated MCP server URL (it will look like `https://api.truto.one/mcp/<token>`).

### Method 2: Via the Truto API

For production use cases where you are spinning up AI agents for your end-users dynamically, you will use the API. This endpoint validates that the integration has available tools, generates a secure hashed token, stores it in the edge key-value store, and returns the endpoint.

Execute a `POST` request to `/integrated-account/:id/mcp`:

```bash
curl -X POST https://api.truto.one/integrated-account/<YOUR_INTEGRATED_ACCOUNT_ID>/mcp \
  -H "Authorization: Bearer <YOUR_TRUTO_API_KEY>" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Lone Wolf Financial Agent MCP",
    "config": {
      "methods": ["read", "write"]
    }
  }'
```

The response provides the secure URL your agent will use:

```json
{
  "id": "mcp_abc123",
  "name": "Lone Wolf Financial Agent MCP",
  "config": { "methods": ["read", "write"] },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f67890..."
}
```

## Connecting the MCP Server to Claude

Because the MCP server URL encapsulates the tenant context and the authentication token, connecting it to an MCP client requires zero additional OAuth flows or environment variable setups.

### Method A: Via the Claude Desktop UI

If you are using the Claude Desktop app, you can connect remote MCP servers directly in the settings.

1. Open Claude Desktop.
2. Navigate to **Settings** -> **Integrations** (or **Connectors** depending on your version).
3. Click **Add MCP Server** (or Add Custom Connector).
4. Paste the Truto MCP URL (`https://api.truto.one/mcp/<token>`).
5. Click **Add**. Claude will immediately perform the initialization handshake and list the available Lone Wolf tools.

### Method B: Via Manual Config File (SSE Transport)

If you are running Claude Desktop and prefer manual configuration, or if you are using a framework that reads the standard Claude config file, you will use the `@modelcontextprotocol/server-sse` transport proxy to wrap the HTTP POST endpoint.

Edit your `claude_desktop_config.json` file (typically located at `~/Library/Application Support/Claude/claude_desktop_config.json` on macOS or `%APPDATA%\Claude\claude_desktop_config.json` on Windows):

```json
{
  "mcpServers": {
    "lonewolf_backoffice": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/<YOUR_TOKEN_HERE>"
      ]
    }
  }
}
```

Restart Claude. The application will spawn the SSE proxy bridge, connect to Truto's JSON-RPC 2.0 endpoint, and ingest the tool schemas.

## Hero Tools for Lone Wolf Back Office

Truto exposes the entirety of the Lone Wolf Back Office API as AI-ready tools. Here are the highest-leverage hero tools for automating real estate workflows.

### List All Transactions
**Tool Name:** `list_all_lone_wolf_back_office_transactions`

This is the core discovery tool for your agent. It allows the LLM to query the pipeline of active, pending, or closed real estate deals. You can filter by `startDate` and `endDate`. Truto automatically injects `limit` and `next_cursor` parameters into the schema to guide the LLM through pagination.

> "Fetch all Lone Wolf transactions created in the last 30 days. Page through the results until you have all of them, and give me a summary of total deal volume."

### Get Single Transaction By ID
**Tool Name:** `get_single_lone_wolf_back_office_transaction_by_id`

Once the LLM identifies a transaction of interest, it must use this tool to fetch the deep details - property address, closing date, sales price, and internal classifications. 

> "Get the full transaction details for deal ID 98765. Who is the primary agent assigned, and what is the current closing date?"

### Get Single Commission By ID
**Tool Name:** `get_single_lone_wolf_back_office_commission_by_id`

Commissions in Lone Wolf are notoriously complex, often split across internal employees, external agents, and brokerage fees. This tool allows the LLM to retrieve the exact financial breakdown for a specific transaction's commission record.

> "Look up the commission record for transaction ID 98765. Calculate the exact dollar amount split between our internal agent and the external co-broker."

### Create a Transaction
**Tool Name:** `create_a_lone_wolf_back_office_transaction`

Give your AI agent write capabilities to open new deals. The LLM must construct a JSON body schema containing required fields like classification, property type, and source of business. 

> "Open a new transaction in Lone Wolf for the property at 123 Main St. Set the property type to Residential and assign John Doe as the primary employee."

### Get Single Deposit By ID
**Tool Name:** `get_single_lone_wolf_back_office_deposit_by_id`

Escrow and earnest money deposits are strictly audited. Use this tool to verify that a buyer's deposit has been logged and cleared for a specific deal.

> "Check the deposit record ID 44556. Has the earnest money been received, and what was the exact deposit amount?"

### List All Employees
**Tool Name:** `list_all_lone_wolf_back_office_employees`

Retrieve the directory of internal staff and real estate agents managed by the brokerage. Useful for cross-referencing agent IDs before assigning them to a new transaction or calculating their commission splits.

> "List all employees in the system. Find the internal ID for 'Sarah Jenkins' so we can assign her to a newly created transaction."

### Get Single External Agent By ID
**Tool Name:** `get_single_lone_wolf_back_office_external_agent_by_id`

In real estate, half the transaction usually belongs to an external agent representing the other side of the deal. This tool pulls their contact information and brokerage details to ensure accurate payment routing.

> "Pull the external agent record ID 88221. Give me their brokerage name and email address so I can draft a closing confirmation email."

For the complete inventory of available tools, query parameters, and schema details, visit the [Lone Wolf Back Office integration page](https://truto.one/integrations/detail/lonewolfbackoffice).

## Workflows in Action

Connecting tools is just the prerequisite. The real value is in how Claude orchestrates these endpoints to execute complex back-office workflows autonomously.

### Workflow 1: End-of-Month Commission Audit

Brokerage administrators spend days at the end of every month reconciling closed deals and ensuring commission splits match expected internal classifications.

> "Find all transactions that closed this month. For each transaction, pull the associated commission record and verify that the internal agent's split matches the standard 70/30 classification. Flag any anomalies where the agent received less than 70%."

**Step-by-step execution:**
1. Claude calls `list_all_lone_wolf_back_office_transactions` with the date filters for the current month.
2. For each returned transaction, the agent extracts the ID and calls `get_single_lone_wolf_back_office_commission_by_id`.
3. The agent analyzes the JSON response, doing the math on the total gross commission versus the agent's net payout.
4. Claude returns a compiled markdown table of flagged transactions, detailing the deal address, the expected payout, and the actual recorded payout.

```mermaid
sequenceDiagram
    participant User
    participant Claude as Claude Desktop
    participant Truto as Truto MCP Server
    participant LoneWolf as Lone Wolf API

    User->>Claude: "Audit this month's closed deals..."
    Claude->>Truto: Call list_all_lone_wolf_back_office_transactions
    Truto->>LoneWolf: GET /transactions
    LoneWolf-->>Truto: Transaction List
    Truto-->>Claude: JSON Array
    
    loop For each transaction
        Claude->>Truto: Call get_single_lone_wolf_back_office_commission_by_id
        Truto->>LoneWolf: GET /commissions/{id}
        LoneWolf-->>Truto: Commission Details
        Truto-->>Claude: JSON Object
    end
    
    Claude-->>User: Markdown table of flagged commission anomalies
```

### Workflow 2: New Deal Intake and Escrow Verification

When a purchase agreement is signed, the deal must be logged, and the earnest money deposit must be verified before the transaction moves to pending status.

> "I just received a signed contract for 456 Elm St. Create a new transaction in Lone Wolf assigning Employee ID 102. Once created, check deposit ID 99112 to verify the escrow funds have cleared."

**Step-by-step execution:**
1. Claude calls `create_a_lone_wolf_back_office_transaction` using the provided address and employee ID, structuring the exact JSON body required by Lone Wolf.
2. Claude receives the success response containing the newly created transaction ID.
3. Claude calls `get_single_lone_wolf_back_office_deposit_by_id` passing ID 99112 to read the escrow status.
4. Claude reports back to the user that the deal is opened under the new ID, and confirms the status of the deposit.

```mermaid
flowchart TD
    A["User Prompt<br>(New Deal Intake)"] --> B["Claude Agent<br>(Plans execution)"]
    
    subgraph Write Operations ["Write Operations"]
        C["Call create_a_lone_wolf...<br>(Constructs JSON body)"]
    end
    
    subgraph Read Operations ["Read Operations"]
        D["Call get_single_deposit...<br>(Verifies escrow funds)"]
    end
    
    B --> C
    C -->|Returns New Tx ID| D
    D --> E["Final Output<br>(Deal created, Escrow confirmed)"]
```

## Security and Access Control

Exposing financial SaaS data to an AI model requires strict boundaries. By default, anyone with the MCP URL can call the tools. Truto provides four critical security controls applied directly to the MCP token configuration:

*   **Method Filtering:** Limit the server's capabilities by explicitly declaring allowed operations. By setting `config.methods: ["read"]`, you completely eliminate the risk of the LLM accidentally creating, updating, or deleting a transaction.
*   **Tag Filtering:** Restrict access to specific functional areas of the API. Setting `config.tags: ["directory"]` will expose the employee and agent listing tools, while hiding all financial, commission, and transaction data.
*   **Expiration (`expires_at`):** Generate ephemeral MCP servers for temporary workloads. Setting an ISO datetime enforces a strict time-to-live, automatically deleting the server and invalidating the token from the edge store when time expires.
*   **Extra Authentication (`require_api_token_auth`):** Enable this flag to require clients to pass a valid Truto API token in the `Authorization` header alongside the URL token. This ensures that even if the MCP URL leaks in a log file, it cannot be used by unauthenticated actors.

## Moving Forward with Agentic Workflows

Connecting Claude to Lone Wolf Back Office transforms how brokerages manage their operations. Instead of forcing administrators to navigate dozens of UI screens to reconcile commissions or hunt down missing escrow deposits, AI agents can execute these multi-step investigations autonomously via the MCP protocol.

By leveraging a managed MCP architecture, you offload the pain of parsing Lone Wolf's complex API schemas, handling token rotation, and keeping tool definitions synchronized with upstream documentation. Your engineering team can focus on designing superior agent prompts and workflow logic, while the infrastructure handles the plumbing.

> Ready to deploy production-grade AI agents? Let's discuss how Truto can manage your MCP infrastructure and give your LLMs secure access to B2B SaaS.
>
> [Talk to us](https://truto.one/book-a-demo/)