> For the complete documentation index, see [llms.txt](https://documentation.justbeep.it/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://documentation.justbeep.it/product-overview/agentic-yield/core-concepts.md).

# core concepts

Agentic Yield isn’t a black box it’s a bunch of simple primitives wired together for ai-agents.\
If you understand how vaults, pools, and strategies interact, you can build, debug, or extend your own agent logic pretty easily.

### 🏦 Vaults

A **vault** is your agent’s working account inside Sui defi protocols.\
It’s a smart contract object on Sui that holds your tokens, tracks positions, and exposes a clean interface for deposits, withdrawals, and reallocation. You (or your agent) are the only one with valid permissions to execute actions inside it.

Vaults handle:

* Token deposits / redemptions
* Balance tracking
* Yield accrual and performance history

Each user or agent gets its own vault. There’s no shared pool risk — your wallet is isolated, composable, and fully on-chain.

> Think of it as a programmable wallet that knows how to farm.

### Pools

A **pool** is an external liquidity source — like Scallop, Navi, Momentum, SUILend, Bluefin, etc. — where the agent actually earns yield.\
Pools define the *where* of your yield, not the *how*.

Each pool has:

* Supported asset (e.g., USDC)
* Current APY / APR
* Liquidity depth
* Utilization rate
* Risk score

Your agent constantly monitors all active pools on Sui.\
When conditions change in your vault's favor — new incentives, liquidity shifts, or risk events — the agent updates its pool scores in real time.

> Pools are the data layer the agent reads before deciding what to do next.

### 🧠 Strategies

A **strategy** is a logic module that decides *how* to allocate across pools.\
This is where your agent actually gets its brain.

Each strategy implements a few key interfaces:

```typescript
interface Strategy {
  scan(): Opportunity[];
  score(opportunity: Opportunity): number;
  execute(opportunity: Opportunity): Txn[];
  compound(): Txn[];
}
```

Under the hood, strategies use on-chain data, oracles, and historical signals to calculate expected net yield after gas and risk.

Common strategies include:

* **Lending Aggregator:** Find best stablecoin lending rate.
* **LP Auto-Compounder:** Reinvest rewards from LP positions.
* **Rewards Optimizer:** Rotate between vaults with boosted rewards.

### ♻️ Compounding

Compounding is where the magic happens.\
Whenever the agent detects accrued yield above a threshold, it rolls it back into the base strategy.

The flow looks like this:

1. Harvest rewards from the current pool.
2. Swap / convert if needed (e.g., reward token → USDC).
3. Re-deposit into the best-performing pool.

This process can happen multiple times a day, depending on gas conditions and profit margin.

Beep agents calculate compounding frequency dynamically — they only act when it’s economically positive to do so (i.e., net yield > gas + slippage).

### 🧩 TLDR;

At runtime:

* The **vault** holds assets.
* The **strategy** picks targets.
* The **pools** supply yield.
* The **compounding loop** keeps it growing.