Skip to content
Multi-tenancy

A separate space for every customer

Every customer and every end user gets their own space in one knowledge base. Isolation lives in the data model, not in filters in your code.

Built into the data model

The tenant is part of the data

You do not add a tenant column and remember to filter on it in every query. The customer is part of how records are stored and addressed.

A space per customer

Each customer is a record, and everything that belongs to that customer lives under it: tickets, notes, files, memory. One knowledge base serves all of them.

Records owned by a customer

Every record in a customer-owned collection belongs to exactly one customer record, and is read through that customer's address.

Reading one customer's data

The customer is part of the route, so a record is only ever read under the customer that owns it.

requests
# Customer records: Acme is dw2qC5qRwxuZ, Globex is hG9tL4nRmXwP

# Acme's tickets sit under Acme's key
GET /customers/dw2qC5qRwxuZ/tickets/
    -> Acme's tickets, and only Acme's

# vr8x2k9m is an Acme ticket, asked for under Globex's key
GET /customers/hG9tL4nRmXwP/tickets/vr8x2k9m/
    -> 404 Not Found

Illustrative routes for a customer-owned collection. Record keys are generated by FoxNose; your collection names set the rest of the path.

Strict reference

Records that belong to one customer

Each customer is a record, and everything under it belongs to that customer. Reads, search and tokens all follow that tree.

Collection Structure

Customers
Tickets → customers
Files → tickets

Each customer owns everything under it. URLs follow the owner, and records are read under the customer that owns them.

Generated endpoints
GET/customers/
GET/customers/:customer_key/
GET/customers/:customer_key/tickets/
GET/customers/:customer_key/tickets/:ticket_key/
GET/customers/:customer_key/tickets/:ticket_key/files/
GET/customers/:customer_key/tickets/:ticket_key/files/:file_key/

One space per customer

Tickets, notes, files and memory live under the customer that owns them.

Read under the owner

Ask for a record under the wrong customer and you get a 404, as if it didn't exist.

Tokens for agents

A token your backend signs keeps an agent inside one customer, on nested and flat routes alike.

Tenant tokens for agents

An agent that sees one user's data

An agent that works for one end user should see that user's data and write only where you allow it. Your backend gives it a token that says so.

An agent works for one customer, Globex, with a short-lived token. Four cases, played in turn: it reads, searches, asks for another customer's ticket, and writes. Choose one to see what comes back.

Signed by your backend

Your backend signs a token for each user without calling FoxNose. FoxNose holds only the public half of the signing key.

Short-lived

A token lasts 15 minutes by default and at most 24 hours. You mint a fresh one per session or before it expires.

Cannot be widened

The holder reads and writes only inside the record the token names. It works over REST and over the hosted MCP server.

session token claims
{
  "aud": "flux:<env key>",
  "sub": "user_42",
  "anc": [
    { "c": "customers", "r": "dw2qC5qRwxuZ" }
  ],
  "col": ["notes", "tickets"],
  "iat": 1790000000,
  "exp": 1790000900,
  "jti": "<unique id>"
}

# signed by your backend, sent as
Authorization: Bearer fxt_…

The anc claim names the customer record the token is limited to; col limits it to the listed collections.

The MCP server builds the agent's tool list from the token. The agent sees only the collections it can reach, and each tool description ends with a plain statement of what it may do, such as which collections it can read and which it can update.

A record outside the token's space gets a 404, the same answer as a record that does not exist, so the agent cannot probe for other customers' data, even if content it reads tells it to try.

For integrations that need a long-lived credential, FoxNose will also be able to issue tokens it stores (soon). For connectors set up once in a chat product, FoxNose will run the OAuth flow, your backend will vouch for the user, and the connector will get a short-lived token limited to that user's data (soon).

Give every customer their own space

Create a project, model your customers as records, and give each agent a token that reaches one customer only.