Vacuum

The Agentic Execution & Capital Orchestration Layer for Arbitrum

Status:

• Fully deployed on Arbitrum Sepolia (testnet)

• Mainnet in private beta (team testing live liquidity)

• Public beta launching soon

Vision

DeFi is fragmented.

• Traders use bots.

• DAOs manage treasuries manually.

• Vaults operate in isolation.

• Strategies are not ownable.

• AI cannot safely execute capital.

We are building:

A programmable capital operating system for Arbitrum.

Vaccum unifies:

• Execution Layer

• Yield Engine

• Strategy Tokenization

• DAO Automation

• Agent Marketplace

• MEV-Resistant Infrastructure

• SDK for external builders

Long-term:

The backend for on-chain capital — human or AI.

Product Overview

Vaccum consists of 6 core layers:

Layer 1 — Execution Layer

Production-grade smart contract router with:

• Uniswap V3 integration

• Real swap execution

• Slippage enforcement

• Fee capture

• Referral system

• Delegate authorization

• Replay protectio

• Emergency controls

Testnet: Live

Mainnet: Private beta

Execution flow:

User → SDK → Private RPC → Simulation → Router → DEX → Settlement

Layer 2 — Vault Engine

ERC-4626 compliant auto-compounding vaults.

Features:

• Strategy abstraction

• Performance fee only on profit

• Harvest logic

• Emergency withdraw

• Strategy upgradeability

• Factory deployment system

Use cases:

• Passive yield parking

• DAO treasury idle capital

• Auto-rebalancing strategies

Layer 3 — Strategy Tokenization

Strategies are tokenized as NFTs.

Each Strategy NFT includes:

• Strategy contract reference

• Version history

• Risk metadata

• Royalty rules

• Subscription pricing

• Revenue split logic

Enables:

• Strategy ownership

• Licensing

• Resale

• Creator economy

We turned trading logic into an asset class.

Layer 4 — DAO Automation Mode

Institutional layer.

DAO Treasuries can:

• Execute buybacks

• Deploy capital to vaults

• Hedge volatility

• Enforce execution policies

• Define on-chain automation rules

• Limit daily exposure

Modules:

• TreasuryAutomationController

• PolicyEngine

• RiskGuard

• GovernanceExecutorAdapter

• BuybackModule

This makes ArbiOS protocol-grade infrastructure.

Layer 5 — Agent Marketplace

Builders can:

• Register agents

• Stake for reputation

• Earn revenue share

• Publish capital strategies

• Collect subscription fees

Agents are:

• Non-custodial

• EIP-712 signed

• RiskGuard validated

• SDK-integrated

Revenue model:

• Execution fees

• Subscription fees

• DAO automation fees

• Vault performance split

Layer 6 — Private RPC + MEV Protection

Execution-grade infrastructure.

Includes:

• Private transaction relay

• Mempool listener

• Sandwich risk detection

• Simulation engine

• Transaction bundling

• Adaptive gas escalation

• Failover broadcast

Designed for:

• Degens

• Treasuries

• High-frequency agents

• Institutional flows

SDK

Professional TypeScript SDK.

Supports:

• Execution swaps

• Vault deposits

• Strategy subscriptions

• DAO automation

• Agent registration

• Revenue claiming

Design:

• Strict typing

• Modular exports

• Ethers v6

• EIP-712 helpers

• Event decoding

• Gas estimation

• Simulation support

Use cases:

• DeFi apps

• Consumer apps

• Game engines

• RWA platforms

• Agent builders

Current Testnet Deployment

Live on Arbitrum Sepolia:

• ExecutionRouter

• VaultFactory

• StrategyNFT

• AgentRegistry

• DAO Automation contracts

• Private RPC relay

Frontend:

• Swap interface

• Vault deposit

• Strategy marketplace

• DAO rule setup

• Agent registration

• Revenue dashboard

Testnet Proof Points:

• Real swaps executed

• Real vault deposits

• Royalty distribution

• Subscription enforcement

• DAO rule trigger

• MEV guard simulation logs

Mainnet Status

Currently:

• Private beta live on Arbitrum One

• Team testing:

  • Liquidity depth

  • Gas escalation logic

  • MEV guard behavior

  • DAO buyback automation

  • Agent execution safety

Public beta soon.

Use Cases

🔹 DeFi Protocols

• Treasury automation

• Liquidity defense

• Emission management

• Buyback execution

• Yield routing

🔹 RWA Platforms

• Automated stablecoin deployment

• Treasury yield allocation

• On-chain settlement engine

• Controlled liquidity execution

🔹 Games

• Automated in-game token swaps

• Treasury yield farming

• NFT-backed strategy NFTs

• SDK integrated execution

🔹 Consumer Apps

• Background yield for idle funds

• One-click swap engine

• Subscription-based strategy access

• AI-assisted investing

🔹 AI Builders

• Strategy bots

• Arbitrage bots

• Sentiment-based agents

• Risk hedge agents

• DAO governance monitors

Solver & LP Model (Future Expansion)

Future design:

ArbiOS as Intent Layer.

Users submit:

“Swap 100k USDC for best execution”

Solvers:

• Compete to fill order

• Provide best price

• Bundle execution

• Earn solver fee

LP providers:

• Provide execution liquidity

• Earn fee share

• Participate in buyback flows

This transitions ArbiOS toward:

Intent-based execution network.

Complete docs - https://www.notion.so/Vacuum-30fa0837aade80a38e73c02fa9a32664?source=copy_link
Github - https://github.com/harshdev2909/vacuum
NPM Package url - https://www.npmjs.com/package/vacuum-sdk

During the hackathon, we built Vaccum, a modular, agentic execution and capital orchestration protocol on Arbitrum designed to unify trading, yield, automation, and programmable capital infrastructure into one cohesive system. What started as a fast on-chain execution router evolved into a full-stack protocol that now includes a production-grade Execution Layer (live on Arbitrum Sepolia), ERC-4626 auto-compounding vaults, tokenized strategy infrastructure (Strategy NFTs with royalty and subscription logic), DAO automation modules, an Agent Marketplace, and a private RPC + MEV-protection backend. Throughout the hackathon, we deployed and tested all core smart contracts on testnet, built and connected a working frontend, integrated real swap execution against live DEX liquidity, validated fee capture and referral flows, implemented vault deposits and harvesting logic, enforced subscription gating for strategies, and tested DAO automation rules such as buybacks and treasury allocation triggers. In parallel, we developed a professional TypeScript SDK to allow external apps, DeFi protocols, and AI builders to integrate with Vaccum, along with a non-custodial AI agent wrapper framework for safe execution using EIP-712 signatures. By the end of the hackathon, Vaccum was fully functional on testnet as a bootstrapped product, with the team currently running controlled tests on Arbitrum mainnet in private beta. The result is not just a trading tool, but a programmable capital operating layer that can power DeFi protocols, DAOs, RWA platforms, games, and AI-driven agents — positioning Vaccum as foundational infrastructure rather than a single application.

Vaccum is currently raising $500K at a $5M valuation via a SAFE + token warrant (1:1 structure) to accelerate its transition from private mainnet beta to full public launch. The round is designed to extend runway for core infrastructure hardening and ecosystem expansion while maintaining disciplined, capital-efficient growth. Funds will primarily be allocated toward a comprehensive smart contract audit and production-grade infrastructure upgrades required for secure mainnet scaling, including MEV-resistant execution infrastructure and monitoring systems. We are also initiating immediate hiring across smart contract engineering and backend infrastructure (with pre-identified candidates already in pipeline) to strengthen protocol security and performance. Additionally, capital will support a coordinated Day-1 go-to-market strategy focused on Crypto Twitter, developer communities, and Arbitrum-native builders to position Vaccum as the execution and automation backbone for DeFi protocols, DAOs, RWAs, and agent builders. This raise enables Vaccum to move from validated testnet infrastructure and private beta testing into a secure, high-visibility public launch with strong ecosystem traction.