Fusion for agents

Router page for AI agents: which Fusion interface (MCP, SDK, API) to use for which task, plus the minimal vault-creation example.

Fusion for agents

Fusion for Agents — Start Here

Use this page to choose the correct machine interface for working with IPOR Fusion.

Start here if you are using Codex, Claude or another AI agent to inspect Fusion vaults, prepare transactions or build integrations.

This page is a router to the canonical Fusion interfaces. It does not replace the detailed technical documentation.

Choose the right interface

Fusion MCP

Use Fusion MCP to inspect deployed Fusion state and research existing vaults, including available vault configuration, Fuses, Balance Fuses, substrates, roles, oracle configuration, registered contracts and other information exposed by the server.

Hosted MCP connection

Transport:

Streamable HTTP

Server URL:

https://mcp.ipor.io/mcp

The server URL is an MCP transport endpoint. Add it through the MCP settings of the relevant AI client. Do not open it as a normal webpage.

Full tool list, resources, prompts, client setup commands and a worked example: MCP

For a locally installed alternative, use the MCP server included in the Python SDK:

Install the SDK-bundled Fusion MCP server (opens in new tab)

Python SDK

Use the official Python SDK to create Fusion vaults, construct contract calls, encode calldata and submit transactions through a configured signer.

The executed, transaction-by-transaction SDK walk is on Deploy your first Fusion vault. Factory addresses per chain are on Addresses; revert selectors and the role table are on Common Errors.

Fusion Vault Launchpad

Use the Fusion Vault Launchpad when the task is a complete vault deployment: create, configure, verify and rehearse a Plasma Vault from one JSON strategy file, with a human in the loop. The pipeline runs 17 idempotent steps on top of the Python SDK and verifies the result from the vault's own contracts. A dry-run needs no key; a fork rehearsal on a local anvil fork deposits, executes every declared fuse, checks accounting and withdraws; a live broadcast needs the human's own funded key and an explicit sign-off.

Supported chains: Ethereum and Base. Two worked examples ship: a USDC vault on Aave V3 and a leveraged wstETH/USDC loop on Morpho Blue, both on Base.

Fusion API

Use the Fusion API for public vault, product and historical data exposed through HTTP endpoints.

Fusion API documentation

Machine-readable documentation

Use the machine-readable documentation indexes to discover and retrieve Fusion documentation:

Pages in this guide written for agents carry the agents tag: MCP, Deploy your first Fusion vault, Addresses, Common Errors and SDK.

Every documentation page is also available as Markdown: append .md to its URL.

If a raw Markdown URL cannot be retrieved, do not assume the page is unavailable. Retry through the normal HTML page, llms.txt, llms-full.txt or the linked GitHub source.

Deployments and ABIs

Use the canonical IPOR ABI and deployment repository to resolve supported contract names, chain-specific deployment addresses and ABIs.

IPOR deployments and ABIs (opens in new tab)

The SDK reads this registry by name, without an RPC provider: fetch_address_registry(ChainId(8453)).address("IporFusionFactoryProxy") (both names import from ipor_fusion). From the CLI: fusion address lookup IporFusionFactoryProxy --chain base. The local MCP server's tools are address_lookup, address_names and address_list; the hosted server's are fusion_address_lookup, fusion_address_names and fusion_addresses_list.

An address or ABI does not, by itself, prove that a Fuse or other component is compatible with a particular vault, market or strategy.

Creating a Fusion vault

Vault creation is available through FusionFactory.clone() in the Python SDK.

from web3 import Web3

from ipor_fusion import FusionFactory, Period, Web3Context

ctx = Web3Context.from_url(
    url=RPC_URL,
    private_key=PRIVATE_KEY,
)

factory = FusionFactory(Web3.to_checksum_address(FUSION_FACTORY_ADDRESS))

clone_call = factory.clone(
    asset_name="Example Fusion Vault",
    asset_symbol="exampleFV",
    underlying_token=Web3.to_checksum_address(ASSET_ADDRESS),
    redemption_delay_seconds=Period(0),
    owner=Web3.to_checksum_address(OWNER_ADDRESS),
    dao_fee_package_index=0,
)

preview = clone_call.call(ctx)
calldata = clone_call.calldata
receipt = clone_call.send(ctx)
instance = factory.decode_clone_receipt(receipt)

The factory wrapper holds its address; the Call holds the target, the encoded calldata and how to decode the result. Neither stores a Web3Context: pass the context to the operation that executes. The returned call supports three workflows:

  • clone_call.call(ctx) performs a read-only eth_call preview and returns the predicted Fusion deployment.
  • clone_call.calldata returns unsigned calldata for an external signer or multisig workflow.
  • clone_call.send(ctx) submits the transaction using the signer configured in ctx; factory.decode_clone_receipt(receipt) returns the addresses the transaction actually created (instance.plasma_vault, instance.access_manager, ...).

Resolve the chain-specific IporFusionFactoryProxy address through the canonical deployment registry:

IPOR deployments and ABIs (opens in new tab)

The preview only predicts the next addresses: another clone can take them before your transaction lands. Use the preview to check the call, and read the deployed addresses from the mined receipt with decode_clone_receipt, never from the preview.

Creation is not configuration

Creating a vault deploys the Fusion vault infrastructure. It does not make the vault strategy-ready.

Depending on the intended strategy, post-deployment configuration can include:

  • access roles and execution permissions;
  • Functional Fuses and Balance Fuses;
  • substrates and dependencies;
  • price feeds and oracle configuration;
  • limits and withdrawal configuration.

Use the existing configuration documentation for the detailed process:

Rules for agents

  • Use Fusion MCP for deployed-state inspection and research.
  • Use the Python SDK for vault creation and call construction.
  • For a complete vault deployment, use the Fusion Vault Launchpad instead of assembling the steps by hand. Never broadcast to a live chain without a clean fork rehearsal and the human's explicit "yes" for that exact strategy file.
  • Resolve production addresses through the canonical deployment registry.
  • Before writing or deploying a fuse, check the Fuse Whitelist Registry of that chain and use an active whitelisted fuse when one covers the market and action. Redeployed or forked copies of existing fuses are not whitelisted, and the IPOR app shows their markets as unknown. See When an existing fuse is enough.
  • Do not infer production configuration from tests or an arbitrary existing vault.
  • If an authoritative integration or configuration requirement cannot be found, return UNKNOWN rather than guessing.
  • Preview and prepare transactions by default. Signing or broadcasting requires explicit authorization.
  • Before signing an execute batch, check it with the actual sender: preflight_execute in the SDK, fusion vault preflight in the CLI or vault_preflight over MCP. They check the permission, fuse registration, balance dependencies and, by default, a simulated execution; they do not broadcast or guarantee success in a later block.
  • Check execution delays with AccessManager.read_call_plan before sending a restricted call. Market limits are Wad fractions of total assets, not token amounts.
  • Crosschain and HyperCore run on production contracts; their SDK API is in preview. The SDK follows only their official deployment, and that API may change or be removed between minor versions, with no backward compatibility.