Skip to content

A knowledge base for AI agents, with trust built in.

Files, messages and tickets from outside your team are checked first, and your agents read them with their source and a verdict. Each customer gets its own space, and an agent working for one can't read another's.

Five examples of content reaching an AI agent through FoxNose, played in turn. Choose one to see what FoxNose finds and what the agent gets.

What people upload or send is labelled and checked before your agents read it

  • Files
  • Messages
  • Tickets
  • Comments
  • Forms
  • Emails
What makes FoxNose different

A space per customer, a verdict on what agents read, one MCP endpoint

Multi-tenant out of the box

A separate space for every customer

Isolation lives in the data model, so no query in your code has to remember to filter by customer.

  • Each record belongs to one customer. Ask for the wrong customer and you get a 404, never an unfiltered list.
  • Short-lived tokens your backend signs for each end user. The token decides whose data an agent sees and writes, so a prompt can't point it at another customer's.
  • OAuth for hosted connectors (soon), and project data stored in the EU.

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.

Trust in agent knowledge

Checked before your agents read it

Everything that did not come from you (user files, agent writes, imports) is labelled, checked and gets a verdict before an agent reads it.

  • User uploads are scanned, rendered to visible text and delivered with a verdict. Agents never receive the original file.
  • Records written by agents and end users are labelled as untrusted, with who wrote each field.
  • Checks on write, quarantine for review, versions and an audit trail.

A refund ticket from a customer chat, a receipt with a prompt attack written on it, and your team's decision. Some steps are done by people (an agent, the customer, your team), some by FoxNose on its own. Choose a step, or drag the timeline, to see what changed.

Agents read and write on their own

A hosted MCP server on every API

Connect the agents you build for support, sales, ops or your shop to one endpoint. They search, read and write your collections with the same permissions as your app.

  • Five read tools, plus two write tools you switch on per key and per collection. A write where they are off is refused, and nothing is written.
  • Answers carry trust labels and who wrote each field, so an agent can tell your data from what a customer sent.
  • One endpoint for every API: the key decides the environment and the API. Works with any MCP client, with bearer tokens or OAuth (soon).

An ops, a support, a sales and a shop agent built for your business connect to one MCP endpoint, which serves your collections with the same permissions as your app. Choose an agent to see its call and the answer.

One service instead of a stack to maintain

Everything you would otherwise run and keep in step. In FoxNose they come from one schema and one set of permissions.

What you would build and keep in sync

  • Records databaseschemas and migrations
  • Embedding pipelinere-embeds on every change
  • Vector databasea second copy to keep in step
  • Keyword searchand code that merges rankings
  • MCP servertools written by hand
  • File intakeupload page, malware scan, safe text
  • Content screeningprompt attacks, hidden text
  • Per-customer accessfilters and scoped tokens
  • Versions and auditwho changed what, and when

FoxNose

One schema, one set of permissions

  • Typed records and schemas
  • Embeddings on write
  • Vector search
  • Keyword and hybrid search
  • A hosted MCP server
  • File intake and checks
  • Verdicts on what comes in
  • A space per customer
  • Versions and audit

See each piece of the stack and what it takes to run it →

Get started

Connect your first agent

Point an MCP client or the LangChain retriever at your knowledge base and your agent can search and read it.

# mcp config for any HTTP MCP client
{
  "mcpServers": {
    "foxnose-support": {
      "type": "http",
      "url": "https://mcp.foxnose.net/_mcp",
      "headers": {
        "Authorization": "Bearer fxk_…"
      }
    }
  }
}
# → tools instantly available:
#   discover_resources · describe_resource · query_records · get_record · search_records
#   + create_record · update_record (opt-in, for keys you allow to write)
# Same auth as REST. Same data. No tool catalog to hand-write.

Define a schema in the dashboard. Its Knowledge MCP server is reachable at mcp.foxnose.net/_mcp over Streamable HTTP, generated for you with no server to deploy; the key picks the API. Works with any MCP client that speaks Streamable HTTP. How it works →

From signup to your first agent query

Sign up. Define a schema. Create an API. Drop the MCP server URL into your MCP client, and your agent is reading your knowledge.