Matador solves critical challenges for DeFi, DAOs, and Institutions. Explore how programmable guardrails work across automation, treasury ops, compliance, security, and wallet UX.

Solutions & Use Cases

The shift from approvals to constraints

Most DeFi, DAO, and institutional teams work the same way: someone proposes a transaction, everyone checks calendars, and approval chains slow everything down. It's safe, but it's painful.

The problem isn't the approval itself—it's that approval is binary. You either say "yes" and trust the person asking, or you say "no" and block progress. This model works fine for one-off decisions, but it breaks under the scale of modern operations.

The new model

Matador flips this: instead of approving who can act, approve what they can do—as explicit, enforceable constraints. Then you can move fast without trading away security, compliance, or governance.

Where do you start?

DeFi Automation

Automate high-frequency strategies like delta-neutral farming while minimizing custody exposure with on-chain guardrails.

Asset Management

Build structured products and managed vaults with codified mandates, drift limits, and risk containment.

DAO Treasury Ops

Streamline grants, payroll, and emergency responses with optimistic execution that stays within governance-defined bounds.

Institutional Compliance

Enforce regulatory compliance (KYC, AML, NAV limits) at the bytecode level with auditable policies.

Protocol Security

Protect protocols from hacks with external invariant checks, circuit breakers, and scoped guardian powers.

Smart Wallet UX

Enable 'One-Click' experiences with safe, scoped session keys that reduce approval fatigue.

The shared DNA: boundaries before execution

Different verticals face different problems, but they share the same root: the need to delegate execution without delegating judgment.

A protocol operator needs automation without giving a bot "god mode" keys. A treasury steward needs fast grant payouts without multisig bottlenecks. A compliance officer needs regulatory checks built into flows. A wallet team wants one-click experiences without asking users to approve every swap.

Matador's answer is the same across all of them: define the boundary first, then let teams operate inside it. Whether you're automating a delta-neutral vault, paying a grant, onboarding an institution, or securing a protocol—the pattern is:

Author a policy that encodes your constraints. Enforce it on-chain. Let your teams move fast inside the box you drew.

This works because constraints are explicit—slippage bounds, budget caps, KYC requirements, health factor floors—and they're enforceable by an interpreter that lives outside any single team's code path. The bot doesn't need to be trustworthy; the policy needs to be correct.

Common patterns (deep dive)

Across all these verticals, Matador applies the same core policy patterns:

1. The Sentinel

A policy that watches for bad states (e.g., price deviation, protocol pause) and blocks actions when they occur.

import "abis/IOracle.json" as Oracle;

permission Sentinel -> 1.0.0 {
  parameters: { maxPrice: uint256 }
  when: { Oracle.latestPrice() <= parameters.maxPrice }
}

Use case: DeFi Automation - Stop automated swaps if oracles report extreme prices or protocols pause.

2. The Allowlist

A policy that restricts interactions to specific known contracts (e.g., only Uniswap V3 router, only Aave pools).

permission Allowlist -> 1.0.0 {
  parameters: { allowed: address }
  when: { context.target == parameters.allowed }
}

Use case: Institutional Compliance - Ensure assets only move to approved protocols, or DAO spending only hits whitelisted contracts.

3. The Rate Limit

A policy that throttles value flow over time or frequency—preventing runaway execution or draining.

permission RateLimit -> 1.0.0 {
  parameters: { limit: uint256, window: uint256 }
  when: {
    context.value <= parameters.limit,
    rate_limit(key: context.caller, limit: parameters.limit, window: parameters.window)
  }
}

Use case: Smart Wallet UX - Allow a session key to spend up to $100/day, or execute a maximum of 5 swaps per hour.

Read about policy patterns → /docs/api/policy-patterns

Why it matters

When teams can ship with constraints instead of approvals, they move faster—and they do it more predictably. You get operational velocity without trading away security or governance.

The compounding effect

Every constrained action you don't have to review is one you can safely automate. Over time, your approval backlog shrinks, your operational overhead drops, and your team can focus on strategy instead of permission-chasing.

Constraints don't just reduce overhead—they reduce risk. A bot with "god mode" keys is a single point of failure. A policy that enforces slippage bounds is a distributed safety layer. A governance process that incorporates veto windows is faster, but still has checks. A compliance check that happens on-chain is more reliable than one that happens in a spreadsheet.

Story snippet

A DAO has been running grant payouts through a multisig for months. Every week: prepare proposal, schedule vote, wait 3 days for quorum, sign transaction, execute. Some grants get delayed weeks because signers are busy or traveling.

They implement Matador with a budget rail: $50,000 per quarter, with individual grant caps of $5,000 and a 3-business-day committee veto window. Now the same multisig signs once to authorize the rail, and grant submitters can call directly within limits.

Week 1: $47,000 paid automatically. Week 2: $49,000 paid automatically. No one touched a private key. No one reviewed a spreadsheet. The DAO shipped eight grants in the time it used to ship one—while keeping full governance control and a clear audit trail.

This is what "governance with guardrails" looks like.

Solutions Overview