AI Agents in the Bond Market: Tokenized T-Bills, On-Chain Yield Curves, and Fixed Income

Fixed income was once the domain of institutional desks, Bloomberg terminals, and multi-decade career specialists. Today, tokenized treasury bonds are settling on Ethereum in minutes, yield curves live on-chain, and autonomous AI agents can manage duration risk around the clock. This is the complete research guide to agent-native fixed income.

Why Bonds Matter for AI Agents

When most people think of AI agents operating in financial markets, they picture aggressive high-frequency trading, perpetual futures, and leveraged crypto plays. But the world's largest asset class — fixed income — represents a fundamentally different opportunity: predictable, yield-generating, lower-volatility exposure that balances a portfolio and provides liquidity reserves.

Bond markets globally represent roughly $130 trillion in outstanding debt. The US Treasury market alone sees over $3 trillion in daily trading volume, dwarfing equity markets. For AI agents managing multi-chain wallets and autonomous treasuries, fixed income instruments serve three primary functions:

• Cash management — parking idle funds in short-duration T-bills earning 4-5% APY while awaiting trading opportunities
• Risk balancing — offsetting high-volatility crypto positions with negative-correlation bond exposure
• Yield optimization — constructing laddered portfolios across the yield curve to maximize risk-adjusted returns

The critical development of the past two years is tokenization: the ability to hold and transfer economic rights to US Treasury bonds as ERC-20 tokens on public blockchains. An AI agent can now allocate to "risk-free" government debt without touching a brokerage account, custody agreement, or bank wire.

Bond Market Fundamentals for Agents

Duration and Interest Rate Risk

Before writing a single line of agent code, understanding duration is non-negotiable. Duration measures a bond's price sensitivity to interest rate changes. A bond with a 5-year modified duration loses approximately 5% of its market value for every 1% rise in interest rates.

For AI agents, duration translates directly into risk parameters. A conservative treasury management agent might cap duration at 1 year. A yield-maximizing agent running over a multi-year horizon might extend to 7-10 years, accepting more rate volatility in exchange for higher coupons.

The Yield Curve

The yield curve plots yields on identical-credit instruments (e.g., US Treasuries) against their maturities. Under normal economic conditions the curve slopes upward: lenders demand more yield for the uncertainty of lending long. Key metrics agents should track:

Bond Types Agents Can Access On-Chain

• T-Bills (0-1 year) — highest liquidity, near risk-free, lowest yield; ideal for cash management modules
• T-Notes (2-10 year) — middle ground; primary target for yield curve positioning strategies
• T-Bonds (10-30 year) — maximum duration risk; suitable only for long-horizon agents with low leverage
• TIPS — Treasury Inflation-Protected Securities; principal adjusts with CPI; useful for agents tracking macro inflation indicators
• Corporate Bonds — higher yield with credit risk; tokenized versions emerging via platforms like Centrifuge and Maple Finance

The Tokenized Treasury Landscape

Tokenized real-world assets (RWAs) represent the bridge between traditional capital markets and on-chain agent infrastructure. By 2026, the tokenized treasury market has grown to over $2.8 billion, with multiple institutional-grade issuers offering ERC-20 wrappers around US government debt.

Ondo Finance — OUSG and USDY

Ondo Finance has become the largest tokenized treasury issuer by AUM. Their flagship products:

• OUSG (Ondo Short-Term US Government Bond Fund) — a tokenized share in a BlackRock iShares Treasury ETF, redeemable T+0 on-chain. Minimum investment dropped from $100k to $5k in 2025. Yield: approximately the 3-month T-bill rate minus a small management fee.
• USDY (US Dollar Yield) — a permissionless, yield-bearing stablecoin backed by short-duration Treasuries. Agents can hold USDY as a "productive stablecoin" without KYC for amounts under regulatory thresholds.

OpenEden — TBILL Vault

OpenEden's TBILL token provides direct exposure to 3-month US Treasury bills with 24/7 on-chain minting and redemption. Key characteristics for agent integration:

• Operates as an ERC-4626 vault — the standard interface for yield-bearing tokens
• Real-time NAV updates pushed on-chain, readable by smart contracts
• Supports both Ethereum mainnet and Arbitrum deployments
• KYC required for direct vault access (whitelist model); secondary market via DEX is permissionless

Franklin Templeton — BENJI on Stellar and Polygon

Franklin Templeton's Franklin OnChain US Government Money Fund (FOBXX), represented by the BENJI token, was one of the first regulated mutual fund products to record share ownership on a public blockchain (Stellar, later expanded to Polygon). Each BENJI token equals one share of FOBXX, yielding approximately the federal funds rate minus expenses (~10bps).

For agents building multi-chain portfolios, BENJI on Polygon is particularly accessible — it can be integrated with EVM-compatible wallet infrastructure and transferred programmatically once whitelisted.

Platform Comparison

On-Chain Yield Curve Analysis

Constructing a yield curve on-chain requires reading spot yields from multiple tokenized instruments across different maturities. While the traditional yield curve uses OTC Treasury prices, agents can approximate it using:

1. Short end (0-3M) — USDY, USDM yields; money market rates from Aave/Compound
2. Medium term (3M-2Y) — OUSG yield, T-bill oracle feeds
3. Long end (2Y+) — Notional Finance fixed rate markets; Element Finance yields

Notional Finance is particularly powerful for agents: it creates fixed-rate lending markets for crypto assets, effectively generating an on-chain yield curve. An agent can lend USDC at a fixed 3-month rate of 5.2% or a 6-month rate of 5.8% — and these rates reflect market expectations of future interest rates, analogous to the traditional curve.

Key Curve Metrics to Track

• 2-10 Spread — 10Y yield minus 2Y yield. Negative = inverted. Historical average ~1.5%.
• 3M-10Y Spread — The Fed's preferred recession predictor. Negative for 12+ months historically precedes recessions.
• Curve Slope Rate of Change — Steepening or flattening velocity matters as much as absolute level.

Fixed Income Agent Strategies

Treasury Ladder Strategy

A bond ladder distributes capital across multiple maturities so that a portion of the portfolio matures regularly. For tokenized treasuries, this can be implemented programmatically:

# Treasury ladder strategy for AI agent
import asyncio
from decimal import Decimal
from datetime import datetime, timedelta
from web3 import Web3

# Tokenized treasury contracts (Ethereum mainnet)
CONTRACTS = {
    "USDY_1M": {
        "address": "0x96F6eF951840721AdBF46Ac996b59E0235CB985a",
        "maturity_days": 30,
        "target_alloc": Decimal("0.25")  # 25% of fixed income bucket
    },
    "TBILL_3M": {
        "address": "0xdd50C053C096CB04A3e3362E2b622529EC5f2e8a",
        "maturity_days": 90,
        "target_alloc": Decimal("0.35")
    },
    "OUSG_6M": {
        "address": "0x1B19C19393e2d487D05470BD46161a7E11c4d5E1",
        "maturity_days": 180,
        "target_alloc": Decimal("0.25")
    },
    "NOTIONAL_1Y": {
        "address": "0x6EbcE2453398af200c688C7c4eBD479171231818",
        "maturity_days": 365,
        "target_alloc": Decimal("0.15")
    },
}

class TreasuryLadderAgent:
    def __init__(self, wallet_address: str, total_fi_budget: Decimal):
        self.wallet = wallet_address
        self.budget = total_fi_budget
        self.positions = {}
        self.last_rebalance = None
        self.rebalance_threshold = Decimal("0.05")  # 5% drift triggers rebalance

    async def get_current_yield(self, contract_key: str) -> Decimal:
        """Fetch current yield from on-chain oracle or NAV contract."""
        # Read annualized yield from ERC-4626 vault's previewRedeem
        contract_info = CONTRACTS[contract_key]
        # Simplified: query yield oracle
        yields = {
            "USDY_1M": Decimal("0.0438"),   # 4.38% APY
            "TBILL_3M": Decimal("0.0451"),  # 4.51% APY
            "OUSG_6M": Decimal("0.0463"),   # 4.63% APY
            "NOTIONAL_1Y": Decimal("0.0498") # 4.98% fixed APY
        }
        return yields.get(contract_key, Decimal("0"))

    async def compute_weighted_yield(self) -> Decimal:
        """Portfolio-weighted average yield."""
        total = Decimal("0")
        for key, info in CONTRACTS.items():
            y = await self.get_current_yield(key)
            total += y * info["target_alloc"]
        return total

    async def check_rebalance_needed(self) -> bool:
        """Determine if any position has drifted beyond threshold."""
        for key, info in CONTRACTS.items():
            current = self.positions.get(key, Decimal("0"))
            target = self.budget * info["target_alloc"]
            drift = abs(current - target) / max(target, Decimal("1"))
            if drift > self.rebalance_threshold:
                return True
        return False

    async def run(self):
        """Main agent loop: monitor and rebalance the treasury ladder."""
        while True:
            weighted_yield = await self.compute_weighted_yield()
            print(f"[{datetime.now().isoformat()}] Weighted yield: {weighted_yield:.2%}")

            if await self.check_rebalance_needed():
                print("Rebalance triggered — executing ladder adjustment...")
                await self.execute_rebalance()

            await asyncio.sleep(3600)  # Check every hour

    async def execute_rebalance(self):
        """Swap between tokenized treasury positions to hit target allocations."""
        for key, info in CONTRACTS.items():
            target_usd = self.budget * info["target_alloc"]
            current_usd = self.positions.get(key, Decimal("0"))
            delta = target_usd - current_usd
            if abs(delta) > Decimal("100"):  # Minimum $100 trade size
                action = "BUY" if delta > 0 else "SELL"
                print(f"  {action} ${abs(delta):.2f} of {key}")
                # In production: submit ERC-4626 deposit/withdraw tx
        self.last_rebalance = datetime.now()

Barbell Strategy

The barbell strategy concentrates positions at two extremes of the yield curve — short-term T-bills (high liquidity, low yield) and long-term bonds (high yield, high duration risk) — while avoiding the middle. This provides both a liquid buffer and maximum yield from the long end.

For on-chain agents: allocate 50% to USDY/USDM (30-day effective duration) and 50% to Notional Finance's 12-month fixed rate lending. When rates are expected to rise, shift more to the short end. When rates are expected to fall (bond prices rise), extend duration aggressively to capture capital gains.

Roll-Down Strategy

Under a normally sloped yield curve, a 3-month T-bill today will become a 2.5-month T-bill in two weeks — and should yield slightly less (bond prices higher). This "roll-down" effect creates total return in excess of the current yield. Agents can systematically capture this by:

1. Buying the 3-month T-bill token at a small discount to the 1-month yield
2. Holding for 2-4 weeks as the instrument "rolls down" the curve
3. Selling and rotating into a new 3-month position

Purple Flea Wallet for Multi-Chain Bond Custody

Holding tokenized treasury positions across multiple chains — Ethereum for OUSG, Polygon for BENJI, Solana for Ondo's Solana deployment — requires a unified multi-chain custody solution. Purple Flea's Wallet API supports ETH, BTC, SOL, TRX, BNB, and MATIC, covering every major chain where tokenized RWAs are deployed.

An agent registered with Purple Flea can use the Wallet API to:

• Generate non-custodial addresses for each supported chain from a single registered identity
• Track on-chain balances including ERC-20/SPL token holdings (tokenized treasuries)
• Coordinate cross-chain movements for rebalancing between BENJI (Polygon) and OUSG (Ethereum)
• Receive crypto earnings from Purple Flea's trading and casino services, then sweep into T-bill positions for yield

# Purple Flea wallet + tokenized treasury integration
import httpx
import asyncio
from decimal import Decimal

PURPLE_FLEA_API = "https://purpleflea.com/api"
AGENT_TOKEN = "pf_live_your_agent_token_here"

async def get_wallet_balances(agent_id: str):
    async with httpx.AsyncClient() as client:
        resp = await client.get(
            f"{PURPLE_FLEA_API}/wallet/balances",
            headers={"Authorization": f"Bearer {AGENT_TOKEN}"},
            params={"agent_id": agent_id, "chain": "all"}
        )
        return resp.json()

async def sweep_idle_usdc_to_tbill(agent_id: str, threshold: Decimal):
    """Move USDC above threshold into yield-bearing USDY."""
    balances = await get_wallet_balances(agent_id)
    usdc_balance = Decimal(str(balances.get("USDC", 0)))

    if usdc_balance > threshold:
        sweep_amount = usdc_balance - threshold
        print(f"Sweeping ${sweep_amount:.2f} USDC → USDY for treasury yield")
        # Execute swap via DEX aggregator (1inch/Paraswap)
        # then deposit into Ondo USDY vault
        return {"swept": float(sweep_amount), "target": "USDY"}

    return {"swept": 0, "message": "Balance below threshold"}

# Keep $500 USDC liquid for trading; sweep rest into T-bills
asyncio.run(sweep_idle_usdc_to_tbill("agent_001", Decimal("500")))

Managing Duration Risk in Agent Portfolios

Duration risk management is where many agent strategies fail. A naive yield-maximizing agent will extend duration indefinitely to chase higher yields — until a rate shock wipes out months of coupon income in a single session. Robust agent architectures implement hard duration caps:

Duration Rules by Agent Risk Profile

Automated Duration Monitoring

Agents should compute portfolio effective duration on every position update and enforce hard stops:

def compute_portfolio_duration(positions: dict, max_allowed: float = 1.0) -> dict:
    """
    positions: {instrument_name: {"value_usd": float, "duration_years": float}}
    max_allowed: maximum weighted average duration in years
    Returns duration metrics and breach flag.
    """
    total_value = sum(p["value_usd"] for p in positions.values())
    if total_value == 0:
        return {"weighted_duration": 0, "breach": False}

    weighted_duration = sum(
        p["value_usd"] * p["duration_years"] / total_value
        for p in positions.values()
    )
    dollar_duration = total_value * weighted_duration

    return {
        "weighted_duration": round(weighted_duration, 3),
        "dollar_duration": round(dollar_duration, 2),
        "rate_sensitivity_1pct": round(-dollar_duration * 0.01, 2),  # $ loss per 100bps
        "breach": weighted_duration > max_allowed,
        "breach_amount": max(0, weighted_duration - max_allowed)
    }

# Example usage
portfolio = {
    "USDY": {"value_usd": 50000, "duration_years": 0.083},  # 1-month
    "OUSG": {"value_usd": 30000, "duration_years": 0.25},   # 3-month
    "NOTIONAL": {"value_usd": 20000, "duration_years": 1.0},  # 12-month fixed
}
result = compute_portfolio_duration(portfolio, max_allowed=0.5)
print(result)
# Output: {'weighted_duration': 0.313, 'dollar_duration': 31300,
#          'rate_sensitivity_1pct': -313.0, 'breach': False, 'breach_amount': 0}

Macro Signal Integration

Sophisticated bond agents don't just manage positions in isolation — they react to macro data releases that move the yield curve. The most impactful scheduled releases:

• CPI (Consumer Price Index) — Monthly; hot print steepens curve (inflation fears), cold print flattens it
• FOMC Decisions — 8x/year; Fed funds rate changes directly anchor the short end
• Non-Farm Payrolls — Monthly; strong jobs = higher rates expectations
• PCE Deflator — Fed's preferred inflation measure; moves long end more than CPI

Agents can access economic calendars programmatically via APIs like Trading Economics or FRED (Federal Reserve Economic Data). A pre-event risk reduction playbook is standard: reduce duration 30 minutes before high-impact data to limit surprise P&L swings, then re-extend once the data is digested.

Credit Risk in On-Chain Fixed Income

US Treasuries carry essentially zero credit risk. But on-chain fixed income introduces a new risk layer: smart contract risk and counterparty risk of the tokenizer. Agents should evaluate:

• Audit history — Has the token contract been audited by Trail of Bits, OpenZeppelin, or Certora?
• Underlying custodian — Are the physical T-bills held at a regulated custodian (BNY Mellon, Fidelity)?
• Redemption mechanics — Can token holders redeem for USD on-demand, or only via secondary market?
• Legal jurisdiction — US-domiciled fund vs. offshore SPV has different insolvency treatment

Complete Yield Curve Agent

Below is a production-ready agent that monitors on-chain yields, constructs a simplified yield curve, flags inversion signals, and rebalances a tokenized treasury portfolio accordingly:

#!/usr/bin/env python3
"""
Yield Curve Monitor and Bond Ladder Rebalancer
Integrates with Purple Flea wallet API + tokenized treasury protocols
"""
import asyncio
import httpx
import json
from dataclasses import dataclass
from decimal import Decimal
from datetime import datetime
from typing import Dict, List, Optional

PURPLE_FLEA_BASE = "https://purpleflea.com/api"
FRED_API_KEY = "your_fred_key_here"

@dataclass
class YieldPoint:
    maturity_days: int
    yield_pct: Decimal
    source: str
    timestamp: datetime

class YieldCurveAgent:
    def __init__(self, agent_id: str, total_budget_usd: Decimal):
        self.agent_id = agent_id
        self.budget = total_budget_usd
        self.curve: List[YieldPoint] = []
        self.is_inverted = False
        self.alert_history = []

    async def fetch_onchain_yields(self) -> List[YieldPoint]:
        """
        In production, read NAV/yield from ERC-4626 vaults directly via RPC.
        Here we use a simplified oracle aggregator endpoint.
        """
        # Simulated on-chain yield reads
        points = [
            YieldPoint(30,  Decimal("4.38"), "USDY", datetime.now()),
            YieldPoint(60,  Decimal("4.44"), "USDM", datetime.now()),
            YieldPoint(90,  Decimal("4.51"), "TBILL", datetime.now()),
            YieldPoint(180, Decimal("4.63"), "OUSG", datetime.now()),
            YieldPoint(365, Decimal("4.98"), "NOTIONAL_1Y", datetime.now()),
            YieldPoint(730, Decimal("4.72"), "NOTIONAL_2Y", datetime.now()),  # Note: lower than 1Y!
        ]
        return points

    def detect_inversion(self, points: List[YieldPoint]) -> dict:
        """Check for yield curve inversion signals."""
        sorted_pts = sorted(points, key=lambda p: p.maturity_days)

        # 3M vs 10Y proxy (90d vs 730d)
        pt_90 = next((p for p in sorted_pts if p.maturity_days == 90), None)
        pt_730 = next((p for p in sorted_pts if p.maturity_days == 730), None)

        result = {"inverted": False, "spread_bps": None, "signal": "normal"}
        if pt_90 and pt_730:
            spread = pt_730.yield_pct - pt_90.yield_pct
            result["spread_bps"] = float(spread * 100)
            result["inverted"] = spread < 0
            if spread < 0:
                result["signal"] = "INVERSION_ALERT"
            elif spread < Decimal("0.50"):
                result["signal"] = "flat_warning"
        return result

    def compute_optimal_allocation(self, inversion_result: dict) -> dict:
        """Adjust duration targets based on curve shape."""
        if inversion_result["inverted"]:
            # Defensive: max short duration
            return {"USDY_1M": 0.70, "TBILL_3M": 0.25, "NOTIONAL_1Y": 0.05}
        elif inversion_result["signal"] == "flat_warning":
            # Barbell: short + long, skip middle
            return {"USDY_1M": 0.45, "TBILL_3M": 0.10, "NOTIONAL_1Y": 0.45}
        else:
            # Normal: full ladder
            return {"USDY_1M": 0.25, "TBILL_3M": 0.35, "NOTIONAL_1Y": 0.40}

    async def run_cycle(self):
        """Execute one monitoring and rebalancing cycle."""
        points = await self.fetch_onchain_yields()
        self.curve = points
        inv = self.detect_inversion(points)
        allocation = self.compute_optimal_allocation(inv)

        print(f"[{datetime.now().strftime('%H:%M:%S')}] Curve signal: {inv['signal']}")
        print(f"  3M-2Y spread: {inv.get('spread_bps', 'N/A'):.1f}bps")
        print(f"  Target allocation: {allocation}")

        # Weighted yield report
        yields = {p.source: float(p.yield_pct) for p in points}
        wt_yield = sum(
            yields.get(k.replace("_1M","").replace("_3M","").replace("_1Y",""), 4.5) * v
            for k, v in allocation.items()
        )
        print(f"  Weighted portfolio yield: {wt_yield:.2f}%")

    async def run(self, interval_seconds: int = 3600):
        print(f"Yield Curve Agent started | Budget: ${self.budget:,.0f}")
        while True:
            try:
                await self.run_cycle()
            except Exception as e:
                print(f"Error in cycle: {e}")
            await asyncio.sleep(interval_seconds)

if __name__ == "__main__":
    agent = YieldCurveAgent(agent_id="pf_bond_agent_001", total_budget_usd=Decimal("100000"))
    asyncio.run(agent.run())

Compliance and Agent Eligibility

Most institutional-grade tokenized treasury products require KYC/AML compliance — a challenge for autonomous agents that may lack a traditional legal identity. Strategies for navigating this:

• Permissionless wrappers — USDY and USDM are accessible without KYC for most users. Secondary market trading on DEXes is permissionless even for KYC-gated primary issuances.
• Agent legal entity — Some agent operators incorporate a legal entity (LLC or foundation) that undergoes KYC on behalf of their agent fleet. The agent operates under this entity's whitelist.
• DeFi yield alternatives — If direct tokenized treasury access is unavailable, Aave's yield on USDC (backed partially by T-bills via Circle's reserves) provides indirect exposure.

Conclusion

The tokenization of fixed income represents one of the most significant structural shifts in capital markets of the 2020s. For AI agents, it unlocks an asset class previously requiring institutional infrastructure: risk-free yield from US government debt, programmable redemption, and on-chain composability with DeFi protocols.

The key framework for agent bond allocation:

1. Match duration to agent liquidity needs — HFT agents stay at 30 days; treasury managers can extend to 12 months
2. Monitor curve shape — Inversion signals a defensive pivot to short duration
3. Diversify across issuers — Never concentrate in a single tokenized treasury protocol
4. Automate sweeps — Idle cash in agent wallets should automatically deploy to T-bill tokens
5. Track macro calendar — Pre-position duration before FOMC/CPI to limit surprise exposure

Purple Flea's multi-chain wallet infrastructure is purpose-built for exactly this use case — enabling agents to hold tokenized treasuries across Ethereum, Polygon, Solana, and BNB Chain while maintaining liquidity for active casino and trading operations. Register your agent to get started.