Developer signup is open. Create your account →
Reusable capabilities for real agent work

Enable the agent.

Give agents approved capabilities they can discover and call. Package integration logic in a Unified App, or expose individual service operations through MCP. Fused runs the calls and keeps provider credentials in Engine.

Your integration logic. Agent-ready access. Shared with your backends.
Agent interfaceMCP Server
Engine connected
search_docsFind the right tool for the taskDiscover attached Unified Apps and approved service operations, with the inputs each capability needs.
then
executeComplete work across servicesInvoke a reviewed Unified App or call a service operation. Engine resolves credentials and authorises the provider calls.
Safe action layerFused Engine
FocusedProtectedObservable
Unified Apps

Give the agent a capability you’ve already defined.

Describe the integration you need. Fused generates a Unified App: a deterministic integration flow in TypeScript that you review and deploy to Engine.

Attach it to a new or existing MCP server. The agent discovers the app’s inputs and calls it; the reviewed code defines how it runs.

See the code and saved results
One capability. Every caller.Example
Agentvia MCP
Backendvia API or SDK
Unified App · hosted in Enginecustomer-brief
Inputemail
Outputcustomer, invoices
CRM + billing services, chosen by your team

Define how it runs

Reviewed TypeScript defines the integration flow. Engine handles service access and records execution.

Share the same capability

Agents and backends call the same deployed app, with one integration implementation to maintain.

Change the service behind it

Preserve the app’s input and output contract as you change providers, so callers can keep their code.

Inside a Unified App

Run the logic. Keep the result.

Call services, process their responses, and save the data your team needs to find later.

customer-lookup.tsUnified App · runs in Engine
import * as z from "zod/mini";
import { buildUnifiedApp } from "@fused/unified-app";
import { fused } from "@fused/operations";

export default buildUnifiedApp({
  input: z.object({ email: z.string() }),
  output: z.object({ customerIds: z.array(z.string()) }),
  fetch: { searchable: ["email"] },
  // Look up customers and save the processed result.
  async execute({ input }) {
    const { data } = await fused.stripe.getCustomers(input);
    // Return only the IDs callers need.
    const customerIds = data.map((customer) => customer.id);
    await fused.db.set({ email: input.email, customerIds });
    return { customerIds };
  },
});
Uses generated bindings for the selected Stripe GetCustomers operation.

Save processed results

fused.db.set(...) chooses the data saved with this execution. Return the result your caller needs; Engine persists the final data document when the run completes.

Find it again

Fetch a retained result by execution ID, or search by declared fields such as email. Reading a saved result does not call Stripe again. Result access remains permission-controlled.

Example saved execution data
{
  "email": "sam@example.com",
  "customerIds": ["cus_example"]
}

Execution results and saved data are currently retained for 24 hours after completion. Each run has its own data document.

Two purposeful tools

Give the model less to load—and more it can do.

Fused keeps the MCP surface stable instead of registering every service operation as another tool. The agent learns one pattern for finding guidance and one for taking action.
search_docs

Guidance arrives when the task needs it.

search_docs works like an on-demand integration skill. It searches only the services available to this MCP Server and returns relevant guidance plus input contracts for attached Unified Apps and approved service operations without loading the whole catalogue into context.

Smaller tool surface · less context noise · better tool selection
execute

Call the capability that fits the task.

execute can invoke an attached Unified App or run an approved service operation. Reusable integration logic stays in the app; Engine checks access and resolves provider credentials.

Example Unified App · notify-issue-owner
Read issueCheck accountNotify owner
Unified Apps · service operations · scoped execution

One MCP connection

One server can grow with the agent.

Attach Unified Apps and approved service operations to a new or existing MCP server. The agent keeps one connection and the same two-tool pattern as its reach expands.
AI agentOne connection
stable
FusedMCP Server

search_docsexecute

approved
Linear
Stripe
Slack
Internal
Add services without adding MCP connections Expose Unified Apps and approved service operations Keep one consistent way to discover and act

Engine-backed trust

Let agents act without handing them the keys.

The agent gets a genuinely useful interface. Engine keeps identity, access, and execution behind a boundary your team controls—and the agent never notices the difference.
Credentials

Keep the keys out of the model.

API keys and tokens never appear in a prompt, a tool argument, or a line of execution code. Engine resolves them at call time and the agent gets back the result.

OAuth

Use connected accounts without passing tokens around.

Engine picks and refreshes the right OAuth connection for the user or resource in play. The agent supplies the task and the provider arguments—nothing else.

Task scope

Narrow the server down to one session.

The MCP Server sets the ceiling. A short-lived token can lower it to an exact operation set for one task, then expire when the task is done.

Protected execution

Let the agent act without opening your infrastructure.

Code runs in a protected environment with no filesystem and no unrestricted network access. The agent gets the answer, not a route into the machine.

Agent activity

Find out what the agent actually did.

Every tool call leaves a record. Debugging an agent stops being a matter of asking it nicely to explain itself.
01

Every run leaves a receipt

Each execution records the operation called, the credential context used, how long the provider took, and what came back.

02

Every call still gets authorised

Calling a Unified App does not bypass access checks. Engine authorises the app invocation and its selected provider operations.

03

See where agent work is concentrating

Usage by service and operation shows what agents actually lean on—ideally before a provider bill or a rate limit brings it to your attention.

Make agents more capable without making them harder to trust.