Moonfire

Moonfire had reached the point many AI-forward teams hit quickly: MCP was useful, but the setup was starting to sprawl.

The team had MCPs spread across different systems, each with its own setup, authentication, and operational behavior. They wanted one place to bring those tools together, while still preserving a critical requirement: actions needed to run as the user, so provenance stayed intact across both reads and writes.

Moonfire built its own MCP server on top of Metorial. With Metorial handling the platform layer, the team created a single pane of glass across data sources, tools, and messaging platforms. Complex authentication flows became simple for users, and session visibility made it easier to see what happened when something broke.

The Challenge

MCP sprawl was becoming its own infrastructure problem

Moonfire was already deep in the agentic tooling world. The team had built and adopted MCPs across different systems, but the more useful the pattern became, the harder it was to manage.

Each MCP carried its own operational surface: authentication, setup, user access, tool behavior, and debugging. That gets especially difficult when tools are not just reading data, but also taking actions on behalf of users.

For Moonfire, user provenance mattered. They needed actions to happen as the user, not as an untraceable shared service account. That meant every read and write needed to preserve who initiated it, what tool was used, and what happened during the session.

The team needed a central layer that could bring the MCP estate together without flattening identity or losing control.

The Solution

Metorial as the platform beneath Moonfire’s MCP layer

Moonfire built its own MCP server on top of Metorial.

Metorial gives the team the foundation for connecting data sources, tools, and messaging platforms through one governed layer. It handles the hard parts underneath: authentication, user-level access, session visibility, and the operational details that make MCP reliable in practice.

From the user’s perspective, the experience becomes simple. What used to require a complicated setup process now feels close to a single click.

For the platform team, the experience becomes easier to operate. If something goes wrong, Metorial gives visibility into the session so they can see what happened, where the breakdown occurred, and how to fix it.

Focus Area

One place for MCP access

Moonfire brings data sources, tools, and messaging platforms together through a single Metorial-backed layer, instead of managing scattered MCP setups across systems.

User provenance

Actions run as the user, preserving provenance across reads and writes. That gives the team a clearer record of who did what and why.

Complex authentication

Metorial handles the auth flows behind the scenes, turning a complicated setup into a simple user experience.

Session visibility

When something breaks, the team can inspect sessions and understand where the issue happened, instead of debugging across disconnected systems.

The Result

A cleaner, more reliable MCP operating model

With Metorial, Moonfire turns a growing set of MCPs into a unified internal platform.

Users get simpler access to tools. The platform team gets stronger control over authentication, provenance, and troubleshooting. The company gets a single pane of glass across data sources, internal tools, and messaging platforms.

The result is both practical and strategic. Metorial makes Moonfire’s own agent infrastructure easier to operate, while reinforcing the investment thesis behind the company’s bet on Metorial.

Broader Impact

MCP needs an operating layer

MCP makes it easier for agents to use tools, but it does not remove the need for infrastructure. As soon as teams use MCP seriously, they run into the same questions: authentication, user identity, provenance, debugging, and how to keep a growing tool surface manageable.

Moonfire’s experience shows what the next layer looks like.

Metorial gives teams a way to bring MCPs together, preserve identity, simplify auth, and see what happened inside each session.

That is what turns MCP from a collection of connectors into infrastructure teams can trust.