Catch the bad call before the provider does
Engine runs approved operations with declared parameters, so undeclared inputs and unsupported behaviour get rejected on the way out—rather than coming back as a provider error at an unsociable hour.
A better integration layer for products
Enable the backend.
Turn integration logic into a Unified App your backend calls through API or SDK. Keep a stable input and output contract as the services behind it change. The same capability is available to your agents.
One capability. API or SDK. Ready for your agents too.
Your productBackend
API / SDK
Unified App
- Reviewed TypeScript, hosted in Engine
- Credentials resolved by Engine
- The same capability for your agents
execute
Internal + external services
verified events return through Engine
Unified Apps
Keep the integration in one place. Use it everywhere.
Describe the integration you need. Fused generates a Unified App with an input and output contract, backed by TypeScript you review and deploy to Engine.
Call it directly through API or add it to a new or existing SDK. Attach the same app to MCP when an agent needs that capability too.
See the code and saved resultsOne capability. Every caller.Example
Agentvia MCP
Backendvia API or SDK
Unified App · hosted in Enginecustomer-brief
Input
emailOutput
customer, 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.
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.
What Engine takes off your plate
The parts of an integration nobody wants to own.
Product teams stay on the experiences customers actually see. The repeated work underneath moves into the runtime, where improving it once improves it for everything.
Keep credentials and OAuth out of product code
Engine resolves secrets and the right connected-user account when an approved operation runs. Your application passes the task, never the token.
Keep resilience out of product logic
Retries, pagination, timeouts, concurrency caps, and shared provider rate limits are handled by the runtime, so no single feature needs its own recovery layer.
Understand every request and event
Central logs and service-use analytics show what happened, how integrations are performing, and which services the product has quietly come to depend on.
Build one app across services
A Unified App runs authored TypeScript against approved service operations while Engine handles credentials, routing, and execution records.
Direct service access
Need individual operations? Call them from your code.
Use a generated SDK when you want to compose service calls inside your backend. When that logic should be shared with another backend or an agent, package it in a Unified App.
Less glue code · faster feature work · safer reuse
linearstripeslack
const issue = await fused.Linear.issues.getIssue({ id });
const customer = await fused.Stripe.customers.retrieve({ customerId });
await fused.Slack.messages.send({ channel, text: issue.summary });