search_docsFind the right tool for the taskDiscover attached Unified Apps and approved service operations, with the inputs each capability needs.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.
executeComplete work across servicesInvoke a reviewed Unified App or call a service operation. Engine resolves credentials and authorises the provider calls.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 resultsemailcustomer, invoicesDefine 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.
Run the logic. Keep the result.
Call services, process their responses, and save the data your team needs to find later.
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 };
},
});
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.
{
"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_docsGuidance 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.
executeCall 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.
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.search_docsexecute
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.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.
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.
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.
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.Every run leaves a receipt
Each execution records the operation called, the credential context used, how long the provider took, and what came back.
Every call still gets authorised
Calling a Unified App does not bypass access checks. Engine authorises the app invocation and its selected provider operations.
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.