Why Vaults Need Allocators, Strategy Managers, and Hook Managers

Start with a simple question

If you were designing a system to manage funds automatically, how would you do it?
The simplest idea: write one contract. Take users' U in. Find a strategy. Deploy. Distribute returns.

That idea isn't wrong. But it's missing something: manageability.
A vault without layered design is like a company without departments. It can do anything. But it does nothing well. More importantly, nothing can be managed well.

Good architecture gives different jobs to different modules

Concrete vaults follow this principle.
Not one monolithic contract. A set of specialized modules. Each does one thing. Does it extremely well.
The three core modules are: Allocator, Strategy Manager, Hook Manager.

Allocator: responsible for "where to go"

The Allocator decides where capital goes.
In DeFi, opportunities are dynamic. This pool is hot today. That pool is better tomorrow. If a vault sticks to one strategy forever, it's no different from users manually parking funds in one place.

The Allocator makes capital flow. It continuously monitors strategy states. Based on preset rules, it deploys funds where they're most suitable.
This isn't chasing yield randomly. This is dynamic optimization within rules.

Strategy Manager: responsible for "where can go"

If the Allocator is the driver, the Strategy Manager is the map.
The driver can go anywhere. But the map defines which roads are open, which are closed.
The Strategy Manager defines a strategy universe. Capital can only operate inside this universe. Inside are strategies that have been reviewed, tested, deemed safe. Outside? No entry, no matter how high the yield.

This is risk control's first line of defense. Not enforced by humans. Enforced by code setting boundaries.

Hook Manager: responsible for "when to stop"

Allocator decides where to go. Strategy Manager decides where can go. Hook Manager decides when to stop.

DeFi risks change in real-time. A strategy safe today could turn dangerous tomorrow from market swings. A protocol fine today could get hacked tomorrow from a vulnerability.

The Hook Manager monitors these risk metrics continuously. Exceed preset thresholds? Protection triggers immediately—pause strategy, withdraw funds, notify managers.
This is automated risk control. No human watching. No human reacting. Code is faster than people.

Why layered architecture matters more

Some might ask: one contract could do all three. Why separate?
Answer: maintainability and upgradeability.

If three functions are packed into one contract, changing one affects the others. Fixing one bug might introduce another. Upgrading one module means shutting down the whole system.
Layered architecture's advantage: each module evolves independently.

Allocator rules can optimize without touching Strategy Manager.
Strategy Manager can expand its universe without affecting Hook Manager.

Hook Manager can adjust thresholds without impacting Allocator execution.
For capital management infrastructure, this flexibility isn't optional. It's critical.

Concrete DeFi USDT's layered practice

Look at Concrete DeFi USDT to understand layered architecture's value.
~8.5% stable yield isn't from simple deposit-interest logic. Behind it:

The Allocator continuously searches for suitable stablecoin strategies, dynamically adjusting positions as markets change.
The Strategy Manager ensures all operations stay within safe bounds. No crossing into risky territory.

The Hook Manager monitors risk metrics in real-time. Any anomaly triggers protection.
Automated compounding works silently in the background, letting returns grow exponentially.
Each module does its job. Together, they form a complete, stable, manageable system.

Architecture philosophy: separation of concerns

Good architecture has a philosophy: separate concerns.
Where to go. Where can go. When to stop. Three different questions. Mix them together, and none get solved well. Separate them, each gets a dedicated module. Overall efficiency maximizes.

This isn't just a code design principle. It's the underlying logic of capital management.
Concrete vaults are built on this logic. So they don't just manage capital. They manage it well. And make management auditable, controllable, upgradeable.

This is what onchain capital deployment infrastructure looks like.

Explore Concrete at app.concrete.xyz
Keywords: DeFi vaults, managed DeFi, Concrete vaults, onchain capital deployment, automated compounding, capital efficiency, institutional DeFi