MCP

Your people already have an AI assistant. It knows nothing about your company.

Take an honest inventory of what is happening in your organization right now.

Somebody in strategy is pasting chunks of a confidential research deck into a consumer chatbot to get a summary. Somebody in marketing is asking an AI assistant to help write a brief, and the assistant is inventing plausible consumer behavior because it has no access to the eleven studies your company paid for. Somebody in finance has built an impressive workflow on top of a model that has never seen a single internal document.

This is not a discipline problem. Those tools are useful, people are busy, and the path of least resistance runs straight through the copy-paste buffer. The problem is that your knowledge base and your employees' AI tools live in separate universes.

MCP closes that gap. Model Context Protocol is an open standard that lets an AI assistant connect to an external system as a tool. We are building a Sharpr MCP server, which means the assistant your people already use can query your knowledge hub directly, with your permissions enforced, and cite what it found.

What this enables

Once connected, an assistant can retrieve and reason over your organization's knowledge as part of whatever the person is already doing.

Someone drafting a strategy memo in their AI tool asks it to check the claim about category growth. It queries your hub, pulls the two relevant studies, and cites them inline.

Someone preparing for a client meeting asks the assistant to summarize everything the firm knows about that client's sector. It reads from the hub rather than from the open internet.

Someone building a competitive analysis asks for the last six months of intel on a named competitor. It pulls from your CI hub, which contains what your team collected, not what a web crawler found.

The assistant becomes useful in a way it currently is not, because it finally has access to the thing that makes your company different from every other company, which is what your company knows.

Permissions, because this is the part that matters

Every MCP request runs as an authenticated user. The server returns only what that person is entitled to see in Sharpr.

If an analyst cannot open the restricted pricing hub in the platform, their AI assistant cannot read it either. If a contractor has access to two hubs and not the other nine, that is exactly what the assistant sees. Role-based access control extends to the protocol layer rather than stopping at the web interface.

We are stating this early and plainly because it is the first question every security team asks, and because the industry is about to produce a generation of AI integrations that get it wrong. An AI connector that ignores entitlements is a data breach with a friendly interface.

Use cases we are building toward

Strategy and corporate development: research inside the drafting tool

Analysts spend most of their day in a small number of tools. Making them leave one to search another is a tax that gets paid in avoidance. With MCP, the hub comes to them, and the memo gets written with the internal evidence rather than despite it.

Competitive intelligence: assembled analysis on demand

CI teams collect relentlessly and then spend hours assembling. An assistant that can query the CI hub directly turns "pull together what we have on their channel strategy" into a task that starts with a complete evidence base instead of a folder crawl.

Insights and research: the duplicate check, one step earlier

The duplicate research problem is already solved by our Answers Engine, but only for people who think to check. MCP moves the check into the workflow where the request is being written, which is where the money gets committed.

Consulting and agencies: client context without the copy-paste

If you run client hubs, MCP lets your consultants work with client knowledge in their assistant while the entitlement boundaries between clients stay enforced. That boundary is the reason most firms have been cautious about AI tooling, and enforcing it at the protocol layer is how the caution gets resolved.

Sales and commercial: preparation that takes four minutes

A relationship manager asks their assistant what the bank knows about a prospect's industry before a call. The answer comes from internal research and analyst subscriptions the organization already pays for, rather than from a generic web summary the prospect could have generated themselves.

Developers and technical teams: build on top of it

MCP is a standard, which means the hub becomes addressable by anything that speaks it. Internal tools, custom agents, workflow automations. We are not going to pretend we can predict everything customers will build, and that is the interesting part.

Why we are building on a standard instead of a proprietary integration

We could ship a custom plugin for whichever AI vendor is largest this quarter. Several of our competitors will.

We are not doing that, for a straightforward reason: nobody knows which assistant your company will be standardized on in three years, including your company. Betting the integration strategy on a single vendor is how you end up rebuilding it twice.

MCP is open. Support is growing across assistants and development tools. Building against the protocol means our customers are not waiting on us to pick winners, and it means the integration keeps working when your internal tooling changes.

What this will not be

It will not be an unrestricted data pipe. Entitlements, audit logging, and admin controls apply. Administrators will decide whether MCP access is enabled at all, for which hubs, and for which users.

It will not send your knowledge base anywhere for training. The server responds to queries. It does not export your corpus, and content retrieved through it remains governed by the same terms as content retrieved through the platform.

It will not replace the platform. Sharpr is where knowledge is captured, curated, distributed, and measured. MCP is a door into it. A door is extremely useful and it is not a building.

The honest status update

This is on our roadmap and it is in active development. We are publishing this page before general availability because customers ask us about it in almost every security and roadmap conversation, and because we would rather tell you what we are building than be coy about it.

If AI tooling integration is part of your evaluation criteria, tell your customer experience manager or raise it during a demo. Customer demand drives our sequencing, and MCP is a feature where a specific description of your intended workflow is more useful to us than a general expression of interest.

We will announce availability through release notes and directly to administrators. We are not going to give you a date on a web page, because roadmap dates on web pages are a promise made by marketing and kept by engineering, and we would rather ship it properly.

What to do in the meantime

Two things are worth doing now, regardless of when MCP lands.

Get your knowledge into one governed place. The value of any AI integration is capped by the quality and coverage of what it can reach. A connected assistant pointed at a fragmented drive produces fragmented answers. The migration work has to happen either way, and it is free.

Get your permissions right. Whatever entitlement structure you have in Sharpr is the structure your AI integration will inherit. Organizations that have thought carefully about hubs and roles will turn this on with confidence. Organizations that have granted everyone access to everything will have a more interesting conversation with their security team.

Both of those are things we help with today, and both of them are worth doing for their own sake.

Try this

Ask three people on your team what they have pasted into an AI assistant this month.

Ask it in a way that makes clear nobody is in trouble, because you want an honest answer, and the honest answer is the business case for this feature. Then book a demo and we will talk about what a governed version of that behavior looks like.