Ampli Composer

The strategy layer for autonomous capital management

Compose trading strategies as scores. Rehearse against live data. Conduct onchain with our MPC-secured smart accounts and ampli's onchain policy engine.

treasury-optimizer.score.score
score TreasuryOptimizer {
  // Which protocols we conduct through
  ensemble: {
    lender:   @aave_v3
    alt:      @morpho_blue
    dex:      @uniswap_v3
  }

  // Guardrails enforced at runtime
  dynamics: {
    max_single_move:       500000 USDC
    max_slippage:          50bps
    require_approval_above: 250000 USDC
  }

  cadenzas: {
    risk: {
      model: "anthropic:claude-opus-4-6"
      timeout: 15
      fallback: false
    }
  }

  on hourly: {
    spread = apy(@alt, USDC) - apy(@lender, USDC)

    if spread > 100bps {
      decision = cadenza risk: "Spread is {spread}bps. Rebalance?" {
        output: { type: boolean }
        fallback: false
      }

      if decision {
        measure rebalance: {
          lender.withdraw(USDC, balance(USDC))
          alt.lend(USDC, balance(USDC))
        }
      }
    }
  }
}
Live Score

Watch the orchestra conduct

A single score flows from agent to SDK, fans out across instruments, and lands onchain. Every note is a real pipeline step.

The Execution Pipeline

Compose. Rehearse. Conduct.

Every score follows the same safety pipeline. Nothing moves onchain until you've rehearsed it and reviewed the feedback.

01
ampli compose
Compose
Write your strategy as a .score file. Define your instruments, dynamics, cadenzas, and execution tempo.
02
ampli tune
Tune
Compile and validate. The type checker, constraint validator, and structural rules catch problems before any capital is at risk.
03
ampli rehearse
Rehearse
Simulate against live protocol data. The preview produces a receipt with planned actions, constraint checks, and drift assumptions.
04
ampli conduct
Conduct
Execute onchain through MPC-secured smart accounts. Commit re-validates before settlement. If anything drifted, it rejects.
# The safe execution path
$ ampli tune scores/treasury-optimizer.score
$ ampli rehearse scores/treasury-optimizer.score --chain 8453
$ ampli conduct scores/treasury-optimizer.score --dry-run --chain 8453
$ ampli conduct scores/treasury-optimizer.score --chain 8453
Architecture

Built to support institutional capital

Scores run on Ampli's full infrastructure stack. MPC custody, onchain governance, smart accounts, and policy enforcement that cannot be bypassed.

MPC

n-of-n Threshold Signing

No single party holds a complete key. The Ampli MPC distributes key shares between client and server. The full private key is never reconstructed, even during signing.

⚖

Onchain Governance

Ampli's policy engine enforces rules at the smart contract level. Even a compromised backend cannot bypass validation. Agent identity, whitelists, and roles live onchain.

◈

Smart Accounts

ERC-4337 account abstraction with ERC-7579 modular validation. Gas sponsorship, batched operations, programmable validation, and deterministic addresses.

♩

Typed Cadenzas

AI decision points with schema validation, timeouts, and fallback values. The model provides judgment; the score controls what happens with it. Fully auditable and replayable.

⟳

Preview / Commit

Every execution produces a typed receipt before settlement. Drift detection at commit time rejects stale previews. Rehearse as many times as needed before conducting live.

∞

Scale to 1M Wallets

Enterprise Message Queue distributed workers process scores across wallets in parallel. One scheduler, N stateless workers, horizontally scalable execution independent of the API.

Instruments

The protocols you conduct through

Each instrument has an adapter that translates score actions into protocol-specific calls. Switch instruments without rewriting strategy logic.

InstrumentTypeActionsChains
@aave_v3Lendinglend, withdraw, borrow, repayEthereum, Base
@morpho_blueLendinglend, withdraw, supply/withdraw collateralBase
@uniswap_v3DEXswapMulti-chain
@uniswap_v4DEXswapMulti-chain
@acrossBridgebridgeCross-chain
@fluidLendinglend, withdrawEthereum, Base
@pendleYieldadd/remove liquidity, market opsMulti-chain
Choose Your Path

Two entry points, one engine

Write scores locally or send intents through the Platform API. Both run the same conductor underneath.

Score SDK

.score files + CLI
  • —Write and test strategies locally
  • —Full control over execution
  • —CI/CD pipeline integration
  • —Agent workflows with LLM skill packs
  • —Anvil fork simulation
  • —Self-custody: your keys, your conductor

Platform API

Ampli composer REST API coming soon
  • —Natural language intent parsing
  • —Automated policy enforcement
  • —Clarification sessions for ambiguous intents
  • —MPC-secured managed execution
  • —Multi-tenant with scoped API keys
  • —Fund Manager Portal with treasury dashboards
Launching Q3 2026

Your capital, precisely scored

Compose once. Rehearse as many times as you need. Conduct onchain with our MPC-secured smart accounts and ampli's onchain policy engine.