# Fume: Full Site Content (Markdown) Source of truth for AI assistants. Concatenates marketing pages, documentation, and blog posts. Investor-only pages are excluded by policy. Canonical URL: https://www.fume.finance --- # Marketing Pages # Fume, AI agents for investment funds Fume delivers and manages AI agents for fund administrators, fund managers, and family offices. Built and run by FumeX AG (Locarno, Switzerland). The agents take over the manual work in fund operations, at 20% of what the work costs by hand, so the same team can serve more funds and more AUM. ## The core offering: managed AI agents We find what's eating the week, build an agent that takes it over, and manage the agent while it runs the task on its own. Typical agents cover compliance monitoring, document processing, NAV workflows, risk monitoring, and investor communication. Agents plug into the fund admin, custody, and trading systems your team already uses. Private deployments on your own infrastructure are available (open-source models, on-prem or private cloud). See [solutions](https://www.fume.finance/solutions) for the patterns we've built, and [AI agents for funds](https://www.fume.finance/ai-agent-funds). ## A separate product line: the tokenization platform You can tokenize a fund without using the agents, and hire the agents without tokenizing anything. The platform: - **Tokenization Engine**: Free fund tokenization using the ERC-6909 standard on Ethereum, Arbitrum, Base, and selected EVM chains. Live cap table, programmable share classes, automated NAV. - **OmniClear**: Stablecoin settlement infrastructure. Subscriptions and redemptions clear in the same block. Multi-currency in, multi-currency out. - **Tokenized Fund Registry**: Public, open registry of tokenized investment funds with onchain verification. Discover funds, compare terms, and connect with managers. - **Fund Builder**: Interactive questionnaire that maps your fund profile to the legal, fund admin, custody, exchange/broker, audit, and AIFM partners that fit. Generates a tailored stack and a one-page PDF you can act on. ## Who Fume is for Fund administrators, fund managers, and family offices. Built by fund operators, for fund operators. ## Headline links - See what we've built: https://www.fume.finance/solutions - Get started: https://www.fume.finance/fund-builder - Tokenize an existing fund for free: https://www.fume.finance/tokenize-free - Browse tokenized funds: https://www.fume.finance/registry - Book a call: https://www.fume.finance/resources/book-a-call # Tokenization Engine, Free Fund Tokenization Tokenization has been commoditized. Fume does it for free. What matters is what comes next: stablecoin subscriptions, onchain admin, and a live cap table, all of it callable, so an AI agent can run the whole thing. Fume is the tokenization engine an agent can actually drive: the first fund infrastructure built for software to operate, not just for a person to click through. ## Pricing **Free forever — Tokenization ($0):** - Drag-and-drop fund tokenization - ERC-6909 tokenized shares onchain - Onchain stakeholder register - Fund Registry listing **Fume Platform ($179/month):** full onchain administration — automated NAV, fees, payouts, and stablecoin subscriptions and redemptions, with an agent-ready API and MCP server and a built-in onchain audit trail. A protocol fee of up to 0.1% applies to subscription and redemption flows by default; no AUM cut, no management or performance fee. Special pricing is available for smaller funds. Just ask. ## What tokenization gets you Traditional fund shares sit in transfer agents and spreadsheets. Tokenized shares live in smart contracts. The difference shows up everywhere. - **Secondary liquidity**: Tokenized shares transfer between whitelisted investors onchain. Frozen commitments become positions that move. - **Live cap table**: Your stakeholder register updates in real time with every subscription, redemption, and transfer, so there is no spreadsheet to reconcile. - **Programmable terms**: Lockups, transfer restrictions, and fee schedules live in the smart contract. They enforce themselves. ## Operations: fund admin that runs itself When your fund runs on smart contracts, the manual work disappears. 1. **Automated NAV**: Enter your gross asset value and the protocol works out fees, high-water marks, and equalizations in seconds. 2. **Instant payouts**: Smart contracts calculate management fees, performance fees, and investor distributions, then pay them out without a manual step. 3. **Built-in audit trail**: Every subscription, transfer, and payout lands onchain, one source of truth that nobody has to maintain by hand. ## Capital in: accept subscriptions in any currency Stablecoins, fiat, or both. Investors subscribe the way they already pay, and the money settles into your fund in minutes. - **Native stablecoin subscriptions**: Investors connect their wallet and deposit USDC or USDT directly into your fund's smart contract. Only whitelisted wallets get through, and AML checks are built in. - **Fiat still works**: Wire transfers, bank deposits, or any other subscription method alongside crypto. - **Minutes, not days**: Subscriptions settle when the transaction confirms instead of waiting on correspondent banks and SWIFT queues. ## Agent-native: built for agents Most tokenization platforms hand an agent a dashboard and a login. Fume hands it an API and an MCP server any agent can plug into. Every action in the engine is callable and every output is machine-readable, so an agent can run the whole fund lifecycle rather than the slice a vendor chose to expose. - **Every action is an API call**: Tokenize, mint, whitelist, run NAV, distribute. No action is portal-only. An agent stands up a fund and operates it start to finish, the same calls a human would make, minus the human. - **Machine-readable cap table**: The onchain stakeholder register is live, structured data. Agents read positions, subscriptions, and transfers straight from the chain instead of scraping PDFs. - **Built on open standards**: ERC-6909 shares with standard RPC and REST endpoints, plus an MCP server. An agent that knows the standards already knows how to drive the fund, and there is no proprietary SDK to learn. - **Guardrails enforced onchain**: Whitelisting, AML checks, lockups, and fee schedules live in the smart contract. Agents move fast inside the limits you set once, and the rules can't be skipped. See also: [AI Agents for Funds](https://www.fume.finance/ai-agent-funds) and [OmniClear](https://www.fume.finance/omniclear) for the settlement layer. # For Asset Managers Tokenize your fund. Accept subscriptions. Automate payouts. All from one platform. ## What you can do with Fume - Accept subscriptions of any kind (stablecoins, fiat wires) - Tokenize your fund shares (ERC-6909) - Simplify NAV calculation - Automate payouts (management fees, performance fees, distributions) - Invest in any asset (equities, crypto, real estate, private credit) ## Two paths to launch ### Path 1, SaaS: Power your fund with Fume Use Fume's smart contracts to run your fund operations. Keep full control over compliance with your existing fund license or set up a new one (e.g. a Delaware fund). **Best for:** Asset managers with an existing license or resources to set up their own fund structure. ### Path 2, FaaS: Launch with Fund-as-a-Service Outsource compliance and fund setup to us. Operate under our established fund structure (e.g. rent our AIFM license in Luxembourg) by creating a dedicated compartment for your fund. **Best for:** Asset managers who want to go live quickly without setting up their own fund structure. # For Fund Administrators Fume is the on-chain layer for fund administrators. Automate the manual work that slows you down: subscription processing, NAV calculation, fee distribution, and audit trail. Plug into your existing accounting and reporting stack. ## What Fume does for fund admins - Automatic shareholder register and cap table maintenance - Onchain settlement of subscriptions and redemptions - Programmable NAV calculation with high-water marks and equalizations - Smart-contract-driven fee extraction (management, performance, distributions) - Full audit trail by construction, every transaction is verifiable onchain - API integration with custodians and accounting systems ## Why fund admins partner with Fume Tokenization is a tailwind for the fund admin business, onchain funds need someone to handle reporting, regulatory filings, and investor relations. Fume gives admins the operational rails to serve those funds without building blockchain infrastructure in-house. White-label and revenue-share arrangements available. # Free Fund Tokenization Not tokenized yet? List on the Registry in 10 minutes. Tokenize your fund shares with ERC-6909 at zero cost. Get an automatic listing on the Tokenized Fund Registry, full onchain auditability, and no lock-in. ## Three steps to tokenized shares 1. **Upload shareholder register**: Share your existing investor list. We map it to ERC-6909 token positions. 2. **Review token terms**: Confirm share classes, denominations, and transfer restrictions before minting. 3. **Deploy**: Your tokens go live onchain and your fund appears in the Registry automatically. ## What you get - Free ERC-6909 tokenization of fund shares - Automatic listing on the Tokenized Fund Registry - No lock-in on fund admin or custody - Supports Ethereum, Arbitrum, and Base - Onchain audit trail from day one ## What's included, and what's not Free tokenization covers share representation only (mint ERC-6909 tokens against your existing shareholder register). For automated subscriptions, redemptions, NAV calculation, and fee extractions in stablecoins, upgrade to Fume Platform (paid, $179/month). ## Frequently asked questions **What does free tokenization actually include?** Free tokenization covers share representation only, we mint ERC-6909 tokens against your existing shareholder register. You get tokenized fund units, an automatic Registry listing, and a public onchain record. **What does it NOT include?** Automated subscriptions, redemptions, NAV calculation, and fee extraction in stablecoins are part of Fume Platform, a paid product. Free tokenization is the share representation layer only. **Is there a catch? Why is it free?** Tokenization is the wedge. We want every fund in the world to have tokenized shares. When you're ready for full onchain fund administration, Fume is the natural upgrade. There's no obligation to upgrade. **Which blockchains are supported?** Ethereum mainnet, Arbitrum One, and Base. We can support any EVM-compatible chain on request. **What token standard do you use?** ERC-6909, a multi-token standard optimised for representing multiple share classes within a single contract. It's gas-efficient and auditor-friendly. **Do I need to change my fund admin or custodian?** No. Free tokenization is compatible with any custody or admin setup. Your existing service providers stay in place. **How long does the process take?** Most funds are tokenized within one business day after we receive the shareholder register and confirm terms. **Will my fund appear on the Registry?** Yes. Every fund tokenized through Fume gets an automatic, verified listing on the Tokenized Fund Registry with the "Powered by Fume" badge. # OmniClear, Stablecoin Settlement for Funds Stablecoin settlement for every fund. Accept any currency, settle any way. ## Bridging two worlds OmniClear sits between traditional finance and onchain finance. - **Traditional finance side**: Wire transfers, SWIFT payments, fiat currencies, traditional custody. - **Onchain side**: Stablecoins (USDC, USDT), smart contract settlement, instant transfers, onchain custody. OmniClear converts, routes, and settles between the two automatically. ## Use cases - **Accept crypto investors**: Traditional funds can receive stablecoin subscriptions and automatically convert to fiat for custody with their existing banking partners. - **Accept traditional investors**: Onchain funds can receive fiat wire transfers from traditional investors and settle subscriptions in stablecoins onchain. - **Cross-border settlement**: Global settlement without correspondent banking delays. Send and receive across jurisdictions in minutes, not days. ## How it works 1. **Investor sends funds**: Fiat wire, USDC, USDT, or any supported stablecoin. 2. **OmniClear converts and settles**: Conversion, compliance checks, and routing in the background. 3. **Fund receives in preferred currency**: Stablecoins onchain or fiat in a bank account, whichever the fund prefers. # The Tokenized Fund Registry The open registry of tokenized investment funds. Compare terms, verify onchain, and connect with fund managers directly. The Registry is a public directory of investment funds with tokenized shares. Each entry shows the strategy, AUM, jurisdiction, fund administrator, and the chain(s) the shares live on. Funds tokenized through Fume get an automatic, verified listing with onchain proof. ## What you can do on the Registry - Browse tokenized funds across strategies, jurisdictions, and chains - View detailed fund pages with onchain contract addresses, audit information, and service-provider stack - Request fund documents directly from the manager - Verify share existence and supply onchain via the linked block explorer ## How to get listed Tokenize your fund through Fume and you're listed automatically. See [free tokenization](https://www.fume.finance/tokenize-free) for the no-cost path. ## See all funds Full table view: https://www.fume.finance/registry/list # AI Agents for Funds AI agents, delivered and managed. Instead of selling software, Fume delivers the finished task: we find the process that eats your team's hours, build an agent for it, deploy it into your stack, and manage it while it runs on its own. ## How it works 1. **Find the process**: We sit with the people who actually do the work and map every manual step. The process that eats the most hours is where the first agent goes. 2. **Build and deploy the agent**: We build the agent around how your team already works and wire it into your existing systems. No migration, no new platform to learn. 3. **Let it run**: The agent performs the task on its own, every cycle. The output lands in the drive, inbox or platform your team already opens. 4. **We maintain it**: We monitor every run, fix issues before they reach you, and ship upgrades as your tools evolve. You get the result of the work, not another tool to babysit. ## Not a chatbot ChatGPT and Copilot are useful, and they still leave the work with your team. An agent has access to your systems, a defined task, and permission to complete it end to end. Your team reviews the output instead of producing it. ## Where we start: the NAV lifecycle Four examples across the NAV lifecycle. Wherever data moves by hand in your operation, an agent can take it over. 1. **Ingest agent**: Pulls data from brokers, banks, email inboxes, and onchain transactions every morning. Manual logins and exports disappear. 2. **Structure agent**: Takes any statement format and turns it into structured transactions, across crypto and traditional assets, in the exact layout your platform expects. 3. **Push NAV agent**: Pushes structured data into Paxus, NTAS, Geneva, Investran, or any NAV engine. The platform runs the calc, the agent returns NAV, fees, and the cap table. 4. **Tokenize agent**: Feeds NAV results, payouts, and the latest unit register into Fume's tokenization engine, fully onchain and end to end. ## More agents we build - **Compliance agent**: Monitors regulatory changes across jurisdictions and flags issues before they become problems. - **Document agent**: Reads legal documents, term sheets, and investor reports. Summarizes, extracts, and flags the terms that matter. - **Risk agent**: Live risk assessment across your portfolio. Spots concentration, correlated exposures, and unusual patterns before they hit. - **Communication agent**: Drafts investor updates, quarterly reports, and responses to common questions in a consistent voice, in a fraction of the time. Need something else? Fume builds bespoke agents wired to your stack. ## How we build agents - **Wired into your stack**: Works with your custodian, admin platform, trading venues, and data providers. No forced migration, no rip-and-replace. - **Bespoke, not off-the-shelf**: We write, deploy, and hand over custom agents built around your process. No 200-page reports, no generic product. - **Guardrails that hold**: Agents act inside limits you set. Every action is logged and auditable, so your compliance team can trace each run. - **Managed by us**: We monitor every run, catch the edge cases, and keep improving the agent over time. You get the result, not a maintenance burden. ## Built to pass your compliance review - **Paperwork before data**: We sign a data processing agreement and share a security overview of the exact setup before any client data flows. - **Certified infrastructure**: Client data runs on a short list of ISO 27001 and SOC 2 certified providers, hosted EU-first and encrypted in transit and at rest. - **Your data never trains models**: Model calls run with zero data retention. The processing is transient, and nobody stores your data or trains on it. - **Humans stay in the loop**: Every run is logged and auditable, the output goes to your team for review, and your manual process keeps running as the fallback. Full details: [Security documentation](https://www.fume.finance/docs/company/security). ## Fully private: agents that run locally Some funds can't send data to a public AI cloud, and they shouldn't have to. Fume deploys the same agents on open-source models that run entirely inside your own infrastructure, with the same guardrails and audit logs. The only difference is that no data ever leaves. - **On your infrastructure**: Open-source models run on your own servers or in your private cloud. Investor data, positions, and documents stay inside your firewall. - **No third-party AI cloud**: Your data never touches a public model API, and nobody trains on it. Since there's no AI vendor in the chain, compliance has nothing new to review. - **Proven in production**: Fume already runs fully on-prem deployments for managers: Docker stacks on their own infrastructure, with their own keys, monitoring, and database. ## The Fume stack for AI Every part of Fume is built for programmatic access, so the agents we deliver can lean on each layer. Agents on the other side of the table use the same stack to browse, subscribe, and invest. - **Fund Builder**: Agents pick legal, admin, custody, and audit providers through the Fund Builder. - **Tokenization Engine**: Free tokenization. Agents get programmable ERC-6909 shares they can issue and distribute. - **OmniClear**: Instant stablecoin settlement. Subscriptions and redemptions clear in the same block. - **Fund Registry**: A public directory of tokenized funds. Agents browse, evaluate, and invest. # Fund Builder Interactive tool to assemble a complete fund stack, answer a short questionnaire and get matched with the right legal, fund admin, custody, exchange/broker, audit, and AIFM providers for your specific situation. ## How it works 1. **Answer 5-6 questions**: License, domicile, investor type, AUM, strategy. Most users finish in under two minutes. 2. **See your matched stack**: Pre-selected providers across all relevant categories. Each card opens a panel with details, pricing, and rationale. 3. **Swap any pick**: Browse alternatives in the Partner Directory and replace recommendations with providers you prefer. 4. **Get a one-pager**: Enter an email and we send a PDF summary of the recommended stack plus introductions to the providers. ## Categories covered - Legal counsel - Fund administration - Custody - Exchange / broker - Audit (or AIFM, depending on your license) ## Partner Directory Browse every provider in the Fume catalog at https://www.fume.finance/fund-builder/providers, search and filter by category, jurisdiction, and pricing. Click any provider for a detailed page with their services, contact, and an option to request an introduction. ## Get listed Service provider for funds? Apply to join the directory at https://www.fume.finance/fund-builder/providers (use the "Get listed" button). # About Fume Fume is built and run by FumeX AG, registered in Locarno, Switzerland (CHE-342.025.757). The team came together around a single observation: fund operations are still mostly manual, and the people who actually run funds know exactly which parts are broken. ## What drives the company - **Built by fund operators, for fund operators.** Every product decision starts with a problem we've watched a fund manager or admin struggle with. - **AI as the through-line.** From automated NAV to bespoke ops agents, AI is how Fume turns operational drudgery into infrastructure. - **Open standards.** ERC-6909, public registries, raw markdown for every page, your data and your stack are not locked in. ## Team - Riccardo Conti, Chief Executive Officer - Marc Bickel, Chief Technology Officer - Raphael Maibach, Head of Legal ## Get in touch - info@fume.finance - https://www.fume.finance/resources/contact-us - https://www.fume.finance/resources/book-a-call --- # Documentation # 🏠 Overview (/docs) Fume is an AI company specializing in the fund industry. We build and run software for investment funds and the people who serve them: fund managers, fund administrators, and family offices. Some of it is productized, some of it is built around one client's exact process, but all of it exists to take manual work off fund teams. These docs are organized by product. Each section below stands on its own. ## AI agents, delivered and managed [#ai-agents-delivered-and-managed] Instead of selling software, we deliver the finished task. We find the process that eats your team's hours (broker reports pulled by hand, statements re-typed, data pushed between systems), build an agent for it, deploy it into the tools you already run, and manage it while it runs on its own. ## Tokenization Platform [#tokenization-platform] The Fume Tokenization Engine handles fund administration and tokenization on-chain: fund setup, investor onboarding, NAV calculations, subscriptions, redemptions, and settlement, for both traditional and digital asset funds. ## OmniClear [#omniclear] Stablecoin settlement for every fund. OmniClear converts and routes between traditional rails (wire, SWIFT, fiat) and on-chain rails (USDC, USDT), so a fund can accept any currency and settle in the one it prefers. ## The rest of Fume [#the-rest-of-fume] Not everything we build has its own docs section yet. These live on the main site: ## Developers and agents [#developers-and-agents] The public API, the OpenAPI specification, and how to read any page on this site as markdown. ## Company [#company] # 🧰 Agent Catalog (/docs/ai-agents/agent-catalog) This catalog is inspiration, not a menu. Every agent we ship is built around one fund's exact process, but these are the shapes that come up again and again. Wherever data moves by hand in your operation, an agent can take it over. ## Where we start: the NAV lifecycle [#where-we-start-the-nav-lifecycle] Four agents that together take a fund from raw broker data to a published, tokenized NAV. We wrote up how this pipeline works in [Automating NAV calculation with AI agents](/resources/blog/automating-nav-calculation-with-ai-agents). 1. **Ingest agent**: pulls data from brokers, banks, email inboxes, and onchain transactions every morning, so nobody logs into portals or exports statements by hand anymore. 2. **Structure agent**: takes any statement format and turns it into structured transactions, across crypto and traditional assets, in the exact layout your platform expects. 3. **Push NAV agent**: pushes structured data into Paxus, NTAS, Geneva, Investran, or any NAV engine. The platform runs the calc, the agent returns NAV, fees, and the cap table. 4. **Tokenize agent**: feeds NAV results, payouts, and the latest unit register into Fume's [Tokenization Engine](/docs/tokenization/whitepaper), fully onchain and end to end. ## Operations agents [#operations-agents] The NAV lifecycle is the starting point. These run alongside it, plugged into how your fund actually works: * **Compliance agent**: monitors regulatory changes across jurisdictions and flags issues before they become problems. * **Document agent**: reads legal documents, term sheets, and investor reports. It summarizes, extracts, and flags the terms that matter. * **Risk agent**: watches risk across your portfolio and spots concentration, correlated exposures, and unusual patterns before they hit. * **Communication agent**: drafts investor updates, quarterly reports, and responses to common questions in a consistent voice, in a fraction of the time. Need something else? [Tell us what you need](/resources/book-a-call). # ⚙️ How It Works (/docs/ai-agents/how-it-works) Every engagement follows the same shape: we find the right process, build an agent around it, and keep running it after it ships. We are your drop-in AI specialists, so your team can focus on review. ## 1. Find the process [#1-find-the-process] We sit with the people who actually do the work and map every manual step: broker reports pulled by hand, statements re-typed, data pushed between systems. We watch how the team actually does the work, exceptions included, and rank the processes by hours saved. The process that eats the most hours is where the first agent goes. ## 2. Build and deploy the agent [#2-build-and-deploy-the-agent] We build the agent around how your team already works and wire it into your existing systems: email, Excel, your accounting platform. Each agent lives in its own dedicated virtual machine and can use frontier models or [local open-source models](/docs/ai-agents/private-ai), so it runs wherever your data needs it. No migration, no new platform to learn: your formats and your controls stay untouched. ## 3. Let it run [#3-let-it-run] The agent performs the task on its own, every cycle, with a watchdog checking every run. The output lands in the drive, inbox, or platform your team already opens, so your team checks results instead of logs. ## 4. We maintain it [#4-we-maintain-it] We monitor every run, fix issues before they reach you, and ship upgrades as your tools evolve. When an exception comes up, we handle it ourselves and fold the fix back into the agent, so the fleet keeps improving. You get the result of the work without new IT hires. ## Why not rules-based automation? [#why-not-rules-based-automation] Fund administration is like self-driving a car: fixed rules never got there. Red light? Stop. Dotted line? Cross. Then come roadworks, fog, and a cat on the road, and ten thousand rules later there are still too many exceptions. Scripted bots and RPA hit the same wall. The automation works until a broker changes their PDF layout, then it breaks and a human gets paged. Self-driving only worked once AI started learning from how humans drive, exceptions included. Fund administration is the same road: our agents learn from your team and work like your team, without a rulebook. ## How we build agents [#how-we-build-agents] Four principles hold across every agent we ship: * The agent is wired into your stack: custodian, admin platform, trading venues, data providers. You are not forced to migrate anything. * It is bespoke. We write, deploy, and hand over a custom agent built around your process, not a generic product or a 200-page report. * Guardrails hold. The agent acts inside limits you set, and every action is logged so your compliance team can trace each run. * We manage it. We monitor every run, catch the edge cases, and keep improving the agent over time. You get the result without the maintenance burden. ## Subscriptions, not consulting [#subscriptions-not-consulting] We target the same output, from the same tools, at 80% less than the cost of the manual labor the fleet replaces. Everything about the engagement is built around hitting that number: 1. **Start.** A fully refundable down payment in agent credits gets the engagement going. 2. **Build.** The first agent goes live in production within about 30 days, and we roll out further agents across the lifecycle from there. 3. **Subscribe.** A recurring monthly subscription priced as a share of the labor cost the fleet replaces, which is how the roughly 80% saving lands in your budget month after month. We are not paid to implement. We are paid for the usage and maintenance of the fleet. [Book a call](/resources/book-a-call) for a tailored offer. ## The Fume stack for AI [#the-fume-stack-for-ai] Every part of Fume is built for programmatic access, so the agents we deliver can lean on each layer. Agents on the other side of the table use the same stack to browse, subscribe, and invest: * [Fund Builder](/fund-builder): agents pick legal, admin, custody, and audit providers. * [Tokenization Engine](/docs/tokenization/whitepaper): programmable on-chain shares that agents can issue and distribute. * [OmniClear](/docs/omniclear): instant stablecoin settlement for subscriptions and redemptions. * [Fund Registry](/registry): a public directory of tokenized funds that agents can browse, evaluate, and invest in. # 🤖 AI Agents (/docs/ai-agents) Instead of selling you software, we deliver the finished task. We find the process that eats your team's hours, build an agent for it, deploy it into your stack, and manage it while it runs on its own. Think of the agents as digital employees. They work the same tools and the same flows as your team, which is why the same team can serve a multiple of the assets. We work with investment funds, asset managers, family offices, and fund administrators. The agents plug into whatever you already run: your custodian, your admin platform, your NAV engine, your inboxes. Systems of record like Paxus, Geneva, or Carta stay exactly where they are; the agents work on top of them, so nothing migrates and your team keeps the software it knows. ## The problem: humans are the integration layer [#the-problem-humans-are-the-integration-layer] Fund operations do not lack tools. The accounting system, the portfolio system, Excel, email, and broker PDFs all exist. What connects them is people. Someone exports, copies, pastes, and reconciles until the NAV pack, the investor report, and the compliance file are done. From our direct discussions with fund administrators: * **5+ hours** of manual data work per fund, per NAV cycle * **20+ data formats** re-keyed before any checks can run * **Over half of team time** spent gathering data rather than judging it That manual layer is what our agents take over, and we target doing it at 80% less than the cost of the manual labor it replaces. The output stays the same and the tools stay the same. What changes is who does the re-keying. ## This is not a chatbot [#this-is-not-a-chatbot] ChatGPT and Copilot are already inside most back offices, and they still leave the work with your team: someone pastes a broker PDF into the chat, gets a wall of text back, and carries the result into the accounting system by hand. Every step waits for a prompt, so the task is still yours. An agent is different. It has access to your systems, a defined task, and permission to complete it end to end. On a typical morning run, an agent pulls the overnight broker reports from the inbox, files the statements, structures the trades into the layout your platform expects, pushes them into the accounting system, and delivers the computed NAV before the team logs in. Your team reviews the output instead of producing it. New to agents? Start with the [complete guide to AI agents for fund operations](/resources/blog/ai-agents-for-fund-operations) or the [agent vs. chatbot vs. RPA breakdown](/resources/blog/ai-agents-vs-chatbots-vs-rpa-fund-administration). ## In this section [#in-this-section] ## Which process should go first? [#which-process-should-go-first] Tell us what's eating your team's week. We'll tell you if an agent can take it over and what it would save; the target is around 80% of the labor cost of that process. [Book a consultation](/resources/book-a-call). # 🔒 Private & Local AI (/docs/ai-agents/private-ai) Some funds can't send data to a public AI cloud, and they shouldn't have to. We deploy the same agents on open-source models that run entirely inside your own infrastructure, with the guardrails and audit logs you'd get from any Fume deployment. The only difference is that no data ever leaves. Every Fume agent lives in its own dedicated virtual machine, so it can run wherever your data needs it. For most funds that machine sits in a managed deployment and uses frontier models. For funds with stricter requirements, the same machine sits on your own servers and runs local models instead. ## On your infrastructure [#on-your-infrastructure] Open-source models run on your own servers or in your private cloud. Investor data, positions, and documents stay inside your firewall. ## No third-party AI cloud [#no-third-party-ai-cloud] Your data never touches a public model API, and nobody trains on it. Since there's no AI vendor in the chain, compliance has nothing new to review. ## Proven in production [#proven-in-production] We already run fully on-prem deployments for managers: Docker stacks on their own infrastructure, with their own keys, monitoring, and database. *** Handling data that can't go to the cloud? [Talk to us about a local deployment](/resources/book-a-call). # 🏢 About Fume (/docs/company/about-fume) Fume was founded in 2023 and is headquartered in Ticino, Switzerland. The company was born out of the frustration we faced while managing our own investment fund in traditional finance: hefty fees paid to intermediaries for tasks that could easily be automated, reliance on too many middlemen, and a lack of transparency. We started by building the [Tokenization Engine](/docs/tokenization/whitepaper) to eliminate those inefficiencies: it automates fund administration on-chain and removes intermediaries. Applying automation to fund operations didn't stop there: today we also [deliver and manage AI agents](/docs/ai-agents) that take over the manual work inside funds and fund administrators, and build the settlement and distribution rails around them, like [OmniClear](/docs/omniclear). Fume is built by a team with deep expertise in blockchain, finance, and law, with the backing of a fintech VC, a family office, and established asset managers. ## Get in touch [#get-in-touch] * [Book a call](/resources/book-a-call): the fastest way to talk to us. * [Contact us](/resources/contact-us) * [All solutions](/solutions): what we've already shipped for the fund industry. # 🏢 Company (/docs/company) What applies across everything Fume ships, and the company behind it. # 🛡️ Security (/docs/company/security) Security principles at Fume are shared across products: restrict access to the minimum each party needs, make every sensitive action traceable, and keep data where it belongs. This page covers the AI agents first, then the Tokenization Engine. ## AI agents [#ai-agents] Agents act inside limits you set, and every action is logged and auditable, so your compliance team can trace each run. We monitor every run in production and handle the edge cases rather than leaving them to your team. Agent engagements run under a written information security and data protection policy with a named executive owner, and we share it with clients so they can assess our posture directly. Before any client data flows, we sign a data processing agreement, and each engagement gets its own security overview describing how data moves through the solution, where it is processed, and how long it is kept. We keep the attack surface small. Client data processing runs on a short list of established infrastructure providers holding ISO 27001 or SOC 2 certification, with EU-first hosting, encryption in transit and at rest, least-privilege access, and multi-factor authentication on every account that can reach client data. Where a language model reads a document, the call goes through an AI gateway with zero data retention enforced: processing is transient, and client data is never used to train models, ours or anyone else's. Retention is bounded, and at the end of an engagement client data is deleted or returned, at the client's choice. Agents work from written, version-controlled instructions derived from the client's own documented process. Their output goes to a human for review, and an agent that hits something its instructions do not cover stops and escalates rather than improvising. Automations also start out running alongside the client's existing manual process, so a documented fallback is always in place. For funds whose data can't touch a public AI cloud, we deploy the same agents on open-source models entirely inside your own infrastructure. See [Private & Local AI](/docs/ai-agents/private-ai). ## Tokenization Engine [#tokenization-engine] Everything from here down is about the Tokenization Engine and the platform around it. The protocol is designed so that underlying liquidity stays in secure, segregated custody, and only interacts with the protocol at key moments: subscriptions, redemptions, and fee management. After a fund is deployed, only authorized parties can interact with its smart contract: the fund manager, and investors the manager has whitelisted. This drastically reduces the on-chain attack surface. We engaged [ChainSecurity](https://www.chainsecurity.com/), one of the leading smart contract auditors, to review the protocol. [Read the report](https://www.chainsecurity.com/security-audit/limited-review-fume-finance-smart-contracts). For the full picture (implementation practices, testing, upgradability, and the catch-up mechanism), see [Security & Risk Mitigation](/docs/tokenization/whitepaper/technical/security-and-risk-mitigation) in the whitepaper. ### Authentication and data handling [#authentication-and-data-handling] There are no passwords on the Tokenization Engine. Users sign in with a one-time code sent to their email, powered by [Privy](https://www.privy.io/) ([security details](https://www.privy.io/security)). Logging in gives a read-only view; any action that moves money or changes a fund requires wallet approval from the fund manager, and we recommend multi-signature solutions like Safe Wallet or Fireblocks for the governance wallet. We store nothing on-chain that could be considered personal or sensitive data. That data lives on our servers, protected by industry-standard security and encryption. All wallets with important responsibilities on the Fume side are multisig smart wallets. # Agent Access to Fume (/docs/developers/agent-access) Fume is an AI company, so this site is built to be read by programs as well as people. Nothing here requires a key, a crawl allowance, or a scraper. ## Ask for markdown, get markdown [#ask-for-markdown-get-markdown] Every documentation page and every canonical marketing page has a markdown twin. Two ways to reach it: **Content negotiation.** Send `Accept: text/markdown` to the canonical URL: ```bash curl -sH "Accept: text/markdown" https://www.fume.finance/docs/ai-agents ``` **An explicit URL.** Append `.mdx` to any `/docs` path, or use the raw route directly: ```bash curl -s https://www.fume.finance/docs/ai-agents.mdx curl -s https://www.fume.finance/llms.mdx/marketing/home/content.md ``` Both representations carry `Vary: Accept`, so a shared cache between you and us will not hand you the wrong one. ## Bulk ingestion [#bulk-ingestion] * [`/llms.txt`](https://www.fume.finance/llms.txt) — an annotated index of the site: what Fume does, the key pages, and where the machine-readable content lives. Start here. * [`/llms-full.txt`](https://www.fume.finance/llms-full.txt) — every marketing page, documentation page and blog post concatenated into one markdown file. One request, whole corpus. * [`/sitemap.xml`](https://www.fume.finance/sitemap.xml) — every canonical URL, with real content dates. Investor-only pages are excluded from both `llms-full.txt` and search indexing by policy. They are reachable by link, and marked `noindex`. ## Structured data [#structured-data] Every page carries schema.org JSON-LD in the server-rendered HTML, not injected after hydration — so it is there with JavaScript disabled. The home page declares the `Organization` (including postal address and contact point), the `WebSite`, and the `SoftwareApplication`. ## Catalog data as JSON [#catalog-data-as-json] Two catalogs are published as JSON rather than only as HTML: ```bash curl -s https://www.fume.finance/api/registry/funds curl -s https://www.fume.finance/api/fund-builder/providers ``` See the [Fume API reference](/docs/developers/api-reference), or read [`/openapi.json`](https://www.fume.finance/openapi.json) directly. ## When you guess wrong [#when-you-guess-wrong] A URL that does not exist returns a real `404`, and the body tells you where to go instead — as HTML for a browser, and as markdown when you ask for it: ```bash curl -sH "Accept: text/markdown" https://www.fume.finance/does-not-exist ``` Under `/api`, an unknown path returns the same JSON error envelope every other endpoint uses, with `code: "unknown_endpoint"` and a `docs` field pointing at the specification. Paths that moved are permanently redirected, so a 404 means the path was never valid — not that you missed a migration. ## Crawling [#crawling] `robots.txt` allows every major AI crawler by name (GPTBot, ClaudeBot, PerplexityBot, Google-Extended, Applebot-Extended, CCBot and others) across the whole site, and allows the public read endpoints under `/api`. There is no rate limit beyond platform defaults; the read endpoints are edge-cached for an hour, so polling faster than that returns cached data. Questions, or something you need that is not published? Email `info@fume.finance`. # Fume API Reference (/docs/developers/api-reference) The machine-readable version of this page is the OpenAPI 3.1 document at [`/openapi.json`](https://www.fume.finance/openapi.json) (mirrored at `/api/openapi.json`). It is the source of truth; this page is the readable summary. Base URL: `https://www.fume.finance`. No authentication. Read endpoints allow any origin and are cached at the edge for an hour. ## Read the tokenized fund registry [#read-the-tokenized-fund-registry] ### `GET /api/registry/funds` [#get-apiregistryfunds] Lists the funds in the [Tokenized Fund Registry](/registry) with strategy, AUM, chain, token standard, fees, jurisdiction and named service providers. | Parameter | Type | Notes | | -------------- | ------- | --------------------------------------------------------------------- | | `chain` | string | Exact match, case-insensitive. `Ethereum`, `Base`, … | | `status` | string | `Open`, `Closed`, `Upcoming`, `Soft Close`, `Hard Close`, `Launching` | | `assetClass` | string | Exact match, case-insensitive | | `jurisdiction` | string | Exact match, case-insensitive | | `q` | string | Substring search over name, manager, issuer, strategy, description | | `limit` | integer | Default 50, max 200. Out-of-range values are clamped, not rejected | | `offset` | integer | Default 0 | ```bash curl -s "https://www.fume.finance/api/registry/funds?chain=Base&status=Open&limit=5" | jq '.total, .funds[].name' ``` Returns `{ total, limit, offset, funds[] }`. Every fund carries `url`, the canonical page to cite, and `dataSource`, which says whether the record was verified onchain, taken from a public filing, or self-reported. ### `GET /api/registry/funds/{id}` [#get-apiregistryfundsid] One fund by its registry slug — the same slug as `/registry/{id}`. ```bash curl -s https://www.fume.finance/api/registry/funds/blackrock-buidl | jq .name ``` Unknown ids return 404 with `code: "fund_not_found"`. ## Read the fund service provider catalog [#read-the-fund-service-provider-catalog] ### `GET /api/fund-builder/providers` [#get-apifund-builderproviders] Every provider listed in [Fund Builder](/fund-builder): legal counsel, fund administrators, custody, exchanges and brokers, auditors, management companies and insurance. | Parameter | Type | Notes | | ---------- | ------- | -------------------------------------------------------------------------- | | `category` | string | `legal`, `fund-admin`, `custody`, `broker`, `auditor`, `aifm`, `insurance` | | `q` | string | Substring search over name, description, specialty, tags, jurisdictions | | `limit` | integer | Default 100, max 200 | | `offset` | integer | Default 0 | ```bash curl -s "https://www.fume.finance/api/fund-builder/providers?category=custody" | jq '.providers[].name' ``` Returns `{ total, limit, offset, categories[], providers[] }`. The `categories` array is always the full list, so one call is enough to discover every valid `category` value. ### `GET /api/fund-builder/providers/{id}` [#get-apifund-builderprovidersid] One provider by its catalog slug. Unknown ids return 404 with `code: "provider_not_found"`. ## Search the documentation [#search-the-documentation] ### `GET /api/search?query=…` [#get-apisearchquery] Full-text search over `/docs`, returning ranked page, heading and text fragments. For bulk ingestion prefer [`/llms-full.txt`](https://www.fume.finance/llms-full.txt), which is the entire corpus in one request. ## Submission endpoints [#submission-endpoints] These deliver a message to the Fume team. They accept `POST` with a JSON body and return `{ "success": true }`. | Endpoint | Required fields | | ---------------------------------------- | ------------------------------------------------------- | | `/api/contact` | `name`, `email`, `message` | | `/api/newsletter` | `email` | | `/api/consulting-inquiry` | `name`, `email` | | `/api/fund-builder/stack-submission` | `email` | | `/api/fund-builder/introduction-request` | `email`, `providerName` | | `/api/fund-builder/partner-listing` | `companyName`, `email`, `category` | | `/api/registry/document-request` | `fundId`, `name`, `email` | | `/api/registry/list-fund` | `fundName`, `contactName`, `email`, `strategy`, `chain` | In production each one also requires a `captchaToken` — a Google reCAPTCHA v3 token, which only a browser session can produce. They exist for the forms on this site. **If you are an agent trying to reach us, email `info@fume.finance`.** The full field list for each endpoint is in [`/openapi.json`](https://www.fume.finance/openapi.json). ## Status codes [#status-codes] | Status | `code` | Meaning | | ------ | --------------------------------------- | --------------------------------------------------------- | | 400 | `missing_required_field` | A required field was absent | | 400 | `invalid_email` | The `email` field is not a valid address | | 400 | `invalid_json` | The body did not parse as JSON | | 404 | `fund_not_found` / `provider_not_found` | No record with that id | | 404 | `unknown_endpoint` | No such endpoint under `/api` | | 405 | `method_not_allowed` | Wrong method; the `Allow` header names the right one | | 500 | `upstream_error` | The request was fine, a downstream service was not. Retry | Every one of them returns the same JSON envelope described in the [developer overview](/docs/developers). # 🛠️ Developers (/docs/developers) Everything Fume publishes for people is also published for programs. This section is the map: what the Fume API exposes, where the OpenAPI specification lives, and how to read any page on this site as markdown instead of HTML. There is no signup, no API key and no SDK to install. Every endpoint documented here is public and unauthenticated. ## Start here [#start-here] ## The short version [#the-short-version] | Resource | URL | | -------------------------------------- | ------------------------------------------------------------------------------------ | | OpenAPI 3.1 specification | [`/openapi.json`](https://www.fume.finance/openapi.json) | | Tokenized fund registry, as JSON | [`/api/registry/funds`](https://www.fume.finance/api/registry/funds) | | Fund service provider catalog, as JSON | [`/api/fund-builder/providers`](https://www.fume.finance/api/fund-builder/providers) | | Index written for language models | [`/llms.txt`](https://www.fume.finance/llms.txt) | | Whole site as one markdown file | [`/llms-full.txt`](https://www.fume.finance/llms-full.txt) | | Sitemap | [`/sitemap.xml`](https://www.fume.finance/sitemap.xml) | Point a tool at the specification and the rest follows: ```bash curl -s https://www.fume.finance/openapi.json | jq '.paths | keys' ``` ## What the Fume API is, and is not [#what-the-fume-api-is-and-is-not] It is a **read API over public catalog data**. The Tokenized Fund Registry and the fund service provider directory are already published as HTML; the endpoints return the same records as JSON so you do not have to scrape them. They are cacheable, CORS-open, and safe to call from a browser or an agent. It is **not** a way to operate a fund. Tokenization, NAV runs, subscriptions and redemptions happen in the Fume application, behind authentication, and are not part of this specification. If that is what you are looking for, [book a call](/resources/book-a-call). The remaining endpoints are the website's own forms — contact, newsletter, provider introductions, registry listings. They are documented for completeness, but production protects them with a captcha, so they expect a browser. An agent that wants to reach a human should email `info@fume.finance` instead. ## Every error looks the same [#every-error-looks-the-same] Any non-2xx response from any endpoint, including a 404 or a 405, returns this envelope: ```json { "error": "A valid email address is required.", "code": "invalid_email", "message": "A valid email address is required.", "hint": "Send a syntactically valid address in the `email` field, e.g. \"jane@example.com\".", "status": 400, "docs": "https://www.fume.finance/openapi.json" } ``` Branch on `code`, show `message`, follow `hint`. `error` carries the same text as `message` and exists because the site's own forms already read that key. # ⚙️ How It Works (/docs/omniclear/how-it-works) ## The settlement flow [#the-settlement-flow] 1. **Investor sends funds**: the investor sends funds however they want: fiat wire, USDC, USDT, or any supported stablecoin. 2. **OmniClear converts and settles**: OmniClear handles conversion, compliance checks, and routing in the background. 3. **Fund receives in its preferred currency**: the fund receives the subscription in its base currency, whether that is stablecoins on-chain or fiat in a bank account. ## Works for any fund structure [#works-for-any-fund-structure] * **Accept crypto investors.** Traditional funds can receive stablecoin subscriptions and automatically convert to fiat for custody with their existing banking partners. * **Accept traditional investors.** Onchain funds can receive fiat wire transfers from traditional investors and settle subscriptions in stablecoins on-chain. * **Cross-border settlement.** Global settlement without correspondent banking delays. Send and receive across jurisdictions in minutes, not days. ## OmniClear and the rest of Fume [#omniclear-and-the-rest-of-fume] OmniClear pairs naturally with the [Tokenization Engine](/docs/tokenization/whitepaper): subscriptions and redemptions on tokenized funds can clear in stablecoins in the same block, while investors and managers keep operating in the currencies they already use. It is also one of the rails the [agents we deliver](/docs/ai-agents) can settle through. # 💱 OmniClear (/docs/omniclear) OmniClear is Fume's settlement layer for funds. It converts and settles between traditional rails and on-chain rails, so a fund can accept subscriptions in any currency and receive them in the one it prefers, in minutes instead of days. ## Bridging two worlds [#bridging-two-worlds] Fund money still lives in two separate systems that don't talk to each other: * **Traditional finance**: wire transfers, SWIFT payments, fiat currencies, traditional custody. * **Onchain**: stablecoins (USDC, USDT), smart contract settlement, instant transfers, on-chain custody. OmniClear sits between them and does three things: **convert, route, settle**. A traditional fund can take stablecoin subscriptions without touching crypto operationally; an on-chain fund can take fiat wires without opening a banking stack. ## Status [#status] OmniClear is in early access. [Book a call](/resources/book-a-call) to talk about integration. # 🪙 Tokenization Platform (/docs/tokenization) The Fume Tokenization Engine handles fund administration and tokenization on-chain: fund setup, investor onboarding, NAV calculations, subscriptions, redemptions, and settlement, for both traditional and digital asset funds. Tokenization itself is free; the platform charges a [protocol fee](/docs/tokenization/whitepaper/protocol-fee) on flows. ## In this section [#in-this-section] ## Elsewhere on the site [#elsewhere-on-the-site] # 🔌 Connect to the Tokenization Engine (/docs/tokenization/user-guides/connect-to-fume) How you access Fume depends on whether you are a fund manager or an investor. ### Sign in with email [#sign-in-with-email] The quickest way in is with your email address. When a fund manager invites you, you receive an email with a link to the platform. Click the link, enter the verification code, and you are in. Fume creates a wallet for you automatically, no extensions or private keys to deal with. This works on any device with a browser and is the recommended approach for most investors. ### Embedded wallets [#embedded-wallets] When you sign in with email, Fume creates an embedded wallet for you. This wallet lives inside the platform and handles your interactions with the fund's smart contract (depositing capital, redeeming units, etc.). You do not need to manage it yourself. If you are a fund manager, each investor gets their own embedded wallet the moment you send the invitation. Your investors can participate without any prior crypto experience. ### Sponsored transactions [#sponsored-transactions] Fume often covers blockchain transaction fees ("gas fees") on your behalf. When this applies, you will see a sponsored label next to the wallet in the connection interface. You can interact with the fund without holding any cryptocurrency for fees. ### Connect an external wallet [#connect-an-external-wallet] Fund managers and advanced users can also connect their own wallet. The Tokenization Engine supports MetaMask, WalletConnect, and Coinbase Wallet, which between them cover most wallets on the market. ## **Metamask** [#metamask] Metamask is one of the most popular wallets for interacting with web3 applications. It is available as a browser extension for chromium-based browsers (like Chrome, Brave, and Edge) and also has a mobile app. To connect, simply click **Connect via Metamask** on the Tokenization Engine, and the Metamask browser extension will open to confirm the connection.
## **Rabby** [#rabby] Rabby is a recent and popular alternative to Metamask, especially favored for interacting with web3 apps using hardware wallets like Ledger. It is also available as a chromium browser extension. If you have both Metamask and Rabby installed on the same browser, make sure to switch the primary connection to **Rabby** so Fume connects to the right extension.
## **Safe Wallet (formerly Gnosis Safe)** [#safe-wallet-formerly-gnosis-safe] We highly recommend **Safe Wallet** for fund managers. It is a multi-signature wallet, meaning it requires multiple signatures for fund operations, significantly enhancing security. Safe is free to use and ideal for fund management. To connect it to Fume: 1. Choose **WalletConnect** as the connection method. 2. Copy the code that appears. 3. Open your Safe Wallet by visiting [Safe](https://app.safe.global/welcome). 4. Click on **WalletConnect** in the top right corner and paste the code.
## **Exodus** [#exodus] You can connect **Exodus** using both the mobile app and the Chrome extension: * **Mobile Version**: To connect using WalletConnect, tap the right-most tab in Exodus, select the **Web3** button, and tap the QR code icon in the top right corner. Then, scan the WalletConnect code displayed on the Tokenization Engine. * **Chrome Extension**: For the Exodus Chrome extension, connect using the **Metamask** option. If you have the Exodus extension installed, it will automatically open and ask for confirmation to connect to the Tokenization Engine.
## **Trust Wallet** [#trust-wallet] To connect **Trust Wallet** via WalletConnect: 1. Open the Trust Wallet mobile app. 2. Tap the settings icon in the top left. 3. Select **WalletConnect**. 4. Scan the QR code from the WalletConnect screen on the Tokenization Engine.
## Using Hardware Wallets [#using-hardware-wallets] Hardware wallets such as **Ledger** and **Trezor** can also be used to interact with the Tokenization Engine for added security. These wallets can be connected through software interfaces like **Metamask** or **Rabby**. > **Note**: To use Ledger devices, you should first enable [blind signing](https://support.ledger.com/article/4405481324433-zd). ## Moving funds between wallets [#moving-funds-between-wallets] You can transfer funds between your wallets within the platform. For example, moving assets from a smart wallet to an embedded wallet does not require an external transfer. # 🎨 Fund Customization (/docs/tokenization/user-guides/customization) Customize your fund's appearance on the platform and how you communicate with investors.
### Branding [#branding] From the Settings page, set primary and accent colors to match your brand. These apply across the platform wherever your investors interact with the fund. You can also upload your fund's logo. It appears on the platform and in emails. ### Email settings [#email-settings] Fume sends investor notifications (subscription confirmations, NAV updates, etc.). You can control the Sender Name (the name that appears in the "From" field), the Reply-To Address (where investor replies go, so they reach you instead of a generic address), and which email templates your fund sends. Emails go through a queuing system with automatic rate limiting and retries, so delivery is reliable even with many investors. ### Investor messaging [#investor-messaging] Display custom messages on your fund's page for announcements or notices. Messages can also trigger email notifications. ### Live support [#live-support] Enable a Telegram widget on your fund's page. A chat icon appears, letting investors reach you directly with questions. ### Subscription plans [#subscription-plans] Fume has a single plan, **Fume Platform**, at $179/month with self-serve checkout. Manage your subscription from Settings. If your subscription expires, you will see a prompt to renew. # 🏗️ Fund Setup (/docs/tokenization/user-guides/fund-setup) Setting up your on-chain fund in the Tokenization Engine is straightforward. Follow the steps below to configure your fund's essential details, fees, wallets, and settings. ## **General Information** [#general-information]
The first step is to define the core details of your fund: * **Fund Name**: This is the name of your fund. * **Ticker**: The ticker is the symbol associated with your tokenized fund units. Hover over the info icon next to this field for guidance on choosing a ticker. * **Base Currency**: The stablecoin used for accounting and subscriptions. Common choices include USDC and USDT. * **Blockchain Network**: The network on which your fund's smart contract will be deployed. The Tokenization Engine supports Ethereum, Arbitrum One, Base, and BNB Smart Chain (BSC). We recommend Arbitrum One for its lower costs and faster transactions. * **Initial NAV**: The starting Net Asset Value per unit. This is the price at which the first units are issued to your early investors. It is commonly set to **100.00**. ## **Fees** [#fees]
Now, define the fee structure of the fund. These fees will apply to investor transactions: * **Management Fee**: Typically a percentage of the fund's total value. * **Performance Fee**: A percentage of profits (above the high-water mark). * **Entry Fee**: This is the fee applied to new subscriptions into the fund. * **Exit Fee**: This is the fee applied when investors redeem their shares. * **Lockup Period**: The lockup period defines how long investors must wait before they can redeem their shares. * **NAV Frequency**: Define how frequently the NAV should be calculated and updated. *Note: The entry and exit fees, as well as the lockup period, can be adjusted later on and even customized on a per-investor basis.* ## **Wallets** [#wallets]
Next, you need to configure three wallets for your fund: * **Governance Wallet**: This is the wallet that the fund manager uses to control the on-chain fund. The manager can whitelist investors, interact with the fund, move liquidity, and manage fee payments. For example, you can use a MetaMask wallet or a more secure solution such as a multisig like **SAFE** or **Fireblocks**. * **Custodian Address**: This is the wallet where the liquidity for the fund is stored. The fund manager can connect any custody solution here, such as a multisig, MPC, or even a centralized exchange. This wallet holds the underlying assets of the fund. * **Fee Collection Address**: This is where the management, performance, entry, and exit fees are collected. In some cases, the fund manager might use the same address for both the governance wallet and fee collection. *Note: These wallets can be updated later on.*

Example of wallets for an On-chain Fund

 ## **Transparency** [#transparency]
Finally, you can configure the transparency settings for your fund. Decide how much information you want to make visible to investors. You can choose to provide full transparency or limit access to specific metrics. You may allow investors to see: * **Key Metrics**: NAV, performance, fees. * **Flows**: Inflows and outflows of capital. * **Shareholder Registry**: Information about other investors in the fund. You can fully customize these settings to match your preferences. You may decide not to show certain details, like the underlying assets or specific flows, while still making other information available. ### Accounting method [#accounting-method] Choose how the fund handles investor positions during each NAV calculation. Equalization-Based (the default) adjusts all investor positions at each NAV event so everyone is treated fairly, regardless of when they invested. Series-Based tracks each group of investors who enter at the same time as its own series, with its own entry price, high-water mark, and fee calculations. When conditions align, series can be merged. ### Unit classes [#unit-classes] If you need to offer different terms to different groups of investors (for example, a lower management fee for early backers or a different lockup period for institutional investors), you can create multiple unit classes within the same fund. Each unit class operates as its own set of terms (fees, lockup, etc.) while sharing the same underlying portfolio and NAV calculation. You can set up unit classes during the initial fund creation or add them later from the Settings page. ### Customization [#customization] Pick primary and accent colors that match your brand, and upload your fund's logo. It appears across the platform wherever your investors interact with the fund. Both can be changed later from the Settings page. # 📖 User Guides (/docs/tokenization/user-guides) These guides cover the day-to-day operations of running a fund, from initial setup, through investor onboarding, to NAV, redemptions, and reporting. # 📊 NAV Calculation (/docs/tokenization/user-guides/nav-calculation) Every time you run a NAV calculation, the platform determines the value of each fund unit, calculates fees owed to managers, updates high-water marks, and adjusts all investor positions.
## **Initiate Fund (Initial NAV)** [#initiate-fund-initial-nav]
Every fund starts with a pre-defined **initial NAV per unit**, set during the fund setup. The very first NAV calculation event is simple: it uses the initial NAV value, as so far there are no investors or assets already in the fund. Once the initial investors are onboarded (by inviting them and receiving their deposits), the manager can begin fund operations: 1. Navigate to **"Overview"**. 2. Click **"Initiate Fund"** in the top-right corner. 3. This action will: * **Issue the first fund units** to investors. * **Liberate the capital** from the on-chain fund, moving it to the fund wallet for deployment. The fund is now live, and the liquidity is ready for deployment according to the manager's investment strategy. *** ## **Assets Valuation** [#assets-valuation] After investing the initial liquidity, it's time to perform the first **NAV calculation** to assess the fund's performance and value. The Tokenization Engine requires only one key input: the **Gross Asset Value (GAV)**. **Valuing the Assets**: To calculate the GAV, determine the **total value of the underlying assets** in the fund. The process for reconciling the fund's positions depends on the type of assets being managed. * For traditional portfolios (stocks, bonds, options), we recommend using portfolio management systems such as [**Utluna**](https://www.utluna.com/). * For advanced digital assets strategies, we recommend [**1Token**](https://1token.tech/), which provides reconciliation across multiple exchanges, wallets (multi-chain), and DeFi protocols. The current liquidity held in the fund wallet is automatically included in the calculation, so you do not need to add it manually. If you wish to outsource this task, [reach out](https://www.fume.finance/resources/book-a-call) to us for customized offers from our partners. > *Note: In upcoming product releases, we're planning to integrate such solutions directly into Fume for smoother fund manager experience.* ## **Calculate NAV** [#calculate-nav]
Once the total asset value has been defined, you can proceed with publishing the latest NAV calculation: * Navigate to **"Overview"**, then click **"Calculate NAV"** in the top-right corner. * You have two methods to calculate NAV: **Method 1 (Recommended)**: Using **Assets & Liabilities**. * Input the total value of the assets (as discussed in the previous section). * Add any additional costs in the **costs field** (e.g., operational costs outside of fees and redemptions). **Method 2**: Using the **GAV Directly**. * For more flexibility, compute the GAV manually (assets - liabilities) and input the final figure directly. * Click **"Preview NAV"** to review the calculation and see an estimation of the updated fund value (this action does not trigger any transactions). * Once satisfied, **submit** the NAV to make the calculation official. This will update the fund's NAV, issue new units, register any new applicable fees, and equalize the investments among all investors. * You can also upload an Excel spreadsheet with your asset data. Fume parses the spreadsheet and calculates the NAV from it. You can preview the results before confirming. The platform shows you an estimated gas fee before you submit. ### NAV dashboard [#nav-dashboard] After your first few NAV calculations, the fund's Overview page shows an AUM Chart (total Assets Under Management over time), a NAV Chart (historical NAV per unit with an annualized return overlay), performance tracking for each NAV event, and total outstanding units in circulation. Investors see a filtered version showing only their own investment, including individual performance and an estimate for the next NAV. #### Exporting NAV data [#exporting-nav-data] Download your complete NAV history at any time with the Export NAVs button. The file contains all historical NAV calculations and is useful for reporting and audits. #### Notifying investors [#notifying-investors] After completing a NAV calculation, you can notify your investors by email. You can send immediately or schedule for a later time, for example if you want to review the numbers or add a personal note first. Emails are sent in batches for reliable delivery, even with a large number of investors. ## Accounting methods [#accounting-methods] During each NAV event, Fume adjusts investor positions using one of two approaches, chosen during fund setup: * **Equalization-Based**: Fume adjusts all unit positions so that every investor's holding reflects the correct value, no matter when they entered. This is the default and handles different entry prices, high-water marks, and performance fees without extra configuration. * **Series-Based**: Each group of investors who subscribed at the same time is tracked as its own "series" with independent entry price, high-water mark, and fee calculations. When conditions align (e.g., after a fee crystallization event), series can be merged. Better for funds that need per-cohort tracking. # 🔑 Permissions & Roles (/docs/tokenization/user-guides/permissions) Whether you run a fund solo or with a team, the permissions system controls who can do what.
### Roles [#roles] There are two roles. Manager: administers the fund, can invite investors, calculate NAV, settle liabilities, manage settings, and perform on-chain operations. Investor: views their investment details, deposits capital, and requests redemptions. Investors cannot access administrative functions. ### Inviting additional managers [#inviting-additional-managers] Go to Settings and invite a manager by email. You choose which wallet they will use for on-chain interactions, or let Fume create an embedded wallet for them. They receive an email invitation to join. ### Per-function permissions [#per-function-permissions] For multi-manager funds, you can control exactly which operations each manager wallet is allowed to perform. From Settings > Permissions, assign specific smart contract functions to specific wallets. For example, one manager whitelists investors and manages subscriptions, another runs NAV calculations and settles fees, a third has read-only access to monitor the fund. This authorization is enforced on-chain. Even if someone accesses the platform, they cannot execute operations their wallet is not authorized for. ### What investors see [#what-investors-see] Investors see a simplified view of the platform. They can check their investment, track performance, deposit capital, and request redemptions. The sidebar and available actions are filtered by role, so no administrative features are shown. # 💧 Prepare Liquidity (/docs/tokenization/user-guides/prepare-liquidity) Before subscribing to a fund on the Tokenization Engine, investors need to make sure they have enough liquidity in their wallet. Most fund managers choose a stablecoin like USDC or USDT as the base currency. The important thing is that the liquidity must be available on the same blockchain network where the fund is deployed (for example, Arbitrum, Ethereum, Base, or BNB Smart Chain). ## **Option 1. Buy Liquidity from an Exchange** [#option-1-buy-liquidity-from-an-exchange] The easiest way to prepare liquidity is by purchasing stablecoins (e.g., USDT or USDC) directly from a centralized exchange such as Coinbase, Binance, or Kraken. After purchasing, withdraw the stablecoins to your wallet on the **correct network**. This method is simple and requires a low level of technical expertise. * Select the correct network (e.g., Arbitrum, Ethereum, Base, or BNB Smart Chain) during the withdrawal so it matches the fund's network. ### Example - Kraken and Metamask on Arbitrum One [#example---kraken-and-metamask-on-arbitrum-one] Let's walk through an example where: * The fund is deployed on **Arbitrum One**. * The stablecoin used for the fund is **USDC**. * The exchange used to buy USDC is **Kraken**. * The wallet used for interacting with the Tokenization Engine is **Metamask**. #### **Buy or Deposit USDC on Kraken** [#buy-or-deposit-usdc-on-kraken] * **Log in** to your **Kraken** account. * If you don't have USDC already, go to the **Buy Crypto** section and purchase the necessary amount of **USDC**. If you already have USDC in your Kraken account, you can skip this step. * Alternatively, if you need to deposit USDC from another source into Kraken, use the **Deposit** feature in Kraken to fund your account.
#### **Withdraw USDC to Metamask on Arbitrum One** [#withdraw-usdc-to-metamask-on-arbitrum-one] * Navigate to the **Transfer** section in Kraken. * **Select Withdraw, then USDC** as the asset to withdraw. * In the **Network** options, **choose Arbitrum One** as the chain to withdraw your USDC. * Open **Metamask** and switch the network to **Arbitrum One** (you can do this by clicking the network dropdown at the top-left of the Metamask interface). * **Copy your Metamask wallet address** (on the Arbitrum One network) and paste it into the **withdrawal address field** on Kraken. * Confirm the withdrawal address by email if it's a new wallet and submit the transaction. Kraken will now send your USDC to your Metamask wallet on the **Arbitrum One** network. Once the transaction is confirmed, you will see your USDC in your Metamask wallet. #### **Get Some ETH for Gas Fees** [#get-some-eth-for-gas-fees] To interact with the Tokenization Engine and complete the investment, you will need a small amount of **ETH** in your Metamask wallet to cover transaction ([gas](https://www.investopedia.com/terms/g/gas-ethereum.asp)) fees on the **Arbitrum One** network. If you don't have any ETH on **Arbitrum One**, follow these steps: * On **Kraken**, go to the **Buy Crypto** section and purchase a small amount of **ETH**. Around **0.002 ETH** is enough for basic transactions. * Go to the **Withdraw** section and select **ETH**. * In the withdrawal options, choose **Arbitrum One** as the network. * **Paste your Metamask wallet address** (the same one you used for USDC). * Submit the transaction, and once confirmed, you will have the ETH in your Metamask wallet to cover gas fees. Now that you have both **USDC** and **ETH** in your Metamask wallet on the **Arbitrum One** network, you are ready to invest in the on-chain fund via the Tokenization Engine. While this example uses Arbitrum One, the same process works for any supported network. Simply select the matching network when withdrawing from the exchange and when configuring your wallet. ## **Option 2. Bridge Liquidity Across Networks** [#option-2-bridge-liquidity-across-networks] If you already have liquidity in your wallet but on the **wrong network**, you can use a **bridge** to transfer the funds to the correct one. * **Built-in Swaps**: Some wallet apps offer a built-in swap or bridge function that allows you to easily move assets between networks. * **Native Bridges**: Alternatively, you can connect to a native blockchain bridge like [**Arbitrum Bridge**](https://bridge.arbitrum.io/?destinationChain=arbitrum-one\&sourceChain=ethereum) to transfer your stablecoins to the correct network. ### Recommended Approach [#recommended-approach] For most investors, the most straightforward way is to purchase stablecoins from a centralized exchange and withdraw them directly to your wallet on the target network. This minimizes the risk of errors and makes sure your liquidity is ready when you subscribe. # 📑 Reports & Exports (/docs/tokenization/user-guides/reports-and-exports) You can generate reports and export data for your records, audits, and investor updates. ### Investor PDF statements [#investor-pdf-statements] Generate a PDF statement for any investor from their details page. The statement covers subscription history, current units held, performance, and redemption details. Go to the investor's profile and click Export PDF. The file downloads immediately. Useful for quarterly/annual reporting or when an investor asks for a position summary. ### Units register export [#units-register-export] Download the full unit register as a CSV from the Register page. You can filter by date to get a snapshot of holdings at any point in time, which is useful for audits and tax filings. ### NAV history export [#nav-history-export] Click Export NAVs on the Overview page to download all NAV calculations. The file includes dates, NAV per unit, AUM, and fee details. ### Transfer agent transactions [#transfer-agent-transactions] Export all transactions processed by the Transfer Agent (subscriptions, redemptions, liabilities, distributions) with dates and amounts. Use the Export button in the relevant section. # 🎬 Demo (/docs/tokenization/whitepaper/demo)