Strategy Writeup: Robust Meta-Aware Dragapult ex Agent

TL;DR

Our final Strategy entry is a deterministic, rule-based Dragapult ex agent. The policy is built around a simple idea: develop Dragapult ex reliably, plan turns around the prize race rather than raw damage, and use matchup-aware disruption only when it improves the current game state.

The best observed Simulation result for Team TomTom was rank #73 with score 1076.4. A later prepared leaderboard snapshot showed rank #86 / 3243 with score 1068.8. This was the strongest prepared Simulation-backed Strategy candidate.

The main lesson from the project was not simply “Dragapult is good.” The important lesson was that local testing and actual leaderboard performance could differ sharply. We therefore treated the public leaderboard, official episode metadata, local gauntlets, meta-proxy tests, and failed submissions as separate pieces of evidence. The final agent is the one that survived that full process best: a conservative, explainable Dragapult policy that adapts to multiple threat families without over-specializing to one local matchup.

Competition context

This Strategy writeup is for the prize competition pokemon-tcg-ai-battle-challenge-strategy (240,000 USD, deadline 2026-09-13 23:59). The Simulation competition pokemon-tcg-ai-battle has reward Knowledge; we use Simulation results as performance evidence, but the prize target is the Strategy submission.

Final agent

Best observed rank/score: rank #73, score 1076.4

Prepared snapshot: rank #86 / 3243, score 1068.8

Primary archetype: Dragapult ex / Budew / Fezandipiti ex / Latias ex / Meowth ex, supported by Dreepy, Drakloak, Rare Candy, Crushing Hammer, Boss's Orders, Crispin, Lillie's Determination, and Team Rocket's Watchtower.

The policy is deterministic. For each legal-option decision, it:

1. Parses the board, hand, discard, available attackers, and visible resources.
2. Estimates card counts where possible.
3. Builds a prize-race plan around Dragapult ex and Phantom Dive.
4. Scores legal actions using setup, evolution, attachment, supporter, retreat, Boss target, bench-damage, and disruption modules.
5. Avoids dangerous or low-value actions, including damage into immunity/counter targets and unnecessary draw/search at low deck count.

Naming guide for experiment labels

Some labels in our local logs were short internal experiment names. For the external writeup, the important point is not the label itself but what strategic idea it represented.

The raw local file names are kept in the private evidence pack for reproducibility, but the Strategy narrative uses the strategic descriptions above.

Why this agent was the final choice

We tried many directions before settling on this one: Dragapult resource variants, Lucario, Iono/Bellibolt, Crustle wall, Abomasnow/Kyogre, same-deck mirror tuning, target-energy variants, no-Hammer/Boss variants, Hop/Dunsparce, Alakazam/Dunsparce, and early search/router ideas.

Several of those ideas were reasonable. Some even looked promising locally. But the actual leaderboard punished brittle changes. Focused patches could improve one local matchup while lowering broader Simulation performance. Meta-counter decks could be useful as teachers or anchors without being the right final package.

The final Dragapult direction won because it was deliberately boring in the right places:

• It tries to reach Dragapult ex reliably before greedier support lines.
• It values multi-prize Phantom Dive turns over generic damage.
• It maps Boss targets and bench damage by matchup instead of using one global target rule.
• It treats Lucario, Alakazam/Dunsparce, Crustle, Iono/Bellibolt, Abomasnow/Kyogre, mirrors, and low-HP swarm boards as different threat classes.
• It uses Crushing Hammer, Boss, Unfair Stamp, and Watchtower only when they support the current prize plan or prevent a loaded attacker line.
• It rejects broad overfit patches, even when they improve a single smoke test.

Top-scoring agent breakdown

The full local submission pack contains the deck-role table and implementation breakdown used to prepare this writeup.

Development process

This was an iterative strategy-engine project, not a neural-network training run. The loop was:

1. Build a candidate deck/agent.
2. Validate package safety and deck legality.
3. Run local gauntlets against archived high-score agents, public agents, and current local candidates.
4. Submit only selected packages to Kaggle Simulation.
5. Treat live underperformance as negative evidence.
6. Convert repeated failures into narrow heuristic changes.
7. Re-test; reject changes that improved one matchup while damaging broader robustness.

The most important part of the process was restraint. We did not treat every local improvement as a submission-worthy improvement. We kept asking: does this change survive broader anchors, or did it only exploit yesterday's local test?

Local-vs-leaderboard meta gap

One of the biggest findings was that local performance and actual leaderboard performance could differ sharply.

The local runner was still essential. It caught deck mistakes, obvious tactical regressions, and gave us enough games to compare ideas cheaply. But it was not a full substitute for the Kaggle leaderboard environment. The live opponent pool was richer, path-dependent, and changing over time.

We saw this gap repeatedly:

• same-deck mirror looked plausible as a targeted idea but scored 710.9 live;
• target-energy scored 723.7;
• no-Hammer-Boss scored 842.6;
• earlier broad meta-teacher / replayfix / metahammer-style ideas produced public-score volatility and stayed below their stronger parent lines;
• the final Dragapult policy itself moved over time: best observed rank #73 / score 1076.4, later prepared snapshot #86 / 3243 / 1068.8, as teams and opponents changed.

This changed how we evaluated agents. We stopped asking only “what wins locally?” and started asking “what is robust to a changing external meta?”

To approximate the external environment, we used a layered process:

1. Official/live evidence first when available. Kaggle public score, rank snapshots, and official episode metadata were treated as separate evidence from local games.
2. High-score archive as meta proxy. We built local anchor, expanded-pit, and meta-proxy leaderboards using archived high-score agents, public-style agents, and our current candidates.
3. Failure labels instead of raw winrate chasing. Repeated losses were grouped into readable threat classes: late Dragapult setup, Lucario pressure, Crustle wall pressure, Alakazam/Dunsparce pressure, and similar patterns. Those labels became target-map and setup-discipline changes.
4. Ablation discipline. When a focused patch improved one smoke test but hurt mirror or broader anchors, we rejected it.
5. Meta-shift planning. Lucario was kept as a secondary/complementary archetype because it gave coverage information and portfolio evidence, but we did not claim the portfolio as a single-package solution under the deck.csv constraint.

The final design is therefore not simply “the best local gauntlet agent.” It is the agent that survived the local-to-live mismatch best: a conservative Dragapult ex policy that recognized meta threat families without over-specializing to yesterday's leaderboard.

The local evidence pack keeps a more detailed table of these environment findings.

Simulation submission trajectory

The live Simulation leaderboard was used as external evidence, not as the final prize submission itself. The most important trajectory was:

This summary intentionally omits raw local package names from the public narrative. They remain available in the private submission-ready pack if exact reproducibility records are needed.

Local evaluation highlights

Alternatives considered and debated

We did not simply keep the highest local winrate candidate. Several non-final directions were seriously considered because they exposed different parts of the metagame.

The central debate was robustness versus specialization. A specialized patch can look clever when it beats the matchup it was designed for. But the leaderboard is not one matchup. It is a moving field. That pushed us toward a final policy that recognizes threat families, but remains conservative in its core game plan.

Failure-to-patch matrix

Secondary Lucario evidence

The Lucario/Riolu policy was not the final top scorer, but it was strategically useful. It covered some Dragapult weaknesses and helped isolate threat classes. Its final public Simulation score in the current downloaded submission table is 967.6.

Offline portfolio analysis comparing the Lucario policy with the final Dragapult policy was stable across 432 games at 245-187-0 / 56.7%. This result is not claimed as a single Kaggle package improvement because the package normally reads one deck.csv; it is included as evidence for how we reasoned about meta coverage and submission risk.

Reproducibility

The local submission-ready pack keeps exact package names, hashes, source snippets, and evidence tables for auditability. They are intentionally not front-loaded in this public-facing narrative because the Strategy argument should be readable without decoding local file names.

The reproducibility basis is:

• final selected policy: deterministic Dragapult ex rule-based agent;
• primary source: the agent implementation and matching deck.csv in the local evidence pack;
• validation: Python compilation, deck checks, and Docker/local-engine gauntlets;
• external evidence: Kaggle Simulation public score/rank snapshots and submission history;
• local evidence: anchor, expanded-pit, meta-proxy, ablation, and failure-analysis tables.

If the final Kaggle form allows attachments or appendices, the exact package hash table can be included there rather than in the main narrative.

Conclusion

The final strategy is a robust, meta-aware Dragapult ex rule-based agent. Its strength came from a deliberate development process: observe live results, compare them against local tests, identify where the local proxy was wrong, convert repeated losses into narrow threat classes, and reject changes that only solved one visible problem.

The most important lesson is methodological. In this environment, reliable board development, prize-race planning, conservative matchup-specific heuristics, and humility about local-vs-live meta mismatch beat brittle complexity. Failed submissions and rejected patches were not wasted attempts; they were the evidence that shaped the final robust policy.

Final Strategy Submission Checklist

Before clicking submit publicly on Kaggle:

• [ ] Open pokemon-tcg-ai-battle-challenge-strategy while logged in.
• [ ] Confirm whether Kaggle expects a Writeup post, Notebook, dataset/file upload, or any additional forms.
• [ ] Paste final-writeup.md into the Strategy writeup editor.
• [ ] Add tables from tables/ where useful.
• [ ] Mention Simulation evidence but make the submission under the Strategy competition.
• [ ] Include package hash from tables/package_hashes.csv.
• [ ] If attachments are supported, attach the primary package/source snippets or link them according to Kaggle rules.
• [ ] Preview formatting.
• [ ] Submit/finalize — do not leave as draft.

Guardrails:

• [ ] Do not fetch more Kaggle replay/history data unless Ivan explicitly re-approves.
• [ ] Do not make public Kaggle submission/post until Ivan explicitly approves the exact final content.

Local audit pack

The local submission-ready folder keeps exact package names, hashes, source snippets, raw submission history, and detailed evidence paths. Those are useful for auditability, but they are intentionally excluded from this external-facing phone preview.

Competition facts

Leaderboard snapshot

Final agent deck breakdown