How to wire a knowledge agent to your company brain via MCP

The agent is the surface. The brain is the hard part.

A useful knowledge agent lives where work already happens — Slack, an internal app, Cursor, a custom agent host — and answers from live company truth instead of a scraped wiki. That agent is yours to build. The missing piece is almost never the chat UI. It is the durable layer underneath: live data, approved definitions, permissions, and memory that every agent can share.

That layer is your company brain. Loxtep builds it. You build the agent on top — through MCP, API, or SDK — and embed it wherever your team already works.

Why bolting MCP onto a model is not enough

Teams already connect Claude, Cursor, and custom agents to Salesforce, Shopify, Stripe, and Zendesk via MCP. Live connectors help — then reality shows up: systems stay separate, relationships are guessed, and every person ends up with their own private “company context” on their own machine. You get five answers to “where is order #4821?” and none of them agree on the refund.

MCP is an activation path, not a company brain. Without a shared governed layer, every new agent re-discovers (and re-misreads) your business. That is the fragmentation we wrote about in one context layer for AI agents and governed context vs. Cowork chaos.

Step 1 — Build the company brain first

Before you obsess over prompts, connect the systems your agent will need and approve what “true” means:

• Connect tools once — orders, tickets, CRM, billing, docs — so the brain reads live data instead of exports.
• Approve definitions — what “order status,” “active customer,” or “refund approved” means in your business.
• Set permissions — fail-closed scopes so an agent cannot mix contexts it should never see together.
• Keep memory durable — patterns that work get promoted into the brain, so the tenth agent is smarter than the first.

If you skip this step, MCP just gives a smart model faster access to the same mess.

Step 2 — Point your agent host at Loxtep MCP

Once the brain exists, activation is the thin layer. Loxtep exposes the company brain through MCP at the hosted surface agents already know how to call (mcp.loxtep.io, with OAuth so access stays tied to real users and roles — not a shared forever-token in a config file).

In practice:

1. Choose the host where your agent will live — Claude, Cursor, a Slack bot, an internal web app, or your own agent runtime.
2. Register Loxtep as an MCP server for that host. Authenticate so the session inherits the right org and permissions.
3. Confirm the agent can only reach the data products, tools, and actions you scoped — out-of-scope calls should fail closed, not “try anyway.”
4. Ask a real question that spans systems (order + payment + ticket). The answer should come from the company brain, not from three disconnected connectors stitched in the model's head.

Step 3 — Scope the agent like a production employee

Knowledge work needs guardrails that do not exist in code compilers: you may have access to two customer contexts separately, and still must never combine them in one analysis. Your company brain has to enforce that class of rule.

When you wire MCP, treat scopes as product decisions: which domains this agent may read, which actions require human approval, and what leaves an audit trail. A support agent that can see order and billing status is useful. A support agent that can quietly rewrite payroll is a lawsuit with a chat window.

Step 4 — Optional: typed SDK for builders who hate stringly-typed tools

If you are building the agent in code — not only chatting through an MCP-capable host — use the typed path:

• Run loxtep generate to emit workspace constants for data products, connectors, and workflows.
• Import @loxtep/sdk and call the brain with identifiers the compiler can check.
• Misspell a resource in development, not in production.

MCP and the SDK read the same company brain. Pick the dialect that matches how you ship — chat host, Slack bot, or typed service. Details for builders live on For Agent Builders.

Step 5 — Embed the agent where work already happens

Do not force people into a new destination app unless that is the product. The point of a company brain with surface-agnostic activation is that the same knowledge shows up in Slack for GTM, inside a finance tool for analysts, and in Cursor for engineers — without five competing truths.

A concrete win: a support agent that answers “Where is order #4821, and was my refund approved?” from live orders, billing, and tickets, with permissions enforced and a trail of what it read. That is real leverage. The chat bubble is the easy part.

What not to do

• Per-user RAG islands — everyone uploads their own docs and calls it “company knowledge.” It is not.
• Unscoped tool access — giving an agent every MCP connector “for flexibility” is how you get creative data leaks.
• Treating MCP as the product — connectors without a company brain recreate the same fragmentation with better branding.
• Skipping approval — if definitions and procedures never get human review, you have automated guessing at scale.

Technical footnote: Enterprise Context Layer

“Company brain” is the public name for what you are building. Technically, Loxtep implements an Enterprise Context Layer — the substrate of governed data, semantics, skills, and compounding loops that make the brain machine-usable. If you want the framework breakdown (substrate parts, five capabilities, token capital), read Loxtep is an Enterprise Context Layer or the platform page. For shipping day-to-day, you only need the split: brain underneath, your agents on the edges via MCP.