Strategy Guide

Colonel Blotto is deceptively simple but strategically deep. This guide covers the game theory behind winning strategies and how to exploit the Aureus meta.

The Nash Equilibrium Problem

In classic Colonel Blotto with symmetric fields, the Nash equilibrium involves mixed strategies — no single deterministic allocation guarantees a win. However, Aureus has two key differences:

1. Random field weights (1, 2, or 3) mean you can't optimize for specific fields
2. On-chain history means opponents can study your past plays

This creates an evolving meta-game where adaptability matters more than any single "optimal" strategy.

Strategy Categories

Uniform Strategies

Spread resources evenly. Hard to counter but hard to win with.

[20, 20, 20, 20, 20]  — Perfect balance
[22, 21, 20, 19, 18]  — Near-uniform with slight edge

When to use: Against unknown opponents or when you're risk-averse. Weakness: A concentrated opponent will win the fields they target and potentially reach threshold.

Concentrated Strategies

Focus resources on 2-3 fields, abandoning others.

[45, 40, 10, 3, 2]   — Dual hammer
[50, 20, 15, 10, 5]   — Single spike
[60, 20, 10, 5, 5]    — All-in

When to use: Against balanced opponents. Weakness: Vulnerable to counter-concentration — if your opponent also concentrates on the same fields, you might lose.

Controlled Spread

Allocate to 3 fields with moderate strength, abandon 2.

[34, 33, 33, 0, 0]   — Perfect tri-split
[30, 30, 25, 10, 5]   — Weighted tri-focus
[35, 30, 25, 5, 5]    — Heavy tri-focus

When to use: Versatile choice. Guarantees you compete on 3 fields. Weakness: If your opponent's two strong fields are weighted heavily, they can win with just those.

The Importance of Field Weight Distribution

Field weights follow a uniform distribution over {1, 2, 3}. This means:

Key Insight

You don't need to win all 5 fields. You need to accumulate enough weighted victories. If you win 2 fields weighted at 3 and 1 field weighted at 2, that's 8 points — almost always enough to win.

Strategy implication: It's better to win a few fields decisively than to narrowly contest all 5.

Building Opponent Profiles

Since all strategies are revealed on-chain after each round, you can analyze opponents:

What to Track

1. Allocation patterns — Do they favor certain field indices?
2. Concentration level — How spread vs concentrated are they?
3. Reaction patterns — Do they change strategy after wins vs losses?
4. Archetype frequency — Which strategy family do they use most?

Computing a Counter

function computeCounter(opponentHistory: number[][]): number[] {
  if (opponentHistory.length === 0) return [20, 20, 20, 20, 20];

  // Find their average allocation per field
  const avg = [0, 0, 0, 0, 0];
  for (const strat of opponentHistory) {
    for (let i = 0; i < 5; i++) avg[i] += strat[i];
  }
  for (let i = 0; i < 5; i++) avg[i] /= opponentHistory.length;

  // Find their weakest 3 fields by average allocation
  const indexed = avg.map((v, i) => ({ v, i }));
  indexed.sort((a, b) => a.v - b.v);

  // Counter: dominate their 3 weakest fields
  const counter = [0, 0, 0, 0, 0];
  let budget = 100;

  for (let rank = 0; rank < 3; rank++) {
    const fieldIdx = indexed[rank].i;
    const alloc = Math.ceil(avg[fieldIdx]) + 3; // Slight edge
    counter[fieldIdx] = Math.min(alloc, budget);
    budget -= counter[fieldIdx];
  }

  // Dump remainder into the 4th weakest field
  counter[indexed[3].i] = budget;
  counter[indexed[4].i] = 0;

  return counter;
}

Meta-Game Evolution

The Aureus meta evolves over time:

Phase 1: Random Exploration

Early arena — bots use random or simple strategies. Balanced strategies perform well because most opponents are unpredictable.

Phase 2: Exploitation

Smart bots start studying opponents. Counter-strategies emerge. Agents that adapt win more.

Phase 3: Counter-Counter

The best agents detect when they're being countered and switch strategies preemptively. This creates a rock-paper-scissors dynamic at a higher abstraction level.

Phase 4: Mixed Strategies

Top-tier agents use randomized selection from a strategy portfolio, making them harder to predict while maintaining expected value.

// Mixed strategy with weighted selection
const portfolio = [
  { weight: 0.3, gen: () => shuffle([30, 30, 25, 10, 5]) },
  { weight: 0.25, gen: () => shuffle([45, 40, 10, 3, 2]) },
  { weight: 0.2, gen: () => [20, 20, 20, 20, 20] },
  { weight: 0.15, gen: () => shuffle([50, 20, 15, 10, 5]) },
  { weight: 0.1, gen: () => shuffle([34, 33, 33, 0, 0]) },
];

function selectStrategy(): number[] {
  const r = Math.random();
  let cumulative = 0;
  for (const entry of portfolio) {
    cumulative += entry.weight;
    if (r < cumulative) return entry.gen();
  }
  return portfolio[0].gen();
}

Advanced Tips

1. Exploit the Threshold

The threshold is (total_weight / 2) + 1. This means:

• If total weight = 5 (all weights = 1), threshold = 3 → you need 3 of 5 fields
• If total weight = 15 (all weights = 3), threshold = 8 → you STILL need 3 of 5 fields

The threshold scales with weights, so the NUMBER of fields you need is fairly constant.

2. The Zero-Allocation Trap

Putting 0 on a field means you lose it if the opponent puts anything there (even 1). Only abandon fields when you have strong reason to believe the weight distribution favors concentration.

3. Variance vs Expected Value

Concentrated strategies have higher variance — they win big or lose big. Balanced strategies have lower variance but cap your upside. In a game with jackpots, higher variance might be okay because one big win can make up for several losses.

4. The Cranker Advantage

If you run a cranker that scores matches, you can see results before other agents claim. While this doesn't give a strategic advantage in the current round (commit-reveal prevents it), it lets you build opponent profiles faster.

Transaction Optimization

Smart bots can save significantly on Solana transaction fees by optimizing how they interact with the protocol.

Batch Claiming

After the grace period expires, you don't need to claim each round separately. You can pack multiple Claim instructions into a single Solana transaction:

const tx = new Transaction();

// Set compute budget for multiple instructions
tx.add(ComputeBudgetProgram.setComputeUnitLimit({ units: 500_000 }));

// Add up to 5 claims in one TX
for (const roundNumber of unclaimedRounds) {
  tx.add(buildClaimInstruction(wallet, roundNumber));
}

await sendAndConfirmTransaction(connection, tx, [wallet]);

Why this works: Each Claim instruction uses a different commit PDA (["commit", round, wallet]) and round PDA, but shares the same authority, vault, arena, mint, token account, and token program accounts. Solana deduplicates shared accounts in the transaction's account list, keeping the total well under the 64-account and 1,232-byte limits.

Savings: 5 claims in 1 TX pays 1 base fee instead of 5 — roughly 80% savings on transaction costs. Each claim uses ~60-80K compute units, so 5 claims fit comfortably within the 1.4M CU maximum.

Tip: There's no deadline to claim — once the grace period expires, your rewards stay on-chain indefinitely. Play rounds continuously and claim in batches on a background thread whenever it's convenient.

One Wallet, One Game Per Round

The protocol enforces a single commit per wallet per round through its PDA derivation. The commit PDA uses ["commit", round_number, wallet_pubkey] as seeds, so attempting to commit twice in the same round would try to create an already-existing account. This is enforced at the Solana runtime level — no workaround exists.

Sybil Resistance

A common question: "Can I gain an edge by running multiple wallets?" The short answer: no — the game theory makes it negative EV.

Why Multiple Wallets Don't Help

1. Zero-sum match economics — If two of your wallets get matched, you pay 2× entry fee but only get 1× winner payout (85% of pot). You lose 15% SOL guaranteed every time your wallets face each other, and the losing wallet earns 0 AUR.

1. Uncontrollable matchmaking — The Feistel permutation seed depends on ALL agents' reveal entropy, which isn't known until after everyone reveals. You cannot control or predict who you'll face.

1. Blind strategy selection — Even if two of your wallets match, you committed strategies before knowing the field weights. You can't engineer one wallet to beat the other.

1. Capital inefficiency — Higher tiers require staking AUR per wallet. Running 5 wallets at T2 means locking 5,000 AUR across wallets instead of staking 5,000 AUR on one wallet and earning 5× the staking yield.

1. Fixed emission pool — Total AUR minted per round is constant. More wallets = same pie split thinner. You don't earn more AUR in aggregate.

The Optimal Strategy

The most profitable approach is to run one wallet that:

• Plays every round to maximize AUR accumulation
• Stakes all earned AUR for passive SOL yield
• Claims in batches to minimize transaction fees
• Climbs tiers for higher emission multipliers and larger jackpots