An Internal AI Marketplace Without the Supply Chain Risk

An Internal AI Marketplace Without the Supply Chain Risk

Table of Contents

Here’s a question every CISO will be asked within the next year: “Can we set up an internal AI marketplace so teams can share AI agents and tools?”

The right answer is yes. The wrong way to deliver it is as an app store with no inspection.

Once teams start building agents, MCP servers and reusable skills (packaged instructions that teach an AI assistant how to do a task), they’ll want to share them. A central catalog is far better than the alternative, which is copying things around in chat messages and personal repositories. But the moment you build that catalog, you’ve built a software supply chain. And unlike most supply chains, this one ships instructions that your AI will follow.

This is the third article in a series. The first covered the MCP protocol, and the second covered the gateway that controls access. This one is about the catalog behind it: how to run an internal AI marketplace that’s safe to shop in.

AI supply chain risk in plain English

An internal AI marketplace typically holds three kinds of item:

  • MCP servers, which give AI access to tools and data.
  • Agents, which perform tasks and can be called by people or by other agents.
  • Skills, which are written instructions that shape how an AI assistant behaves.

Each one is a way for someone else’s work to influence what your AI does. So before you open the doors, ask:

  1. Who is allowed to publish, and what checks happen before something is listed?
  2. Who can see each item? Is everything visible to everyone by default?
  3. If an item changes after it’s approved, will we know?
  4. If we discover a bad item, can we pull it immediately and see who used it?

These are the same questions you’d ask about any software supply chain. The difference is how quickly a bad item turns into a bad action.

Let me paint a picture

Think about how a supermarket handles what goes on its shelves.

Nothing arrives straight from a supplier’s van onto the shelf. Goods are checked when they come in. Some products are clearly labeled as own-brand, some as premium, some as budget. Certain items only go in certain aisles, and some are kept behind the counter. Packaging has tamper-evident seals, so if anything is opened after it leaves the factory, you can tell. And when a problem is found, the supermarket issues a recall: the product comes off every shelf at once, and they know which batches were sold.

Now imagine a supermarket where anyone can walk in and put anything on any shelf, with no labels, no seals and no way to run a recall.

You wouldn’t shop there. Yet that’s roughly what an uncontrolled AI catalog looks like.

Now what?

Why “scan it once” isn’t enough

The instinctive control is to run a security scan when something is submitted. You should. But on its own it leaves two big gaps.

AI components change after you approve them. A skill is often registered as a link to a file in a code repository. An MCP server is a live service. Both can change tomorrow. Scanning once checks the item you were shown, not the item that’s running next month.

The biggest risk is often exposure, not malice. A perfectly well-intentioned HR agent with access to salary data is a problem if every engineer in the company can find and call it. Most marketplace incidents won’t start with an attacker. They’ll start with something useful being visible to the wrong people.

Principles for a secure AI marketplace

If you only take one section of this article back to your team, take this one.

  1. Nothing goes on the shelf until it’s been inspected. Every agent, server and skill passes admission checks before anyone can discover or use it.
  2. Failing a check means disabled, not deleted. Suspicious items are held for review, not silently dropped, so security teams can see what was attempted.
  3. Labels must mean something. Trust levels reflect actual verification, not the publisher’s opinion. Popularity ratings are not a security signal.
  4. Private by default, shared on purpose. New items should be visible only to their owner or team until someone deliberately widens access.
  5. Seal what you approve. Record exactly what was approved and detect when it changes.
  6. Be able to recall anything in minutes. Disable an item for everyone at once, and know who used it.
  7. Imports are suppliers too. Anything pulled in from an external or partner registry goes through the same checks as internal submissions.

A secure AI marketplace architecture

The registry my team built for our AI platform is, in effect, this marketplace. It catalogs MCP servers, agents, skills and curated virtual servers (bundles of approved tools) in one place, with a named owner and a lifecycle status (draft, beta, active or deprecated) on each item, searchable by keyword and meaning. Everything in it is reached through the gateway, behind one access model.

Here’s the lifecycle I design for.

flowchart TB
    P["Publisher submits, or
auto-discovery finds, an item"] --> GATE{"Admission check
(your approval policy)"} GATE -->|"denied"| X["Rejected and logged"] GATE -->|"approved"| SCAN{"Security scan"} SCAN -->|"high or critical findings"| HOLD["Registered but disabled
pending review"] HOLD -->|"reviewed and fixed"| SCAN SCAN -->|"clean"| LIST["Listed with owner, status,
trust level and visibility"] LIST --> USE["Discovered and used
through the gateway"] LIST -.->|"content changes
or scheduled rescan"| SCAN USE -.->|"recall"| OFF["Disabled for everyone"]

1. Goods in: admission and scanning

Two checks should happen before anything is listed.

An admission gate. Every registration is sent to an approval step you control, which returns allow or deny. That’s where your own policy lives: required ownership metadata, naming rules, an architecture review for anything touching regulated data, or a simple human approval. It must fail closed: if the approval service can’t be reached, nothing gets registered.

Automated security scanning. Each item type needs a purpose-built analyzer. Open-source scanners now exist for MCP servers, agents and skills, looking for hidden instructions and prompt injection, command injection, data exfiltration patterns and hardcoded secrets. Anything with high or critical findings should be registered but disabled, so it can’t be discovered or called until someone reviews it. Build the scanner in as a pluggable service, so you can swap or combine tools as they mature.

One trap to avoid: auto-discovery that skips the queue. Our registry can discover MCP servers running in our Kubernetes clusters automatically and add them to the catalog, and remove them again when they disappear. That keeps the inventory complete and honest, which is hugely valuable. But automatically discovered items must go through the same admission and scanning as everything else. Discovery should make an item known, not available.

The result: nothing reaches the shelf without passing both your policy and a security check.

2. Labels: trust levels that mean something

Every item should carry a trust label, for example unverified, community, verified and trusted, tied to a real process. Verified should mean your team verified it, not that the publisher said so. For agents, cryptographic identity (such as signed agent cards) can back the label up.

Lifecycle status is a label too. Draft and beta items shouldn’t be callable by production workloads, and deprecated ones should carry a clear end date.

And the star ratings every marketplace ends up with (ours included) should be treated as what they are: a measure of usefulness, not safety.

The result: people can make informed choices, and policy can require a minimum trust level for sensitive use.

3. Aisles: who can see what

Visibility needs two layers, and both must say yes:

  • Administrators grant each group access to the marketplace, either broadly or to specific items.
  • Publishers restrict their own item to named groups, even within a broad grant. The HR team should be able to publish a salary agent that only HR can see, without waiting for an administrator to redesign everyone’s permissions.

Items can be public, group-restricted or private, and new items should start private. Crucially, search and discovery results must be filtered by the same rules. It’s easy to secure the “call” path and forget that the catalog itself leaks what exists.

The result: sharing is easy, and oversharing is a deliberate act rather than an accident.

4. Seals and recalls: catch change, act fast

Record a cryptographic fingerprint of exactly what you approved, especially for skills, which are often registered as a link to a file that can change at any time. If the content changes, flag it and send it back through review. For MCP servers, versioning does the same job: our gateway can run several versions of a server side by side, so clients can be pinned to a known version and rolled back instantly if a new one misbehaves. Scheduled rescans catch newly discovered issues in items that were clean when approved.

And when you need a recall, every item in our registry has an enable switch. Turning it off removes the item from the gateway for everyone, immediately, while the audit log tells you exactly who used it.

The result: approval isn’t a one-off event. It holds for as long as the item is on the shelf.

5. Imported goods: federation

Large organizations rarely have one catalog. Business units run their own, and you may want to import from public or partner registries. Our registry federates with other registries and peers, only exporting items marked for sharing, and I’d apply three rules to any federation:

  • Import only what you’ve chosen, using an explicit allowlist or tag filter rather than syncing everything.
  • Imported items go through the same admission, scanning and trust labeling as internal ones.
  • Prefer short-lived OAuth credentials between registries over long-lived shared tokens, and clean up items when a peer is removed so stale entries don’t linger.

How this fixes the problem

Let’s go back to the supermarket.

Goods are checked on arrival. They’re clearly labeled. They’re shelved in the right aisles, some behind the counter. They carry tamper-evident seals. And when something goes wrong, they’re recalled from every shelf at once, with a record of who bought them.

In practice, that gives you:

  1. A single, trusted catalog of every AI component in use.
  2. Admission control that combines your policy with automated security analysis.
  3. Least exposure by default, with sharing as a deliberate choice.
  4. Change detection, so approvals don’t silently go stale.
  5. Fast, complete recalls backed by an audit trail.

An AI marketplace is a software supply chain that ships instructions, not just code. Run it like one.

What this doesn’t do

  • Scanners are not a guarantee. They catch known patterns and obvious intent. A carefully crafted malicious skill or tool description can still get past them. Human review still matters for high-risk items.
  • A clean scan says nothing about business risk. An agent can be perfectly safe code and still be the wrong thing for most people to access. That’s what visibility and approvals are for.
  • Drift detection is only as good as its coverage. Know which item types are fingerprinted and which rely on scheduled rescans, and fill the gaps with version pinning.
  • The catalog doesn’t control runtime behavior. Once something is approved, the gateway and the agents themselves still have to enforce least privilege on every call.

How I’d roll it out

  1. Phase 0: Find what exists. Inventory the agents, MCP servers and skills already circulating across teams.
  2. Phase 1: Register and scan. Bring them into the catalog, scan everything and quarantine what fails. Expect some surprises.
  3. Phase 2: Set the defaults. Private by default, unverified until reviewed, and a named owner required for every item.
  4. Phase 3: Plug in approvals. Connect the admission gate to your existing review workflow, starting with anything that touches sensitive data or can take actions.
  5. Phase 4: Make it the only way in. Route usage through the gateway so unregistered items simply don’t work.
  6. Phase 5: Keep it honest. Scheduled rescans, drift alerts, quarterly access reviews and a practiced recall procedure.

The trade-offs to watch

  • Speed versus scrutiny. Heavy approval processes push people back to sharing things informally. Automate the low-risk path and reserve human review for high-risk items.
  • False positives. Security tools legitimately describe dangerous-sounding things. Give publishers a fast way to request review so good work isn’t stuck in quarantine.
  • Ownership decay. Every item needs a named owner, and ownership must transfer when people move on. Orphaned agents are tomorrow’s incident.
  • Federation trust. Every connected registry extends your supply chain. Treat partner registries as suppliers, with the same due diligence.

What to ask your team on Monday

  1. Where are teams sharing AI agents, MCP servers and skills today, and who approves them?
  2. What checks happen before an item becomes discoverable, and do they fail closed?
  3. Is a new item visible to everyone by default, or only to its owner?
  4. If an approved skill or server changed tonight, would anything flag it?
  5. How quickly could we pull a bad item from use everywhere, and could we see who used it?

An internal AI marketplace will happen whether security leads it or not. If you lead it, you get a single catalog with inspection, labels, seals and recalls. If you don’t, you get the same components, shared anyway, with none of those things.

Nothing goes on the shelf until it’s been inspected. Then keep inspecting it for as long as it stays there.

Frequently asked questions

What is an internal AI marketplace?

An internal AI marketplace is a central catalog where teams publish and discover AI agents, MCP servers and skills. It replaces sharing AI components informally, and gives the organization one place to approve, label, control and recall them.

What is AI supply chain security?

AI supply chain security protects the components your AI systems depend on, such as models, MCP servers, agents and skills, from malicious or vulnerable content. It covers admission checks, scanning, provenance, change detection and the ability to recall a bad component.

How do you secure agent skills?

Treat skills as untrusted instructions: scan them for prompt injection and exfiltration patterns before approval, record a fingerprint of the approved content, flag any change for re-review, and restrict who can see and use each skill.


If you’re building an internal AI marketplace and want to pressure-test your architecture, book a strategy session.

Share :

Related Posts

Welcome to AI Security Architects

Welcome to AI Security Architects

AI systems are moving from experiments to production faster than most security architectures can adapt. Models call tools, agents act with real credentials, and sensitive data flows through retrieval pipelines that did not exist a year ago. AI Security Architects is a place to work through what secure design looks like in that world.

Read More