From 842d45b8eeb64dc2c52b0216b78450622651b888 Mon Sep 17 00:00:00 2001 From: Foy Savas Date: Sun, 18 Oct 2026 13:57:16 -0400 Subject: [PATCH 1/4] Stop rescanning the miner store for every gossiped block On 2026-10-18 the public testnet had no shared chain. Every gossiped miner block ran a fork-choice pass that decoded the whole store several times and did work quadratic in stored blocks, all under the one datastore mutex. Nothing was pruned, so after 15 days a pass took about five minutes. Status, the Identify handler on the networking task, and Shoal broadcasts all waited on that lock, so peers stopped seeing each other's blocks and node1, node2, and node3 each mined alone. A non-bootstrap miner's unlinkable chain kept feeding the queue. Nothing waits on scoring: - /status.json is served from a snapshot a background task retakes every five seconds; `status_age_secs` shows how old it is, so a wedged node answers with a growing age instead of hanging. No snapshot yet is 503. - Identify stores peer info off the networking task. - Shoal draft, certificate, and ack sends wait at most two seconds for the swarm. Fork choice is incremental: - The datastore keeps an exact in-memory mirror of the three miner stores, updated by every multi_store write, with a change journal. Store scans read the mirror in the same key order, so results do not change. - A tree derived from it keeps each live block's linked work, the winner and canonical spine tips, and the linked branch tips, and relinks only what changed. The target check is memoized per hash and walks back only to the previous epoch. - select_best_stored_chain and adopt_connected_extensions decide on the tree with the same guards and log lines, and fall back to the full scan where it cannot decide. A block off every linked walk is stored without scoring. - Scoring a gossiped block takes about 250us in a debug build at both 2k and 20k stored blocks (test). Randomized tests check select against the full scan, the canonical set against verified_spine, adoption against the rule that no branch beats the chain, and the incremental tree against a rebuilt one. They also show two full-scan bugs the tree does not repeat: a demoted block on the winner left a hole under the tip, and adoption in store order could take a lighter branch and orphan the heavier one. Untrusted gossip is bounded: - Miner blocks are rate limited per forwarding peer (1/s, burst 120). - Parked blocks are capped per author (1024) and in all (8192); the oldest still unlinked is dropped. - Missing parents are requested from the block's author, not only from bootstrappers, at most once a minute per peer. The store stops growing with every fork: blocks that are not canonical two epochs under the latest sequencer checkpoint are pruned, since fork choice already refuses any chain that leaves that prefix. Chain validation indexes blocks once instead of searching per index. Co-Authored-By: Claude Opus 5.5 --- .../src/datastore_manager.rs | 92 ++ .../src/models/miner/cache.rs | 156 +++ .../src/models/miner/mod.rs | 4 + .../src/models/miner/multi_store.rs | 424 ++++---- .../src/models/miner/tree.rs | 375 +++++++ .../src/actions/chain_integrity.rs | 2 + .../src/actions/miner/background_tasks.rs | 39 +- .../src/actions/observer/chain_maintenance.rs | 129 ++- rust/modality-node/src/chain/fork_choice.rs | 26 +- rust/modality-node/src/chain/mod.rs | 1 + rust/modality-node/src/chain/reorg.rs | 83 +- rust/modality-node/src/chain/tree_choice.rs | 915 ++++++++++++++++++ .../src/consensus/node_communication.rs | 47 +- rust/modality-node/src/gossip/limits.rs | 137 +++ rust/modality-node/src/gossip/miner/block.rs | 159 ++- rust/modality-node/src/gossip/mod.rs | 1 + rust/modality-node/src/node/mod.rs | 26 +- rust/modality-node/src/status_server.rs | 15 +- rust/modality-node/src/status_snapshot.rs | 102 +- rust/modality-node/src/sync/parent_hash.rs | 35 +- 20 files changed, 2397 insertions(+), 371 deletions(-) create mode 100644 rust/modality-datastore/src/models/miner/cache.rs create mode 100644 rust/modality-datastore/src/models/miner/tree.rs create mode 100644 rust/modality-node/src/chain/tree_choice.rs create mode 100644 rust/modality-node/src/gossip/limits.rs diff --git a/rust/modality-datastore/src/datastore_manager.rs b/rust/modality-datastore/src/datastore_manager.rs index f4f95190..f7e30100 100644 --- a/rust/modality-datastore/src/datastore_manager.rs +++ b/rust/modality-datastore/src/datastore_manager.rs @@ -55,6 +55,11 @@ pub struct DatastoreManager { sequencer_active: SequencerActiveStore, node_state: NodeStateStore, epoch_config: EpochConfig, + /// Mirror of the three miner stores; loaded on first use. + miner_cache: std::sync::Mutex>, + miner_cache_loads: std::sync::atomic::AtomicU64, + /// Fork-choice tree derived from `miner_cache`. + miner_tree: std::sync::Mutex, } impl std::fmt::Debug for DatastoreManager { @@ -158,6 +163,9 @@ impl DatastoreManager { sequencer_active, node_state, epoch_config: EpochConfig::default(), + miner_cache: std::sync::Mutex::new(None), + miner_cache_loads: std::sync::atomic::AtomicU64::new(0), + miner_tree: std::sync::Mutex::new(Default::default()), }) } @@ -182,6 +190,9 @@ impl DatastoreManager { sequencer_active, node_state, epoch_config: EpochConfig::default(), + miner_cache: std::sync::Mutex::new(None), + miner_cache_loads: std::sync::atomic::AtomicU64::new(0), + miner_tree: std::sync::Mutex::new(Default::default()), }) } @@ -206,9 +217,90 @@ impl DatastoreManager { sequencer_active, node_state, epoch_config: EpochConfig::default(), + miner_cache: std::sync::Mutex::new(None), + miner_cache_loads: std::sync::atomic::AtomicU64::new(0), + miner_tree: std::sync::Mutex::new(Default::default()), }) } + /// Run `f` on the miner block cache, loading it from the stores first if + /// it is not loaded. Do not call back into a miner read or write from + /// `f`; the cache lock is held. + pub fn with_miner_cache( + &self, + f: impl FnOnce(&mut crate::models::miner::MinerBlockCache) -> R, + ) -> Result { + let mut slot = self + .miner_cache + .lock() + .unwrap_or_else(|poisoned| poisoned.into_inner()); + if slot.is_none() { + *slot = Some(self.load_miner_cache()?); + } + Ok(f(slot.as_mut().expect("miner cache loaded"))) + } + + /// Apply a store write to the cache. A cache that is not loaded yet will + /// read the write from the store when it loads. + pub(crate) fn update_miner_cache(&self, f: impl FnOnce(&mut crate::models::miner::MinerBlockCache)) { + let mut slot = self + .miner_cache + .lock() + .unwrap_or_else(|poisoned| poisoned.into_inner()); + if let Some(cache) = slot.as_mut() { + f(cache); + } + } + + /// Drop the cache after writing a miner store without `multi_store`. + /// The next read reloads it, and derived state rebuilds. + pub fn invalidate_miner_cache(&self) { + let mut slot = self + .miner_cache + .lock() + .unwrap_or_else(|poisoned| poisoned.into_inner()); + *slot = None; + } + + fn load_miner_cache(&self) -> Result { + use crate::models::miner::MinerBlock; + use std::collections::BTreeMap; + use std::sync::Arc; + fn load(store: &S, name: &str) -> Result>> { + let mut blocks = BTreeMap::new(); + for item in store.iterator("/miner_blocks/hash") { + let (key, value) = item?; + match serde_json::from_slice::(&value) { + Ok(block) => { + blocks.insert(block.hash.clone(), Arc::new(block)); + } + Err(e) => log::warn!( + "Skipping undecodable miner block {} in {name}: {e}", + String::from_utf8_lossy(&key) + ), + } + } + Ok(blocks) + } + let generation = self + .miner_cache_loads + .fetch_add(1, std::sync::atomic::Ordering::Relaxed) + + 1; + Ok(crate::models::miner::MinerBlockCache::new( + generation, + load(&self.miner_active, "MinerActive")?, + load(&self.miner_forks, "MinerForks")?, + load(&self.miner_canon, "MinerCanon")?, + )) + } + + /// The fork-choice tree. Lock order: tree, then cache. + pub fn miner_tree(&self) -> std::sync::MutexGuard<'_, crate::models::miner::MinerTree> { + self.miner_tree + .lock() + .unwrap_or_else(|poisoned| poisoned.into_inner()) + } + /// Get the data directory path pub fn data_dir(&self) -> &Path { &self.data_dir diff --git a/rust/modality-datastore/src/models/miner/cache.rs b/rust/modality-datastore/src/models/miner/cache.rs new file mode 100644 index 00000000..ee77edfa --- /dev/null +++ b/rust/modality-datastore/src/models/miner/cache.rs @@ -0,0 +1,156 @@ +//! In-memory mirror of the three miner block stores. +//! +//! Fork choice used to decode every stored block from RocksDB several times +//! for each gossiped block. The cache holds the same records, keyed and +//! ordered the way each store iterates them, and every miner block write in +//! `multi_store` updates it after the store write succeeds. Readers that +//! scanned a store scan the matching map instead, so results do not change. +//! +//! Each change is also appended to a journal. A reader that keeps derived +//! state (the fork-choice tree) asks for the hashes changed since the +//! version it last saw, instead of rescanning. + +use crate::models::miner::MinerBlock; +use std::collections::{BTreeMap, VecDeque}; +use std::sync::Arc; + +/// Which store a cached record mirrors. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum MinerStoreKind { + Active, + Forks, + Canon, +} + +/// Journal entries kept for readers that sync incrementally. A reader that +/// falls further behind than this rebuilds from the maps. +const JOURNAL_CAPACITY: usize = 200_000; + +pub struct MinerBlockCache { + active: BTreeMap>, + forks: BTreeMap>, + canon: BTreeMap>, + generation: u64, + version: u64, + journal: VecDeque<(u64, String)>, +} + +impl MinerBlockCache { + pub(crate) fn new( + generation: u64, + active: BTreeMap>, + forks: BTreeMap>, + canon: BTreeMap>, + ) -> Self { + Self { + active, + forks, + canon, + generation, + version: 0, + journal: VecDeque::new(), + } + } + + /// Records of one store, in that store's key order. + pub fn store(&self, kind: MinerStoreKind) -> &BTreeMap> { + match kind { + MinerStoreKind::Active => &self.active, + MinerStoreKind::Forks => &self.forks, + MinerStoreKind::Canon => &self.canon, + } + } + + fn store_mut(&mut self, kind: MinerStoreKind) -> &mut BTreeMap> { + match kind { + MinerStoreKind::Active => &mut self.active, + MinerStoreKind::Forks => &mut self.forks, + MinerStoreKind::Canon => &mut self.canon, + } + } + + /// The record a hash lookup returns: MinerActive, then MinerForks, then + /// MinerCanon, the order `find_by_hash_multi` reads them in. + pub fn effective(&self, hash: &str) -> Option<&Arc> { + self.active + .get(hash) + .or_else(|| self.forks.get(hash)) + .or_else(|| self.canon.get(hash)) + } + + /// Every hash once, with the record `effective` returns for it. + pub fn effective_all(&self) -> impl Iterator> + '_ { + let forks = self + .forks + .iter() + .filter(|(hash, _)| !self.active.contains_key(*hash)) + .map(|(_, block)| block); + let canon = self + .canon + .iter() + .filter(|(hash, _)| !self.active.contains_key(*hash) && !self.forks.contains_key(*hash)) + .map(|(_, block)| block); + self.active.values().chain(forks).chain(canon) + } + + pub fn len_effective(&self) -> usize { + self.effective_all().count() + } + + pub(crate) fn put(&mut self, kind: MinerStoreKind, block: &MinerBlock) { + self.store_mut(kind) + .insert(block.hash.clone(), Arc::new(block.clone())); + self.touch(&block.hash); + } + + pub(crate) fn remove(&mut self, kind: MinerStoreKind, hash: &str) { + if self.store_mut(kind).remove(hash).is_some() { + self.touch(hash); + } + } + + fn touch(&mut self, hash: &str) { + self.version += 1; + self.journal.push_back((self.version, hash.to_string())); + while self.journal.len() > JOURNAL_CAPACITY { + self.journal.pop_front(); + } + } + + /// Identifies this load of the cache. It changes whenever the cache is + /// rebuilt from the stores, which invalidates every journal position. + pub fn generation(&self) -> u64 { + self.generation + } + + pub fn version(&self) -> u64 { + self.version + } + + /// Hashes whose record changed after `version`, each once, in the order + /// they last changed. `None` when the journal cannot answer: a different + /// generation, or entries already dropped. + pub fn changes_since(&self, generation: u64, version: u64) -> Option> { + if generation != self.generation || version > self.version { + return None; + } + if version == self.version { + return Some(Vec::new()); + } + match self.journal.front() { + Some((oldest, _)) if *oldest <= version + 1 => {} + _ => return None, + } + let mut seen = std::collections::HashSet::new(); + let mut changed: Vec = self + .journal + .iter() + .rev() + .take_while(|(at, _)| *at > version) + .filter(|(_, hash)| seen.insert(hash.as_str())) + .map(|(_, hash)| hash.clone()) + .collect(); + changed.reverse(); + Some(changed) + } +} diff --git a/rust/modality-datastore/src/models/miner/mod.rs b/rust/modality-datastore/src/models/miner/mod.rs index 0dfc2dee..b0c2470c 100644 --- a/rust/modality-datastore/src/models/miner/mod.rs +++ b/rust/modality-datastore/src/models/miner/mod.rs @@ -1,9 +1,13 @@ +pub mod cache; pub mod checkpoint; pub mod integrity; pub mod miner_block; pub mod miner_block_height; pub mod multi_store; +pub mod tree; pub use checkpoint::MinerCheckpoint; pub use miner_block::MinerBlock; pub use miner_block_height::MinerBlockHeight; +pub use cache::{MinerBlockCache, MinerStoreKind}; +pub use tree::{Eligibility, LinkedWork, MinerTree}; diff --git a/rust/modality-datastore/src/models/miner/multi_store.rs b/rust/modality-datastore/src/models/miner/multi_store.rs index be09f643..26377741 100644 --- a/rust/modality-datastore/src/models/miner/multi_store.rs +++ b/rust/modality-datastore/src/models/miner/multi_store.rs @@ -9,13 +9,39 @@ //! - `find_all_canonical`: Merge MinerActive + MinerCanon //! - `find_all_orphaned`: Merge MinerActive + MinerForks -use crate::models::miner::MinerBlock; +use crate::models::miner::{MinerBlock, MinerBlockCache, MinerStoreKind}; use crate::{DatastoreManager, Store}; -use anyhow::{Context, Result}; +use anyhow::Result; /// Key prefix for miner blocks in stores const MINER_BLOCK_PREFIX: &str = "/miner_blocks/hash"; +/// Records of one store, in its key order, from the cache. +fn cached(cache: &MinerBlockCache, kind: MinerStoreKind) -> impl Iterator + '_ { + cache.store(kind).values().map(|block| block.as_ref()) +} + +/// Delete a block's record and height entry from one store, and from the cache. +fn delete_from_store(mgr: &DatastoreManager, kind: MinerStoreKind, block: &MinerBlock) { + let key = format!("{}/{}", MINER_BLOCK_PREFIX, block.hash); + let height_key = format!("/miner_blocks/index/{}/hash/{}", block.index, block.hash); + let _ = match kind { + MinerStoreKind::Active => mgr + .miner_active() + .delete(&key) + .and_then(|_| mgr.miner_active().delete(&height_key)), + MinerStoreKind::Forks => mgr + .miner_forks() + .delete(&key) + .and_then(|_| mgr.miner_forks().delete(&height_key)), + MinerStoreKind::Canon => mgr + .miner_canon() + .delete(&key) + .and_then(|_| mgr.miner_canon().delete(&height_key)), + }; + mgr.update_miner_cache(|cache| cache.remove(kind, &block.hash)); +} + impl MinerBlock { // ============================================================ // Multi-store query methods @@ -25,33 +51,12 @@ impl MinerBlock { /// /// Search order: MinerActive → MinerCanon → MinerForks pub async fn find_by_hash_multi(mgr: &DatastoreManager, hash: &str) -> Result> { - let key = format!("{}/{}", MINER_BLOCK_PREFIX, hash); - - // Try MinerActive first (hot path for recent blocks) - if let Some(data) = mgr.miner_active().get(&key)? { - let block: MinerBlock = serde_json::from_slice(&data) - .context("Failed to deserialize MinerBlock from MinerActive")?; - return Ok(Some(block)); - } - - // A block promoted to MinerCanon and later orphaned into MinerForks - // exists in both. Listing treats the forks copy as the newer state, so - // the hash lookup must agree or a walk mistakes a stale canonical copy - // for the live chain. - if let Some(data) = mgr.miner_forks().get(&key)? { - let block: MinerBlock = serde_json::from_slice(&data) - .context("Failed to deserialize MinerBlock from MinerForks")?; - return Ok(Some(block)); - } - - // Check MinerCanon for older canonical blocks - if let Some(data) = mgr.miner_canon().get(&key)? { - let block: MinerBlock = serde_json::from_slice(&data) - .context("Failed to deserialize MinerBlock from MinerCanon")?; - return Ok(Some(block)); - } - - Ok(None) + // MinerActive is the hot path for recent blocks. A block promoted to + // MinerCanon and later orphaned into MinerForks exists in both. + // Listing treats the forks copy as the newer state, so the hash + // lookup must agree or a walk mistakes a stale canonical copy for + // the live chain. `effective` reads in that order. + Ok(mgr.with_miner_cache(|cache| cache.effective(hash).map(|block| (**block).clone()))?) } /// Find the canonical block at a specific index, routing based on epoch @@ -64,31 +69,20 @@ impl MinerBlock { current_epoch: u64, ) -> Result> { let block_epoch = mgr.block_index_to_epoch(index); - - // Check if block is old enough to be in MinerCanon - if mgr.should_promote(block_epoch, current_epoch) { - // Check MinerCanon first for finalized blocks - for item in mgr.miner_canon().iterator(MINER_BLOCK_PREFIX) { - let (_, value) = item?; - let block: MinerBlock = - serde_json::from_slice(&value).context("Failed to deserialize MinerBlock")?; - if block.index == index && block.is_canonical { - return Ok(Some(block)); - } - } - } - - // Fall back to MinerActive (may still have the block during overlap period) - for item in mgr.miner_active().iterator(MINER_BLOCK_PREFIX) { - let (_, value) = item?; - let block: MinerBlock = - serde_json::from_slice(&value).context("Failed to deserialize MinerBlock")?; - if block.index == index && block.is_canonical { - return Ok(Some(block)); - } - } - - Ok(None) + let check_canon = mgr.should_promote(block_epoch, current_epoch); + Ok(mgr.with_miner_cache(|cache| { + let hit = |kind| { + cached(cache, kind) + .find(|block| block.index == index && block.is_canonical) + .cloned() + }; + // Check MinerCanon first for finalized blocks, then MinerActive + // (it may still have the block during the overlap period). + check_canon + .then(|| hit(MinerStoreKind::Canon)) + .flatten() + .or_else(|| hit(MinerStoreKind::Active)) + })?) } /// Find canonical block by index (simple version - always checks both stores). @@ -98,41 +92,23 @@ impl MinerBlock { mgr: &DatastoreManager, index: u64, ) -> Result> { - let mut active_hit = None; - let mut active_orphan_hashes = std::collections::HashSet::new(); - for item in mgr.miner_active().iterator(MINER_BLOCK_PREFIX) { - let (_, value) = item?; - let block: MinerBlock = - serde_json::from_slice(&value).context("Failed to deserialize MinerBlock")?; - if block.index != index { - continue; - } - if block.is_canonical && !block.is_orphaned { - if active_hit.is_none() { - active_hit = Some(block); + Ok(mgr.with_miner_cache(|cache| { + let mut active_orphan_hashes = std::collections::HashSet::new(); + for block in cached(cache, MinerStoreKind::Active).filter(|block| block.index == index) { + if block.is_canonical && !block.is_orphaned { + return Some(block.clone()); } - } else { - active_orphan_hashes.insert(block.hash); - } - } - if let Some(block) = active_hit { - return Ok(Some(block)); - } - - for item in mgr.miner_canon().iterator(MINER_BLOCK_PREFIX) { - let (_, value) = item?; - let block: MinerBlock = - serde_json::from_slice(&value).context("Failed to deserialize MinerBlock")?; - if block.index == index - && block.is_canonical - && !block.is_orphaned - && !active_orphan_hashes.contains(&block.hash) - { - return Ok(Some(block)); + active_orphan_hashes.insert(block.hash.as_str()); } - } - - Ok(None) + cached(cache, MinerStoreKind::Canon) + .find(|block| { + block.index == index + && block.is_canonical + && !block.is_orphaned + && !active_orphan_hashes.contains(block.hash.as_str()) + }) + .cloned() + })?) } /// Find all canonical blocks, merging MinerActive and MinerCanon. @@ -140,41 +116,32 @@ impl MinerBlock { /// MinerActive is the newer write. A hash orphaned there stays /// orphaned even when MinerCanon still has the promoted canonical copy. pub async fn find_all_canonical_multi(mgr: &DatastoreManager) -> Result> { - let merged = Self::load_blocks_active_authoritative(mgr)?; - let mut blocks: Vec = merged - .into_values() - .filter(|block| block.is_canonical && !block.is_orphaned) - .collect(); + let mut blocks = + Self::load_blocks_active_authoritative(mgr, |block| { + block.is_canonical && !block.is_orphaned + })?; blocks.sort_by_key(|b| b.index); Ok(blocks) } /// Find all orphaned blocks, merging MinerActive and MinerForks pub async fn find_all_orphaned_multi(mgr: &DatastoreManager) -> Result> { - let mut blocks = Vec::new(); - let mut seen_hashes = std::collections::HashSet::new(); - - // Get from MinerForks (archived orphans) - for item in mgr.miner_forks().iterator(MINER_BLOCK_PREFIX) { - let (_, value) = item?; - let block: MinerBlock = serde_json::from_slice(&value) - .context("Failed to deserialize MinerBlock from MinerForks")?; - if block.is_orphaned { - seen_hashes.insert(block.hash.clone()); - blocks.push(block); + let mut blocks = mgr.with_miner_cache(|cache| { + // MinerForks (archived orphans), then MinerActive (recent orphans, + // avoiding duplicates). + let mut seen_hashes = std::collections::HashSet::new(); + let mut blocks = Vec::new(); + for block in cached(cache, MinerStoreKind::Forks).filter(|block| block.is_orphaned) { + seen_hashes.insert(block.hash.as_str()); + blocks.push(block.clone()); } - } - - // Get from MinerActive (recent orphans, avoiding duplicates) - for item in mgr.miner_active().iterator(MINER_BLOCK_PREFIX) { - let (_, value) = item?; - let block: MinerBlock = serde_json::from_slice(&value) - .context("Failed to deserialize MinerBlock from MinerActive")?; - if block.is_orphaned && !seen_hashes.contains(&block.hash) { - blocks.push(block); + for block in cached(cache, MinerStoreKind::Active) { + if block.is_orphaned && !seen_hashes.contains(block.hash.as_str()) { + blocks.push(block.clone()); + } } - } - + blocks + })?; blocks.sort_by_key(|b| b.index); Ok(blocks) } @@ -183,45 +150,25 @@ impl MinerBlock { /// /// The MinerActive record wins when the same hash exists in more than one store. pub async fn find_all_blocks_multi(mgr: &DatastoreManager) -> Result> { - let merged = Self::load_blocks_active_authoritative(mgr)?; - let mut blocks: Vec = merged.into_values().collect(); + let mut blocks = Self::load_blocks_active_authoritative(mgr, |_| true)?; blocks.sort_by_key(|b| b.index); Ok(blocks) } /// Find all blocks at a specific index (canonical, orphaned, pending) pub async fn find_by_index_multi(mgr: &DatastoreManager, index: u64) -> Result> { - let mut blocks = Vec::new(); - let mut seen_hashes = std::collections::HashSet::new(); - - // Check all three stores - for item in mgr.miner_canon().iterator(MINER_BLOCK_PREFIX) { - let (_, value) = item?; - let block: MinerBlock = serde_json::from_slice(&value)?; - if block.index == index { - seen_hashes.insert(block.hash.clone()); - blocks.push(block); - } - } - - for item in mgr.miner_forks().iterator(MINER_BLOCK_PREFIX) { - let (_, value) = item?; - let block: MinerBlock = serde_json::from_slice(&value)?; - if block.index == index && !seen_hashes.contains(&block.hash) { - seen_hashes.insert(block.hash.clone()); - blocks.push(block); - } - } - - for item in mgr.miner_active().iterator(MINER_BLOCK_PREFIX) { - let (_, value) = item?; - let block: MinerBlock = serde_json::from_slice(&value)?; - if block.index == index && !seen_hashes.contains(&block.hash) { - blocks.push(block); + Ok(mgr.with_miner_cache(|cache| { + let mut seen_hashes = std::collections::HashSet::new(); + let mut blocks = Vec::new(); + for kind in [MinerStoreKind::Canon, MinerStoreKind::Forks, MinerStoreKind::Active] { + for block in cached(cache, kind).filter(|block| block.index == index) { + if seen_hashes.insert(block.hash.as_str()) { + blocks.push(block.clone()); + } + } } - } - - Ok(blocks) + blocks + })?) } /// Find canonical blocks in a specific epoch @@ -230,58 +177,47 @@ impl MinerBlock { epoch: u64, current_epoch: u64, ) -> Result> { - let mut blocks = Vec::new(); - let mut seen_hashes = std::collections::HashSet::new(); - - // If epoch is old enough, check MinerCanon first - if mgr.should_promote(epoch, current_epoch) { - for item in mgr.miner_canon().iterator(MINER_BLOCK_PREFIX) { - let (_, value) = item?; - let block: MinerBlock = serde_json::from_slice(&value)?; - if block.epoch == epoch && block.is_canonical { - seen_hashes.insert(block.hash.clone()); - blocks.push(block); + let check_canon = mgr.should_promote(epoch, current_epoch); + let mut blocks = mgr.with_miner_cache(|cache| { + let mut seen_hashes = std::collections::HashSet::new(); + let mut blocks = Vec::new(); + // If epoch is old enough, check MinerCanon first. Also check + // MinerActive (it may have blocks during the overlap period). + if check_canon { + for block in cached(cache, MinerStoreKind::Canon) + .filter(|block| block.epoch == epoch && block.is_canonical) + { + seen_hashes.insert(block.hash.as_str()); + blocks.push(block.clone()); } } - } - - // Also check MinerActive (may have blocks during overlap period) - for item in mgr.miner_active().iterator(MINER_BLOCK_PREFIX) { - let (_, value) = item?; - let block: MinerBlock = serde_json::from_slice(&value)?; - if block.epoch == epoch && block.is_canonical && !seen_hashes.contains(&block.hash) { - blocks.push(block); + for block in cached(cache, MinerStoreKind::Active) { + if block.epoch == epoch + && block.is_canonical + && !seen_hashes.contains(block.hash.as_str()) + { + blocks.push(block.clone()); + } } - } - + blocks + })?; blocks.sort_by_key(|b| b.index); Ok(blocks) } - /// MinerActive overwrites MinerCanon and MinerForks for the same hash. + /// Every hash once. MinerActive overwrites MinerForks, which overwrites + /// MinerCanon, for the same hash. fn load_blocks_active_authoritative( mgr: &DatastoreManager, - ) -> Result> { - let mut by_hash = std::collections::HashMap::new(); - for item in mgr.miner_canon().iterator(MINER_BLOCK_PREFIX) { - let (_, value) = item?; - let block: MinerBlock = serde_json::from_slice(&value) - .context("Failed to deserialize MinerBlock from MinerCanon")?; - by_hash.insert(block.hash.clone(), block); - } - for item in mgr.miner_forks().iterator(MINER_BLOCK_PREFIX) { - let (_, value) = item?; - let block: MinerBlock = serde_json::from_slice(&value) - .context("Failed to deserialize MinerBlock from MinerForks")?; - by_hash.insert(block.hash.clone(), block); - } - for item in mgr.miner_active().iterator(MINER_BLOCK_PREFIX) { - let (_, value) = item?; - let block: MinerBlock = serde_json::from_slice(&value) - .context("Failed to deserialize MinerBlock from MinerActive")?; - by_hash.insert(block.hash.clone(), block); - } - Ok(by_hash) + keep: impl Fn(&MinerBlock) -> bool, + ) -> Result> { + Ok(mgr.with_miner_cache(|cache| { + cache + .effective_all() + .filter(|block| keep(block)) + .map(|block| (**block).clone()) + .collect() + })?) } // ============================================================ @@ -320,6 +256,16 @@ impl MinerBlock { let _ = mgr.miner_forks().delete(&height_key); } + mgr.update_miner_cache(|cache| { + cache.put(MinerStoreKind::Active, self); + if !self.is_canonical || self.is_orphaned { + cache.remove(MinerStoreKind::Canon, &self.hash); + } + if !self.is_orphaned { + cache.remove(MinerStoreKind::Forks, &self.hash); + } + }); + mgr.apply_native_mod_for_miner_block(self)?; Ok(()) @@ -346,6 +292,7 @@ impl MinerBlock { &height_key, serde_json::to_string(&height_entry)?.as_bytes(), )?; + mgr.update_miner_cache(|cache| cache.put(MinerStoreKind::Canon, self)); Ok(()) } @@ -372,6 +319,7 @@ impl MinerBlock { &height_key, serde_json::to_string(&height_entry)?.as_bytes(), )?; + mgr.update_miner_cache(|cache| cache.put(MinerStoreKind::Forks, self)); Ok(()) } @@ -384,6 +332,7 @@ impl MinerBlock { // Also delete height index let height_key = format!("/miner_blocks/index/{}/hash/{}", self.index, self.hash); mgr.miner_active().delete(&height_key)?; + mgr.update_miner_cache(|cache| cache.remove(MinerStoreKind::Active, &self.hash)); Ok(()) } @@ -397,18 +346,12 @@ impl MinerBlock { mgr: &DatastoreManager, current_epoch: u64, ) -> Result> { - let mut to_promote = Vec::new(); - - for item in mgr.miner_active().iterator(MINER_BLOCK_PREFIX) { - let (_, value) = item?; - let block: MinerBlock = serde_json::from_slice(&value)?; - - if mgr.should_promote(block.epoch, current_epoch) { - to_promote.push(block); - } - } - - Ok(to_promote) + Ok(mgr.with_miner_cache(|cache| { + cached(cache, MinerStoreKind::Active) + .filter(|block| mgr.should_promote(block.epoch, current_epoch)) + .cloned() + .collect() + })?) } /// Find all blocks in MinerActive that should be purged (12+ epochs old) @@ -416,32 +359,25 @@ impl MinerBlock { mgr: &DatastoreManager, current_epoch: u64, ) -> Result> { - let mut to_purge = Vec::new(); - - for item in mgr.miner_active().iterator(MINER_BLOCK_PREFIX) { - let (_, value) = item?; - let block: MinerBlock = serde_json::from_slice(&value)?; - - if !mgr.should_purge(block.epoch, current_epoch) { - continue; - } - // A parked block (neither canonical nor orphaned) is only held - // in MinerActive. Deleting it loses a competing chain that a peer - // walk just fetched, so it stays until fork choice settles it. - let key = format!("{}/{}", MINER_BLOCK_PREFIX, block.hash); - let settled = if block.is_canonical && !block.is_orphaned { - mgr.miner_canon().get(&key)?.is_some() - } else if block.is_orphaned { - mgr.miner_forks().get(&key)?.is_some() - } else { - false - }; - if settled { - to_purge.push(block); - } - } - - Ok(to_purge) + Ok(mgr.with_miner_cache(|cache| { + cached(cache, MinerStoreKind::Active) + .filter(|block| mgr.should_purge(block.epoch, current_epoch)) + .filter(|block| { + // A parked block (neither canonical nor orphaned) is only + // held in MinerActive. Deleting it loses a competing chain + // that a peer walk just fetched, so it stays until fork + // choice settles it. + if block.is_canonical && !block.is_orphaned { + cache.store(MinerStoreKind::Canon).contains_key(&block.hash) + } else if block.is_orphaned { + cache.store(MinerStoreKind::Forks).contains_key(&block.hash) + } else { + false + } + }) + .cloned() + .collect() + })?) } /// Run the promotion task: move canonical blocks to MinerCanon, orphans to MinerForks @@ -456,17 +392,18 @@ impl MinerBlock { let mut orphan_count = 0; for block in blocks_to_promote { + let in_store = |kind| { + mgr.with_miner_cache(|cache| cache.store(kind).contains_key(&block.hash)) + }; if block.is_canonical { // Check if already in MinerCanon - let key = format!("{}/{}", MINER_BLOCK_PREFIX, block.hash); - if mgr.miner_canon().get(&key)?.is_none() { + if !in_store(MinerStoreKind::Canon)? { block.promote_to_canon(mgr).await?; canonical_count += 1; } } else if block.is_orphaned { // Check if already in MinerForks - let key = format!("{}/{}", MINER_BLOCK_PREFIX, block.hash); - if mgr.miner_forks().get(&key)?.is_none() { + if !in_store(MinerStoreKind::Forks)? { block.archive_to_forks(mgr).await?; orphan_count += 1; } @@ -533,17 +470,8 @@ impl MinerBlock { let count = blocks_to_prune.len(); for block in &blocks_to_prune { - // Delete from MinerActive if present - let key = format!("{}/{}", MINER_BLOCK_PREFIX, block.hash); - let _ = mgr.miner_active().delete(&key); - - // Delete from MinerForks if present - let _ = mgr.miner_forks().delete(&key); - - // Delete height index from both stores - let height_key = format!("/miner_blocks/index/{}/hash/{}", block.index, block.hash); - let _ = mgr.miner_active().delete(&height_key); - let _ = mgr.miner_forks().delete(&height_key); + delete_from_store(mgr, MinerStoreKind::Active, block); + delete_from_store(mgr, MinerStoreKind::Forks, block); } if count > 0 { @@ -663,15 +591,9 @@ impl MinerBlock { let count = invalid_blocks.len(); for block in &invalid_blocks { - let key = format!("{}/{}", MINER_BLOCK_PREFIX, block.hash); - let _ = mgr.miner_active().delete(&key); - let _ = mgr.miner_canon().delete(&key); - let _ = mgr.miner_forks().delete(&key); - - let height_key = format!("/miner_blocks/index/{}/hash/{}", block.index, block.hash); - let _ = mgr.miner_active().delete(&height_key); - let _ = mgr.miner_canon().delete(&height_key); - let _ = mgr.miner_forks().delete(&height_key); + delete_from_store(mgr, MinerStoreKind::Active, block); + delete_from_store(mgr, MinerStoreKind::Canon, block); + delete_from_store(mgr, MinerStoreKind::Forks, block); } if count > 0 { diff --git a/rust/modality-datastore/src/models/miner/tree.rs b/rust/modality-datastore/src/models/miner/tree.rs new file mode 100644 index 00000000..717a503f --- /dev/null +++ b/rust/modality-datastore/src/models/miner/tree.rs @@ -0,0 +1,375 @@ +//! Fork-choice tree over the live miner blocks. +//! +//! `MinerBlock::verified_spine` rebuilt this from every stored block on each +//! call. The tree keeps it between calls. A sync reads the hashes the cache +//! journal says changed, and relinks only those blocks and the descendants +//! whose result moved. +//! +//! Two spines are tracked, by the same rule `verified_spine` applies: a +//! parent-linked walk from an index-0 block, most work, then the higher tip, +//! then the lower tip hash. +//! +//! - The winner spine runs over live blocks (not orphaned) that pass the +//! caller's eligibility check (the target check, in the node). +//! - The canonical spine runs over live blocks flagged canonical, with no +//! eligibility check, as `verified_spine(canonical)` did. +//! +//! Each linked block also records whether every mined block under it meets +//! its claimed target, which is what turns spine work into `Linked` work in +//! the node's scoring. + +use crate::models::miner::{MinerBlock, MinerBlockCache}; +use std::cmp::Reverse; +use std::collections::{BTreeSet, HashMap, HashSet}; +use std::sync::Arc; + +/// Work of the parent-linked walk from index 0 to a block. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct LinkedWork { + /// Sum of actualized difficulty, genesis included, as `verified_spine` + /// ranks spines. + pub work: u128, + /// Every block above index 0 on the walk meets its claimed target. + pub proofs_ok: bool, +} + +/// Whether a block may be on the winner spine. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum Eligibility { + /// Eligible, and the answer cannot change: it is kept for the hash. + Eligible, + /// Eligible for now; asked again the next time the block is relinked. + EligibleForNow, + /// Never eligible. Kept for the hash. + Ineligible, +} + +type Rank = (u128, u64, Reverse); + +fn rank(block: &MinerBlock, linked: LinkedWork) -> Rank { + (linked.work, block.index, Reverse(block.hash.clone())) +} + +fn meets_target(block: &MinerBlock) -> bool { + let Ok(actual) = block.get_actualized_difficulty_u128() else { + return false; + }; + let Ok(target) = block.target_difficulty.parse::() else { + return false; + }; + target > 0 && actual >= target +} + +#[derive(Default)] +pub struct MinerTree { + synced: Option<(u64, u64)>, + nodes: HashMap>, + children: HashMap>, + linked: HashMap, + ranked: BTreeSet, + canonical: HashSet, + clinked: HashMap, + cranked: BTreeSet, + verdicts: HashMap, + /// Parent of each linked block, and how many linked children each + /// linked block has; a linked block with none is a leaf. + linked_parent: HashMap, + linked_children: HashMap, + leaves: HashSet, +} + +impl MinerTree { + /// Bring the tree up to the cache. `eligibility` decides whether a block + /// whose parent is on a linked winner walk may extend it; it gets the + /// live blocks by hash to walk ancestors. + pub fn sync(&mut self, cache: &MinerBlockCache, eligibility: &mut E) + where + E: FnMut(&MinerBlock, &HashMap>) -> Eligibility, + { + let changes = self + .synced + .and_then(|(generation, version)| cache.changes_since(generation, version)); + match changes { + Some(changed) => { + let mut dirty = Vec::with_capacity(changed.len()); + for hash in changed { + self.apply(cache, &hash, &mut dirty); + } + self.relink(dirty, eligibility); + } + None => self.rebuild(cache, eligibility), + } + self.synced = Some((cache.generation(), cache.version())); + } + + fn rebuild(&mut self, cache: &MinerBlockCache, eligibility: &mut E) + where + E: FnMut(&MinerBlock, &HashMap>) -> Eligibility, + { + self.nodes.clear(); + self.children.clear(); + self.linked.clear(); + self.ranked.clear(); + self.canonical.clear(); + self.clinked.clear(); + self.cranked.clear(); + self.linked_parent.clear(); + self.linked_children.clear(); + self.leaves.clear(); + let mut dirty = Vec::new(); + for block in cache.effective_all() { + if block.is_orphaned { + continue; + } + self.insert_node(block.clone()); + dirty.push(block.hash.clone()); + } + self.verdicts.retain(|hash, _| self.nodes.contains_key(hash)); + self.relink(dirty, eligibility); + } + + fn insert_node(&mut self, block: Arc) { + let siblings = self.children.entry(block.previous_hash.clone()).or_default(); + if !siblings.contains(&block.hash) { + siblings.push(block.hash.clone()); + } + if block.is_canonical { + self.canonical.insert(block.hash.clone()); + } + self.nodes.insert(block.hash.clone(), block); + } + + fn apply(&mut self, cache: &MinerBlockCache, hash: &str, dirty: &mut Vec) { + if let Some(old) = self.nodes.remove(hash) { + if let Some(siblings) = self.children.get_mut(&old.previous_hash) { + siblings.retain(|child| child != hash); + if siblings.is_empty() { + self.children.remove(&old.previous_hash); + } + } + self.canonical.remove(hash); + } + if let Some(block) = cache.effective(hash).filter(|block| !block.is_orphaned) { + self.insert_node(block.clone()); + } + dirty.push(hash.to_string()); + } + + /// Recompute `start` and every descendant whose linked work changed, + /// parents before children. + fn relink(&mut self, start: Vec, eligibility: &mut E) + where + E: FnMut(&MinerBlock, &HashMap>) -> Eligibility, + { + let mut work: BTreeSet<(u64, String)> = BTreeSet::new(); + for hash in start { + let index = self + .nodes + .get(&hash) + .map(|block| block.index) + .unwrap_or(0); + work.insert((index, hash)); + } + while let Some((_, hash)) = work.pop_first() { + let linked = self.compute_linked(&hash, eligibility); + let clinked = self.compute_clinked(&hash); + let changed_winner = + Self::set_linked(&mut self.linked, &mut self.ranked, &self.nodes, &hash, linked); + if changed_winner { + self.update_leaves(&hash, linked.is_some()); + } + let changed_canonical = + Self::set_linked(&mut self.clinked, &mut self.cranked, &self.nodes, &hash, clinked); + let changed = changed_winner || changed_canonical; + if changed { + for child in self.children.get(&hash).into_iter().flatten() { + if let Some(block) = self.nodes.get(child) { + work.insert((block.index, child.clone())); + } + } + } + } + } + + fn set_linked( + linked: &mut HashMap, + ranked: &mut BTreeSet, + nodes: &HashMap>, + hash: &str, + new: Option, + ) -> bool { + if linked.get(hash).map(|(work, _)| *work) == new { + return false; + } + if let Some((_, old_rank)) = linked.remove(hash) { + ranked.remove(&old_rank); + } + if let (Some(new), Some(block)) = (new, nodes.get(hash)) { + let new_rank = rank(block, new); + ranked.insert(new_rank.clone()); + linked.insert(hash.to_string(), (new, new_rank)); + } + true + } + + /// Keep `leaves` after `hash` joined or left the winner walks. + fn update_leaves(&mut self, hash: &str, now_linked: bool) { + let was_linked = self.linked_parent.contains_key(hash) || self.leaves.contains(hash) + || self.linked_children.contains_key(hash); + if now_linked { + let parent = self + .nodes + .get(hash) + .filter(|block| block.index > 0) + .map(|block| block.previous_hash.clone()); + if !was_linked { + if let Some(parent) = &parent { + *self.linked_children.entry(parent.clone()).or_default() += 1; + self.leaves.remove(parent); + self.linked_parent.insert(hash.to_string(), parent.clone()); + } + let children = self.linked_children.entry(hash.to_string()).or_default(); + if *children == 0 { + self.leaves.insert(hash.to_string()); + } + } + return; + } + if !was_linked { + return; + } + self.leaves.remove(hash); + self.linked_children.remove(hash); + if let Some(parent) = self.linked_parent.remove(hash) { + if let Some(count) = self.linked_children.get_mut(&parent) { + *count = count.saturating_sub(1); + if *count == 0 && self.linked.contains_key(&parent) { + self.leaves.insert(parent); + } + } + } + } + + fn parent_of(&self, block: &MinerBlock) -> Option<&Arc> { + if block.index == 0 { + return None; + } + self.nodes + .get(&block.previous_hash) + .filter(|parent| parent.index + 1 == block.index) + } + + fn compute_linked(&mut self, hash: &str, eligibility: &mut E) -> Option + where + E: FnMut(&MinerBlock, &HashMap>) -> Eligibility, + { + let block = self.nodes.get(hash)?.clone(); + let difficulty = block.get_actualized_difficulty_u128().ok()?; + let below = if block.index == 0 { + None + } else { + let parent = self.parent_of(&block)?; + Some(self.linked.get(&parent.hash)?.0) + }; + let eligible = match self.verdicts.get(hash) { + Some(verdict) => *verdict, + None => match eligibility(&block, &self.nodes) { + Eligibility::Eligible => { + self.verdicts.insert(hash.to_string(), true); + true + } + Eligibility::Ineligible => { + self.verdicts.insert(hash.to_string(), false); + false + } + Eligibility::EligibleForNow => true, + }, + }; + if !eligible { + return None; + } + Some(match below { + None => LinkedWork { + work: difficulty, + proofs_ok: true, + }, + Some(parent) => LinkedWork { + work: parent.work.checked_add(difficulty)?, + proofs_ok: parent.proofs_ok && meets_target(&block), + }, + }) + } + + fn compute_clinked(&self, hash: &str) -> Option { + let block = self.nodes.get(hash)?; + if !block.is_canonical { + return None; + } + let difficulty = block.get_actualized_difficulty_u128().ok()?; + if block.index == 0 { + return Some(LinkedWork { + work: difficulty, + proofs_ok: true, + }); + } + let parent = self.parent_of(block)?; + let below = self.clinked.get(&parent.hash)?.0; + Some(LinkedWork { + work: below.work.checked_add(difficulty)?, + proofs_ok: below.proofs_ok && meets_target(block), + }) + } + + /// Tip of the winner spine. + pub fn best(&self) -> Option<(&Arc, LinkedWork)> { + let (_, _, Reverse(hash)) = self.ranked.last()?; + Some((self.nodes.get(hash)?, self.linked.get(hash)?.0)) + } + + /// Tip of the canonical spine, when it reaches index 0. + pub fn canonical_best(&self) -> Option<(&Arc, LinkedWork)> { + let (_, _, Reverse(hash)) = self.cranked.last()?; + Some((self.nodes.get(hash)?, self.clinked.get(hash)?.0)) + } + + pub fn node(&self, hash: &str) -> Option<&Arc> { + self.nodes.get(hash) + } + + /// The live block a block's `previous_hash` names, one index lower. + pub fn parent(&self, hash: &str) -> Option<&Arc> { + self.parent_of(self.nodes.get(hash)?) + } + + /// Winner-walk work of a block, when it is on a linked walk. + pub fn linked(&self, hash: &str) -> Option { + self.linked.get(hash).map(|(work, _)| *work) + } + + /// Canonical-walk work of a block, when it is on one. + pub fn canonical_linked(&self, hash: &str) -> Option { + self.clinked.get(hash).map(|(work, _)| *work) + } + + /// Live blocks flagged canonical. + pub fn canonical_hashes(&self) -> impl Iterator + '_ { + self.canonical.iter() + } + + pub fn canonical_count(&self) -> usize { + self.canonical.len() + } + + /// Linked blocks with no linked child: the tips of every winner-eligible + /// branch. + pub fn linked_leaves(&self) -> Vec<&Arc> { + self.leaves + .iter() + .filter_map(|hash| self.nodes.get(hash)) + .collect() + } + + pub fn live_count(&self) -> usize { + self.nodes.len() + } +} diff --git a/rust/modality-node/src/actions/chain_integrity.rs b/rust/modality-node/src/actions/chain_integrity.rs index afd38570..50b8a83b 100644 --- a/rust/modality-node/src/actions/chain_integrity.rs +++ b/rust/modality-node/src/actions/chain_integrity.rs @@ -235,6 +235,8 @@ async fn drop_promoted_copies_of_active_orphans(mgr: &DatastoreManager) -> Resul let _ = mgr.miner_canon().delete(&key); let _ = mgr.miner_canon().delete(&height_key); } + // Those deletes bypass `multi_store`, so the miner cache reloads. + mgr.invalidate_miner_cache(); Ok(()) } diff --git a/rust/modality-node/src/actions/miner/background_tasks.rs b/rust/modality-node/src/actions/miner/background_tasks.rs index f9ff26f6..07d089da 100644 --- a/rust/modality-node/src/actions/miner/background_tasks.rs +++ b/rust/modality-node/src/actions/miner/background_tasks.rs @@ -41,7 +41,9 @@ pub fn start_sync_request_handler( mining_update_tx: tokio::sync::mpsc::UnboundedSender, ) { tokio::spawn(async move { - while let Some((peer_id, _peer_addr)) = sync_request_rx.recv().await { + let mut last_peer_sync: std::collections::HashMap = + std::collections::HashMap::new(); + while let Some((peer_id, peer_addr)) = sync_request_rx.recv().await { // Check if we're already syncing with this peer { let mut peers = syncing_peers.lock().await; @@ -60,6 +62,41 @@ pub fn start_sync_request_handler( peer_id ); + // A block from a peer that is not a bootstrapper names parents + // only that peer may have. Ask it, at most once per cooldown. + let is_bootstrapper = bootstrappers.iter().any(|addr| { + addr.iter() + .any(|proto| matches!(proto, libp2p::multiaddr::Protocol::P2p(id) if id == peer_id)) + }); + let cooled_down = last_peer_sync.get(&peer_id).is_none_or(|at| { + at.elapsed() >= crate::gossip::limits::SYNC_COOLDOWN + }); + if !is_bootstrapper && cooled_down { + last_peer_sync.insert(peer_id, std::time::Instant::now()); + last_peer_sync.retain(|_, at| at.elapsed() < crate::gossip::limits::SYNC_COOLDOWN); + match request_chain_info_impl( + peer_id, + peer_addr.clone(), + swarm.clone(), + datastore.clone(), + ignored_peers.clone(), + reqres_response_txs.clone(), + ) + .await + { + Ok(()) => { + let new_tip = get_chain_tip_index(&datastore).await; + log::info!( + "📡 Chain sync with block author {} completed, chain tip is now {}", + peer_id, + new_tip + ); + let _ = mining_update_tx.send(new_tip); + } + Err(e) => log::warn!("Chain sync failed for block author {}: {}", peer_id, e), + } + } + // Check all bootstrappers for heavier chains for bootstrapper in &bootstrappers { let bp_peer_id = bootstrapper.iter().find_map(|proto| { diff --git a/rust/modality-node/src/actions/observer/chain_maintenance.rs b/rust/modality-node/src/actions/observer/chain_maintenance.rs index 252a2d04..6e931190 100644 --- a/rust/modality-node/src/actions/observer/chain_maintenance.rs +++ b/rust/modality-node/src/actions/observer/chain_maintenance.rs @@ -65,11 +65,71 @@ pub fn start_promotion_task(datastore: Arc>, shutdown: A log::warn!("Block purge task failed: {}", e); } } + + // Drop blocks under the sequenced prefix that can never be canonical + { + let mgr_lock = datastore.lock().await; + if let Err(e) = prune_under_sequenced_prefix(&mgr_lock).await { + log::warn!("Pruning under the sequenced prefix failed: {}", e); + } + } } log::info!("🗃️ Block promotion/purge background task stopped"); }); } +/// Epochs kept under the checkpoint floor before blocks there are pruned. +const PRUNE_MARGIN_EPOCHS: u64 = 2; + +/// Delete stored blocks that are not canonical and sit at least +/// `PRUNE_MARGIN_EPOCHS` under the latest sequencer checkpoint. +/// +/// Fork choice refuses any chain that leaves the canonical chain at or +/// under that checkpoint, so such a block can never become canonical. Kept, +/// it stays in the store and in every pass over it; parked and orphaned +/// blocks were never deleted, so the store grew with every fork any peer +/// sent. Nothing is pruned unless the canonical chain links to genesis with +/// every target met, which is when the checkpoint guard applies. +pub async fn prune_under_sequenced_prefix(mgr: &DatastoreManager) -> anyhow::Result { + use modality_datastore::models::miner::MinerCheckpoint; + let Some(floor) = MinerCheckpoint::find_latest_multi(mgr) + .await? + .map(|checkpoint| checkpoint.last_block_index) + else { + return Ok(0); + }; + let margin = PRUNE_MARGIN_EPOCHS.saturating_mul(mgr.epoch_config().blocks_per_epoch); + let Some(below) = floor.checked_sub(margin) else { + return Ok(0); + }; + let params = crate::chain::tree_choice::retarget_params(mgr); + let anchored = crate::chain::tree_choice::with_synced_tree(mgr, params, |tree| { + tree.canonical_best().is_some_and(|(_, work)| work.proofs_ok) + })?; + if !anchored { + return Ok(0); + } + let dead: Vec = mgr.with_miner_cache(|cache| { + cache + .effective_all() + .filter(|block| block.index <= below && (block.is_orphaned || !block.is_canonical)) + .map(|block| (**block).clone()) + .collect() + })?; + let orphaned = MinerBlock::prune_orphaned_before_checkpoint_multi(mgr, below).await?; + let mut parked = 0usize; + for block in dead.iter().filter(|block| !block.is_orphaned) { + block.delete_from_active(mgr).await?; + parked += 1; + } + if parked > 0 { + log::info!( + "🗑️ Pruned {parked} non-canonical blocks at or under index {below} (checkpoint {floor})" + ); + } + Ok(orphaned + parked) +} + /// Validate and cleanup local chain. /// /// This function: @@ -98,10 +158,16 @@ pub async fn validate_and_cleanup_chain( log::warn!("⚠️ Missing genesis block during chain validation"); chain_is_valid = false; } else { - // Validate chain continuity + // Validate chain continuity. The first block listed at each index + // is the one checked, as a search of the list would find it. + let mut by_index: std::collections::HashMap = + std::collections::HashMap::with_capacity(all_blocks.len()); + for block in &all_blocks { + by_index.entry(block.index).or_insert(block); + } for i in 1..=max_index { - if let Some(block) = all_blocks.iter().find(|b| b.index == i) { - if let Some(prev_block) = all_blocks.iter().find(|b| b.index == i - 1) { + if let Some(block) = by_index.get(&i) { + if let Some(prev_block) = by_index.get(&(i - 1)) { if block.previous_hash != prev_block.hash { chain_is_valid = false; break; @@ -271,3 +337,60 @@ pub async fn sync_missing_blocks( } } } + +#[cfg(test)] +mod prune_tests { + use super::*; + use modality_datastore::models::miner::MinerCheckpoint; + + fn block(hash: &str, index: u64, previous: &str, canonical: bool) -> MinerBlock { + let mut block = MinerBlock::new_canonical( + hash.to_string(), + index, + index / 4, + 1_700_000_000 + index as i64, + previous.to_string(), + "data".to_string(), + 1, + 1000, + "peer".to_string(), + 1, + ); + block.actualized_difficulty = "2000".to_string(); + block.is_canonical = canonical; + block + } + + #[tokio::test] + async fn only_dead_blocks_under_the_margin_are_pruned() { + let mut mgr = DatastoreManager::create_in_memory().unwrap(); + mgr.set_blocks_per_epoch(4); + let mut previous = "".to_string(); + for index in 0..30u64 { + let hash = format!("c{index:02}"); + block(&hash, index, &previous, true).save_to_active(&mgr).await.unwrap(); + previous = hash; + } + // A competing block and an orphan deep under the floor, and a + // competing block inside the margin. + block("deep_fork", 3, "c02", false).save_to_active(&mgr).await.unwrap(); + let mut orphan = block("deep_orphan", 5, "c04", false); + orphan.mark_as_orphaned("test".to_string(), None); + orphan.save_to_active(&mgr).await.unwrap(); + block("near_fork", 18, "c17", false).save_to_active(&mgr).await.unwrap(); + MinerCheckpoint::new_manual(5, 20, "c20".to_string(), String::new(), 21, None) + .save_to_canon(&mgr) + .await + .unwrap(); + + let pruned = prune_under_sequenced_prefix(&mgr).await.unwrap(); + assert_eq!(pruned, 2); + for (hash, kept) in [("deep_fork", false), ("deep_orphan", false), ("near_fork", true), ("c03", true)] { + assert_eq!( + MinerBlock::find_by_hash_multi(&mgr, hash).await.unwrap().is_some(), + kept, + "{hash}" + ); + } + } +} diff --git a/rust/modality-node/src/chain/fork_choice.rs b/rust/modality-node/src/chain/fork_choice.rs index 2b0ef6b5..94ff9795 100644 --- a/rust/modality-node/src/chain/fork_choice.rs +++ b/rust/modality-node/src/chain/fork_choice.rs @@ -305,6 +305,19 @@ pub fn check_expected_target_indexed( block: &MinerBlock, by_hash: &BlocksByHash<'_>, params: RetargetParams, +) -> TargetCheck { + check_expected_target_with(block, |hash| by_hash.get(hash).copied(), params) +} + +/// `check_expected_target` with stored blocks looked up by hash. +/// +/// The check reads the parent, the blocks of the block's own epoch, and the +/// previous epoch's span, so the walk stops at the start of the previous +/// epoch instead of at genesis. +pub fn check_expected_target_with<'a>( + block: &MinerBlock, + lookup: impl Fn(&str) -> Option<&'a MinerBlock>, + params: RetargetParams, ) -> TargetCheck { let Ok(target) = block.target_difficulty.parse::() else { return TargetCheck::Reject; @@ -326,7 +339,7 @@ pub fn check_expected_target_indexed( None => TargetCheck::Unresolved, }; } - let ancestors = ancestors_of(block, by_hash); + let ancestors = ancestors_of(block, &lookup, manager.get_epoch_start_index(epoch - 1)); // `ancestors_of` reverses the walk, so the immediate parent is last. // The check guards against a block naming an easier target than its // chain established. A harder target only costs the miner more work, @@ -400,12 +413,17 @@ pub fn check_expected_target_indexed( } } -fn ancestors_of<'a>(block: &MinerBlock, by_hash: &BlocksByHash<'a>) -> Vec<&'a MinerBlock> { +/// Parent-linked ancestors down to `stop_index`, lowest first. +fn ancestors_of<'a>( + block: &MinerBlock, + lookup: &impl Fn(&str) -> Option<&'a MinerBlock>, + stop_index: u64, +) -> Vec<&'a MinerBlock> { let mut chain = Vec::new(); let mut previous = block.previous_hash.as_str(); let mut index = block.index; - while index > 0 { - let Some(parent) = by_hash.get(previous).copied() else { + while index > 0 && index > stop_index { + let Some(parent) = lookup(previous) else { break; }; if parent.index + 1 != index { diff --git a/rust/modality-node/src/chain/mod.rs b/rust/modality-node/src/chain/mod.rs index 20b48902..83896fc0 100644 --- a/rust/modality-node/src/chain/mod.rs +++ b/rust/modality-node/src/chain/mod.rs @@ -9,6 +9,7 @@ pub mod fork_choice; pub mod metrics; pub mod reorg; +pub mod tree_choice; // Re-export commonly used items pub use fork_choice::{choose_chain, compare_chains, ChainComparison, ForkChoiceResult}; diff --git a/rust/modality-node/src/chain/reorg.rs b/rust/modality-node/src/chain/reorg.rs index c28ac8b0..da395aff 100644 --- a/rust/modality-node/src/chain/reorg.rs +++ b/rust/modality-node/src/chain/reorg.rs @@ -527,13 +527,70 @@ pub async fn store_peer_batch(mgr: &DatastoreManager, peer_blocks: &[MinerBlock] Ok(adopted + usize::from(switched)) } -/// A refused parked run that forks this many epochs under the local tip -/// is archived instead of being scored on every pass. -const STALE_FORK_EPOCHS: u64 = 2; +use crate::chain::tree_choice::STALE_FORK_EPOCHS; + +/// Rounds of adoption one call makes before it stops. Each adoption changes +/// the canonical chain, so the branch tips are decided again after it. +const ADOPTION_ROUNDS: usize = 64; + +/// Index of the canonical spine's tip, as `verified_spine` of the canonical +/// set reports it. +pub async fn canonical_tip_index(mgr: &DatastoreManager) -> Result> { + use crate::chain::tree_choice::{retarget_params, with_synced_tree}; + let params = retarget_params(mgr); + let tip = with_synced_tree(mgr, params, |tree| { + tree.canonical_best().map(|(block, _)| block.index) + })?; + if tip.is_some() { + return Ok(tip); + } + Ok( + MinerBlock::verified_spine(&MinerBlock::find_all_canonical_multi(mgr).await?) + .last() + .map(|block| block.index), + ) +} + +/// The last miner index the sequencers have committed. +async fn checkpoint_floor(mgr: &DatastoreManager) -> Option { + use modality_datastore::models::miner::MinerCheckpoint; + MinerCheckpoint::find_latest_multi(mgr) + .await + .ok() + .flatten() + .map(|checkpoint| checkpoint.last_block_index) +} /// Promote parked runs whose parent walk now reaches the canonical chain /// and whose verified work above that ancestor wins. +/// +/// Decided on the miner tree; a case the tree cannot decide runs the full +/// scan. pub async fn adopt_connected_extensions(mgr: &DatastoreManager) -> Result { + use crate::chain::tree_choice::{plan_adopt, retarget_params, with_synced_tree, Plan}; + let params = retarget_params(mgr); + let floor = checkpoint_floor(mgr).await; + let mut adopted = 0usize; + for _ in 0..ADOPTION_ROUNDS { + let plan = with_synced_tree(mgr, params, |tree| { + plan_adopt(tree, floor, params.blocks_per_epoch) + })?; + match plan { + Plan::Scan => return Ok(adopted + adopt_connected_extensions_scan(mgr).await?), + Plan::Apply { writes, changed } => { + writes.apply(mgr).await?; + if changed == 0 { + break; + } + adopted += changed; + } + } + } + Ok(adopted) +} + +/// `adopt_connected_extensions` over a full scan of the store. +pub(crate) async fn adopt_connected_extensions_scan(mgr: &DatastoreManager) -> Result { use crate::chain::fork_choice::{decide_adoption, Adoption}; use modality_datastore::models::miner::MinerCheckpoint; @@ -681,7 +738,27 @@ pub fn validate_block_chain(blocks: &[MinerBlock]) -> Result<()> { /// win without another peer sending the whole suffix. A switch that would /// drop a sequencer checkpoint, or a nomination epoch the current chain /// already has, is refused. +/// +/// Decided on the miner tree; a case the tree cannot decide runs the full +/// scan. pub async fn select_best_stored_chain(mgr: &DatastoreManager) -> Result { + use crate::chain::tree_choice::{plan_select, retarget_params, with_synced_tree, Plan}; + let params = retarget_params(mgr); + let floor = checkpoint_floor(mgr).await; + let plan = with_synced_tree(mgr, params, |tree| { + plan_select(tree, floor, params.blocks_per_epoch) + })?; + match plan { + Plan::Scan => select_best_stored_chain_scan(mgr).await, + Plan::Apply { writes, changed } => { + writes.apply(mgr).await?; + Ok(changed > 0) + } + } +} + +/// `select_best_stored_chain` over a full scan of the store. +pub(crate) async fn select_best_stored_chain_scan(mgr: &DatastoreManager) -> Result { use crate::chain::fork_choice::{ check_expected_target_indexed, choose_verified, index_by_hash, nomination_epoch_complete, score_canonical_chain, ChainWork, ForkChoiceResult, RetargetParams, TargetCheck, diff --git a/rust/modality-node/src/chain/tree_choice.rs b/rust/modality-node/src/chain/tree_choice.rs new file mode 100644 index 00000000..1ec1e16a --- /dev/null +++ b/rust/modality-node/src/chain/tree_choice.rs @@ -0,0 +1,915 @@ +//! Fork choice on the datastore's miner tree. +//! +//! `reorg::select_best_stored_chain` and `reorg::adopt_connected_extensions` +//! decoded and rescored every stored block for each gossiped block, under +//! the datastore lock. The tree keeps each live block's linked work and the +//! best tips between calls, so a decision here walks only the two suffixes +//! above their fork point, and the linked branch tips. +//! +//! The rules are the ones those functions apply, in the same order and with +//! the same log lines: the sequenced-prefix floor, the nomination epoch, +//! then verified work. A plan is computed under the tree lock and the +//! writes are applied afterwards. Where the tree cannot answer (no anchored +//! canonical spine, a proof that misses its target), the planner says so and +//! the caller runs the full scan. + +use crate::chain::fork_choice::{ + check_expected_target_with, choose_verified, proof_meets_target, ChainWork, ForkChoiceResult, + RetargetParams, TargetCheck, +}; +use modality_datastore::models::miner::LinkedWork; +use anyhow::Result; +use modality_datastore::models::miner::{Eligibility, MinerTree}; +use modality_datastore::models::MinerBlock; +use modality_datastore::DatastoreManager; +use std::collections::{BTreeMap, HashSet}; +use std::sync::Arc; + +/// A refused branch that forks this many epochs under the local tip is +/// archived instead of being scored again. +pub(crate) const STALE_FORK_EPOCHS: u64 = 2; + +pub(crate) fn retarget_params(mgr: &DatastoreManager) -> RetargetParams { + RetargetParams { + blocks_per_epoch: mgr.epoch_config().blocks_per_epoch, + target_block_time_secs: mgr.network_u64("target_block_time_secs").unwrap_or(60), + initial_difficulty: mgr + .network_u64("initial_difficulty") + .map(|value| value as u128), + } +} + +/// Run `f` on the tree after syncing it with the store. The target check is +/// the eligibility rule, as `select_best_stored_chain` filtered on it. +pub(crate) fn with_synced_tree( + mgr: &DatastoreManager, + params: RetargetParams, + f: impl FnOnce(&MinerTree) -> R, +) -> Result { + let mut tree = mgr.miner_tree(); + mgr.with_miner_cache(|cache| { + tree.sync(cache, &mut |block, live| { + match check_expected_target_with(block, |hash| live.get(hash).map(|b| b.as_ref()), params) + { + TargetCheck::Matches => Eligibility::Eligible, + TargetCheck::Reject => Eligibility::Ineligible, + TargetCheck::Unresolved => Eligibility::EligibleForNow, + } + }); + })?; + Ok(f(&tree)) +} + +/// Which stored blocks the target check may walk through. +#[derive(Clone, Copy)] +pub(crate) enum Ancestors { + /// Every stored block, as the gossip handler checked. + Stored, + /// Blocks that are not orphaned, as parent sync checked. + Live, +} + +/// The target check for a block that is not stored yet, against the +/// stored blocks, without the full scan it used to take. +pub(crate) fn check_target_against_store( + mgr: &DatastoreManager, + block: &MinerBlock, + params: RetargetParams, + ancestors: Ancestors, +) -> Result { + Ok(mgr.with_miner_cache(|cache| { + check_expected_target_with( + block, + |hash| { + cache + .effective(hash) + .filter(|b| matches!(ancestors, Ancestors::Stored) || !b.is_orphaned) + .map(|b| b.as_ref()) + }, + params, + ) + })?) +} + +/// Flag writes a plan makes, keyed by hash so a later write to the same +/// block replaces an earlier one. +#[derive(Default)] +pub(crate) struct Writes(BTreeMap); + +impl Writes { + fn current<'a>(&'a self, block: &'a MinerBlock) -> &'a MinerBlock { + self.0.get(&block.hash).unwrap_or(block) + } + + fn set(&mut self, block: MinerBlock) { + self.0.insert(block.hash.clone(), block); + } + + fn promote(&mut self, block: &MinerBlock) { + let mut promoted = self.current(block).clone(); + promoted.is_canonical = true; + promoted.is_orphaned = false; + promoted.orphan_reason = None; + self.set(promoted); + } + + fn demote(&mut self, block: &MinerBlock, reason: &str) { + let mut competing = self.current(block).clone(); + competing.is_canonical = false; + competing.is_orphaned = false; + competing.orphan_reason = Some(reason.to_string()); + self.set(competing); + } + + fn orphan(&mut self, block: &MinerBlock, reason: String, competing_hash: Option) { + let mut orphaned = self.current(block).clone(); + orphaned.mark_as_orphaned(reason, competing_hash); + self.set(orphaned); + } + + pub(crate) fn is_empty(&self) -> bool { + self.0.is_empty() + } + + /// Save every write, lowest index first. + pub(crate) async fn apply(self, mgr: &DatastoreManager) -> Result<()> { + let mut blocks: Vec = self.0.into_values().collect(); + blocks.sort_by_key(|block| block.index); + for block in blocks { + block.save_to_active(mgr).await?; + } + Ok(()) + } +} + +/// The blocks of a linked walk from `tip` down to, not including, `stop` +/// (or to index 0), highest first. +fn walk_down<'a>(tree: &'a MinerTree, tip: &'a Arc, stop: Option<&str>) -> Vec<&'a Arc> { + let mut out = Vec::new(); + let mut current = tip; + loop { + if stop == Some(current.hash.as_str()) { + break; + } + out.push(current); + match tree.parent(¤t.hash) { + Some(parent) => current = parent, + None => break, + } + } + out +} + +/// The highest block both walks share, or `None` when they do not meet. +fn fork_point<'a>( + tree: &'a MinerTree, + left: &'a Arc, + right: &'a Arc, +) -> Option<&'a Arc> { + let (mut a, mut b) = (left, right); + while a.index > b.index { + a = tree.parent(&a.hash)?; + } + while b.index > a.index { + b = tree.parent(&b.hash)?; + } + while a.hash != b.hash { + a = tree.parent(&a.hash)?; + b = tree.parent(&b.hash)?; + } + Some(a) +} + +/// True when the walk to `tip` holds `block`. +fn on_walk(tree: &MinerTree, tip: &Arc, block: &MinerBlock) -> bool { + let mut current = tip; + while current.index > block.index { + match tree.parent(¤t.hash) { + Some(parent) => current = parent, + None => return false, + } + } + current.hash == block.hash +} + +/// A walk from index 0 to `tip` holds every block of the nomination epoch +/// for `tip`'s epoch. This is `nomination_epoch_complete` for a walk that +/// has one block at every index below its tip. +fn covers_nomination_epoch(tip: &MinerBlock, blocks_per_epoch: u64) -> bool { + if tip.epoch < 2 || blocks_per_epoch == 0 { + return true; + } + let start = (tip.epoch - 2).saturating_mul(blocks_per_epoch); + tip.index.saturating_add(1) >= start.saturating_add(blocks_per_epoch) +} + +/// Spine work the node's scoring compares: linked when every mined block on +/// the walk meets its target, unknown otherwise. +fn scored(work: LinkedWork) -> ChainWork { + if work.proofs_ok { + ChainWork::Linked(work.work) + } else { + ChainWork::Unknown + } +} + +pub(crate) enum Plan { + /// The tree cannot decide this case; run the full scan. + Scan, + /// Apply these writes. `changed` is the value the scan would return. + Apply { writes: Writes, changed: usize }, +} + +/// `select_best_stored_chain` on the tree. +pub(crate) fn plan_select(tree: &MinerTree, floor: Option, blocks_per_epoch: u64) -> Plan { + let Some((winner, winner_work)) = tree.best() else { + return Plan::Scan; + }; + let Some((local, local_work)) = tree.canonical_best() else { + return Plan::Scan; + }; + // A checkpoint or nomination epoch on a chain whose work is unknown + // protects nothing that can be verified. + let local_anchored = local_work.proofs_ok; + let mut writes = Writes::default(); + + // Canonical blocks off the canonical spine leave the canonical set, + // except under the sequenced prefix. + let mut kept_off_spine: Vec<&Arc> = Vec::new(); + if tree.canonical_count() != (local.index + 1) as usize { + let spine: HashSet<&str> = walk_down(tree, local, None) + .into_iter() + .map(|block| block.hash.as_str()) + .collect(); + for hash in tree.canonical_hashes() { + if spine.contains(hash.as_str()) { + continue; + } + let Some(block) = tree.node(hash) else { + continue; + }; + if floor.is_some_and(|floor| block.index <= floor) { + kept_off_spine.push(block); + } else { + writes.demote(block, "Off the verified spine"); + } + } + } + let demoted = usize::from(!writes.is_empty()); + let keep = |writes| Plan::Apply { + writes, + changed: demoted, + }; + + if winner.hash == local.hash && kept_off_spine.is_empty() { + return keep(writes); + } + let Some(fork) = fork_point(tree, winner, local) else { + return Plan::Scan; + }; + + if let Some(floor) = floor.filter(|_| local_anchored) { + let spine_under_floor = local.index > fork.index && fork.index < floor; + let kept_under_floor = kept_off_spine + .iter() + .any(|block| block.index <= floor && !on_walk(tree, winner, block)); + if spine_under_floor || kept_under_floor { + log::warn!("Refusing to switch off the sequenced prefix through {floor}"); + return keep(writes); + } + } + if local_anchored + && covers_nomination_epoch(local, blocks_per_epoch) + && !covers_nomination_epoch(winner, blocks_per_epoch) + { + log::warn!("Refusing a fork that drops the nomination epoch"); + return keep(writes); + } + + let decision = choose_verified( + scored(local_work), + local.index, + &local.hash, + scored(winner_work), + winner.index, + &winner.hash, + ); + let fills_parents = fork.hash == local.hash + && kept_off_spine + .iter() + .all(|block| on_walk(tree, winner, block)); + if decision.result != ForkChoiceResult::AdoptRemote && !fills_parents { + log::info!( + "Keeping local chain at {} ({:?}) over stored spine at {} ({:?}): {}", + local.index, + scored(local_work), + winner.index, + scored(winner_work), + decision.reason + ); + return keep(writes); + } + log::info!( + "Switching to stored spine at {} ({:?}) from local {} ({:?})", + winner.index, + scored(winner_work), + local.index, + scored(local_work) + ); + for block in walk_down(tree, winner, Some(&fork.hash)) { + if !writes.current(block).is_canonical { + writes.promote(block); + } + } + for block in walk_down(tree, local, Some(&fork.hash)) { + writes.demote(block, "Competing fork"); + } + for block in kept_off_spine { + if !on_walk(tree, winner, block) { + writes.demote(block, "Competing fork"); + } + } + Plan::Apply { writes, changed: 1 } +} + +/// One pass of `adopt_connected_extensions` on the tree: every linked branch +/// tip off the canonical spine is decided against the canonical chain. The +/// pass stops at the first adoption, since that changes the canonical +/// chain; the caller plans again. +pub(crate) fn plan_adopt(tree: &MinerTree, floor: Option, blocks_per_epoch: u64) -> Plan { + let Some((local, local_work)) = tree.canonical_best() else { + return Plan::Scan; + }; + if tree.canonical_count() != (local.index + 1) as usize { + return Plan::Scan; + } + let local_anchored = local_work.proofs_ok; + let local_covers = covers_nomination_epoch(local, blocks_per_epoch); + let mut leaves = tree.linked_leaves(); + leaves.sort_by(|a, b| { + let work = |block: &MinerBlock| tree.linked(&block.hash).map(|w| w.work).unwrap_or(0); + work(b) + .cmp(&work(a)) + .then(b.index.cmp(&a.index)) + .then(a.hash.cmp(&b.hash)) + }); + + let mut writes = Writes::default(); + for leaf in leaves { + if leaf.is_canonical { + continue; + } + // The branch above its highest canonical block, lowest first. + let mut extension: Vec<&Arc> = Vec::new(); + let mut current = leaf; + let ancestor = loop { + if current.is_canonical { + break Some(current); + } + extension.push(current); + match tree.parent(¤t.hash) { + Some(parent) => current = parent, + None => break None, + } + }; + let Some(ancestor) = ancestor else { + continue; + }; + extension.reverse(); + if extension.is_empty() { + continue; + } + + let safe_len = if local_covers { + extension + .iter() + .take_while(|block| covers_nomination_epoch(block, blocks_per_epoch)) + .count() + } else { + extension.len() + }; + let bottom = extension[0].index; + if safe_len == 0 { + let tip = extension[extension.len() - 1].index; + log::info!("Keeping parked extension {bottom}..={tip}: nomination epoch"); + continue; + } + let safe = &extension[..safe_len]; + let safe_tip = safe[safe_len - 1]; + + let floor_refusal = floor.filter(|floor| { + local_anchored && local.index > ancestor.index && ancestor.index < *floor + }); + let refusal = if let Some(floor) = floor_refusal { + Err(format!("Refusing to orphan the sequenced prefix through {floor}")) + } else { + // Local work above the ancestor counts up to the first block that + // misses its target, as `work_above_ancestor` walks it. + let mut local_top: Option<&Arc> = None; + for block in walk_down(tree, local, Some(&ancestor.hash)).into_iter().rev() { + if !proof_meets_target(block) { + break; + } + local_top = Some(block); + } + let ancestor_work = tree.canonical_linked(&ancestor.hash).map(|w| w.work); + let (local_chain_work, local_tip, local_hash) = + match (local_top, ancestor_work) { + (Some(top), Some(below)) => ( + ChainWork::Linked( + tree.canonical_linked(&top.hash) + .map(|w| w.work) + .unwrap_or(below) + .saturating_sub(below), + ), + top.index, + top.hash.clone(), + ), + _ => (ChainWork::Unknown, local.index, local.hash.clone()), + }; + let suffix_meets = safe.iter().all(|block| proof_meets_target(block)); + let remote_work = match (tree.linked(&safe_tip.hash), tree.linked(&ancestor.hash)) { + (Some(tip), Some(below)) if suffix_meets => { + ChainWork::Linked(tip.work.saturating_sub(below.work)) + } + _ => ChainWork::Unknown, + }; + let comparison = choose_verified( + local_chain_work, + local_tip, + &local_hash, + remote_work, + safe_tip.index, + &safe_tip.hash, + ); + if comparison.result == ForkChoiceResult::AdoptRemote { + Ok(comparison.reason) + } else { + Err(comparison.reason) + } + }; + + match refusal { + Err(reason) => { + log::info!( + "Keeping parked extension {bottom}..={}: {reason}", + safe_tip.index + ); + if bottom.saturating_add(STALE_FORK_EPOCHS.saturating_mul(blocks_per_epoch)) + <= local.index + { + for block in &extension { + writes.orphan( + block, + format!("Stale fork {} epochs under the tip", STALE_FORK_EPOCHS), + None, + ); + } + log::info!( + "Archived stale fork {bottom}..={} under local tip {}", + leaf.index, + local.index + ); + } + } + Ok(reason) => { + log::info!("Adopting linked extension: {reason}"); + for block in walk_down(tree, local, Some(&ancestor.hash)) { + let competing = safe + .iter() + .find(|candidate| candidate.index == block.index) + .map(|candidate| candidate.hash.clone()); + writes.orphan(block, reason.clone(), competing); + } + for block in safe { + writes.promote(block); + } + return Plan::Apply { + writes, + changed: safe_len, + }; + } + } + } + Plan::Apply { writes, changed: 0 } +} + +#[cfg(test)] +mod tests { + use crate::chain::reorg::{ + adopt_connected_extensions, select_best_stored_chain, select_best_stored_chain_scan, + }; + use modality_datastore::models::MinerBlock; + use modality_datastore::DatastoreManager; + use rand::rngs::StdRng; + use rand::{Rng, SeedableRng}; + + struct Shape { + blocks_per_epoch: u64, + strays: bool, + bad_proofs: bool, + } + + fn block(hash: String, index: u64, previous: &str, actual: u64, blocks_per_epoch: u64) -> MinerBlock { + let mut block = MinerBlock::new_canonical( + hash, + index, + index / blocks_per_epoch, + 1_700_000_000 + index as i64 * 60, + previous.to_string(), + "data".to_string(), + 1, + 1000, + "peer".to_string(), + 1, + ); + block.actualized_difficulty = actual.to_string(); + block.is_canonical = false; + block + } + + /// A random store: a canonical chain, forks off it, parked runs whose + /// parent is missing, and orphans; with `strays`, canonical flags off + /// that chain; with `bad_proofs`, a few blocks that miss their target. + fn random_store(rng: &mut StdRng, shape: &Shape) -> Vec { + let bpe = shape.blocks_per_epoch; + let mut blocks = vec![block("g".into(), 0, "", 1000, bpe)]; + blocks[0].is_canonical = true; + let n = rng.gen_range(5..60); + for i in 0..n { + let parent = blocks[rng.gen_range(0..blocks.len())].clone(); + let parked = rng.gen_bool(0.08); + let previous = if parked { + format!("missing{i}") + } else { + parent.hash.clone() + }; + let actual = if shape.bad_proofs && rng.gen_bool(0.04) { + rng.gen_range(1..999) + } else { + rng.gen_range(1000..6000) + }; + let mut child = block(format!("b{i:03}"), parent.index + 1, &previous, actual, bpe); + child.is_orphaned = rng.gen_bool(0.08); + blocks.push(child); + } + // Flag one walk canonical, from a random block down to genesis. + let mut current = blocks[rng.gen_range(0..blocks.len())].hash.clone(); + let mut walk = Vec::new(); + while let Some(at) = blocks.iter().position(|b| b.hash == current) { + if blocks[at].is_orphaned { + walk.clear(); + break; + } + walk.push(at); + if blocks[at].index == 0 { + break; + } + current = blocks[at].previous_hash.clone(); + } + for at in walk { + blocks[at].is_canonical = true; + } + if shape.strays && rng.gen_bool(0.3) { + let at = rng.gen_range(0..blocks.len()); + if !blocks[at].is_orphaned { + blocks[at].is_canonical = true; + } + } + blocks + } + + async fn store_of(blocks: &[MinerBlock], blocks_per_epoch: u64) -> DatastoreManager { + let mut mgr = DatastoreManager::create_in_memory().unwrap(); + mgr.set_blocks_per_epoch(blocks_per_epoch); + for block in blocks { + block.save_to_active(&mgr).await.unwrap(); + } + mgr + } + + async fn state(mgr: &DatastoreManager) -> Vec<(String, bool, bool)> { + let mut out: Vec<_> = MinerBlock::find_all_blocks_multi(mgr) + .await + .unwrap() + .into_iter() + .map(|b| (b.hash, b.is_canonical, b.is_orphaned)) + .collect(); + out.sort(); + out + } + + fn diff(case: usize, blocks: &[MinerBlock], fast: &[(String, bool, bool)], scan: &[(String, bool, bool)]) -> String { + let mut out = format!("case {case}\n"); + for b in blocks { + out.push_str(&format!( + " {} i{} prev={} act={} canon={} orph={}\n", + b.hash, b.index, b.previous_hash, b.actualized_difficulty, b.is_canonical, b.is_orphaned + )); + } + for (f, s) in fast.iter().zip(scan) { + if f != s { + out.push_str(&format!(" fast {f:?} scan {s:?}\n")); + } + } + out + } + + /// One select pass gives what the full scan gives. + /// + /// Stray canonical flags are left out: there the full scan decides from + /// the store as it read it at the start of the pass, so a block it + /// demotes off the canonical spine that is also on the winner stays + /// demoted, leaving a hole under the canonical tip. + /// `tree_choice_follows_the_verified_spine` covers those stores. + #[tokio::test] + async fn tree_select_matches_the_full_scan() { + let shape = Shape { + blocks_per_epoch: 4, + strays: false, + bad_proofs: true, + }; + let mut rng = StdRng::seed_from_u64(7); + for case in 0..600 { + let blocks = random_store(&mut rng, &shape); + let fast = store_of(&blocks, shape.blocks_per_epoch).await; + let scan = store_of(&blocks, shape.blocks_per_epoch).await; + // A sequenced prefix through a random canonical index, now and then. + if rng.gen_bool(0.4) { + let canonical: Vec<&MinerBlock> = blocks.iter().filter(|b| b.is_canonical).collect(); + let at = canonical[rng.gen_range(0..canonical.len())]; + let checkpoint = modality_datastore::models::miner::MinerCheckpoint::new_manual( + 0, + at.index, + at.hash.clone(), + String::new(), + at.index + 1, + None, + ); + checkpoint.save_to_canon(&fast).await.unwrap(); + checkpoint.save_to_canon(&scan).await.unwrap(); + } + let fast_switched = select_best_stored_chain(&fast).await.unwrap(); + let scan_switched = select_best_stored_chain_scan(&scan).await.unwrap(); + let (f, s) = (state(&fast).await, state(&scan).await); + assert!(f == s, "{}", diff(case, &blocks, &f, &s)); + assert_eq!(fast_switched, scan_switched, "case {case}: select result"); + } + } + + /// After a select pass and an adoption pass, with no nomination epoch or + /// sequenced prefix in play: the canonical set is one walk from genesis, + /// no live branch beats it by the adoption rule (work above the fork + /// point, every block of the branch meeting its target), and another + /// pass changes nothing. + /// + /// The full scan's adoption pass is not the reference here. It takes + /// extensions in store order, so it can adopt a lighter branch first and + /// then refuse the heavier one, which no longer links. + #[tokio::test] + async fn tree_adoption_leaves_no_branch_that_beats_the_chain() { + use crate::chain::fork_choice::{choose_verified, proof_meets_target, ChainWork, ForkChoiceResult}; + let shape = Shape { + blocks_per_epoch: 1000, + strays: false, + bad_proofs: true, + }; + let mut rng = StdRng::seed_from_u64(13); + for case in 0..600 { + let blocks = random_store(&mut rng, &shape); + let fast = store_of(&blocks, shape.blocks_per_epoch).await; + select_best_stored_chain(&fast).await.unwrap(); + adopt_connected_extensions(&fast).await.unwrap(); + + let all = MinerBlock::find_all_blocks_multi(&fast).await.unwrap(); + let live: Vec<&MinerBlock> = all.iter().filter(|b| !b.is_orphaned).collect(); + let by_hash: std::collections::HashMap<&str, &MinerBlock> = + live.iter().map(|b| (b.hash.as_str(), *b)).collect(); + let parent = |b: &MinerBlock| { + by_hash + .get(b.previous_hash.as_str()) + .copied() + .filter(|p| b.index > 0 && p.index + 1 == b.index) + }; + let walk = |tip: &MinerBlock| -> Option> { + let mut path = vec![by_hash[tip.hash.as_str()]]; + while path.last().unwrap().index > 0 { + path.push(parent(path.last().unwrap())?); + } + path.reverse(); + Some(path) + }; + let canonical: Vec<&MinerBlock> = live.iter().copied().filter(|b| b.is_canonical).collect(); + let tip = *canonical.iter().max_by_key(|b| b.index).unwrap(); + let spine = walk(tip).expect("canonical tip links to genesis"); + assert!( + spine.iter().all(|b| b.is_canonical) && spine.len() == canonical.len(), + "case {case}: canonical set is not one walk\n{}", + diff(case, &blocks, &[], &[]) + ); + + let work = |path: &[&MinerBlock]| -> ChainWork { + if path.iter().all(|b| proof_meets_target(b)) { + ChainWork::Linked(path.iter().map(|b| b.get_actualized_difficulty_u128().unwrap()).sum()) + } else { + ChainWork::Unknown + } + }; + for leaf in &live { + let Some(path) = walk(leaf) else { continue }; + let is_leaf = !live.iter().any(|c| parent(c).is_some_and(|p| p.hash == leaf.hash)); + if !is_leaf || leaf.is_canonical { + continue; + } + let at = path.iter().rposition(|b| b.is_canonical).unwrap(); + let suffix = &path[at + 1..]; + let above = &spine[at + 1..]; + // Local work counts up to the first block that misses its target. + let ok = above.iter().take_while(|b| proof_meets_target(b)).count(); + let (local_work, local_tip, local_hash) = if ok > 0 { + let top = above[ok - 1]; + (work(&above[..ok]), top.index, top.hash.as_str()) + } else { + (ChainWork::Unknown, tip.index, tip.hash.as_str()) + }; + let remote_tip = suffix.last().unwrap(); + let decision = choose_verified( + local_work, + local_tip, + local_hash, + work(suffix), + remote_tip.index, + &remote_tip.hash, + ); + assert!( + decision.result != ForkChoiceResult::AdoptRemote, + "case {case}: branch to {} beats the chain: {}\n{}", + leaf.hash, + decision.reason, + diff(case, &blocks, &[], &[]) + ); + } + assert_eq!( + adopt_connected_extensions(&fast).await.unwrap(), + 0, + "case {case}: a second adoption pass adopted" + ); + } + } + + /// With no nomination epoch in play, one pass leaves exactly the + /// verified spine of the live blocks canonical, and a second pass + /// changes nothing. Stray canonical flags included. + #[tokio::test] + async fn tree_choice_follows_the_verified_spine() { + let shape = Shape { + blocks_per_epoch: 1000, + strays: true, + bad_proofs: false, + }; + let mut rng = StdRng::seed_from_u64(11); + for case in 0..600 { + let blocks = random_store(&mut rng, &shape); + let live: Vec = blocks.iter().filter(|b| !b.is_orphaned).cloned().collect(); + let mut expected: Vec = + MinerBlock::verified_spine(&live).into_iter().map(|b| b.hash).collect(); + expected.sort(); + let fast = store_of(&blocks, shape.blocks_per_epoch).await; + select_best_stored_chain(&fast).await.unwrap(); + adopt_connected_extensions(&fast).await.unwrap(); + let mut canonical: Vec = MinerBlock::find_all_canonical_multi(&fast) + .await + .unwrap() + .into_iter() + .map(|b| b.hash) + .collect(); + canonical.sort(); + assert_eq!(canonical, expected, "case {case}: {blocks:#?}"); + assert!( + !select_best_stored_chain(&fast).await.unwrap(), + "case {case}: a second pass changed the chain" + ); + } + } + + /// The incremental tree, synced across many writes, agrees with a tree + /// rebuilt from scratch. + #[tokio::test] + async fn an_incremental_tree_matches_a_rebuilt_one() { + let mut rng = StdRng::seed_from_u64(3); + for case in 0..100 { + let shape = Shape { + blocks_per_epoch: 4, + strays: true, + bad_proofs: true, + }; + let blocks = random_store(&mut rng, &shape); + let mgr = store_of(&blocks[..1], shape.blocks_per_epoch).await; + let params = super::retarget_params(&mgr); + for block in &blocks[1..] { + block.save_to_active(&mgr).await.unwrap(); + super::with_synced_tree(&mgr, params, |_| ()).unwrap(); + } + select_best_stored_chain(&mgr).await.unwrap(); + adopt_connected_extensions(&mgr).await.unwrap(); + let incremental = super::with_synced_tree(&mgr, params, |tree| { + { + let mut leaves: Vec = + tree.linked_leaves().iter().map(|b| b.hash.clone()).collect(); + leaves.sort(); + ( + tree.best().map(|(b, w)| (b.hash.clone(), w)), + tree.canonical_best().map(|(b, w)| (b.hash.clone(), w)), + tree.canonical_count(), + leaves, + ) + } + }) + .unwrap(); + mgr.invalidate_miner_cache(); + let rebuilt = super::with_synced_tree(&mgr, params, |tree| { + { + let mut leaves: Vec = + tree.linked_leaves().iter().map(|b| b.hash.clone()).collect(); + leaves.sort(); + ( + tree.best().map(|(b, w)| (b.hash.clone(), w)), + tree.canonical_best().map(|(b, w)| (b.hash.clone(), w)), + tree.canonical_count(), + leaves, + ) + } + }) + .unwrap(); + assert_eq!(incremental, rebuilt, "case {case}"); + } + } + + /// A store of `len` blocks on one canonical chain, with a short dead + /// fork every 50 blocks and a parked block every 100. + async fn long_store(len: u64) -> (DatastoreManager, MinerBlock) { + let bpe = 40; + let mgr = store_of(&[], bpe).await; + let mut previous = block("g".into(), 0, "", 1000, bpe); + previous.is_canonical = true; + previous.save_to_active(&mgr).await.unwrap(); + for index in 1..len { + let mut next = block(format!("c{index:06}"), index, &previous.hash, 2000, bpe); + next.is_canonical = true; + next.save_to_active(&mgr).await.unwrap(); + if index % 50 == 0 { + block(format!("f{index:06}"), index + 1, &next.hash, 1500, bpe) + .save_to_active(&mgr) + .await + .unwrap(); + } + if index % 100 == 0 { + block(format!("p{index:06}"), index + 5, "nowhere", 3000, bpe) + .save_to_active(&mgr) + .await + .unwrap(); + } + previous = next; + } + (mgr, previous) + } + + /// What the gossip handler does for one block, after its checks. + async fn score_one(mgr: &DatastoreManager, previous: &MinerBlock, n: u64) -> MinerBlock { + let next = block(format!("n{n:06}"), previous.index + 1, &previous.hash, 2000, 40); + next.save_to_active(mgr).await.unwrap(); + let params = super::retarget_params(mgr); + super::with_synced_tree(mgr, params, |tree| tree.linked(&next.hash).is_some()).unwrap(); + select_best_stored_chain(mgr).await.unwrap(); + adopt_connected_extensions(mgr).await.unwrap(); + let tip = crate::chain::reorg::canonical_tip_index(mgr).await.unwrap(); + assert_eq!(tip, Some(next.index)); + next + } + + async fn time_per_block(len: u64) -> std::time::Duration { + let (mgr, mut previous) = long_store(len).await; + // The first pass builds the tree from the store once. + previous = score_one(&mgr, &previous, 0).await; + let started = std::time::Instant::now(); + let rounds = 40; + for n in 1..=rounds { + previous = score_one(&mgr, &previous, n).await; + } + started.elapsed() / rounds as u32 + } + + /// Scoring a gossiped block costs about the same on a store ten times + /// larger. The full scan cost grew faster than the store; the testnet + /// spent minutes per block at about 20k blocks. + #[tokio::test] + async fn scoring_a_gossiped_block_does_not_grow_with_the_store() { + let small = time_per_block(2_000).await; + let large = time_per_block(20_000).await; + eprintln!("per gossiped block: {small:?} at 2k blocks, {large:?} at 20k blocks"); + assert!( + large < small * 3 + std::time::Duration::from_millis(5), + "{large:?} at 20k blocks against {small:?} at 2k" + ); + } +} diff --git a/rust/modality-node/src/consensus/node_communication.rs b/rust/modality-node/src/consensus/node_communication.rs index 89d87a35..a44bb384 100644 --- a/rust/modality-node/src/consensus/node_communication.rs +++ b/rust/modality-node/src/consensus/node_communication.rs @@ -14,6 +14,12 @@ use modality_sequencer_consensus::communication::Message as ConsensusMessage; use crate::gossip::consensus::block::cert::TOPIC as BLOCK_CERT_TOPIC; use crate::gossip::consensus::block::draft::TOPIC as BLOCK_DRAFT_TOPIC; +/// How long a Shoal broadcast waits for the swarm. A draft or certificate +/// that misses this is dropped and logged; the loop rebroadcasts stale +/// drafts, and peers fetch missing certificates. Waiting without a bound +/// let one stalled swarm stretch a Shoal tick to tens of seconds. +const SWARM_PUBLISH_WAIT: std::time::Duration = std::time::Duration::from_secs(2); + pub struct NodeCommunication { pub swarm: Arc>, pub consensus_tx: mpsc::Sender, @@ -39,6 +45,20 @@ impl NodeCommunication { } } } + + /// Publish on `topic` if the swarm frees up within `SWARM_PUBLISH_WAIT`. + async fn publish(&self, topic: &str, data: String) -> Result<()> { + let Ok(mut swarm) = tokio::time::timeout(SWARM_PUBLISH_WAIT, self.swarm.lock()).await + else { + log::warn!("swarm busy for {SWARM_PUBLISH_WAIT:?}; dropped a {topic} publish"); + return Ok(()); + }; + swarm + .behaviour_mut() + .gossipsub + .publish(libp2p::gossipsub::IdentTopic::new(topic), data)?; + Ok(()) + } } #[async_trait::async_trait] @@ -54,14 +74,8 @@ impl Communication for NodeCommunication { block: block.clone(), }; self.enqueue(msg)?; - { - let mut swarm = self.swarm.lock().await; - swarm.behaviour_mut().gossipsub.publish( - libp2p::gossipsub::IdentTopic::new(BLOCK_DRAFT_TOPIC), - serde_json::to_string(block)?, - )?; - } - Ok(()) + self.publish(BLOCK_DRAFT_TOPIC, serde_json::to_string(block)?) + .await } async fn broadcast_certified_block( @@ -70,14 +84,8 @@ impl Communication for NodeCommunication { block: &SequencerBlock, ) -> Result<()> { // The author already saved and applied its own certificate. - { - let mut swarm = self.swarm.lock().await; - swarm.behaviour_mut().gossipsub.publish( - libp2p::gossipsub::IdentTopic::new(BLOCK_CERT_TOPIC), - serde_json::to_string(block)?, - )?; - } - Ok(()) + self.publish(BLOCK_CERT_TOPIC, serde_json::to_string(block)?) + .await } async fn send_block_ack(&mut self, from_peer: &str, to_peer: &str, ack: &Ack) -> Result<()> { @@ -93,12 +101,15 @@ impl Communication for NodeCommunication { ack: ack.clone(), }; self.enqueue(msg)?; - } else { - let mut swarm = self.swarm.lock().await; + } else if let Ok(mut swarm) = + tokio::time::timeout(SWARM_PUBLISH_WAIT, self.swarm.lock()).await + { let _req_id = swarm .behaviour_mut() .reqres .send_request(&target_peer, request); + } else { + log::warn!("swarm busy for {SWARM_PUBLISH_WAIT:?}; dropped an ack to {to_peer}"); } Ok(()) diff --git a/rust/modality-node/src/gossip/limits.rs b/rust/modality-node/src/gossip/limits.rs new file mode 100644 index 00000000..7b47c283 --- /dev/null +++ b/rust/modality-node/src/gossip/limits.rs @@ -0,0 +1,137 @@ +//! Bounds on what one peer's miner-block gossip can make this node do. +//! +//! Gossipsub forwards a valid signed message before the node looks at it, and +//! each miner block it hands over is stored and may be scored. A peer that +//! publishes blocks no one can link (the 2026-10-18 testnet outage) could +//! fill the store and keep the scoring queue full. These limits are local: +//! they bound this node's work, and they do not change which chain wins. + +use std::collections::{HashMap, VecDeque}; +use std::sync::{Mutex, OnceLock}; +use std::time::{Duration, Instant}; + +/// Miner blocks one forwarding peer may hand this node per second, and the +/// burst it may send at once. A block is a minute-scale event; relays of +/// every miner's blocks fit well inside this. +const MINER_BLOCKS_PER_SEC: f64 = 1.0; +const MINER_BLOCK_BURST: f64 = 120.0; + +/// Blocks off every linked walk (parked) kept per authoring peer, and in +/// all. Past either, the oldest such block is dropped from the store; a +/// parent walk fetches it again if its chain turns out to link. +pub const PARKED_PER_AUTHOR: usize = 1024; +pub const PARKED_TOTAL: usize = 8192; + +/// How often one peer's unlinked blocks may start a sync with it. +pub const SYNC_COOLDOWN: Duration = Duration::from_secs(60); + +struct Bucket { + tokens: f64, + last: Instant, +} + +#[derive(Default)] +struct RateLimiter { + buckets: HashMap, +} + +impl RateLimiter { + fn allow(&mut self, peer: libp2p::PeerId, now: Instant) -> bool { + let bucket = self.buckets.entry(peer).or_insert(Bucket { + tokens: MINER_BLOCK_BURST, + last: now, + }); + let elapsed = now.saturating_duration_since(bucket.last).as_secs_f64(); + bucket.tokens = (bucket.tokens + elapsed * MINER_BLOCKS_PER_SEC).min(MINER_BLOCK_BURST); + bucket.last = now; + if bucket.tokens >= 1.0 { + bucket.tokens -= 1.0; + true + } else { + false + } + } +} + +fn rate_limiter() -> std::sync::MutexGuard<'static, RateLimiter> { + static LIMITER: OnceLock> = OnceLock::new(); + LIMITER + .get_or_init(Default::default) + .lock() + .unwrap_or_else(|poisoned| poisoned.into_inner()) +} + +/// True when the node should handle one more miner block forwarded by `peer`. +pub fn admit_miner_block(peer: libp2p::PeerId) -> bool { + rate_limiter().allow(peer, Instant::now()) +} + +/// Parked gossip blocks, oldest first, per author and in all. +#[derive(Default)] +pub struct ParkedLedger { + by_author: HashMap>, + all: VecDeque<(String, String)>, +} + +impl ParkedLedger { + /// Record a parked block. Returns the hashes past the caps, oldest first, + /// for the caller to drop if they are still parked. + pub fn record(&mut self, author: &str, hash: &str) -> Vec { + let mut evict = Vec::new(); + let queue = self.by_author.entry(author.to_string()).or_default(); + if queue.iter().any(|parked| parked == hash) { + return evict; + } + queue.push_back(hash.to_string()); + self.all.push_back((author.to_string(), hash.to_string())); + while queue.len() > PARKED_PER_AUTHOR { + if let Some(oldest) = queue.pop_front() { + self.all.retain(|(_, parked)| parked != &oldest); + evict.push(oldest); + } + } + while self.all.len() > PARKED_TOTAL { + if let Some((owner, oldest)) = self.all.pop_front() { + if let Some(queue) = self.by_author.get_mut(&owner) { + queue.retain(|parked| parked != &oldest); + } + evict.push(oldest); + } + } + evict + } +} + +pub fn parked_ledger() -> std::sync::MutexGuard<'static, ParkedLedger> { + static LEDGER: OnceLock> = OnceLock::new(); + LEDGER + .get_or_init(Default::default) + .lock() + .unwrap_or_else(|poisoned| poisoned.into_inner()) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn a_peer_past_its_burst_is_refused_until_it_refills() { + let mut limiter = RateLimiter::default(); + let peer = libp2p::PeerId::random(); + let start = Instant::now(); + let admitted = (0..200).filter(|_| limiter.allow(peer, start)).count(); + assert_eq!(admitted, MINER_BLOCK_BURST as usize); + assert!(limiter.allow(peer, start + Duration::from_secs(2))); + assert!(limiter.allow(libp2p::PeerId::random(), start), "other peers keep their own burst"); + } + + #[test] + fn the_ledger_evicts_an_authors_oldest_parked_block() { + let mut ledger = ParkedLedger::default(); + for n in 0..PARKED_PER_AUTHOR { + assert!(ledger.record("a", &format!("h{n}")).is_empty()); + } + assert_eq!(ledger.record("a", "newest"), vec!["h0".to_string()]); + assert!(ledger.record("b", "other").is_empty()); + } +} diff --git a/rust/modality-node/src/gossip/miner/block.rs b/rust/modality-node/src/gossip/miner/block.rs index 6739c542..8d4fa5b7 100644 --- a/rust/modality-node/src/gossip/miner/block.rs +++ b/rust/modality-node/src/gossip/miner/block.rs @@ -157,33 +157,8 @@ pub async fn handler( drop(mgr); - // Send sync request via channel if available - if let Some(ref tx) = sync_request_tx { - if let Some(peer_id) = source_peer { - let peer_addr = bootstrappers.iter() - .find(|addr| { - addr.iter().any(|proto| matches!(proto, libp2p::multiaddr::Protocol::P2p(id) if id == peer_id)) - }) - .map(|addr| addr.to_string()); - - if let Some(addr) = peer_addr { - let delay_ms = 100 + (rand::random::() % 400); - tokio::time::sleep(tokio::time::Duration::from_millis(delay_ms)).await; - - log::info!("📡 Orphan detected from peer {} - requesting chain sync (after {}ms delay)", peer_id, delay_ms); - if let Err(e) = tx.send((peer_id, addr)) { - log::warn!("Failed to send sync request: {}", e); - } - } else { - log::warn!( - "Could not find address for peer {} in bootstrappers", - peer_id - ); - } - } - } else { - log::debug!("Sync request channel not initialized yet"); - } + evict_past_parked_caps(&datastore_manager, source_peer, &miner_block.hash).await; + request_parents(sync_request_tx.as_ref(), source_peer, &bootstrappers).await; return Ok(()); } @@ -207,15 +182,13 @@ pub async fn handler( return Ok(()); } - let stored = MinerBlock::find_all_blocks_multi(&mgr).await?; - let params = crate::chain::fork_choice::RetargetParams { - blocks_per_epoch: mgr.epoch_config().blocks_per_epoch, - target_block_time_secs: mgr.network_u64("target_block_time_secs").unwrap_or(60), - initial_difficulty: mgr - .network_u64("initial_difficulty") - .map(|value| value as u128), - }; - if crate::chain::fork_choice::check_expected_target(&miner_block, &stored, params) + let params = crate::chain::tree_choice::retarget_params(&mgr); + if crate::chain::tree_choice::check_target_against_store( + &mgr, + &miner_block, + params, + crate::chain::tree_choice::Ancestors::Stored, + )? == crate::chain::fork_choice::TargetCheck::Reject { log::warn!( @@ -273,17 +246,34 @@ pub async fn handler( competing.is_canonical = false; competing.is_orphaned = false; competing.save_to_active(&mgr).await?; - log::info!( - "Stored block {} at index {} and scoring stored forks", - &miner_block.hash[..16.min(miner_block.hash.len())], - miner_block.index - ); - crate::chain::reorg::select_best_stored_chain(&mgr).await?; - crate::chain::reorg::adopt_connected_extensions(&mgr).await?; - MinerBlock::verified_spine(&MinerBlock::find_all_canonical_multi(&mgr).await?) - .into_iter() - .last() - .map(|block| block.index) + let params = crate::chain::tree_choice::retarget_params(&mgr); + let off_linked_walk = crate::chain::tree_choice::with_synced_tree(&mgr, params, |tree| { + tree.best().is_some() && tree.linked(&miner_block.hash).is_none() + })?; + let short_hash = &miner_block.hash[..16.min(miner_block.hash.len())]; + if off_linked_walk { + // A block whose walk does not reach index 0 changes no spine and + // no branch tip, so there is nothing to score until its parents + // arrive (fork-choice "score only after the walk connects"). A + // node with no linked walk at all still scores: its spine is the + // longest linked run. + log::info!( + "Stored block {short_hash} at index {} off any linked walk; not scoring", + miner_block.index + ); + drop(mgr); + evict_past_parked_caps(&datastore_manager, source_peer, &miner_block.hash).await; + request_parents(sync_request_tx.as_ref(), source_peer, &bootstrappers).await; + None + } else { + log::info!( + "Stored block {short_hash} at index {} and scoring stored forks", + miner_block.index + ); + crate::chain::reorg::select_best_stored_chain(&mgr).await?; + crate::chain::reorg::adopt_connected_extensions(&mgr).await?; + crate::chain::reorg::canonical_tip_index(&mgr).await? + } }; if let Some(tip) = current_tip { @@ -299,6 +289,81 @@ pub async fn handler( Ok(()) } +/// Ask the block's author for the parents this node is missing. +/// +/// A bootstrapper is reached by its configured address; any other author +/// by its peer id, since it just published to this node's mesh. Asking only +/// bootstrappers left a non-bootstrap miner's chain parked for good +/// (fork-choice "parent-hash sync", step 2). +async fn request_parents( + sync_request_tx: Option<&tokio::sync::mpsc::UnboundedSender<(libp2p::PeerId, String)>>, + source_peer: Option, + bootstrappers: &[libp2p::Multiaddr], +) { + let (Some(tx), Some(peer_id)) = (sync_request_tx, source_peer) else { + log::debug!("No sync channel or no block author; not requesting parents"); + return; + }; + let peer_addr = bootstrappers + .iter() + .find(|addr| { + addr.iter() + .any(|proto| matches!(proto, libp2p::multiaddr::Protocol::P2p(id) if id == peer_id)) + }) + .map(|addr| addr.to_string()) + .unwrap_or_else(|| format!("/p2p/{peer_id}")); + let delay_ms = 100 + (rand::random::() % 400); + tokio::time::sleep(tokio::time::Duration::from_millis(delay_ms)).await; + log::info!( + "📡 Unlinked block from peer {peer_id} - requesting chain sync (after {delay_ms}ms delay)" + ); + if let Err(e) = tx.send((peer_id, peer_addr)) { + log::warn!("Failed to send sync request: {}", e); + } +} + +/// Record a parked block against its author, and drop the oldest parked +/// blocks past the per-author and total caps if they are still off every +/// linked walk. +async fn evict_past_parked_caps( + datastore_manager: &Arc>, + source_peer: Option, + hash: &str, +) { + let author = source_peer + .map(|peer| peer.to_string()) + .unwrap_or_else(|| "unknown".to_string()); + let evict = crate::gossip::limits::parked_ledger().record(&author, hash); + if evict.is_empty() { + return; + } + let mgr = datastore_manager.lock().await; + let params = crate::chain::tree_choice::retarget_params(&mgr); + let Ok(still_parked) = crate::chain::tree_choice::with_synced_tree(&mgr, params, |tree| { + evict + .iter() + .filter(|hash| { + tree.linked(hash).is_none() + && tree.node(hash).is_some_and(|block| !block.is_canonical) + }) + .filter_map(|hash| tree.node(hash).map(|block| (**block).clone())) + .collect::>() + }) else { + return; + }; + for block in &still_parked { + if let Err(e) = block.delete_from_active(&mgr).await { + log::warn!("Failed to drop parked block {}: {e}", block.hash); + } + } + if !still_parked.is_empty() { + log::info!( + "Dropped {} parked block(s) from {author} past the parked-block caps", + still_parked.len() + ); + } +} + #[cfg(test)] mod tests { use super::*; diff --git a/rust/modality-node/src/gossip/mod.rs b/rust/modality-node/src/gossip/mod.rs index f67de024..0377ffb2 100644 --- a/rust/modality-node/src/gossip/mod.rs +++ b/rust/modality-node/src/gossip/mod.rs @@ -10,6 +10,7 @@ use modality_sequencer_consensus::communication::Message as ConsensusMessage; use crate::node::Node; pub mod consensus; +pub mod limits; pub mod miner; pub async fn add_sequencer_event_listeners(node: &mut Node) -> Result<()> { diff --git a/rust/modality-node/src/node/mod.rs b/rust/modality-node/src/node/mod.rs index 977b0318..397ec057 100644 --- a/rust/modality-node/src/node/mod.rs +++ b/rust/modality-node/src/node/mod.rs @@ -711,12 +711,20 @@ impl Node { }, SwarmEvent::Behaviour(swarm::NodeBehaviourEvent::Gossipsub( gossipsub::Event::Message { - propagation_source: _peer_id, + propagation_source, message_id: _message_id, message, }, )) => { log::info!("Gossip received {:?}", message.topic.to_string()); + if message.topic.as_str() == gossip::miner::block::TOPIC + && !gossip::limits::admit_miner_block(propagation_source) + { + log::warn!( + "Dropped a miner block from {propagation_source}: over its gossip rate" + ); + continue; + } // Handle off the networking task. A block handler scores // the store under the datastore lock, and while it ran // inline the swarm sent and received nothing. @@ -778,11 +786,17 @@ impl Node { role, ); - // Store in NodeState - let mgr = datastore_manager.lock().await; - if let Err(e) = peer_info.save_to(mgr.node_state()).await { - log::warn!("Failed to store peer info: {}", e); - } + // Store off the networking task. Identify arrives + // from every peer each minute, and waiting here for + // the datastore stopped the swarm for as long as a + // scoring pass held it. + let datastore_manager = datastore_manager.clone(); + tokio::spawn(async move { + let mgr = datastore_manager.lock().await; + if let Err(e) = peer_info.save_to(mgr.node_state()).await { + log::warn!("Failed to store peer info: {}", e); + } + }); } } SwarmEvent::Behaviour(event) => { diff --git a/rust/modality-node/src/status_server.rs b/rust/modality-node/src/status_server.rs index fd56e913..34868023 100644 --- a/rust/modality-node/src/status_server.rs +++ b/rust/modality-node/src/status_server.rs @@ -180,9 +180,15 @@ async fn contract_page( async fn status_json_handler( source: NodeStatusSource, ) -> Result { - let status = collect_node_status(&source) - .await - .map_err(|_| warp::reject::not_found())?; + let status = match collect_node_status(&source).await { + Ok(status) => status, + Err(e) => { + return Ok(cors_json_status( + StatusCode::SERVICE_UNAVAILABLE, + serde_json::json!({ "error": e.to_string() }), + )); + } + }; let genesis_hash = status .genesis .as_ref() @@ -219,6 +225,7 @@ async fn status_json_handler( "dest_apply_requires_cert": status.dest_apply_requires_cert, "predicate_theory_version": status.predicate_theory_version, "gas_base_permille": status.gas_base_permille, + "status_age_secs": status.snapshot_age_secs, "mod": { "address": status.mod_holdings.address, "held": status.mod_holdings.held, @@ -242,7 +249,7 @@ async fn status_json_handler( }) .collect::>(), }); - Ok(cors_json_reply(warp::reply::json(&body))) + Ok(cors_json_status(StatusCode::OK, body)) } async fn chain_json_handler(source: NodeStatusSource) -> Result { diff --git a/rust/modality-node/src/status_snapshot.rs b/rust/modality-node/src/status_snapshot.rs index eab6c98d..d8e561fb 100644 --- a/rust/modality-node/src/status_snapshot.rs +++ b/rust/modality-node/src/status_snapshot.rs @@ -97,6 +97,10 @@ pub struct NodeStatus { /// The base price, in parts per thousand of the network's gas price, this /// node's next block would state; `None` where gas is not priced. pub gas_base_permille: Option, + /// Seconds since this snapshot was taken. Status is served without + /// waiting on the node, so a large age means the node is not + /// releasing its datastore. + pub snapshot_age_secs: u64, } /// The MOD this node's id holds, and the mint sends to it not yet received. @@ -315,30 +319,98 @@ pub fn derive_active_roles( } /// A snapshot scans the whole miner chain under the datastore lock, which the -/// Shoal loop needs for every draft. Viewers polling status share one snapshot. -const STATUS_SNAPSHOT_TTL: Duration = Duration::from_secs(10); +/// Shoal loop needs for every draft. Viewers polling status share one +/// snapshot, retaken this often in the background. +const STATUS_REFRESH_INTERVAL: Duration = Duration::from_secs(5); + +/// How long a request waits for the first snapshot a node has ever taken. +/// After that, a request never waits on the datastore: it gets the last +/// snapshot and its age. +const STATUS_FIRST_SNAPSHOT_WAIT: Duration = Duration::from_secs(5); + +#[derive(Default)] +struct StatusSlot { + latest: Option<(Instant, NodeStatus)>, + refresher_running: bool, +} -type StatusCache = Mutex>; +type StatusCache = std::sync::Mutex>; type CommitteeCache = std::sync::Mutex>>; static STATUS_CACHE: OnceLock = OnceLock::new(); +static STATUS_REFRESHED: OnceLock = OnceLock::new(); static COMMITTEE_CACHE: OnceLock = OnceLock::new(); -/// Collect a status snapshot, reusing one taken in the last few seconds. +fn status_cache() -> std::sync::MutexGuard<'static, HashMap> { + STATUS_CACHE + .get_or_init(|| std::sync::Mutex::new(HashMap::new())) + .lock() + .unwrap_or_else(|poisoned| poisoned.into_inner()) +} + +fn status_refreshed() -> &'static tokio::sync::Notify { + STATUS_REFRESHED.get_or_init(tokio::sync::Notify::new) +} + +/// The last snapshot for `key`, aged to now, and whether the background +/// refresher still has to be started. +fn cached_status(key: &str) -> (Option, bool) { + let mut cache = status_cache(); + let slot = cache.entry(key.to_string()).or_default(); + let start_refresh = !slot.refresher_running; + slot.refresher_running = true; + let status = slot.latest.as_ref().map(|(taken, status)| { + let mut status = status.clone(); + status.snapshot_age_secs = taken.elapsed().as_secs(); + status + }); + (status, start_refresh) +} + +/// Retake the snapshot for `key` every `STATUS_REFRESH_INTERVAL`, for the +/// life of the process. One refresher runs per node. +fn spawn_status_refresh(source: &NodeStatusSource, key: String) { + let source = source.clone(); + tokio::spawn(async move { + loop { + match collect_node_status_uncached(&source).await { + Ok(status) => { + status_cache().entry(key.clone()).or_default().latest = + Some((Instant::now(), status)); + } + Err(e) => log::warn!("Status snapshot failed: {e}"), + } + status_refreshed().notify_waiters(); + tokio::time::sleep(STATUS_REFRESH_INTERVAL).await; + } + }); +} + +/// Collect a status snapshot without waiting on the node. +/// +/// The first request starts a background refresher that retakes the +/// snapshot every few seconds; every request gets the latest one with its +/// age in `snapshot_age_secs`. A node whose datastore is held for minutes +/// keeps answering, and the growing age is what shows it is wedged. Only +/// the first snapshot is waited for, and only for a few seconds. pub async fn collect_node_status(source: &NodeStatusSource) -> anyhow::Result { let key = source.peerid.to_string(); - let mut cache = STATUS_CACHE - .get_or_init(|| Mutex::new(HashMap::new())) - .lock() - .await; - if let Some((taken, status)) = cache.get(&key) { - if taken.elapsed() < STATUS_SNAPSHOT_TTL { - return Ok(status.clone()); + let deadline = tokio::time::Instant::now() + STATUS_FIRST_SNAPSHOT_WAIT; + loop { + let refreshed = status_refreshed().notified(); + tokio::pin!(refreshed); + refreshed.as_mut().enable(); + let (status, start_refresh) = cached_status(&key); + if start_refresh { + spawn_status_refresh(source, key.clone()); + } + if let Some(status) = status { + return Ok(status); + } + if tokio::time::timeout_at(deadline, refreshed).await.is_err() { + anyhow::bail!("no status snapshot yet; the node has not released its datastore"); } } - let status = collect_node_status_uncached(source).await?; - cache.insert(key, (Instant::now(), status.clone())); - Ok(status) } /// The N−2 committee for `epoch`. It is fixed once the epoch opens. @@ -545,6 +617,7 @@ async fn collect_node_status_uncached(source: &NodeStatusSource) -> anyhow::Resu last_cert_round_by_author, mod_holdings, gas_base_permille, + snapshot_age_secs: 0, }) } @@ -825,6 +898,7 @@ pub(crate) fn sample_status() -> NodeStatus { last_cert_round_by_author: vec![], mod_holdings: ModHoldings::default(), gas_base_permille: None, + snapshot_age_secs: 0, } } diff --git a/rust/modality-node/src/sync/parent_hash.rs b/rust/modality-node/src/sync/parent_hash.rs index f81c7dfa..8a5e5269 100644 --- a/rust/modality-node/src/sync/parent_hash.rs +++ b/rust/modality-node/src/sync/parent_hash.rs @@ -11,7 +11,7 @@ use std::sync::{Arc, Mutex as StdMutex, OnceLock}; use std::time::{Duration, Instant}; use tokio::sync::Mutex; -use crate::chain::fork_choice::{check_expected_target, RetargetParams, TargetCheck}; +use crate::chain::fork_choice::TargetCheck; use crate::chain::reorg::{ adopt_connected_extensions, missing_parent_hashes, select_best_stored_chain, }; @@ -369,24 +369,7 @@ async fn store_parent( score: bool, ) -> StoreParent { let ds = datastore.lock().await; - let stored = match MinerBlock::find_all_blocks_multi(&ds).await { - Ok(blocks) => blocks, - Err(e) => { - log::warn!("Could not load blocks to store parent {}: {e}", block.hash); - return StoreParent::Failed; - } - }; - let live: Vec = stored - .into_iter() - .filter(|block| !block.is_orphaned) - .collect(); - let params = RetargetParams { - blocks_per_epoch: ds.epoch_config().blocks_per_epoch, - target_block_time_secs: ds.network_u64("target_block_time_secs").unwrap_or(60), - initial_difficulty: ds - .network_u64("initial_difficulty") - .map(|value| value as u128), - }; + let params = crate::chain::tree_choice::retarget_params(&ds); if MinerBlock::find_by_hash_multi(&ds, &block.hash) .await .ok() @@ -395,7 +378,19 @@ async fn store_parent( { return StoreParent::AlreadyThere; } - if check_expected_target(block, &live, params) == TargetCheck::Reject { + let target = match crate::chain::tree_choice::check_target_against_store( + &ds, + block, + params, + crate::chain::tree_choice::Ancestors::Live, + ) { + Ok(target) => target, + Err(e) => { + log::warn!("Could not load blocks to store parent {}: {e}", block.hash); + return StoreParent::Failed; + } + }; + if target == TargetCheck::Reject { log::warn!( "Parent {} at index {} rejected: target is not the difficulty this chain expects", &block.hash[..16.min(block.hash.len())], From febed68b4e3938ec75caf9f38426736528da5b32 Mon Sep 17 00:00:00 2001 From: Foy Savas Date: Sun, 18 Oct 2026 15:08:08 -0400 Subject: [PATCH 2/4] feat: implement mined header verdict caching for efficiency - Introduced a caching mechanism for verdicts of `mined_header_holds`, utilizing a `OnceLock` and `Mutex` to store results and reduce redundant computations. - Added a limit to the cache size to prevent excessive memory usage, ensuring efficient management of verdicts during mint checks. - Refactored the `mined_header_holds` function to leverage the new caching logic, improving performance during header validation processes. - Updated the `retarget_params` and `with_synced_tree` functions to public visibility for broader access within the module. These changes enhance the performance of header validation by minimizing repeated calculations and optimizing resource usage. --- examples/multi-agent-smax/.gitignore | 2 + examples/multi-agent-smax/agents.py | 187 +++++++++++++++ examples/multi-agent-smax/battle.py | 214 ++++++++++++++++++ examples/multi-agent-smax/requirements.txt | 1 + .../ask-01d66c5781e500f888c55bb8.json | 5 + .../ask-033584840f50b1e23a45116d.json | 5 + .../ask-03dea57166153c8c7a1c02e8.json | 5 + .../ask-064b3275a719d756e6c66734.json | 5 + .../ask-0f2d051eaed276d20668c691.json | 5 + .../ask-128559c704ffe85a77f2434e.json | 5 + .../ask-138dee111d1c2c59440adb1d.json | 5 + .../ask-16130dacb5e93d4bfdc887d6.json | 5 + .../ask-19ee9fbec09c4bc102585ea2.json | 5 + .../ask-1a4cd1c3caa5bc2aa3b8895c.json | 5 + .../ask-1e2977df8701f166cbc31f92.json | 5 + .../ask-1ffc837c3d76e8d007a2692e.json | 5 + .../ask-220a4e14407a971a95fdef54.json | 5 + .../ask-223e170d63f5e4ddf98e96d7.json | 5 + .../ask-226d48af73fdd52e73a1b478.json | 5 + .../ask-23dc70245a90ca2bfab72172.json | 5 + .../ask-25e64c76b59eaea761751270.json | 5 + .../ask-2604d5023d9655410ea880ca.json | 5 + .../ask-2792cb9314cf4dd29b1520a9.json | 5 + .../ask-28c844ad852a25e2e6165f90.json | 5 + .../ask-2cf7d47e3093a64f18ecddd4.json | 5 + .../ask-2db9f2b170d6b7a10075716d.json | 5 + .../ask-2e28f18daa89db95ab73ff25.json | 5 + .../ask-32eb1c0003ea0b6697af18b9.json | 5 + .../ask-3339de2e52451a22bb968147.json | 5 + .../ask-337472a8c1c63db25d536c6c.json | 5 + .../ask-35960015f5ddcacb7c80d151.json | 5 + .../ask-35d42185f32d04ec8e7eac1c.json | 5 + .../ask-368293e1db1b36e848441631.json | 5 + .../ask-36d7fd978c1cc32e961732de.json | 5 + .../ask-37237750005264c69534ae90.json | 5 + .../ask-37e1d323fb5ada1879a24df8.json | 5 + .../ask-381df78894b5a558ba4d2f2f.json | 5 + .../ask-391a4fedbbdc2f5bc4477612.json | 5 + .../ask-3dd5270c0ea2bce80fd1fb16.json | 5 + .../ask-45fa3f809979aa1afcc3a623.json | 5 + .../ask-4614baf6f00a29be4f0a3415.json | 5 + .../ask-472e9a8b50304a28126974a4.json | 5 + .../ask-48f2b1785c24aaf8e0ff7a46.json | 5 + .../ask-49f9c5ee7db3bfb680b50bf1.json | 5 + .../ask-4ac242d625cafd1f2c2fc309.json | 5 + .../ask-4c5478a662dd00aa9d4a3e03.json | 5 + .../ask-5014d4b0675fc3a2148fdaee.json | 5 + .../ask-53ed59e5ffb966d4143cecd3.json | 5 + .../ask-546466e3e6006d31c216b380.json | 5 + .../ask-551741a861f562f58f729e3a.json | 5 + .../ask-5920d6926ec51b105048a059.json | 5 + .../ask-599d1ddfdd8f0e324db12f26.json | 5 + .../ask-5ab8770adfed2031e69b5b05.json | 5 + .../ask-5add4c23221a2edda6ff7b97.json | 5 + .../ask-5b4bc9b346e6ad06fa8ef4f0.json | 5 + .../ask-5c90373e0d0ad26b6173d228.json | 5 + .../ask-61610780f1a6051403036d64.json | 5 + .../ask-6330a35d72912b52aee26c43.json | 5 + .../ask-6696b9ac4f7f0e50ef075918.json | 5 + .../ask-68274bfd6f21a298a1495674.json | 5 + .../ask-6b67985c7fcf06c42a1add4b.json | 5 + .../ask-6eca7d7b590133da4cc57077.json | 5 + .../ask-70c5660af83dbb41d41d1dda.json | 5 + .../ask-70e515816b111db42a63a01d.json | 5 + .../ask-714431603cca0d61b3611321.json | 5 + .../ask-7148ad9da81a6699b62c860a.json | 5 + .../ask-721e9c7ac3766abb5924c964.json | 5 + .../ask-73d80ced022b9e8f29ff120d.json | 5 + .../ask-77b959195948970ee75706d5.json | 5 + .../ask-78392daefb45ff2a8ab5fbf0.json | 5 + .../ask-7a7a76a54e38dc423032c422.json | 5 + .../ask-7b1f645410969d44a81631b7.json | 5 + .../ask-7c21d829526079778555dbff.json | 5 + .../ask-7d806c984803f7c076625ccf.json | 5 + .../ask-81ca4a6bc40eb6ac43cda086.json | 5 + .../ask-83d70c538065496e0b553fc5.json | 5 + .../ask-89a19c33bfba8b96ef4c5264.json | 5 + .../ask-8a9dfc8ef97a5c05188780ed.json | 5 + .../ask-8e2a6ce4734f5ab31ff8201b.json | 5 + .../ask-8f328d937493e48ad8ac7986.json | 5 + .../ask-8fcaf100b1e39d8e99480e5a.json | 5 + .../ask-95d2a02ec1774de384045f04.json | 5 + .../ask-984d59e95ca7904204424198.json | 5 + .../ask-994acb01baf9f8a7d6a76bff.json | 5 + .../ask-9b8007d84a3a3e7ce72f10e8.json | 5 + .../ask-9b9d516a005b9ec88ba85142.json | 5 + .../ask-9c59525009d1ff4f6b932f32.json | 5 + .../ask-9cf485ace9e00a8aad8b2dc5.json | 5 + .../ask-9d829d4069e9e94421c817c9.json | 5 + .../ask-9ffc7a8485117180f5342a44.json | 5 + .../ask-a0547a87978cfbf7bda9286c.json | 5 + .../ask-a1388afa8175977123ca4943.json | 5 + .../ask-a13b76f401188cc42cc12108.json | 5 + .../ask-a18fbb66ff94280766b70a3c.json | 5 + .../ask-a64834217fbf0f665654c8b3.json | 5 + .../ask-a7fd827d54f21feaf25b992e.json | 5 + .../ask-ab4bf3fe2fc100c11f214495.json | 5 + .../ask-b210980082297735dd49a602.json | 5 + .../ask-b23986eec530787953462c2e.json | 5 + .../ask-b25f2702511b2c1bdb3833a1.json | 5 + .../ask-b5ef7ae741f66d4a8b31ad78.json | 5 + .../ask-b799d0e362b2879fbfd98336.json | 5 + .../ask-b985aedb2c9539243d9e9a22.json | 5 + .../ask-bb10817982d2dc1093aff16b.json | 5 + .../ask-c044aef0d20390b06f43d799.json | 5 + .../ask-c0757f5f1fe819d92a682aec.json | 5 + .../ask-c208c97f3e3638d730e506b4.json | 5 + .../ask-c306fa918ca95be55007b19d.json | 5 + .../ask-c4137c72e4f32c8a1bb1cab9.json | 5 + .../ask-c448fe9ceb41e8321f689bf7.json | 5 + .../ask-c453404863c5bac720735db3.json | 5 + .../ask-c5a41ff8a5b7ec66fa3b9fef.json | 5 + .../ask-caaac786bed9a0605231a4a8.json | 5 + .../ask-ccb797298531c8c924d0c9fb.json | 5 + .../ask-cdd8d44d00300e8188e6ae40.json | 5 + .../ask-cff31db073b3840be44391d8.json | 5 + .../ask-d46718bf55b552c6d9ed521b.json | 5 + .../ask-d59e9a35baeb72285e900dd0.json | 5 + .../ask-d5ddb70b3dfabba016d7dc56.json | 5 + .../ask-d65f153a05b134e9fcc22871.json | 5 + .../ask-dabc5de41b5052d4765d468f.json | 5 + .../ask-de53961d0a4c886ae397852e.json | 5 + .../ask-dfdd72d87686022c6ad5e198.json | 5 + .../ask-e01f5d39e7b100a7a50ec147.json | 5 + .../ask-e4e69036b1b7a923de998631.json | 5 + .../ask-e7630efde281d51501457442.json | 5 + .../ask-e7b5859be2887c0c925b5e4d.json | 5 + .../ask-ea4624cad8f01975311ad835.json | 5 + .../ask-ea70fde18aee65263787091d.json | 5 + .../ask-eb5da34bb6a723554d43768d.json | 5 + .../ask-eca4640265a157ad75751209.json | 5 + .../ask-ed3dc445ee44b95b35c8f10c.json | 5 + .../ask-f05e3a33245d4f7242d67d55.json | 5 + .../ask-f383a6d6f18835f47246307f.json | 5 + .../ask-f579759a985e3d258af6443e.json | 5 + .../ask-f6ebab0ccf2730bbc812df8d.json | 5 + .../ask-fcf4f02ccff34bd75787d721.json | 5 + examples/multi-agent-smax/smax_demo.py | 158 +++++++++++++ rust/modality-common/src/model_governance.rs | 32 +++ rust/modality-node/examples/replay_store.rs | 85 +++++++ rust/modality-node/src/chain/tree_choice.rs | 4 +- 141 files changed, 1346 insertions(+), 2 deletions(-) create mode 100644 examples/multi-agent-smax/.gitignore create mode 100644 examples/multi-agent-smax/agents.py create mode 100644 examples/multi-agent-smax/battle.py create mode 100644 examples/multi-agent-smax/requirements.txt create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-01d66c5781e500f888c55bb8.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-033584840f50b1e23a45116d.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-03dea57166153c8c7a1c02e8.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-064b3275a719d756e6c66734.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-0f2d051eaed276d20668c691.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-128559c704ffe85a77f2434e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-138dee111d1c2c59440adb1d.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-16130dacb5e93d4bfdc887d6.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-19ee9fbec09c4bc102585ea2.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-1a4cd1c3caa5bc2aa3b8895c.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-1e2977df8701f166cbc31f92.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-1ffc837c3d76e8d007a2692e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-220a4e14407a971a95fdef54.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-223e170d63f5e4ddf98e96d7.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-226d48af73fdd52e73a1b478.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-23dc70245a90ca2bfab72172.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-25e64c76b59eaea761751270.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-2604d5023d9655410ea880ca.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-2792cb9314cf4dd29b1520a9.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-28c844ad852a25e2e6165f90.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-2cf7d47e3093a64f18ecddd4.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-2db9f2b170d6b7a10075716d.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-2e28f18daa89db95ab73ff25.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-32eb1c0003ea0b6697af18b9.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-3339de2e52451a22bb968147.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-337472a8c1c63db25d536c6c.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-35960015f5ddcacb7c80d151.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-35d42185f32d04ec8e7eac1c.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-368293e1db1b36e848441631.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-36d7fd978c1cc32e961732de.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-37237750005264c69534ae90.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-37e1d323fb5ada1879a24df8.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-381df78894b5a558ba4d2f2f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-391a4fedbbdc2f5bc4477612.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-3dd5270c0ea2bce80fd1fb16.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-45fa3f809979aa1afcc3a623.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-4614baf6f00a29be4f0a3415.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-472e9a8b50304a28126974a4.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-48f2b1785c24aaf8e0ff7a46.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-49f9c5ee7db3bfb680b50bf1.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-4ac242d625cafd1f2c2fc309.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-4c5478a662dd00aa9d4a3e03.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-5014d4b0675fc3a2148fdaee.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-53ed59e5ffb966d4143cecd3.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-546466e3e6006d31c216b380.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-551741a861f562f58f729e3a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-5920d6926ec51b105048a059.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-599d1ddfdd8f0e324db12f26.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-5ab8770adfed2031e69b5b05.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-5add4c23221a2edda6ff7b97.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-5b4bc9b346e6ad06fa8ef4f0.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-5c90373e0d0ad26b6173d228.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-61610780f1a6051403036d64.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-6330a35d72912b52aee26c43.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-6696b9ac4f7f0e50ef075918.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-68274bfd6f21a298a1495674.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-6b67985c7fcf06c42a1add4b.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-6eca7d7b590133da4cc57077.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-70c5660af83dbb41d41d1dda.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-70e515816b111db42a63a01d.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-714431603cca0d61b3611321.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-7148ad9da81a6699b62c860a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-721e9c7ac3766abb5924c964.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-73d80ced022b9e8f29ff120d.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-77b959195948970ee75706d5.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-78392daefb45ff2a8ab5fbf0.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-7a7a76a54e38dc423032c422.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-7b1f645410969d44a81631b7.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-7c21d829526079778555dbff.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-7d806c984803f7c076625ccf.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-81ca4a6bc40eb6ac43cda086.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-83d70c538065496e0b553fc5.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-89a19c33bfba8b96ef4c5264.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-8a9dfc8ef97a5c05188780ed.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-8e2a6ce4734f5ab31ff8201b.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-8f328d937493e48ad8ac7986.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-8fcaf100b1e39d8e99480e5a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-95d2a02ec1774de384045f04.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-984d59e95ca7904204424198.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-994acb01baf9f8a7d6a76bff.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-9b8007d84a3a3e7ce72f10e8.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-9b9d516a005b9ec88ba85142.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-9c59525009d1ff4f6b932f32.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-9cf485ace9e00a8aad8b2dc5.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-9d829d4069e9e94421c817c9.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-9ffc7a8485117180f5342a44.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-a0547a87978cfbf7bda9286c.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-a1388afa8175977123ca4943.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-a13b76f401188cc42cc12108.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-a18fbb66ff94280766b70a3c.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-a64834217fbf0f665654c8b3.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-a7fd827d54f21feaf25b992e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ab4bf3fe2fc100c11f214495.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-b210980082297735dd49a602.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-b23986eec530787953462c2e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-b25f2702511b2c1bdb3833a1.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-b5ef7ae741f66d4a8b31ad78.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-b799d0e362b2879fbfd98336.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-b985aedb2c9539243d9e9a22.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-bb10817982d2dc1093aff16b.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-c044aef0d20390b06f43d799.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-c0757f5f1fe819d92a682aec.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-c208c97f3e3638d730e506b4.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-c306fa918ca95be55007b19d.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-c4137c72e4f32c8a1bb1cab9.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-c448fe9ceb41e8321f689bf7.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-c453404863c5bac720735db3.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-c5a41ff8a5b7ec66fa3b9fef.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-caaac786bed9a0605231a4a8.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ccb797298531c8c924d0c9fb.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-cdd8d44d00300e8188e6ae40.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-cff31db073b3840be44391d8.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-d46718bf55b552c6d9ed521b.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-d59e9a35baeb72285e900dd0.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-d5ddb70b3dfabba016d7dc56.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-d65f153a05b134e9fcc22871.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-dabc5de41b5052d4765d468f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-de53961d0a4c886ae397852e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-dfdd72d87686022c6ad5e198.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-e01f5d39e7b100a7a50ec147.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-e4e69036b1b7a923de998631.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-e7630efde281d51501457442.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-e7b5859be2887c0c925b5e4d.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ea4624cad8f01975311ad835.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ea70fde18aee65263787091d.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-eb5da34bb6a723554d43768d.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-eca4640265a157ad75751209.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ed3dc445ee44b95b35c8f10c.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-f05e3a33245d4f7242d67d55.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-f383a6d6f18835f47246307f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-f579759a985e3d258af6443e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-f6ebab0ccf2730bbc812df8d.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-fcf4f02ccff34bd75787d721.json create mode 100644 examples/multi-agent-smax/smax_demo.py create mode 100644 rust/modality-node/examples/replay_store.rs diff --git a/examples/multi-agent-smax/.gitignore b/examples/multi-agent-smax/.gitignore new file mode 100644 index 00000000..ea93687f --- /dev/null +++ b/examples/multi-agent-smax/.gitignore @@ -0,0 +1,2 @@ +out/ +__pycache__/ diff --git a/examples/multi-agent-smax/agents.py b/examples/multi-agent-smax/agents.py new file mode 100644 index 00000000..99ae7499 --- /dev/null +++ b/examples/multi-agent-smax/agents.py @@ -0,0 +1,187 @@ +"""Claude agents, one per unit, talking over team chat. + +Every half second each living unit's agent is asked for its own order. It +sees what its unit sees, its team's orders, and what its teammates said last +time, and may say one short thing back. Messages arrive on the next step. + +Every call goes through the Claude Code CLI and is cached on disk by its +prompt, so a rerun of the same battle asks nothing new. +""" + +import concurrent.futures +import hashlib +import json +import os +import pathlib +import re +import subprocess +import tempfile + +from battle import parse_order + +# Every answer comes from one pinned model, and the model is part of each +# cache key, so answers from another model are never reused. +CLAUDE_CLI = os.environ.get("CLAUDE_CLI", "claude") +LLM_MODEL = os.environ.get("LLM_MODEL", "claude-sonnet-5-5") + + +class LLM: + def __init__(self, cache_dir): + self.cache = pathlib.Path(cache_dir) + self.cache.mkdir(parents=True, exist_ok=True) + self.calls = 0 + + def ask(self, prompt): + key = hashlib.sha256(f"ask\n{LLM_MODEL}\n{prompt}".encode()).hexdigest()[:24] + path = self.cache / f"ask-{key}.json" + if path.exists(): + return json.loads(path.read_text())["response"] + with tempfile.TemporaryDirectory(prefix="smax-agent-") as empty: + error = "" + for _ in range(4): + try: + proc = subprocess.run( + [CLAUDE_CLI, "-p", "--output-format", "text", "--model", LLM_MODEL, "--tools", "", + "--strict-mcp-config", "--setting-sources", "", "--no-session-persistence", "--", prompt], + cwd=empty, capture_output=True, text=True, timeout=180, + ) + except subprocess.TimeoutExpired: + error = "timed out" + continue + if proc.returncode == 0 and proc.stdout.strip(): + break + error = proc.stderr.strip()[:500] + else: + raise RuntimeError(f"{CLAUDE_CLI} failed: {error}") + response = proc.stdout.strip() + self.calls += 1 + tmp = path.with_suffix(".tmp") + tmp.write_text(json.dumps({"model": LLM_MODEL, "input": prompt, "response": response}, indent=1)) + tmp.rename(path) + return response + + +def parse_json(text): + m = re.search(r"\{.*\}", text, re.S) + if not m: + return None + try: + return json.loads(m.group(0)) + except json.JSONDecodeError: + return None + + +BRIEF = """\ +You are one unit in a squad of {allies} fighting {enemies} enemy units on a 32 by 32 map (x grows east, y grows +north). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others +decide for themselves. You cannot see inside their heads; you only see their current orders and what they say +on team chat. Every half second of game time you give your unit one order: + + attack E shoot enemy E when it is in range, otherwise walk toward it + move walk to a point without shooting + hold stand still and shoot the closest enemy in range + retreat walk away from the closest enemy without shooting + +A unit dies at 0 health. The battle is won when every enemy is dead. +The enemy units each shoot the closest of you in range and keep shooting it until it dies.""" + +TURN = """\ +{brief} +{rules} +Time: {seconds:.1f} seconds into the battle. +{view} +{chat} +Reply with JSON only: {{"order": "", "say": ""}}""" + + +def chat_lines(messages): + if not messages: + return "Team chat: nothing said yet." + return "Team chat (most recent last):\n" + "\n".join(f" {m['from']} ({m['t']:.1f}s): {m['text']}" + for m in messages[-8:]) + + +def rules_text(rules): + if not rules: + return "" + return ("\nYour squad's RULES.md, written by your squad after earlier battles:\n" + + "\n".join(f" {i}. {r}" for i, r in enumerate(rules, 1)) + "\n") + + +class ChatTeam: + """Our side: one Claude agent per unit, coordinating over team chat. + + With `rules`, every prompt also shows the squad's RULES.md. Nothing checks + that an order follows them.""" + + def __init__(self, llm, rules=()): + self.llm = llm + self.rules = list(rules) + self.messages = [] + + def decide(self, battle): + brief = BRIEF.format(allies=battle.allies, enemies=battle.enemies) + alive = [u.name for u in battle.units()[: battle.allies] if u.alive] + seconds = battle.step_count * 0.5 + heard = list(self.messages) + rules = rules_text(self.rules) + prompts = {name: TURN.format(brief=brief, rules=rules, seconds=seconds, view=battle.view(name), + chat=chat_lines(heard)) + for name in alive} + with concurrent.futures.ThreadPoolExecutor(max_workers=len(prompts) or 1) as pool: + answers = dict(zip(prompts, pool.map(self.llm.ask, prompts.values()))) + decisions = {} + for name in sorted(answers): + reply = parse_json(answers[name]) or {} + order = parse_order(str(reply.get("order", ""))) + said = str(reply.get("say", "") or "").strip()[:120] + decisions[name] = {"order": order or battle.orders[name], "raw": reply.get("order"), + "valid": order is not None, "say": said} + if order: + battle.orders[name] = order + if said: + self.messages.append({"from": name, "t": seconds, "text": said}) + return decisions + + +RETRO = """\ +{brief} + +Your squad just fought a battle on map {scenario} and {outcome}. Here is how it went, one line per half second: +our units' orders and health, the enemies' health, and what was said on team chat. + +{log} + +{rules_now} +Write ONE new rule for your squad's RULES.md that would have helped you win this battle. Every unit in your +squad will read RULES.md before every order in later battles. Make it a concrete rule about what a unit should +do, in one sentence, and do not repeat a rule already there. +Reply with JSON only: {{"rule": ""}}""" + + +def battle_log(record): + allies = sum(1 for u in record["frames"][0]["units"] if u["name"].startswith("A")) + lines = [] + for f in record["frames"]: + ours = " ".join(f"{u['name']} {f['orders'].get(u['name'], '-')} ({u['health']:.0f}hp)" if u["alive"] + else f"{u['name']} dead" for u in f["units"][:allies]) + theirs = " ".join(f"{u['name']} {u['health']:.0f}hp" if u["alive"] else f"{u['name']} dead" + for u in f["units"][allies:]) + lines.append(f"{f['step'] * 0.5:4.1f}s {ours} | {theirs}") + for name, d in sorted(f.get("decisions", {}).items()): + if d.get("say"): + lines.append(f" {name} said: {d['say']}") + return "\n".join(lines) + + +def write_rule(llm, record, rules): + allies = sum(1 for u in record["frames"][0]["units"] if u["name"].startswith("A")) + enemies = len(record["frames"][0]["units"]) - allies + rules_now = ("RULES.md now:\n" + "\n".join(f" {i}. {r}" for i, r in enumerate(rules, 1)) + if rules else "RULES.md is empty.") + prompt = RETRO.format(brief=BRIEF.format(allies=allies, enemies=enemies), scenario=record["scenario"], + outcome="lost" if record["outcome"] == "lost" else "did not win", + log=battle_log(record), rules_now=rules_now) + reply = parse_json(llm.ask(prompt)) or {} + rule = str(reply.get("rule", "")).strip() + return rule or None diff --git a/examples/multi-agent-smax/battle.py b/examples/multi-agent-smax/battle.py new file mode 100644 index 00000000..af40d4be --- /dev/null +++ b/examples/multi-agent-smax/battle.py @@ -0,0 +1,214 @@ +"""A SMAX battle where every unit takes orders, and a small controller plays them. + +SMAX (JaxMARL) is an open-source rewrite of the StarCraft Multi-Agent +Challenge: two small armies on a 32 by 32 map, one environment step every +half second of game time. Each unit is its own agent. An agent does not pick +raw actions; it gives its unit an order, and `act` turns the order into the +unit's action on every step until the next order: + + attack E2 shoot enemy E2 when in range, otherwise close in on it + move 12 18 walk to a point, without shooting + hold stand still and shoot the closest enemy in range + retreat walk away from the closest enemy, without shooting + +The other side is SMAX's own heuristic: each unit shoots the closest enemy in +range and keeps shooting it until it dies, and otherwise walks at the enemy. +""" + +import dataclasses +import math +import re + +import jax +import jax.numpy as jnp +import numpy as np +from jaxmarl.environments.smax import SMAX, map_name_to_scenario +from jaxmarl.environments.smax.heuristic_enemy import ( + create_heuristic_policy, + get_heuristic_policy_initial_state, +) + +NORTH, EAST, SOUTH, WEST, STOP = range(5) +MOVES = 5 +STEP_SECONDS = 0.5 # 8 world steps of 1/16 s + + +@dataclasses.dataclass +class Unit: + name: str # A0.. for our side, E0.. for theirs + kind: str + x: float + y: float + health: float + max_health: float + alive: bool + attack_range: float + sight_range: float + cooldown: float + + +ORDER = re.compile(r"^\s*(attack\s+E\d+|move\s+-?\d+(\.\d+)?\s*,?\s+-?\d+(\.\d+)?|hold|retreat)\s*$", re.I) + + +def parse_order(text): + """An order in canonical form, or None.""" + if not text or not ORDER.match(text): + return None + words = text.replace(",", " ").split() + head = words[0].lower() + if head == "attack": + return f"attack {words[1].upper()}" + if head == "move": + return f"move {float(words[1]):g} {float(words[2]):g}" + return head + + +class Battle: + """One battle: our units (team 0) under orders, theirs under the heuristic.""" + + def __init__(self, scenario="3m", seed=0, max_steps=100): + self.env = SMAX(scenario=map_name_to_scenario(scenario), max_steps=max_steps) + self.scenario = scenario + self.key = jax.random.PRNGKey(seed) + self.key, k = jax.random.split(self.key) + _, self.state = self.env.reset(k) + self.allies = self.env.num_allies + self.enemies = self.env.num_enemies + self.enemy_agents = [f"enemy_{i}" for i in range(self.enemies)] + policy = create_heuristic_policy(self.env, 1, shoot=True, attack_mode="closest") + self._enemy_policy = jax.jit(jax.vmap(policy)) + self._enemy_state = jax.vmap(lambda _: get_heuristic_policy_initial_state())(jnp.arange(self.enemies)) + self.orders = {f"A{i}": "hold" for i in range(self.allies)} + self.step_count = 0 + + # The board, in plain numbers. + + def units(self): + s = self.state + pos = np.asarray(s.unit_positions) + health = np.asarray(s.unit_health) + alive = np.asarray(s.unit_alive) + types = np.asarray(s.unit_types) + cool = np.asarray(s.unit_weapon_cooldowns) + out = [] + for i in range(self.allies + self.enemies): + t = int(types[i]) + name = f"A{i}" if i < self.allies else f"E{i - self.allies}" + out.append(Unit(name, self.env.unit_type_names[t], float(pos[i, 0]), float(pos[i, 1]), + float(health[i]), float(self.env.unit_type_health[t]), bool(alive[i]), + float(self.env.unit_type_attack_ranges[t]), + float(self.env.unit_type_sight_ranges[t]), float(cool[i]))) + return out + + @property + def done(self): + return bool(self.state.done) + + def outcome(self): + us = self.units() + ours = sum(u.alive for u in us[: self.allies]) + theirs = sum(u.alive for u in us[self.allies:]) + if theirs == 0 and ours > 0: + return "won" + if ours == 0 and theirs > 0: + return "lost" + return "draw" + + # From orders to actions. + + def act(self, unit, order, units): + if not unit.alive: + return STOP + enemies = [u for u in units[self.allies:] if u.alive] + def dist(u): + return math.hypot(u.x - unit.x, u.y - unit.y) + in_range = [u for u in enemies if dist(u) < unit.attack_range] + def shoot(u): + return MOVES + int(u.name[1:]) + if order.startswith("attack"): + target = next((u for u in enemies if u.name == order.split()[1]), None) + if target is None: # dead: hold instead + return shoot(min(in_range, key=dist)) if in_range else STOP + if dist(target) < unit.attack_range: + return shoot(target) + return toward(unit, target.x, target.y) + if order.startswith("move"): + _, x, y = order.split() + x, y = float(x), float(y) + if math.hypot(x - unit.x, y - unit.y) < 0.5: + return STOP + return toward(unit, x, y) + if order == "retreat": + if not enemies: + return STOP + near = min(enemies, key=dist) + return toward(unit, 2 * unit.x - near.x, 2 * unit.y - near.y) + return shoot(min(in_range, key=dist)) if in_range else STOP # hold + + def step(self): + """One environment step (half a second) under the current orders.""" + units = self.units() + actions = {f"ally_{i}": jnp.int32(self.act(units[i], self.orders[f"A{i}"], units)) + for i in range(self.allies)} + obs = self.env.get_obs_unit_list(self.state) + enemy_obs = jnp.stack([obs[a] for a in self.enemy_agents]) + self.key, k_enemy, k_step = jax.random.split(self.key, 3) + enemy_actions, self._enemy_state = self._enemy_policy( + jax.random.split(k_enemy, self.enemies), self._enemy_state, enemy_obs) + for i, a in enumerate(self.enemy_agents): + actions[a] = enemy_actions[i] + _, self.state, _, _, _ = self.env.step_env(k_step, self.state, actions) + self.step_count += 1 + return units + + # What a unit sees. + + def view(self, name): + units = self.units() + me = next(u for u in units if u.name == name) + def seen(u): + return u.alive and math.hypot(u.x - me.x, u.y - me.y) <= me.sight_range + lines = [f"You are {me.name}, a {me.kind} at ({me.x:.1f}, {me.y:.1f}) with " + f"{me.health:.0f}/{me.max_health:.0f} health; you shoot up to {me.attack_range:g} away " + f"and see up to {me.sight_range:g} away. Your order now: {self.orders[name]}."] + lines.append("Your team:") + for u in units[: self.allies]: + if u.name == name: + continue + if not u.alive: + lines.append(f" {u.name}: dead") + else: + lines.append(f" {u.name} {u.kind} at ({u.x:.1f}, {u.y:.1f}), {u.health:.0f}/{u.max_health:.0f} " + f"health, order: {self.orders[u.name]}") + enemies = [u for u in units[self.allies:] if seen(u)] + if enemies: + lines.append("Enemies you can see:") + for u in enemies: + d = math.hypot(u.x - me.x, u.y - me.y) + lines.append(f" {u.name} {u.kind} at ({u.x:.1f}, {u.y:.1f}), {u.health:.0f}/{u.max_health:.0f} " + f"health, {d:.1f} away{' (in range)' if d < me.attack_range else ''}") + else: + lines.append("You see no enemies.") + lost = sum(not u.alive for u in units[self.allies:]) + if lost: + lines.append(f"Enemies killed so far: {lost} of {self.enemies}.") + return "\n".join(lines) + + def frame(self): + """The board for a replay.""" + return { + "step": self.step_count, + "units": [{"name": u.name, "kind": u.kind, "x": round(u.x, 2), "y": round(u.y, 2), + "health": round(u.health, 1), "max": u.max_health, "alive": u.alive} + for u in self.units()], + "orders": dict(self.orders), + } + + +def toward(unit, x, y): + dx, dy = x - unit.x, y - unit.y + if abs(dx) < 1e-6 and abs(dy) < 1e-6: + return STOP + if abs(dx) >= abs(dy): + return EAST if dx > 0 else WEST + return NORTH if dy > 0 else SOUTH diff --git a/examples/multi-agent-smax/requirements.txt b/examples/multi-agent-smax/requirements.txt new file mode 100644 index 00000000..a6f9bf14 --- /dev/null +++ b/examples/multi-agent-smax/requirements.txt @@ -0,0 +1 @@ +jaxmarl==0.2.0 diff --git a/examples/multi-agent-smax/results/llm-cache/ask-01d66c5781e500f888c55bb8.json b/examples/multi-agent-smax/results/llm-cache/ask-01d66c5781e500f888c55bb8.json new file mode 100644 index 00000000..0751752d --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-01d66c5781e500f888c55bb8.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.0 seconds into the battle.\nYou are A0, a marine at (7.2, 15.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (6.5, 16.0), 45/45 health, order: hold\n A2 marine at (7.1, 16.5), 45/45 health, order: move 7 16.5\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.5s): A1 holding; will focus closest enemy when seen.\n A2 (0.5s): A2 holding at (7,18); stay grouped, focus closest enemy when seen.\n A0 (1.0s): A0 holding; will focus closest enemy when it appears.\n A1 (1.0s): A1 holding; will shoot closest enemy when seen, stay grouped.\n A2 (1.0s): A2 holding at (7,18); I'm slightly north, staying close to group.\n A0 (1.5s): A0 holding; no enemies yet. Focus closest when they appear.\n A1 (1.5s): A1 holding; no enemies yet. Focus closest when they appear.\n A2 (1.5s): A2 moving south to tighten up with the group; focus closest enemy.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A0 holding; no enemies seen. Focus closest when they appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-033584840f50b1e23a45116d.json b/examples/multi-agent-smax/results/llm-cache/ask-033584840f50b1e23a45116d.json new file mode 100644 index 00000000..4c1f60ab --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-033584840f50b1e23a45116d.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.0 seconds into the battle.\nYou are A2, a marine at (8.4, 16.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.5, 18.0), 45/45 health, order: hold\n A1 marine at (8.6, 17.2), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding together; focus fire on the first enemy that enters range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-03dea57166153c8c7a1c02e8.json b/examples/multi-agent-smax/results/llm-cache/ask-03dea57166153c8c7a1c02e8.json new file mode 100644 index 00000000..296dac46 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-03dea57166153c8c7a1c02e8.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.0 seconds into the battle.\nYou are A2, a marine at (8.3, 17.3) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.9, 15.6), 45/45 health, order: hold\n A1 marine at (6.7, 14.2), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together; stay grouped and focus fire on the first enemy that appears.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together near (7,16); focus fire on whoever appears first.\n A0 (0.5s): No enemies yet; holding grouped. Focus fire on the closest when they appear.\n A1 (0.5s): A1 holding at (6.7,14.2); will focus the closest enemy that appears.\n A2 (0.5s): A2 holding at (8,17); shoot closest enemy together, stay grouped.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 7.5 16\", \"say\": \"Tightening up near (7.5,16); A2 holding formation, focus closest.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-064b3275a719d756e6c66734.json b/examples/multi-agent-smax/results/llm-cache/ask-064b3275a719d756e6c66734.json new file mode 100644 index 00000000..290c8ced --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-064b3275a719d756e6c66734.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.0 seconds into the battle.\nYou are A2, a marine at (7.8, 14.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.4, 15.4), 45/45 health, order: hold\n A1 marine at (8.6, 14.6), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding together as a group; focus fire on the closest enemy when they appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-0f2d051eaed276d20668c691.json b/examples/multi-agent-smax/results/llm-cache/ask-0f2d051eaed276d20668c691.json new file mode 100644 index 00000000..14d3487c --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-0f2d051eaed276d20668c691.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.0 seconds into the battle.\nYou are A2, a marine at (7.1, 16.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 7 16.5.\nYour team:\n A0 marine at (7.2, 15.7), 45/45 health, order: hold\n A1 marine at (6.5, 16.0), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.5s): A1 holding; will focus closest enemy when seen.\n A2 (0.5s): A2 holding at (7,18); stay grouped, focus closest enemy when seen.\n A0 (1.0s): A0 holding; will focus closest enemy when it appears.\n A1 (1.0s): A1 holding; will shoot closest enemy when seen, stay grouped.\n A2 (1.0s): A2 holding at (7,18); I'm slightly north, staying close to group.\n A0 (1.5s): A0 holding; no enemies yet. Focus closest when they appear.\n A1 (1.5s): A1 holding; no enemies yet. Focus closest when they appear.\n A2 (1.5s): A2 moving south to tighten up with the group; focus closest enemy.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A2 holding at (7,16.5), grouped with team; focus closest enemy.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-128559c704ffe85a77f2434e.json b/examples/multi-agent-smax/results/llm-cache/ask-128559c704ffe85a77f2434e.json new file mode 100644 index 00000000..4980df10 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-128559c704ffe85a77f2434e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.5 seconds into the battle.\nYou are A2, a marine at (9.9, 15.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (10.3, 16.5), 36/45 health, order: attack E0\n A1 marine at (10.1, 17.3), 45/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (14.6, 16.4), 18/45 health, 4.7 away (in range)\n E1 marine at (13.8, 17.3), 45/45 health, 4.2 away (in range)\n E2 marine at (14.4, 14.8), 45/45 health, 4.6 away (in range)\nTeam chat (most recent last):\n A1 (2.0s): Enemies E0,E1 east ~8 away. Hold together, focus E0 when in range.\n A2 (2.0s): Holding here as a group; everyone focus fire on closest enemy, E0 first.\n A0 (2.5s): Holding. Enemies close in; all focus E0 when it enters range 5.\n A1 (2.5s): Holding; enemies at 6+ range. Focus E0 when it enters range 5.\n A2 (2.5s): A2 holding; let them come into range, focus E0 together.\n A0 (3.0s): E0 in range, all focus fire E0 now.\n A1 (3.0s): E0 in range, attacking E0 now. Everyone focus E0.\n A2 (3.0s): Attacking E0 now, E0 in range. Everyone focus fire E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 at 18hp, keep focusing E0, then E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-138dee111d1c2c59440adb1d.json b/examples/multi-agent-smax/results/llm-cache/ask-138dee111d1c2c59440adb1d.json new file mode 100644 index 00000000..fd1964da --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-138dee111d1c2c59440adb1d.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.5 seconds into the battle.\nYou are A0, a marine at (8.9, 14.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1: dead\n A2 marine at (8.9, 14.0), 45/45 health, order: attack E1\nEnemies you can see:\n E0 marine at (12.4, 17.2), 45/45 health, 4.2 away (in range)\n E1 marine at (13.3, 14.8), 9/45 health, 4.3 away (in range)\n E2 marine at (11.6, 17.6), 45/45 health, 3.9 away (in range)\nTeam chat (most recent last):\n A1 (3.0s): E1 in range at 4.5. All focus fire E1 now.\n A2 (3.0s): A2 holding. Focus E1 when it enters range 5; fire together.\n A0 (3.5s): Attacking E1 (36hp), closing to range. Focus E1 together.\n A1 (3.5s): Firing E1 (36hp). A0, A2 attack E1 too; E1 is 4.5 from me, others closing.\n A2 (3.5s): A2 attacking E1 now, focus fire together.\n A0 (4.0s): Firing E1 (27hp). Keep focus, A1 is hurt, stay behind us.\n A1 (4.0s): E1 at 27hp, finish it. I'm low at 18hp, so cover me.\n A2 (4.0s): Firing E1 (27hp), keep focus until dead.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E1 at 9hp, finishing it. Then focus E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-16130dacb5e93d4bfdc887d6.json b/examples/multi-agent-smax/results/llm-cache/ask-16130dacb5e93d4bfdc887d6.json new file mode 100644 index 00000000..8469c448 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-16130dacb5e93d4bfdc887d6.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.0 seconds into the battle.\nYou are A0, a marine at (6.9, 15.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (6.7, 14.2), 45/45 health, order: hold\n A2 marine at (8.3, 17.3), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together; stay grouped and focus fire on the first enemy that appears.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together near (7,16); focus fire on whoever appears first.\n A0 (0.5s): No enemies yet; holding grouped. Focus fire on the closest when they appear.\n A1 (0.5s): A1 holding at (6.7,14.2); will focus the closest enemy that appears.\n A2 (0.5s): A2 holding at (8,17); shoot closest enemy together, stay grouped.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A0 holding; will focus closest enemy when it appears.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-19ee9fbec09c4bc102585ea2.json b/examples/multi-agent-smax/results/llm-cache/ask-19ee9fbec09c4bc102585ea2.json new file mode 100644 index 00000000..ede1815b --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-19ee9fbec09c4bc102585ea2.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.0 seconds into the battle.\nYou are A2, a marine at (9.9, 15.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (10.3, 16.5), 45/45 health, order: hold\n A1 marine at (10.1, 17.3), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (14.6, 16.4), 45/45 health, 4.7 away (in range)\n E1 marine at (15.4, 17.3), 45/45 health, 5.7 away\n E2 marine at (16.0, 14.8), 45/45 health, 6.1 away\nTeam chat (most recent last):\n A1 (1.5s): A1 advancing east to stay with A0; keep grouped, focus closest.\n A2 (1.5s): Moving east to join A0; stay grouped, focus closest enemy.\n A0 (2.0s): Holding here, grouped. Focus fire on E0 (closest) when in range.\n A1 (2.0s): Enemies E0,E1 east ~8 away. Hold together, focus E0 when in range.\n A2 (2.0s): Holding here as a group; everyone focus fire on closest enemy, E0 first.\n A0 (2.5s): Holding. Enemies close in; all focus E0 when it enters range 5.\n A1 (2.5s): Holding; enemies at 6+ range. Focus E0 when it enters range 5.\n A2 (2.5s): A2 holding; let them come into range, focus E0 together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Attacking E0 now, E0 in range. Everyone focus fire E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-1a4cd1c3caa5bc2aa3b8895c.json b/examples/multi-agent-smax/results/llm-cache/ask-1a4cd1c3caa5bc2aa3b8895c.json new file mode 100644 index 00000000..2a27499a --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-1a4cd1c3caa5bc2aa3b8895c.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.5 seconds into the battle.\nYou are A1, a marine at (8.3, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.1, 15.8), 45/45 health, order: move 8 15.5\n A2 marine at (6.5, 14.9), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Regrouping with you both at (8,15); hold together, focus fire once enemies appear.\n A1 (0.0s): Holding together; no enemies seen. Stay grouped, focus fire on the closest.\n A2 (0.0s): Holding together as a group; focus fire on the closest enemy once seen.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding at (8,14); will focus fire closest enemy when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-1e2977df8701f166cbc31f92.json b/examples/multi-agent-smax/results/llm-cache/ask-1e2977df8701f166cbc31f92.json new file mode 100644 index 00000000..50b9f888 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-1e2977df8701f166cbc31f92.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.0 seconds into the battle.\nYou are A1, a marine at (8.6, 17.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.5, 18.0), 45/45 health, order: hold\n A2 marine at (8.4, 16.0), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): No enemies seen. Holding together; focus fire on the closest enemy once spotted.\n A1 (0.0s): Holding together as a group; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on the first enemy that enters range.\n A0 (0.5s): Still no enemies. Holding; will focus fire on first one in range.\n A1 (0.5s): A1 holding; will focus fire on closest enemy when spotted.\n A2 (0.5s): Holding; will focus fire on the closest enemy once in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A1 holding; no enemies yet. Focus fire on closest when spotted.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-1ffc837c3d76e8d007a2692e.json b/examples/multi-agent-smax/results/llm-cache/ask-1ffc837c3d76e8d007a2692e.json new file mode 100644 index 00000000..e8d0b871 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-1ffc837c3d76e8d007a2692e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.5 seconds into the battle.\nYou are A0, a marine at (7.2, 15.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (6.5, 16.0), 45/45 health, order: hold\n A2 marine at (7.1, 16.5), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (1.0s): A1 holding; will shoot closest enemy when seen, stay grouped.\n A2 (1.0s): A2 holding at (7,18); I'm slightly north, staying close to group.\n A0 (1.5s): A0 holding; no enemies yet. Focus closest when they appear.\n A1 (1.5s): A1 holding; no enemies yet. Focus closest when they appear.\n A2 (1.5s): A2 moving south to tighten up with the group; focus closest enemy.\n A0 (2.0s): A0 holding; no enemies seen. Focus closest when they appear.\n A1 (2.0s): A1 holding; no enemies visible. Focus closest when they appear.\n A2 (2.0s): A2 holding at (7,16.5), grouped with team; focus closest enemy.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A0 holding; waiting for enemies to come into range, focus closest.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-220a4e14407a971a95fdef54.json b/examples/multi-agent-smax/results/llm-cache/ask-220a4e14407a971a95fdef54.json new file mode 100644 index 00000000..e69cc609 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-220a4e14407a971a95fdef54.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.5 seconds into the battle.\nYou are A0, a marine at (8.1, 15.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 8 15.5.\nYour team:\n A1 marine at (8.3, 14.1), 45/45 health, order: hold\n A2 marine at (6.5, 14.9), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Regrouping with you both at (8,15); hold together, focus fire once enemies appear.\n A1 (0.0s): Holding together; no enemies seen. Stay grouped, focus fire on the closest.\n A2 (0.0s): Holding together as a group; focus fire on the closest enemy once seen.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding at (8,15); focus fire on closest enemy when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-223e170d63f5e4ddf98e96d7.json b/examples/multi-agent-smax/results/llm-cache/ask-223e170d63f5e4ddf98e96d7.json new file mode 100644 index 00000000..0c66aa6e --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-223e170d63f5e4ddf98e96d7.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.0 seconds into the battle.\nYou are A2, a marine at (8.3, 15.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.9, 15.6), 45/45 health, order: hold\n A1 marine at (6.7, 14.2), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (16.8, 16.8), 45/45 health, 8.5 away\nTeam chat (most recent last):\n A1 (0.5s): A1 holding at (6.7,14.2); will focus the closest enemy that appears.\n A2 (0.5s): A2 holding at (8,17); shoot closest enemy together, stay grouped.\n A0 (1.0s): A0 holding; will focus closest enemy when it appears.\n A1 (1.0s): A1 holding; will focus fire on the closest enemy when seen.\n A2 (1.0s): Tightening up near (7.5,16); A2 holding formation, focus closest.\n A0 (1.5s): A0 holding; no enemies visible, will focus closest when seen.\n A1 (1.5s): A1 holding; will focus fire on the first enemy in range.\n A2 (1.5s): A2 holding at (8.3,15.7); will focus closest enemy with team.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"E0 at (16.8,16.8) approaching; hold and focus it when in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-226d48af73fdd52e73a1b478.json b/examples/multi-agent-smax/results/llm-cache/ask-226d48af73fdd52e73a1b478.json new file mode 100644 index 00000000..9ef9714d --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-226d48af73fdd52e73a1b478.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.5 seconds into the battle.\nYou are A2, a marine at (8.4, 16.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (10.1, 18.0), 45/45 health, order: move 12 17\n A1 marine at (8.6, 17.2), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.0s): Holding together as a group; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on the first enemy that enters range.\n A0 (0.5s): Still no enemies. Holding; will focus fire on first one in range.\n A1 (0.5s): A1 holding; will focus fire on closest enemy when spotted.\n A2 (0.5s): Holding; will focus fire on the closest enemy once in range.\n A0 (1.0s): Advancing east slowly to find enemies; stay close, focus fire on closest.\n A1 (1.0s): A1 holding; no enemies yet. Focus fire on closest when spotted.\n A2 (1.0s): A2 holding; still no enemies. Will focus fire on closest once in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 11 17\", \"say\": \"Moving east to join A0; stay grouped, focus closest enemy.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-23dc70245a90ca2bfab72172.json b/examples/multi-agent-smax/results/llm-cache/ask-23dc70245a90ca2bfab72172.json new file mode 100644 index 00000000..6e32b3b5 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-23dc70245a90ca2bfab72172.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.0 seconds into the battle.\nYou are A1, a marine at (6.7, 14.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.9, 15.6), 45/45 health, order: hold\n A2 marine at (8.3, 17.3), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding together; focus fire on the closest enemy when they appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-25e64c76b59eaea761751270.json b/examples/multi-agent-smax/results/llm-cache/ask-25e64c76b59eaea761751270.json new file mode 100644 index 00000000..2e6429be --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-25e64c76b59eaea761751270.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.5 seconds into the battle.\nYou are A2, a marine at (7.1, 16.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.2, 15.7), 45/45 health, order: hold\n A1 marine at (6.5, 16.0), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (13.9, 17.7), 45/45 health, 6.9 away\n E1 marine at (14.7, 16.0), 45/45 health, 7.7 away\n E2 marine at (13.4, 14.7), 45/45 health, 6.6 away\nTeam chat (most recent last):\n A1 (2.0s): A1 holding; no enemies visible. Focus closest when they appear.\n A2 (2.0s): A2 holding at (7,16.5), grouped with team; focus closest enemy.\n A0 (2.5s): A0 holding; waiting for enemies to come into range, focus closest.\n A1 (2.5s): A1 holding in formation; all focus fire on closest enemy when seen.\n A2 (2.5s): A2 holding; will focus closest enemy when seen.\n A0 (3.0s): Enemies approaching at ~8 range; hold together, fire on closest when in range.\n A1 (3.0s): A1 holding; E2 seen east at 8.6. Let them come into range, focus closest.\n A2 (3.0s): A2 holding; enemies at 8 range, let them come in, focus closest.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A2 holding; enemies closing, fire on closest E2 when in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-2604d5023d9655410ea880ca.json b/examples/multi-agent-smax/results/llm-cache/ask-2604d5023d9655410ea880ca.json new file mode 100644 index 00000000..7599062f --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-2604d5023d9655410ea880ca.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.0 seconds into the battle.\nYou are A2, a marine at (8.3, 17.3) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.9, 15.6), 45/45 health, order: hold\n A1 marine at (6.7, 14.2), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding together near (7,16); focus fire on whoever appears first.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-2792cb9314cf4dd29b1520a9.json b/examples/multi-agent-smax/results/llm-cache/ask-2792cb9314cf4dd29b1520a9.json new file mode 100644 index 00000000..b261cb62 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-2792cb9314cf4dd29b1520a9.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.5 seconds into the battle.\nYou are A1, a marine at (8.8, 14.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.1, 14.5), 45/45 health, order: hold\n A2 marine at (7.4, 14.1), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (17.1, 17.2), 45/45 health, 8.7 away\n E1 marine at (14.8, 14.8), 45/45 health, 6.0 away\n E2 marine at (14.7, 17.6), 45/45 health, 6.7 away\nTeam chat (most recent last):\n A1 (1.0s): Holding. A0, move closer to me; focus closest enemy when seen.\n A2 (1.0s): A2 holding. A0, close up toward A1 and me; focus closest enemy.\n A0 (1.5s): Closing on A1 and A2 now; will focus the closest enemy when seen.\n A1 (1.5s): A1 holding. A0 is close now; focus closest enemy when seen.\n A2 (1.5s): A2 holding. Group is tight now; focus closest enemy when it appears.\n A0 (2.0s): A0 holding with the group; focus fire on closest enemy when in range.\n A1 (2.0s): Hold together. Focus fire E1 (closest) when in range.\n A2 (2.0s): A2 holding. E1 is at 9 range; let it come, then focus E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding. Focus E1 when it enters range 5; all fire together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-28c844ad852a25e2e6165f90.json b/examples/multi-agent-smax/results/llm-cache/ask-28c844ad852a25e2e6165f90.json new file mode 100644 index 00000000..7d198044 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-28c844ad852a25e2e6165f90.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.5 seconds into the battle.\nYou are A0, a marine at (9.7, 15.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 10 15.\nYour team:\n A1 marine at (8.3, 14.1), 45/45 health, order: move 8.5 15\n A2 marine at (8.1, 14.9), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (16.0, 15.0), 45/45 health, 6.3 away\n E1 marine at (16.5, 16.2), 45/45 health, 6.8 away\n E2 marine at (16.0, 14.3), 45/45 health, 6.5 away\nTeam chat (most recent last):\n A1 (1.0s): Holding at (8,14); focus fire closest enemy when seen.\n A2 (1.0s): Moving to group at (8,15); will focus fire closest enemy.\n A0 (1.5s): Holding at (8,16); grouped, focus fire closest enemy when seen.\n A1 (1.5s): Advancing east slowly to find enemies; stay grouped, focus closest.\n A2 (1.5s): In position at (8,15); holding, focus fire closest enemy when seen.\n A0 (2.0s): Moving east to group with A1; focus closest enemy when seen.\n A1 (2.0s): Falling back to group; hold and focus fire when enemies enter range.\n A2 (2.0s): A2 holding at (8,15); A1 is advancing east, stay close, focus closest.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 8.5 15\", \"say\": \"Enemies 3 at east x16. Pull back to group at (8.5,15), then focus E0 together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-2cf7d47e3093a64f18ecddd4.json b/examples/multi-agent-smax/results/llm-cache/ask-2cf7d47e3093a64f18ecddd4.json new file mode 100644 index 00000000..d83b0e0a --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-2cf7d47e3093a64f18ecddd4.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.5 seconds into the battle.\nYou are A1, a marine at (6.7, 14.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.9, 15.6), 45/45 health, order: hold\n A2 marine at (8.3, 15.7), 45/45 health, order: move 7.5 16\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together near (7,16); focus fire on whoever appears first.\n A0 (0.5s): No enemies yet; holding grouped. Focus fire on the closest when they appear.\n A1 (0.5s): A1 holding at (6.7,14.2); will focus the closest enemy that appears.\n A2 (0.5s): A2 holding at (8,17); shoot closest enemy together, stay grouped.\n A0 (1.0s): A0 holding; will focus closest enemy when it appears.\n A1 (1.0s): A1 holding; will focus fire on the closest enemy when seen.\n A2 (1.0s): Tightening up near (7.5,16); A2 holding formation, focus closest.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A1 holding; will focus fire on the first enemy in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-2db9f2b170d6b7a10075716d.json b/examples/multi-agent-smax/results/llm-cache/ask-2db9f2b170d6b7a10075716d.json new file mode 100644 index 00000000..aeb55bec --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-2db9f2b170d6b7a10075716d.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.0 seconds into the battle.\nYou are A1, a marine at (6.5, 16.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.2, 15.8), 45/45 health, order: hold\n A2 marine at (7.0, 18.0), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding together; focus fire on closest enemy when they appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-2e28f18daa89db95ab73ff25.json b/examples/multi-agent-smax/results/llm-cache/ask-2e28f18daa89db95ab73ff25.json new file mode 100644 index 00000000..7b233555 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-2e28f18daa89db95ab73ff25.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.0 seconds into the battle.\nYou are A0, a marine at (7.2, 15.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (6.5, 16.1), 45/45 health, order: hold\n A2 marine at (7.0, 18.0), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding together; focus fire on the closest enemy when they appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-32eb1c0003ea0b6697af18b9.json b/examples/multi-agent-smax/results/llm-cache/ask-32eb1c0003ea0b6697af18b9.json new file mode 100644 index 00000000..dcb45c00 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-32eb1c0003ea0b6697af18b9.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 8.5 seconds into the battle.\nYou are A2, a marine at (8.9, 14.0) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0: dead\n A1: dead\nEnemies you can see:\n E0 marine at (12.4, 17.2), 27/45 health, 4.8 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A2 (5.0s): E1 down. Focus E2, closest at 4.5. A0, you're hurt, stay behind me.\n A0 (5.5s): Focus E2 (27hp), then E0. A2 keep firing.\n A2 (5.5s): Firing E2 (27hp). A0 stay back, I'm closest.\n A2 (6.0s): E2 at 18hp, finishing it. Then E0.\n A2 (6.5s): E2 at 9hp, finishing it. Then E0.\n A2 (7.0s): E2 at 9hp, finishing it. Then E0 alone.\n A2 (7.5s): E2 down. Last enemy E0, 45hp, engaging.\n A2 (8.0s): Last enemy E0 at 36hp. I'm at 9hp, fighting on.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 at 27hp, I'm at 9hp. Last enemy, firing.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-3339de2e52451a22bb968147.json b/examples/multi-agent-smax/results/llm-cache/ask-3339de2e52451a22bb968147.json new file mode 100644 index 00000000..3abeb219 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-3339de2e52451a22bb968147.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.0 seconds into the battle.\nYou are A0, a marine at (6.4, 15.4) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (8.6, 14.6), 45/45 health, order: hold\n A2 marine at (7.8, 14.7), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding together; focus fire on closest enemy once they appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-337472a8c1c63db25d536c6c.json b/examples/multi-agent-smax/results/llm-cache/ask-337472a8c1c63db25d536c6c.json new file mode 100644 index 00000000..64253a82 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-337472a8c1c63db25d536c6c.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.0 seconds into the battle.\nYou are A0, a marine at (8.1, 17.4) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (8.3, 14.1), 45/45 health, order: hold\n A2 marine at (6.5, 14.9), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 8 15.5\", \"say\": \"Regrouping with you both at (8,15); hold together, focus fire once enemies appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-35960015f5ddcacb7c80d151.json b/examples/multi-agent-smax/results/llm-cache/ask-35960015f5ddcacb7c80d151.json new file mode 100644 index 00000000..dab6f563 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-35960015f5ddcacb7c80d151.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.0 seconds into the battle.\nYou are A2, a marine at (8.9, 14.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (8.9, 14.8), 27/45 health, order: attack E1\n A1: dead\nEnemies you can see:\n E0 marine at (12.4, 17.2), 45/45 health, 4.8 away (in range)\n E2 marine at (11.6, 17.6), 45/45 health, 4.5 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (3.5s): Attacking E1 (36hp), closing to range. Focus E1 together.\n A1 (3.5s): Firing E1 (36hp). A0, A2 attack E1 too; E1 is 4.5 from me, others closing.\n A2 (3.5s): A2 attacking E1 now, focus fire together.\n A0 (4.0s): Firing E1 (27hp). Keep focus, A1 is hurt, stay behind us.\n A1 (4.0s): E1 at 27hp, finish it. I'm low at 18hp, so cover me.\n A2 (4.0s): Firing E1 (27hp), keep focus until dead.\n A0 (4.5s): E1 at 9hp, finishing it. Then focus E2.\n A2 (4.5s): E1 at 9hp, finishing it now. Then focus E2, closest.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E1 down. Focus E2, closest at 4.5. A0, you're hurt, stay behind me.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-35d42185f32d04ec8e7eac1c.json b/examples/multi-agent-smax/results/llm-cache/ask-35d42185f32d04ec8e7eac1c.json new file mode 100644 index 00000000..a3447e95 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-35d42185f32d04ec8e7eac1c.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.5 seconds into the battle.\nYou are A0, a marine at (8.1, 14.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (8.8, 14.6), 45/45 health, order: hold\n A2 marine at (7.4, 14.1), 45/45 health, order: hold\nEnemies you can see:\n E1 marine at (14.8, 14.8), 45/45 health, 6.8 away\n E2 marine at (14.7, 17.6), 45/45 health, 7.4 away\nTeam chat (most recent last):\n A1 (1.0s): Holding. A0, move closer to me; focus closest enemy when seen.\n A2 (1.0s): A2 holding. A0, close up toward A1 and me; focus closest enemy.\n A0 (1.5s): Closing on A1 and A2 now; will focus the closest enemy when seen.\n A1 (1.5s): A1 holding. A0 is close now; focus closest enemy when seen.\n A2 (1.5s): A2 holding. Group is tight now; focus closest enemy when it appears.\n A0 (2.0s): A0 holding with the group; focus fire on closest enemy when in range.\n A1 (2.0s): Hold together. Focus fire E1 (closest) when in range.\n A2 (2.0s): A2 holding. E1 is at 9 range; let it come, then focus E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding. Focus fire E1 when it enters range 5.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-368293e1db1b36e848441631.json b/examples/multi-agent-smax/results/llm-cache/ask-368293e1db1b36e848441631.json new file mode 100644 index 00000000..afd1a2de --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-368293e1db1b36e848441631.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 7.0 seconds into the battle.\nYou are A2, a marine at (8.9, 14.0) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0: dead\n A1: dead\nEnemies you can see:\n E0 marine at (12.4, 17.2), 45/45 health, 4.8 away (in range)\n E2 marine at (11.6, 17.6), 9/45 health, 4.5 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (4.5s): E1 at 9hp, finishing it. Then focus E2.\n A2 (4.5s): E1 at 9hp, finishing it now. Then focus E2, closest.\n A0 (5.0s): E1 dead. Focus E2, closest at 3.9. A2 fire too.\n A2 (5.0s): E1 down. Focus E2, closest at 4.5. A0, you're hurt, stay behind me.\n A0 (5.5s): Focus E2 (27hp), then E0. A2 keep firing.\n A2 (5.5s): Firing E2 (27hp). A0 stay back, I'm closest.\n A2 (6.0s): E2 at 18hp, finishing it. Then E0.\n A2 (6.5s): E2 at 9hp, finishing it. Then E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 at 9hp, finishing it. Then E0 alone.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-36d7fd978c1cc32e961732de.json b/examples/multi-agent-smax/results/llm-cache/ask-36d7fd978c1cc32e961732de.json new file mode 100644 index 00000000..62cd5e09 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-36d7fd978c1cc32e961732de.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.5 seconds into the battle.\nYou are A0, a marine at (7.2, 15.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (6.5, 16.1), 45/45 health, order: hold\n A2 marine at (7.0, 18.0), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A1 (0.0s): Holding together; focus fire on closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on the closest enemy when they appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Staying grouped; focus fire on closest enemy when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-37237750005264c69534ae90.json b/examples/multi-agent-smax/results/llm-cache/ask-37237750005264c69534ae90.json new file mode 100644 index 00000000..ad26df47 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-37237750005264c69534ae90.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.0 seconds into the battle.\nYou are A1, a marine at (6.5, 16.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.2, 15.7), 45/45 health, order: hold\n A2 marine at (7.1, 16.5), 45/45 health, order: move 7 16.5\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.5s): A1 holding; will focus closest enemy when seen.\n A2 (0.5s): A2 holding at (7,18); stay grouped, focus closest enemy when seen.\n A0 (1.0s): A0 holding; will focus closest enemy when it appears.\n A1 (1.0s): A1 holding; will shoot closest enemy when seen, stay grouped.\n A2 (1.0s): A2 holding at (7,18); I'm slightly north, staying close to group.\n A0 (1.5s): A0 holding; no enemies yet. Focus closest when they appear.\n A1 (1.5s): A1 holding; no enemies yet. Focus closest when they appear.\n A2 (1.5s): A2 moving south to tighten up with the group; focus closest enemy.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A1 holding; no enemies visible. Focus closest when they appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-37e1d323fb5ada1879a24df8.json b/examples/multi-agent-smax/results/llm-cache/ask-37e1d323fb5ada1879a24df8.json new file mode 100644 index 00000000..5201f15e --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-37e1d323fb5ada1879a24df8.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.0 seconds into the battle.\nYou are A0, a marine at (7.2, 15.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (6.5, 16.0), 45/45 health, order: hold\n A2 marine at (7.1, 16.5), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (15.4, 17.7), 45/45 health, 8.4 away\n E2 marine at (15.0, 14.7), 45/45 health, 7.8 away\nTeam chat (most recent last):\n A1 (1.5s): A1 holding; no enemies yet. Focus closest when they appear.\n A2 (1.5s): A2 moving south to tighten up with the group; focus closest enemy.\n A0 (2.0s): A0 holding; no enemies seen. Focus closest when they appear.\n A1 (2.0s): A1 holding; no enemies visible. Focus closest when they appear.\n A2 (2.0s): A2 holding at (7,16.5), grouped with team; focus closest enemy.\n A0 (2.5s): A0 holding; waiting for enemies to come into range, focus closest.\n A1 (2.5s): A1 holding in formation; all focus fire on closest enemy when seen.\n A2 (2.5s): A2 holding; will focus closest enemy when seen.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Enemies approaching at ~8 range; hold together, fire on closest when in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-381df78894b5a558ba4d2f2f.json b/examples/multi-agent-smax/results/llm-cache/ask-381df78894b5a558ba4d2f2f.json new file mode 100644 index 00000000..0a9d0a08 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-381df78894b5a558ba4d2f2f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.0 seconds into the battle.\nYou are A0, a marine at (8.5, 18.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (8.6, 17.2), 45/45 health, order: hold\n A2 marine at (8.4, 16.0), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"No enemies seen. Holding together; focus fire on the closest enemy once spotted.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-391a4fedbbdc2f5bc4477612.json b/examples/multi-agent-smax/results/llm-cache/ask-391a4fedbbdc2f5bc4477612.json new file mode 100644 index 00000000..9785950d --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-391a4fedbbdc2f5bc4477612.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.0 seconds into the battle.\nYou are A2, a marine at (9.9, 15.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 11 17.\nYour team:\n A0 marine at (10.3, 16.5), 45/45 health, order: move 11 17\n A1 marine at (10.1, 17.3), 45/45 health, order: move 11 17\nEnemies you can see:\n E0 marine at (17.7, 16.4), 45/45 health, 7.9 away\n E1 marine at (18.5, 17.3), 45/45 health, 8.8 away\nTeam chat (most recent last):\n A1 (0.5s): A1 holding; will focus fire on closest enemy when spotted.\n A2 (0.5s): Holding; will focus fire on the closest enemy once in range.\n A0 (1.0s): Advancing east slowly to find enemies; stay close, focus fire on closest.\n A1 (1.0s): A1 holding; no enemies yet. Focus fire on closest when spotted.\n A2 (1.0s): A2 holding; still no enemies. Will focus fire on closest once in range.\n A0 (1.5s): Advancing slowly east; teammates please close up on me, focus closest.\n A1 (1.5s): A1 advancing east to stay with A0; keep grouped, focus closest.\n A2 (1.5s): Moving east to join A0; stay grouped, focus closest enemy.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding here as a group; everyone focus fire on closest enemy, E0 first.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-3dd5270c0ea2bce80fd1fb16.json b/examples/multi-agent-smax/results/llm-cache/ask-3dd5270c0ea2bce80fd1fb16.json new file mode 100644 index 00000000..f55fba85 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-3dd5270c0ea2bce80fd1fb16.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.0 seconds into the battle.\nYou are A0, a marine at (8.1, 15.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (8.3, 14.1), 45/45 health, order: hold\n A2 marine at (6.5, 14.9), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Regrouping with you both at (8,15); hold together, focus fire once enemies appear.\n A1 (0.0s): Holding together; no enemies seen. Stay grouped, focus fire on the closest.\n A2 (0.0s): Holding together as a group; focus fire on the closest enemy once seen.\n A0 (0.5s): Holding at (8,15); focus fire on closest enemy when seen.\n A1 (0.5s): Holding at (8,14); will focus fire closest enemy when seen.\n A2 (0.5s): Holding at group; will focus fire on closest enemy once seen.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Still holding at (8,15); no enemies yet. Focus fire closest when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-45fa3f809979aa1afcc3a623.json b/examples/multi-agent-smax/results/llm-cache/ask-45fa3f809979aa1afcc3a623.json new file mode 100644 index 00000000..10c82c72 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-45fa3f809979aa1afcc3a623.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.5 seconds into the battle.\nYou are A1, a marine at (10.1, 17.3) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (10.3, 16.5), 36/45 health, order: attack E0\n A2 marine at (9.9, 15.8), 45/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (14.6, 16.4), 18/45 health, 4.6 away (in range)\n E1 marine at (13.8, 17.3), 45/45 health, 3.7 away (in range)\n E2 marine at (14.4, 14.8), 45/45 health, 5.0 away (in range)\nTeam chat (most recent last):\n A1 (2.0s): Enemies E0,E1 east ~8 away. Hold together, focus E0 when in range.\n A2 (2.0s): Holding here as a group; everyone focus fire on closest enemy, E0 first.\n A0 (2.5s): Holding. Enemies close in; all focus E0 when it enters range 5.\n A1 (2.5s): Holding; enemies at 6+ range. Focus E0 when it enters range 5.\n A2 (2.5s): A2 holding; let them come into range, focus E0 together.\n A0 (3.0s): E0 in range, all focus fire E0 now.\n A1 (3.0s): E0 in range, attacking E0 now. Everyone focus E0.\n A2 (3.0s): Attacking E0 now, E0 in range. Everyone focus fire E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Keep focusing E0, it's at 18 health. Then E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-4614baf6f00a29be4f0a3415.json b/examples/multi-agent-smax/results/llm-cache/ask-4614baf6f00a29be4f0a3415.json new file mode 100644 index 00000000..acc2dddb --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-4614baf6f00a29be4f0a3415.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.5 seconds into the battle.\nYou are A2, a marine at (8.7, 15.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.0, 15.5), 45/45 health, order: move 11 15.6\n A1 marine at (6.7, 14.2), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (15.2, 16.8), 45/45 health, 6.5 away\n E1 marine at (16.9, 16.2), 45/45 health, 8.1 away\n E2 marine at (16.9, 17.3), 45/45 health, 8.3 away\nTeam chat (most recent last):\n A1 (1.0s): A1 holding; will focus fire on the closest enemy when seen.\n A2 (1.0s): Tightening up near (7.5,16); A2 holding formation, focus closest.\n A0 (1.5s): A0 holding; no enemies visible, will focus closest when seen.\n A1 (1.5s): A1 holding; will focus fire on the first enemy in range.\n A2 (1.5s): A2 holding at (8.3,15.7); will focus closest enemy with team.\n A0 (2.0s): Advancing slowly east to scout; stay close, focus closest enemy when seen.\n A1 (2.0s): A1 holding; no enemies yet, will focus closest when one appears.\n A2 (2.0s): E0 at (16.8,16.8) approaching; hold and focus it when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A2 holding; enemies approaching, all focus E0 when in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-472e9a8b50304a28126974a4.json b/examples/multi-agent-smax/results/llm-cache/ask-472e9a8b50304a28126974a4.json new file mode 100644 index 00000000..8aceb863 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-472e9a8b50304a28126974a4.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.5 seconds into the battle.\nYou are A2, a marine at (8.3, 15.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 7.5 16.\nYour team:\n A0 marine at (6.9, 15.6), 45/45 health, order: hold\n A1 marine at (6.7, 14.2), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together near (7,16); focus fire on whoever appears first.\n A0 (0.5s): No enemies yet; holding grouped. Focus fire on the closest when they appear.\n A1 (0.5s): A1 holding at (6.7,14.2); will focus the closest enemy that appears.\n A2 (0.5s): A2 holding at (8,17); shoot closest enemy together, stay grouped.\n A0 (1.0s): A0 holding; will focus closest enemy when it appears.\n A1 (1.0s): A1 holding; will focus fire on the closest enemy when seen.\n A2 (1.0s): Tightening up near (7.5,16); A2 holding formation, focus closest.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A2 holding at (8.3,15.7); will focus closest enemy with team.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-48f2b1785c24aaf8e0ff7a46.json b/examples/multi-agent-smax/results/llm-cache/ask-48f2b1785c24aaf8e0ff7a46.json new file mode 100644 index 00000000..008c24ff --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-48f2b1785c24aaf8e0ff7a46.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.5 seconds into the battle.\nYou are A1, a marine at (8.6, 14.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.4, 15.4), 45/45 health, order: hold\n A2 marine at (7.8, 14.7), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together; focus fire on closest enemy once they appear.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together as a group; focus fire on the closest enemy when they appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding. A0 is a bit far west; tighten up on me.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-49f9c5ee7db3bfb680b50bf1.json b/examples/multi-agent-smax/results/llm-cache/ask-49f9c5ee7db3bfb680b50bf1.json new file mode 100644 index 00000000..3ac53287 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-49f9c5ee7db3bfb680b50bf1.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 7.5 seconds into the battle.\nYou are A2, a marine at (8.9, 14.0) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0: dead\n A1: dead\nEnemies you can see:\n E0 marine at (12.4, 17.2), 45/45 health, 4.8 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A2 (4.5s): E1 at 9hp, finishing it now. Then focus E2, closest.\n A0 (5.0s): E1 dead. Focus E2, closest at 3.9. A2 fire too.\n A2 (5.0s): E1 down. Focus E2, closest at 4.5. A0, you're hurt, stay behind me.\n A0 (5.5s): Focus E2 (27hp), then E0. A2 keep firing.\n A2 (5.5s): Firing E2 (27hp). A0 stay back, I'm closest.\n A2 (6.0s): E2 at 18hp, finishing it. Then E0.\n A2 (6.5s): E2 at 9hp, finishing it. Then E0.\n A2 (7.0s): E2 at 9hp, finishing it. Then E0 alone.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E2 down. Last enemy E0, 45hp, engaging.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-4ac242d625cafd1f2c2fc309.json b/examples/multi-agent-smax/results/llm-cache/ask-4ac242d625cafd1f2c2fc309.json new file mode 100644 index 00000000..78b5e4dd --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-4ac242d625cafd1f2c2fc309.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.0 seconds into the battle.\nYou are A2, a marine at (7.0, 18.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.2, 15.8), 45/45 health, order: hold\n A1 marine at (6.5, 16.1), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding together; focus fire on the closest enemy when they appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-4c5478a662dd00aa9d4a3e03.json b/examples/multi-agent-smax/results/llm-cache/ask-4c5478a662dd00aa9d4a3e03.json new file mode 100644 index 00000000..45988da9 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-4c5478a662dd00aa9d4a3e03.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.0 seconds into the battle.\nYou are A0, a marine at (6.4, 15.4) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (8.6, 14.6), 45/45 health, order: hold\n A2 marine at (7.8, 14.7), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together; focus fire on closest enemy once they appear.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together as a group; focus fire on the closest enemy when they appear.\n A0 (0.5s): Holding. Will focus fire on the closest enemy once visible.\n A1 (0.5s): Holding. A0 is a bit far west; tighten up on me.\n A2 (0.5s): A2 holding; will focus fire on closest enemy when seen.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 8 15\", \"say\": \"Moving east to tighten up on A1 and A2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-5014d4b0675fc3a2148fdaee.json b/examples/multi-agent-smax/results/llm-cache/ask-5014d4b0675fc3a2148fdaee.json new file mode 100644 index 00000000..37b4ca1f --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-5014d4b0675fc3a2148fdaee.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.0 seconds into the battle.\nYou are A1, a marine at (8.6, 14.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.4, 15.4), 45/45 health, order: hold\n A2 marine at (7.8, 14.7), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding together; focus fire on the closest enemy when they appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-53ed59e5ffb966d4143cecd3.json b/examples/multi-agent-smax/results/llm-cache/ask-53ed59e5ffb966d4143cecd3.json new file mode 100644 index 00000000..778f6d20 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-53ed59e5ffb966d4143cecd3.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 8.0 seconds into the battle.\nYou are A2, a marine at (8.9, 14.0) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0: dead\n A1: dead\nEnemies you can see:\n E0 marine at (12.4, 17.2), 36/45 health, 4.8 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (5.0s): E1 dead. Focus E2, closest at 3.9. A2 fire too.\n A2 (5.0s): E1 down. Focus E2, closest at 4.5. A0, you're hurt, stay behind me.\n A0 (5.5s): Focus E2 (27hp), then E0. A2 keep firing.\n A2 (5.5s): Firing E2 (27hp). A0 stay back, I'm closest.\n A2 (6.0s): E2 at 18hp, finishing it. Then E0.\n A2 (6.5s): E2 at 9hp, finishing it. Then E0.\n A2 (7.0s): E2 at 9hp, finishing it. Then E0 alone.\n A2 (7.5s): E2 down. Last enemy E0, 45hp, engaging.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Last enemy E0 at 36hp. I'm at 9hp, fighting on.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-546466e3e6006d31c216b380.json b/examples/multi-agent-smax/results/llm-cache/ask-546466e3e6006d31c216b380.json new file mode 100644 index 00000000..2ebe2c20 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-546466e3e6006d31c216b380.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.0 seconds into the battle.\nYou are A0, a marine at (6.9, 15.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (6.7, 14.2), 45/45 health, order: hold\n A2 marine at (8.3, 15.7), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.5s): A1 holding at (6.7,14.2); will focus the closest enemy that appears.\n A2 (0.5s): A2 holding at (8,17); shoot closest enemy together, stay grouped.\n A0 (1.0s): A0 holding; will focus closest enemy when it appears.\n A1 (1.0s): A1 holding; will focus fire on the closest enemy when seen.\n A2 (1.0s): Tightening up near (7.5,16); A2 holding formation, focus closest.\n A0 (1.5s): A0 holding; no enemies visible, will focus closest when seen.\n A1 (1.5s): A1 holding; will focus fire on the first enemy in range.\n A2 (1.5s): A2 holding at (8.3,15.7); will focus closest enemy with team.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 11 15.6\", \"say\": \"Advancing slowly east to scout; stay close, focus closest enemy when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-551741a861f562f58f729e3a.json b/examples/multi-agent-smax/results/llm-cache/ask-551741a861f562f58f729e3a.json new file mode 100644 index 00000000..3ec3fe63 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-551741a861f562f58f729e3a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.0 seconds into the battle.\nYou are A0, a marine at (10.3, 16.5) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1 marine at (10.1, 17.3), 45/45 health, order: attack E0\n A2 marine at (9.9, 15.8), 45/45 health, order: attack E0\nEnemies you can see:\n E1 marine at (13.8, 17.3), 45/45 health, 3.6 away (in range)\n E2 marine at (14.4, 14.8), 45/45 health, 4.4 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (2.5s): Holding; enemies at 6+ range. Focus E0 when it enters range 5.\n A2 (2.5s): A2 holding; let them come into range, focus E0 together.\n A0 (3.0s): E0 in range, all focus fire E0 now.\n A1 (3.0s): E0 in range, attacking E0 now. Everyone focus E0.\n A2 (3.0s): Attacking E0 now, E0 in range. Everyone focus fire E0.\n A0 (3.5s): Keep focusing E0 (18hp), then E1.\n A1 (3.5s): Keep focusing E0, it's at 18 health. Then E1.\n A2 (3.5s): E0 at 18hp, keep focusing E0, then E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E0 dead. Focus E1 (3.6 away), then E2. I'm at 18hp.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-5920d6926ec51b105048a059.json b/examples/multi-agent-smax/results/llm-cache/ask-5920d6926ec51b105048a059.json new file mode 100644 index 00000000..58e7bed5 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-5920d6926ec51b105048a059.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.5 seconds into the battle.\nYou are A2, a marine at (9.9, 15.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (10.3, 16.5), 45/45 health, order: hold\n A1 marine at (10.1, 17.3), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (16.2, 16.4), 45/45 health, 6.3 away\n E1 marine at (17.0, 17.3), 45/45 health, 7.2 away\n E2 marine at (17.5, 14.8), 45/45 health, 7.7 away\nTeam chat (most recent last):\n A1 (1.0s): A1 holding; no enemies yet. Focus fire on closest when spotted.\n A2 (1.0s): A2 holding; still no enemies. Will focus fire on closest once in range.\n A0 (1.5s): Advancing slowly east; teammates please close up on me, focus closest.\n A1 (1.5s): A1 advancing east to stay with A0; keep grouped, focus closest.\n A2 (1.5s): Moving east to join A0; stay grouped, focus closest enemy.\n A0 (2.0s): Holding here, grouped. Focus fire on E0 (closest) when in range.\n A1 (2.0s): Enemies E0,E1 east ~8 away. Hold together, focus E0 when in range.\n A2 (2.0s): Holding here as a group; everyone focus fire on closest enemy, E0 first.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A2 holding; let them come into range, focus E0 together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-599d1ddfdd8f0e324db12f26.json b/examples/multi-agent-smax/results/llm-cache/ask-599d1ddfdd8f0e324db12f26.json new file mode 100644 index 00000000..e85455ac --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-599d1ddfdd8f0e324db12f26.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 0.0 seconds into the battle.\nYou are A1, a marine at (6.7, 14.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.9, 15.6), 45/45 health, order: hold\n A2 marine at (8.3, 17.3), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A1 holding. No enemies seen; wait until all in range 5, then focus same target.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-5ab8770adfed2031e69b5b05.json b/examples/multi-agent-smax/results/llm-cache/ask-5ab8770adfed2031e69b5b05.json new file mode 100644 index 00000000..39c5997b --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-5ab8770adfed2031e69b5b05.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.5 seconds into the battle.\nYou are A0, a marine at (8.5, 18.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (8.6, 17.2), 45/45 health, order: hold\n A2 marine at (8.4, 16.0), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): No enemies seen. Holding together; focus fire on the closest enemy once spotted.\n A1 (0.0s): Holding together as a group; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on the first enemy that enters range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Still no enemies. Holding; will focus fire on first one in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-5add4c23221a2edda6ff7b97.json b/examples/multi-agent-smax/results/llm-cache/ask-5add4c23221a2edda6ff7b97.json new file mode 100644 index 00000000..e3f6b2d2 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-5add4c23221a2edda6ff7b97.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.5 seconds into the battle.\nYou are A0, a marine at (8.0, 15.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 11 15.6.\nYour team:\n A1 marine at (6.7, 14.2), 45/45 health, order: hold\n A2 marine at (8.7, 15.8), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (15.2, 16.8), 45/45 health, 7.3 away\n E1 marine at (16.9, 16.2), 45/45 health, 8.9 away\nTeam chat (most recent last):\n A1 (1.0s): A1 holding; will focus fire on the closest enemy when seen.\n A2 (1.0s): Tightening up near (7.5,16); A2 holding formation, focus closest.\n A0 (1.5s): A0 holding; no enemies visible, will focus closest when seen.\n A1 (1.5s): A1 holding; will focus fire on the first enemy in range.\n A2 (1.5s): A2 holding at (8.3,15.7); will focus closest enemy with team.\n A0 (2.0s): Advancing slowly east to scout; stay close, focus closest enemy when seen.\n A1 (2.0s): A1 holding; no enemies yet, will focus closest when one appears.\n A2 (2.0s): E0 at (16.8,16.8) approaching; hold and focus it when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A0 holding with you; enemies approaching, focus E0 when in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-5b4bc9b346e6ad06fa8ef4f0.json b/examples/multi-agent-smax/results/llm-cache/ask-5b4bc9b346e6ad06fa8ef4f0.json new file mode 100644 index 00000000..06a07da2 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-5b4bc9b346e6ad06fa8ef4f0.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.5 seconds into the battle.\nYou are A1, a marine at (8.6, 17.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.5, 18.0), 45/45 health, order: hold\n A2 marine at (8.4, 16.0), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): No enemies seen. Holding together; focus fire on the closest enemy once spotted.\n A1 (0.0s): Holding together as a group; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on the first enemy that enters range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A1 holding; will focus fire on closest enemy when spotted.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-5c90373e0d0ad26b6173d228.json b/examples/multi-agent-smax/results/llm-cache/ask-5c90373e0d0ad26b6173d228.json new file mode 100644 index 00000000..5d86ea7c --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-5c90373e0d0ad26b6173d228.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.0 seconds into the battle.\nYou are A1, a marine at (6.7, 14.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.9, 15.6), 45/45 health, order: hold\n A2 marine at (8.3, 17.3), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together; stay grouped and focus fire on the first enemy that appears.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together near (7,16); focus fire on whoever appears first.\n A0 (0.5s): No enemies yet; holding grouped. Focus fire on the closest when they appear.\n A1 (0.5s): A1 holding at (6.7,14.2); will focus the closest enemy that appears.\n A2 (0.5s): A2 holding at (8,17); shoot closest enemy together, stay grouped.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A1 holding; will focus fire on the closest enemy when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-61610780f1a6051403036d64.json b/examples/multi-agent-smax/results/llm-cache/ask-61610780f1a6051403036d64.json new file mode 100644 index 00000000..7fea61c0 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-61610780f1a6051403036d64.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.0 seconds into the battle.\nYou are A1, a marine at (8.8, 14.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.1, 14.5), 45/45 health, order: hold\n A2 marine at (7.4, 14.1), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (15.6, 17.2), 45/45 health, 7.2 away\n E1 marine at (13.3, 14.8), 45/45 health, 4.5 away (in range)\n E2 marine at (13.2, 17.6), 45/45 health, 5.3 away\nTeam chat (most recent last):\n A1 (1.5s): A1 holding. A0 is close now; focus closest enemy when seen.\n A2 (1.5s): A2 holding. Group is tight now; focus closest enemy when it appears.\n A0 (2.0s): A0 holding with the group; focus fire on closest enemy when in range.\n A1 (2.0s): Hold together. Focus fire E1 (closest) when in range.\n A2 (2.0s): A2 holding. E1 is at 9 range; let it come, then focus E1.\n A0 (2.5s): Holding. Focus fire E1 when it enters range 5.\n A1 (2.5s): Holding. Focus E1 when it enters range 5; all fire together.\n A2 (2.5s): A2 holding. Focus E1 when it enters range 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E1 in range at 4.5. All focus fire E1 now.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-6330a35d72912b52aee26c43.json b/examples/multi-agent-smax/results/llm-cache/ask-6330a35d72912b52aee26c43.json new file mode 100644 index 00000000..acc4ac53 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-6330a35d72912b52aee26c43.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.5 seconds into the battle.\nYou are A2, a marine at (8.1, 14.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (9.7, 15.8), 45/45 health, order: move 10 15\n A1 marine at (8.3, 14.1), 45/45 health, order: move 8.5 15\nEnemies you can see:\n E0 marine at (16.0, 15.0), 45/45 health, 7.9 away\n E1 marine at (16.5, 16.2), 45/45 health, 8.5 away\n E2 marine at (16.0, 14.3), 45/45 health, 8.0 away\nTeam chat (most recent last):\n A1 (1.0s): Holding at (8,14); focus fire closest enemy when seen.\n A2 (1.0s): Moving to group at (8,15); will focus fire closest enemy.\n A0 (1.5s): Holding at (8,16); grouped, focus fire closest enemy when seen.\n A1 (1.5s): Advancing east slowly to find enemies; stay grouped, focus closest.\n A2 (1.5s): In position at (8,15); holding, focus fire closest enemy when seen.\n A0 (2.0s): Moving east to group with A1; focus closest enemy when seen.\n A1 (2.0s): Falling back to group; hold and focus fire when enemies enter range.\n A2 (2.0s): A2 holding at (8,15); A1 is advancing east, stay close, focus closest.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Enemies ~8 east. Hold at range 5, focus closest when they approach.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-6696b9ac4f7f0e50ef075918.json b/examples/multi-agent-smax/results/llm-cache/ask-6696b9ac4f7f0e50ef075918.json new file mode 100644 index 00000000..bd3391ac --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-6696b9ac4f7f0e50ef075918.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.0 seconds into the battle.\nYou are A0, a marine at (6.9, 15.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (6.7, 14.2), 45/45 health, order: hold\n A2 marine at (8.3, 17.3), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding together; stay grouped and focus fire on the first enemy that appears.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-68274bfd6f21a298a1495674.json b/examples/multi-agent-smax/results/llm-cache/ask-68274bfd6f21a298a1495674.json new file mode 100644 index 00000000..13048966 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-68274bfd6f21a298a1495674.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.5 seconds into the battle.\nYou are A0, a marine at (8.1, 15.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (8.3, 14.1), 45/45 health, order: hold\n A2 marine at (8.1, 14.9), 45/45 health, order: move 8 15\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.0s): Holding together; no enemies seen. Stay grouped, focus fire on the closest.\n A2 (0.0s): Holding together as a group; focus fire on the closest enemy once seen.\n A0 (0.5s): Holding at (8,15); focus fire on closest enemy when seen.\n A1 (0.5s): Holding at (8,14); will focus fire closest enemy when seen.\n A2 (0.5s): Holding at group; will focus fire on closest enemy once seen.\n A0 (1.0s): Still holding at (8,15); no enemies yet. Focus fire closest when seen.\n A1 (1.0s): Holding at (8,14); focus fire closest enemy when seen.\n A2 (1.0s): Moving to group at (8,15); will focus fire closest enemy.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding at (8,16); grouped, focus fire closest enemy when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-6b67985c7fcf06c42a1add4b.json b/examples/multi-agent-smax/results/llm-cache/ask-6b67985c7fcf06c42a1add4b.json new file mode 100644 index 00000000..c532c36a --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-6b67985c7fcf06c42a1add4b.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.5 seconds into the battle.\nYou are A1, a marine at (10.1, 17.3) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (10.3, 16.5), 45/45 health, order: hold\n A2 marine at (9.9, 15.8), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (16.2, 16.4), 45/45 health, 6.1 away\n E1 marine at (17.0, 17.3), 45/45 health, 6.9 away\n E2 marine at (17.5, 14.8), 45/45 health, 7.8 away\nTeam chat (most recent last):\n A1 (1.0s): A1 holding; no enemies yet. Focus fire on closest when spotted.\n A2 (1.0s): A2 holding; still no enemies. Will focus fire on closest once in range.\n A0 (1.5s): Advancing slowly east; teammates please close up on me, focus closest.\n A1 (1.5s): A1 advancing east to stay with A0; keep grouped, focus closest.\n A2 (1.5s): Moving east to join A0; stay grouped, focus closest enemy.\n A0 (2.0s): Holding here, grouped. Focus fire on E0 (closest) when in range.\n A1 (2.0s): Enemies E0,E1 east ~8 away. Hold together, focus E0 when in range.\n A2 (2.0s): Holding here as a group; everyone focus fire on closest enemy, E0 first.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding; enemies at 6+ range. Focus E0 when it enters range 5.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-6eca7d7b590133da4cc57077.json b/examples/multi-agent-smax/results/llm-cache/ask-6eca7d7b590133da4cc57077.json new file mode 100644 index 00000000..8cabab84 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-6eca7d7b590133da4cc57077.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.5 seconds into the battle.\nYou are A0, a marine at (6.9, 15.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (6.7, 14.2), 45/45 health, order: hold\n A2 marine at (8.3, 17.3), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together; stay grouped and focus fire on the first enemy that appears.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together near (7,16); focus fire on whoever appears first.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"No enemies yet; holding grouped. Focus fire on the closest when they appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-70c5660af83dbb41d41d1dda.json b/examples/multi-agent-smax/results/llm-cache/ask-70c5660af83dbb41d41d1dda.json new file mode 100644 index 00000000..d9a9553a --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-70c5660af83dbb41d41d1dda.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.5 seconds into the battle.\nYou are A1, a marine at (6.5, 16.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.2, 15.8), 45/45 health, order: hold\n A2 marine at (7.0, 18.0), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.0s): Holding together; focus fire on closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A0 (0.5s): Staying grouped; focus fire on closest enemy when seen.\n A1 (0.5s): A1 holding; will focus closest enemy when seen.\n A2 (0.5s): A2 holding at (7,18); stay grouped, focus closest enemy when seen.\n A0 (1.0s): A0 holding; will focus closest enemy when it appears.\n A1 (1.0s): A1 holding; will shoot closest enemy when seen, stay grouped.\n A2 (1.0s): A2 holding at (7,18); I'm slightly north, staying close to group.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A1 holding; no enemies yet. Focus closest when they appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-70e515816b111db42a63a01d.json b/examples/multi-agent-smax/results/llm-cache/ask-70e515816b111db42a63a01d.json new file mode 100644 index 00000000..c70e58be --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-70e515816b111db42a63a01d.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.5 seconds into the battle.\nYou are A0, a marine at (6.9, 15.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (6.7, 14.2), 45/45 health, order: hold\n A2 marine at (8.3, 15.7), 45/45 health, order: move 7.5 16\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together near (7,16); focus fire on whoever appears first.\n A0 (0.5s): No enemies yet; holding grouped. Focus fire on the closest when they appear.\n A1 (0.5s): A1 holding at (6.7,14.2); will focus the closest enemy that appears.\n A2 (0.5s): A2 holding at (8,17); shoot closest enemy together, stay grouped.\n A0 (1.0s): A0 holding; will focus closest enemy when it appears.\n A1 (1.0s): A1 holding; will focus fire on the closest enemy when seen.\n A2 (1.0s): Tightening up near (7.5,16); A2 holding formation, focus closest.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A0 holding; no enemies visible, will focus closest when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-714431603cca0d61b3611321.json b/examples/multi-agent-smax/results/llm-cache/ask-714431603cca0d61b3611321.json new file mode 100644 index 00000000..9d8505ee --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-714431603cca0d61b3611321.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.5 seconds into the battle.\nYou are A1, a marine at (6.5, 16.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.2, 15.8), 45/45 health, order: hold\n A2 marine at (7.0, 18.0), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A1 (0.0s): Holding together; focus fire on closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on the closest enemy when they appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A1 holding; will focus closest enemy when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-7148ad9da81a6699b62c860a.json b/examples/multi-agent-smax/results/llm-cache/ask-7148ad9da81a6699b62c860a.json new file mode 100644 index 00000000..00ff2ec2 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-7148ad9da81a6699b62c860a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.5 seconds into the battle.\nYou are A1, a marine at (8.3, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.1, 15.8), 45/45 health, order: hold\n A2 marine at (8.1, 14.9), 45/45 health, order: move 8 15\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.0s): Holding together; no enemies seen. Stay grouped, focus fire on the closest.\n A2 (0.0s): Holding together as a group; focus fire on the closest enemy once seen.\n A0 (0.5s): Holding at (8,15); focus fire on closest enemy when seen.\n A1 (0.5s): Holding at (8,14); will focus fire closest enemy when seen.\n A2 (0.5s): Holding at group; will focus fire on closest enemy once seen.\n A0 (1.0s): Still holding at (8,15); no enemies yet. Focus fire closest when seen.\n A1 (1.0s): Holding at (8,14); focus fire closest enemy when seen.\n A2 (1.0s): Moving to group at (8,15); will focus fire closest enemy.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 11 15\", \"say\": \"Advancing east slowly to find enemies; stay grouped, focus closest.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-721e9c7ac3766abb5924c964.json b/examples/multi-agent-smax/results/llm-cache/ask-721e9c7ac3766abb5924c964.json new file mode 100644 index 00000000..69d98ae2 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-721e9c7ac3766abb5924c964.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.0 seconds into the battle.\nYou are A2, a marine at (8.9, 14.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0: dead\n A1: dead\nEnemies you can see:\n E0 marine at (12.4, 17.2), 45/45 health, 4.8 away (in range)\n E2 marine at (11.6, 17.6), 18/45 health, 4.5 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (4.0s): E1 at 27hp, finish it. I'm low at 18hp, so cover me.\n A2 (4.0s): Firing E1 (27hp), keep focus until dead.\n A0 (4.5s): E1 at 9hp, finishing it. Then focus E2.\n A2 (4.5s): E1 at 9hp, finishing it now. Then focus E2, closest.\n A0 (5.0s): E1 dead. Focus E2, closest at 3.9. A2 fire too.\n A2 (5.0s): E1 down. Focus E2, closest at 4.5. A0, you're hurt, stay behind me.\n A0 (5.5s): Focus E2 (27hp), then E0. A2 keep firing.\n A2 (5.5s): Firing E2 (27hp). A0 stay back, I'm closest.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 at 18hp, finishing it. Then E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-73d80ced022b9e8f29ff120d.json b/examples/multi-agent-smax/results/llm-cache/ask-73d80ced022b9e8f29ff120d.json new file mode 100644 index 00000000..e2924910 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-73d80ced022b9e8f29ff120d.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.0 seconds into the battle.\nYou are A1, a marine at (8.8, 14.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.1, 14.5), 45/45 health, order: move 8.4 14.8\n A2 marine at (7.5, 14.2), 45/45 health, order: hold\nEnemies you can see:\n E1 marine at (16.4, 14.8), 45/45 health, 7.6 away\n E2 marine at (16.3, 17.6), 45/45 health, 8.2 away\nTeam chat (most recent last):\n A1 (0.5s): Holding. A0 is a bit far west; tighten up on me.\n A2 (0.5s): A2 holding; will focus fire on closest enemy when seen.\n A0 (1.0s): Moving east to tighten up on A1 and A2.\n A1 (1.0s): Holding. A0, move closer to me; focus closest enemy when seen.\n A2 (1.0s): A2 holding. A0, close up toward A1 and me; focus closest enemy.\n A0 (1.5s): Closing on A1 and A2 now; will focus the closest enemy when seen.\n A1 (1.5s): A1 holding. A0 is close now; focus closest enemy when seen.\n A2 (1.5s): A2 holding. Group is tight now; focus closest enemy when it appears.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Hold together. Focus fire E1 (closest) when in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-77b959195948970ee75706d5.json b/examples/multi-agent-smax/results/llm-cache/ask-77b959195948970ee75706d5.json new file mode 100644 index 00000000..af08da27 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-77b959195948970ee75706d5.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.0 seconds into the battle.\nYou are A1, a marine at (8.3, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.1, 17.4), 45/45 health, order: hold\n A2 marine at (6.5, 14.9), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding together; no enemies seen. Stay grouped, focus fire on the closest.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-78392daefb45ff2a8ab5fbf0.json b/examples/multi-agent-smax/results/llm-cache/ask-78392daefb45ff2a8ab5fbf0.json new file mode 100644 index 00000000..8f37d48f --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-78392daefb45ff2a8ab5fbf0.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.0 seconds into the battle.\nYou are A1, a marine at (10.1, 17.3) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (10.3, 16.5), 45/45 health, order: hold\n A2 marine at (9.9, 15.8), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (14.6, 16.4), 45/45 health, 4.6 away (in range)\n E1 marine at (15.4, 17.3), 45/45 health, 5.3 away\n E2 marine at (16.0, 14.8), 45/45 health, 6.4 away\nTeam chat (most recent last):\n A1 (1.5s): A1 advancing east to stay with A0; keep grouped, focus closest.\n A2 (1.5s): Moving east to join A0; stay grouped, focus closest enemy.\n A0 (2.0s): Holding here, grouped. Focus fire on E0 (closest) when in range.\n A1 (2.0s): Enemies E0,E1 east ~8 away. Hold together, focus E0 when in range.\n A2 (2.0s): Holding here as a group; everyone focus fire on closest enemy, E0 first.\n A0 (2.5s): Holding. Enemies close in; all focus E0 when it enters range 5.\n A1 (2.5s): Holding; enemies at 6+ range. Focus E0 when it enters range 5.\n A2 (2.5s): A2 holding; let them come into range, focus E0 together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 in range, attacking E0 now. Everyone focus E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-7a7a76a54e38dc423032c422.json b/examples/multi-agent-smax/results/llm-cache/ask-7a7a76a54e38dc423032c422.json new file mode 100644 index 00000000..7312c148 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-7a7a76a54e38dc423032c422.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.0 seconds into the battle.\nYou are A2, a marine at (7.4, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.1, 14.5), 45/45 health, order: hold\n A1 marine at (8.8, 14.6), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (15.6, 17.2), 45/45 health, 8.7 away\n E1 marine at (13.3, 14.8), 45/45 health, 5.9 away\n E2 marine at (13.2, 17.6), 45/45 health, 6.7 away\nTeam chat (most recent last):\n A1 (1.5s): A1 holding. A0 is close now; focus closest enemy when seen.\n A2 (1.5s): A2 holding. Group is tight now; focus closest enemy when it appears.\n A0 (2.0s): A0 holding with the group; focus fire on closest enemy when in range.\n A1 (2.0s): Hold together. Focus fire E1 (closest) when in range.\n A2 (2.0s): A2 holding. E1 is at 9 range; let it come, then focus E1.\n A0 (2.5s): Holding. Focus fire E1 when it enters range 5.\n A1 (2.5s): Holding. Focus E1 when it enters range 5; all fire together.\n A2 (2.5s): A2 holding. Focus E1 when it enters range 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A2 holding. Focus E1 when it enters range 5; fire together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-7b1f645410969d44a81631b7.json b/examples/multi-agent-smax/results/llm-cache/ask-7b1f645410969d44a81631b7.json new file mode 100644 index 00000000..13f0e044 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-7b1f645410969d44a81631b7.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.0 seconds into the battle.\nYou are A0, a marine at (8.1, 15.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (9.9, 14.1), 45/45 health, order: move 11 15\n A2 marine at (8.1, 14.9), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.5s): Holding at (8,14); will focus fire closest enemy when seen.\n A2 (0.5s): Holding at group; will focus fire on closest enemy once seen.\n A0 (1.0s): Still holding at (8,15); no enemies yet. Focus fire closest when seen.\n A1 (1.0s): Holding at (8,14); focus fire closest enemy when seen.\n A2 (1.0s): Moving to group at (8,15); will focus fire closest enemy.\n A0 (1.5s): Holding at (8,16); grouped, focus fire closest enemy when seen.\n A1 (1.5s): Advancing east slowly to find enemies; stay grouped, focus closest.\n A2 (1.5s): In position at (8,15); holding, focus fire closest enemy when seen.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 10 15\", \"say\": \"Moving east to group with A1; focus closest enemy when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-7c21d829526079778555dbff.json b/examples/multi-agent-smax/results/llm-cache/ask-7c21d829526079778555dbff.json new file mode 100644 index 00000000..825a3368 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-7c21d829526079778555dbff.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.0 seconds into the battle.\nYou are A0, a marine at (8.9, 14.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1 marine at (9.6, 14.5), 18/45 health, order: attack E1\n A2 marine at (8.9, 14.0), 45/45 health, order: attack E1\nEnemies you can see:\n E0 marine at (12.4, 17.2), 45/45 health, 4.2 away (in range)\n E1 marine at (13.3, 14.8), 27/45 health, 4.3 away (in range)\n E2 marine at (11.6, 17.6), 45/45 health, 3.9 away (in range)\nTeam chat (most recent last):\n A1 (2.5s): Holding. Focus E1 when it enters range 5; all fire together.\n A2 (2.5s): A2 holding. Focus E1 when it enters range 5.\n A0 (3.0s): Holding. Focus E1 the moment it enters range 5.\n A1 (3.0s): E1 in range at 4.5. All focus fire E1 now.\n A2 (3.0s): A2 holding. Focus E1 when it enters range 5; fire together.\n A0 (3.5s): Attacking E1 (36hp), closing to range. Focus E1 together.\n A1 (3.5s): Firing E1 (36hp). A0, A2 attack E1 too; E1 is 4.5 from me, others closing.\n A2 (3.5s): A2 attacking E1 now, focus fire together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Firing E1 (27hp). Keep focus, A1 is hurt, stay behind us.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-7d806c984803f7c076625ccf.json b/examples/multi-agent-smax/results/llm-cache/ask-7d806c984803f7c076625ccf.json new file mode 100644 index 00000000..81bda877 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-7d806c984803f7c076625ccf.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.0 seconds into the battle.\nYou are A0, a marine at (8.0, 15.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (6.7, 14.2), 45/45 health, order: hold\n A2 marine at (8.7, 15.8), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (13.6, 16.8), 45/45 health, 5.7 away\n E1 marine at (15.3, 16.2), 45/45 health, 7.3 away\n E2 marine at (15.4, 17.3), 45/45 health, 7.5 away\nTeam chat (most recent last):\n A1 (1.5s): A1 holding; will focus fire on the first enemy in range.\n A2 (1.5s): A2 holding at (8.3,15.7); will focus closest enemy with team.\n A0 (2.0s): Advancing slowly east to scout; stay close, focus closest enemy when seen.\n A1 (2.0s): A1 holding; no enemies yet, will focus closest when one appears.\n A2 (2.0s): E0 at (16.8,16.8) approaching; hold and focus it when in range.\n A0 (2.5s): A0 holding with you; enemies approaching, focus E0 when in range.\n A1 (2.5s): A1 holding at (6.7,14.2); A0 fall back to us, focus E0 together.\n A2 (2.5s): A2 holding; enemies approaching, all focus E0 when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A0 holding; focus E0 when in range 5.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-81ca4a6bc40eb6ac43cda086.json b/examples/multi-agent-smax/results/llm-cache/ask-81ca4a6bc40eb6ac43cda086.json new file mode 100644 index 00000000..afa29c0a --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-81ca4a6bc40eb6ac43cda086.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.0 seconds into the battle.\nYou are A1, a marine at (8.6, 14.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.4, 15.4), 45/45 health, order: hold\n A2 marine at (7.8, 14.7), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together; focus fire on closest enemy once they appear.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together as a group; focus fire on the closest enemy when they appear.\n A0 (0.5s): Holding. Will focus fire on the closest enemy once visible.\n A1 (0.5s): Holding. A0 is a bit far west; tighten up on me.\n A2 (0.5s): A2 holding; will focus fire on closest enemy when seen.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding. A0, move closer to me; focus closest enemy when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-83d70c538065496e0b553fc5.json b/examples/multi-agent-smax/results/llm-cache/ask-83d70c538065496e0b553fc5.json new file mode 100644 index 00000000..9fb07372 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-83d70c538065496e0b553fc5.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 0.0 seconds into the battle.\nYou are A0, a marine at (6.9, 15.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (6.7, 14.2), 45/45 health, order: hold\n A2 marine at (8.3, 17.3), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding per rules until enemy within 5 of all; then focus same target.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-89a19c33bfba8b96ef4c5264.json b/examples/multi-agent-smax/results/llm-cache/ask-89a19c33bfba8b96ef4c5264.json new file mode 100644 index 00000000..27ad97b6 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-89a19c33bfba8b96ef4c5264.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.5 seconds into the battle.\nYou are A2, a marine at (7.8, 14.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.9, 15.5), 45/45 health, order: move 8 15\n A1 marine at (8.6, 14.6), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together as a group; focus fire on the closest enemy when they appear.\n A0 (0.5s): Holding. Will focus fire on the closest enemy once visible.\n A1 (0.5s): Holding. A0 is a bit far west; tighten up on me.\n A2 (0.5s): A2 holding; will focus fire on closest enemy when seen.\n A0 (1.0s): Moving east to tighten up on A1 and A2.\n A1 (1.0s): Holding. A0, move closer to me; focus closest enemy when seen.\n A2 (1.0s): A2 holding. A0, close up toward A1 and me; focus closest enemy.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A2 holding. Group is tight now; focus closest enemy when it appears.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-8a9dfc8ef97a5c05188780ed.json b/examples/multi-agent-smax/results/llm-cache/ask-8a9dfc8ef97a5c05188780ed.json new file mode 100644 index 00000000..704d95ac --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-8a9dfc8ef97a5c05188780ed.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.0 seconds into the battle.\nYou are A1, a marine at (6.7, 14.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.9, 15.6), 45/45 health, order: hold\n A2 marine at (8.3, 15.7), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.5s): A1 holding at (6.7,14.2); will focus the closest enemy that appears.\n A2 (0.5s): A2 holding at (8,17); shoot closest enemy together, stay grouped.\n A0 (1.0s): A0 holding; will focus closest enemy when it appears.\n A1 (1.0s): A1 holding; will focus fire on the closest enemy when seen.\n A2 (1.0s): Tightening up near (7.5,16); A2 holding formation, focus closest.\n A0 (1.5s): A0 holding; no enemies visible, will focus closest when seen.\n A1 (1.5s): A1 holding; will focus fire on the first enemy in range.\n A2 (1.5s): A2 holding at (8.3,15.7); will focus closest enemy with team.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A1 holding; no enemies yet, will focus closest when one appears.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-8e2a6ce4734f5ab31ff8201b.json b/examples/multi-agent-smax/results/llm-cache/ask-8e2a6ce4734f5ab31ff8201b.json new file mode 100644 index 00000000..72b92f4f --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-8e2a6ce4734f5ab31ff8201b.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.5 seconds into the battle.\nYou are A0, a marine at (10.3, 16.5) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1 marine at (10.1, 17.3), 45/45 health, order: attack E0\n A2 marine at (9.9, 15.8), 45/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (14.6, 16.4), 18/45 health, 4.3 away (in range)\n E1 marine at (13.8, 17.3), 45/45 health, 3.6 away (in range)\n E2 marine at (14.4, 14.8), 45/45 health, 4.4 away (in range)\nTeam chat (most recent last):\n A1 (2.0s): Enemies E0,E1 east ~8 away. Hold together, focus E0 when in range.\n A2 (2.0s): Holding here as a group; everyone focus fire on closest enemy, E0 first.\n A0 (2.5s): Holding. Enemies close in; all focus E0 when it enters range 5.\n A1 (2.5s): Holding; enemies at 6+ range. Focus E0 when it enters range 5.\n A2 (2.5s): A2 holding; let them come into range, focus E0 together.\n A0 (3.0s): E0 in range, all focus fire E0 now.\n A1 (3.0s): E0 in range, attacking E0 now. Everyone focus E0.\n A2 (3.0s): Attacking E0 now, E0 in range. Everyone focus fire E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Keep focusing E0 (18hp), then E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-8f328d937493e48ad8ac7986.json b/examples/multi-agent-smax/results/llm-cache/ask-8f328d937493e48ad8ac7986.json new file mode 100644 index 00000000..f565c23a --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-8f328d937493e48ad8ac7986.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.0 seconds into the battle.\nYou are A0, a marine at (8.1, 14.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (8.8, 14.6), 45/45 health, order: hold\n A2 marine at (7.4, 14.1), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (15.6, 17.2), 45/45 health, 7.9 away\n E1 marine at (13.3, 14.8), 45/45 health, 5.2 away\n E2 marine at (13.2, 17.6), 45/45 health, 6.0 away\nTeam chat (most recent last):\n A1 (1.5s): A1 holding. A0 is close now; focus closest enemy when seen.\n A2 (1.5s): A2 holding. Group is tight now; focus closest enemy when it appears.\n A0 (2.0s): A0 holding with the group; focus fire on closest enemy when in range.\n A1 (2.0s): Hold together. Focus fire E1 (closest) when in range.\n A2 (2.0s): A2 holding. E1 is at 9 range; let it come, then focus E1.\n A0 (2.5s): Holding. Focus fire E1 when it enters range 5.\n A1 (2.5s): Holding. Focus E1 when it enters range 5; all fire together.\n A2 (2.5s): A2 holding. Focus E1 when it enters range 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding. Focus E1 the moment it enters range 5.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-8fcaf100b1e39d8e99480e5a.json b/examples/multi-agent-smax/results/llm-cache/ask-8fcaf100b1e39d8e99480e5a.json new file mode 100644 index 00000000..9510ac84 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-8fcaf100b1e39d8e99480e5a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.5 seconds into the battle.\nYou are A2, a marine at (8.9, 14.0) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0: dead\n A1: dead\nEnemies you can see:\n E0 marine at (12.4, 17.2), 45/45 health, 4.8 away (in range)\n E2 marine at (11.6, 17.6), 9/45 health, 4.5 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A2 (4.0s): Firing E1 (27hp), keep focus until dead.\n A0 (4.5s): E1 at 9hp, finishing it. Then focus E2.\n A2 (4.5s): E1 at 9hp, finishing it now. Then focus E2, closest.\n A0 (5.0s): E1 dead. Focus E2, closest at 3.9. A2 fire too.\n A2 (5.0s): E1 down. Focus E2, closest at 4.5. A0, you're hurt, stay behind me.\n A0 (5.5s): Focus E2 (27hp), then E0. A2 keep firing.\n A2 (5.5s): Firing E2 (27hp). A0 stay back, I'm closest.\n A2 (6.0s): E2 at 18hp, finishing it. Then E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 at 9hp, finishing it. Then E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-95d2a02ec1774de384045f04.json b/examples/multi-agent-smax/results/llm-cache/ask-95d2a02ec1774de384045f04.json new file mode 100644 index 00000000..4d3f77f2 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-95d2a02ec1774de384045f04.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.0 seconds into the battle.\nYou are A0, a marine at (8.2, 16.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (9.8, 15.7), 45/45 health, order: hold\n A2 marine at (9.0, 16.2), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding together as a group; focus fire on the closest enemy when they appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-984d59e95ca7904204424198.json b/examples/multi-agent-smax/results/llm-cache/ask-984d59e95ca7904204424198.json new file mode 100644 index 00000000..2e53e9e9 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-984d59e95ca7904204424198.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.0 seconds into the battle.\nYou are A0, a marine at (8.1, 14.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 8.4 14.8.\nYour team:\n A1 marine at (8.8, 14.6), 45/45 health, order: hold\n A2 marine at (7.5, 14.2), 45/45 health, order: hold\nEnemies you can see:\n E1 marine at (16.4, 14.8), 45/45 health, 8.3 away\n E2 marine at (16.3, 17.6), 45/45 health, 8.8 away\nTeam chat (most recent last):\n A1 (0.5s): Holding. A0 is a bit far west; tighten up on me.\n A2 (0.5s): A2 holding; will focus fire on closest enemy when seen.\n A0 (1.0s): Moving east to tighten up on A1 and A2.\n A1 (1.0s): Holding. A0, move closer to me; focus closest enemy when seen.\n A2 (1.0s): A2 holding. A0, close up toward A1 and me; focus closest enemy.\n A0 (1.5s): Closing on A1 and A2 now; will focus the closest enemy when seen.\n A1 (1.5s): A1 holding. A0 is close now; focus closest enemy when seen.\n A2 (1.5s): A2 holding. Group is tight now; focus closest enemy when it appears.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A0 holding with the group; focus fire on closest enemy when in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-994acb01baf9f8a7d6a76bff.json b/examples/multi-agent-smax/results/llm-cache/ask-994acb01baf9f8a7d6a76bff.json new file mode 100644 index 00000000..f878a0a3 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-994acb01baf9f8a7d6a76bff.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.0 seconds into the battle.\nYou are A1, a marine at (9.6, 14.5) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (8.9, 14.8), 45/45 health, order: attack E1\n A2 marine at (8.9, 14.0), 45/45 health, order: attack E1\nEnemies you can see:\n E0 marine at (12.4, 17.2), 45/45 health, 3.8 away (in range)\n E1 marine at (13.3, 14.8), 27/45 health, 3.6 away (in range)\n E2 marine at (11.6, 17.6), 45/45 health, 3.7 away (in range)\nTeam chat (most recent last):\n A1 (2.5s): Holding. Focus E1 when it enters range 5; all fire together.\n A2 (2.5s): A2 holding. Focus E1 when it enters range 5.\n A0 (3.0s): Holding. Focus E1 the moment it enters range 5.\n A1 (3.0s): E1 in range at 4.5. All focus fire E1 now.\n A2 (3.0s): A2 holding. Focus E1 when it enters range 5; fire together.\n A0 (3.5s): Attacking E1 (36hp), closing to range. Focus E1 together.\n A1 (3.5s): Firing E1 (36hp). A0, A2 attack E1 too; E1 is 4.5 from me, others closing.\n A2 (3.5s): A2 attacking E1 now, focus fire together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E1 at 27hp, finish it. I'm low at 18hp, so cover me.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-9b8007d84a3a3e7ce72f10e8.json b/examples/multi-agent-smax/results/llm-cache/ask-9b8007d84a3a3e7ce72f10e8.json new file mode 100644 index 00000000..08111c23 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-9b8007d84a3a3e7ce72f10e8.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.5 seconds into the battle.\nYou are A0, a marine at (7.2, 15.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (6.5, 16.1), 45/45 health, order: hold\n A2 marine at (7.0, 18.0), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.0s): Holding together; focus fire on closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A0 (0.5s): Staying grouped; focus fire on closest enemy when seen.\n A1 (0.5s): A1 holding; will focus closest enemy when seen.\n A2 (0.5s): A2 holding at (7,18); stay grouped, focus closest enemy when seen.\n A0 (1.0s): A0 holding; will focus closest enemy when it appears.\n A1 (1.0s): A1 holding; will shoot closest enemy when seen, stay grouped.\n A2 (1.0s): A2 holding at (7,18); I'm slightly north, staying close to group.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A0 holding; no enemies yet. Focus closest when they appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-9b9d516a005b9ec88ba85142.json b/examples/multi-agent-smax/results/llm-cache/ask-9b9d516a005b9ec88ba85142.json new file mode 100644 index 00000000..e27244bc --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-9b9d516a005b9ec88ba85142.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.5 seconds into the battle.\nYou are A2, a marine at (8.4, 16.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.5, 18.0), 45/45 health, order: hold\n A1 marine at (8.6, 17.2), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): No enemies seen. Holding together; focus fire on the closest enemy once spotted.\n A1 (0.0s): Holding together as a group; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on the first enemy that enters range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding; will focus fire on the closest enemy once in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-9c59525009d1ff4f6b932f32.json b/examples/multi-agent-smax/results/llm-cache/ask-9c59525009d1ff4f6b932f32.json new file mode 100644 index 00000000..890491b7 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-9c59525009d1ff4f6b932f32.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.5 seconds into the battle.\nYou are A2, a marine at (8.1, 14.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 8 15.\nYour team:\n A0 marine at (8.1, 15.8), 45/45 health, order: hold\n A1 marine at (8.3, 14.1), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.0s): Holding together; no enemies seen. Stay grouped, focus fire on the closest.\n A2 (0.0s): Holding together as a group; focus fire on the closest enemy once seen.\n A0 (0.5s): Holding at (8,15); focus fire on closest enemy when seen.\n A1 (0.5s): Holding at (8,14); will focus fire closest enemy when seen.\n A2 (0.5s): Holding at group; will focus fire on closest enemy once seen.\n A0 (1.0s): Still holding at (8,15); no enemies yet. Focus fire closest when seen.\n A1 (1.0s): Holding at (8,14); focus fire closest enemy when seen.\n A2 (1.0s): Moving to group at (8,15); will focus fire closest enemy.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"In position at (8,15); holding, focus fire closest enemy when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-9cf485ace9e00a8aad8b2dc5.json b/examples/multi-agent-smax/results/llm-cache/ask-9cf485ace9e00a8aad8b2dc5.json new file mode 100644 index 00000000..4ad58445 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-9cf485ace9e00a8aad8b2dc5.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 0.0 seconds into the battle.\nYou are A2, a marine at (8.3, 17.3) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.9, 15.6), 45/45 health, order: hold\n A1 marine at (6.7, 14.2), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A2 holding. Will attack together once enemy is within 5 of all of us.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-9d829d4069e9e94421c817c9.json b/examples/multi-agent-smax/results/llm-cache/ask-9d829d4069e9e94421c817c9.json new file mode 100644 index 00000000..266edf4d --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-9d829d4069e9e94421c817c9.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.5 seconds into the battle.\nYou are A0, a marine at (7.9, 15.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 8 15.\nYour team:\n A1 marine at (8.6, 14.6), 45/45 health, order: hold\n A2 marine at (7.8, 14.7), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together as a group; focus fire on the closest enemy when they appear.\n A0 (0.5s): Holding. Will focus fire on the closest enemy once visible.\n A1 (0.5s): Holding. A0 is a bit far west; tighten up on me.\n A2 (0.5s): A2 holding; will focus fire on closest enemy when seen.\n A0 (1.0s): Moving east to tighten up on A1 and A2.\n A1 (1.0s): Holding. A0, move closer to me; focus closest enemy when seen.\n A2 (1.0s): A2 holding. A0, close up toward A1 and me; focus closest enemy.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 8.4 14.8\", \"say\": \"Closing on A1 and A2 now; will focus the closest enemy when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-9ffc7a8485117180f5342a44.json b/examples/multi-agent-smax/results/llm-cache/ask-9ffc7a8485117180f5342a44.json new file mode 100644 index 00000000..e1ea8f61 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-9ffc7a8485117180f5342a44.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.5 seconds into the battle.\nYou are A1, a marine at (8.6, 17.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (10.1, 18.0), 45/45 health, order: move 12 17\n A2 marine at (8.4, 16.0), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.0s): Holding together as a group; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on the first enemy that enters range.\n A0 (0.5s): Still no enemies. Holding; will focus fire on first one in range.\n A1 (0.5s): A1 holding; will focus fire on closest enemy when spotted.\n A2 (0.5s): Holding; will focus fire on the closest enemy once in range.\n A0 (1.0s): Advancing east slowly to find enemies; stay close, focus fire on closest.\n A1 (1.0s): A1 holding; no enemies yet. Focus fire on closest when spotted.\n A2 (1.0s): A2 holding; still no enemies. Will focus fire on closest once in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 11 17\", \"say\": \"A1 advancing east to stay with A0; keep grouped, focus closest.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-a0547a87978cfbf7bda9286c.json b/examples/multi-agent-smax/results/llm-cache/ask-a0547a87978cfbf7bda9286c.json new file mode 100644 index 00000000..13b8033d --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-a0547a87978cfbf7bda9286c.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.0 seconds into the battle.\nYou are A0, a marine at (7.2, 15.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (6.5, 16.1), 45/45 health, order: hold\n A2 marine at (7.0, 18.0), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A1 (0.0s): Holding together; focus fire on closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A0 (0.5s): Staying grouped; focus fire on closest enemy when seen.\n A1 (0.5s): A1 holding; will focus closest enemy when seen.\n A2 (0.5s): A2 holding at (7,18); stay grouped, focus closest enemy when seen.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A0 holding; will focus closest enemy when it appears.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-a1388afa8175977123ca4943.json b/examples/multi-agent-smax/results/llm-cache/ask-a1388afa8175977123ca4943.json new file mode 100644 index 00000000..36a9afe7 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-a1388afa8175977123ca4943.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.0 seconds into the battle.\nYou are A1, a marine at (6.5, 16.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.2, 15.8), 45/45 health, order: hold\n A2 marine at (7.0, 18.0), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A1 (0.0s): Holding together; focus fire on closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A0 (0.5s): Staying grouped; focus fire on closest enemy when seen.\n A1 (0.5s): A1 holding; will focus closest enemy when seen.\n A2 (0.5s): A2 holding at (7,18); stay grouped, focus closest enemy when seen.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A1 holding; will shoot closest enemy when seen, stay grouped.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-a13b76f401188cc42cc12108.json b/examples/multi-agent-smax/results/llm-cache/ask-a13b76f401188cc42cc12108.json new file mode 100644 index 00000000..3cd77dbe --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-a13b76f401188cc42cc12108.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.5 seconds into the battle.\nYou are A1, a marine at (6.7, 14.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.0, 15.5), 45/45 health, order: move 11 15.6\n A2 marine at (8.7, 15.8), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (15.2, 16.8), 45/45 health, 8.9 away\nTeam chat (most recent last):\n A1 (1.0s): A1 holding; will focus fire on the closest enemy when seen.\n A2 (1.0s): Tightening up near (7.5,16); A2 holding formation, focus closest.\n A0 (1.5s): A0 holding; no enemies visible, will focus closest when seen.\n A1 (1.5s): A1 holding; will focus fire on the first enemy in range.\n A2 (1.5s): A2 holding at (8.3,15.7); will focus closest enemy with team.\n A0 (2.0s): Advancing slowly east to scout; stay close, focus closest enemy when seen.\n A1 (2.0s): A1 holding; no enemies yet, will focus closest when one appears.\n A2 (2.0s): E0 at (16.8,16.8) approaching; hold and focus it when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A1 holding at (6.7,14.2); A0 fall back to us, focus E0 together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-a18fbb66ff94280766b70a3c.json b/examples/multi-agent-smax/results/llm-cache/ask-a18fbb66ff94280766b70a3c.json new file mode 100644 index 00000000..cfc68d52 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-a18fbb66ff94280766b70a3c.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.5 seconds into the battle.\nYou are A2, a marine at (7.4, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.1, 14.5), 45/45 health, order: hold\n A1 marine at (8.8, 14.6), 45/45 health, order: hold\nEnemies you can see:\n E1 marine at (14.8, 14.8), 45/45 health, 7.4 away\n E2 marine at (14.7, 17.6), 45/45 health, 8.1 away\nTeam chat (most recent last):\n A1 (1.0s): Holding. A0, move closer to me; focus closest enemy when seen.\n A2 (1.0s): A2 holding. A0, close up toward A1 and me; focus closest enemy.\n A0 (1.5s): Closing on A1 and A2 now; will focus the closest enemy when seen.\n A1 (1.5s): A1 holding. A0 is close now; focus closest enemy when seen.\n A2 (1.5s): A2 holding. Group is tight now; focus closest enemy when it appears.\n A0 (2.0s): A0 holding with the group; focus fire on closest enemy when in range.\n A1 (2.0s): Hold together. Focus fire E1 (closest) when in range.\n A2 (2.0s): A2 holding. E1 is at 9 range; let it come, then focus E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A2 holding. Focus E1 when it enters range 5.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-a64834217fbf0f665654c8b3.json b/examples/multi-agent-smax/results/llm-cache/ask-a64834217fbf0f665654c8b3.json new file mode 100644 index 00000000..77a085bc --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-a64834217fbf0f665654c8b3.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.5 seconds into the battle.\nYou are A1, a marine at (8.3, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 8.5 15.\nYour team:\n A0 marine at (9.7, 15.8), 45/45 health, order: move 10 15\n A2 marine at (8.1, 14.9), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (16.0, 15.0), 45/45 health, 7.7 away\n E1 marine at (16.5, 16.2), 45/45 health, 8.5 away\n E2 marine at (16.0, 14.3), 45/45 health, 7.7 away\nTeam chat (most recent last):\n A1 (1.0s): Holding at (8,14); focus fire closest enemy when seen.\n A2 (1.0s): Moving to group at (8,15); will focus fire closest enemy.\n A0 (1.5s): Holding at (8,16); grouped, focus fire closest enemy when seen.\n A1 (1.5s): Advancing east slowly to find enemies; stay grouped, focus closest.\n A2 (1.5s): In position at (8,15); holding, focus fire closest enemy when seen.\n A0 (2.0s): Moving east to group with A1; focus closest enemy when seen.\n A1 (2.0s): Falling back to group; hold and focus fire when enemies enter range.\n A2 (2.0s): A2 holding at (8,15); A1 is advancing east, stay close, focus closest.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Enemies east at 16,15. Hold grouped; focus fire on the closest, starting with E2 or E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-a7fd827d54f21feaf25b992e.json b/examples/multi-agent-smax/results/llm-cache/ask-a7fd827d54f21feaf25b992e.json new file mode 100644 index 00000000..7c902ea0 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-a7fd827d54f21feaf25b992e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.0 seconds into the battle.\nYou are A0, a marine at (10.3, 16.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (10.1, 17.3), 45/45 health, order: hold\n A2 marine at (9.9, 15.8), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (14.6, 16.4), 45/45 health, 4.3 away (in range)\n E1 marine at (15.4, 17.3), 45/45 health, 5.1 away\n E2 marine at (16.0, 14.8), 45/45 health, 5.9 away\nTeam chat (most recent last):\n A1 (1.5s): A1 advancing east to stay with A0; keep grouped, focus closest.\n A2 (1.5s): Moving east to join A0; stay grouped, focus closest enemy.\n A0 (2.0s): Holding here, grouped. Focus fire on E0 (closest) when in range.\n A1 (2.0s): Enemies E0,E1 east ~8 away. Hold together, focus E0 when in range.\n A2 (2.0s): Holding here as a group; everyone focus fire on closest enemy, E0 first.\n A0 (2.5s): Holding. Enemies close in; all focus E0 when it enters range 5.\n A1 (2.5s): Holding; enemies at 6+ range. Focus E0 when it enters range 5.\n A2 (2.5s): A2 holding; let them come into range, focus E0 together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 in range, all focus fire E0 now.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ab4bf3fe2fc100c11f214495.json b/examples/multi-agent-smax/results/llm-cache/ask-ab4bf3fe2fc100c11f214495.json new file mode 100644 index 00000000..5466b283 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ab4bf3fe2fc100c11f214495.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.0 seconds into the battle.\nYou are A0, a marine at (8.5, 18.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (8.6, 17.2), 45/45 health, order: hold\n A2 marine at (8.4, 16.0), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): No enemies seen. Holding together; focus fire on the closest enemy once spotted.\n A1 (0.0s): Holding together as a group; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on the first enemy that enters range.\n A0 (0.5s): Still no enemies. Holding; will focus fire on first one in range.\n A1 (0.5s): A1 holding; will focus fire on closest enemy when spotted.\n A2 (0.5s): Holding; will focus fire on the closest enemy once in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 17\", \"say\": \"Advancing east slowly to find enemies; stay close, focus fire on closest.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-b210980082297735dd49a602.json b/examples/multi-agent-smax/results/llm-cache/ask-b210980082297735dd49a602.json new file mode 100644 index 00000000..349ebdd8 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-b210980082297735dd49a602.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.0 seconds into the battle.\nYou are A2, a marine at (6.5, 14.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.1, 15.8), 45/45 health, order: hold\n A1 marine at (8.3, 14.1), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Regrouping with you both at (8,15); hold together, focus fire once enemies appear.\n A1 (0.0s): Holding together; no enemies seen. Stay grouped, focus fire on the closest.\n A2 (0.0s): Holding together as a group; focus fire on the closest enemy once seen.\n A0 (0.5s): Holding at (8,15); focus fire on closest enemy when seen.\n A1 (0.5s): Holding at (8,14); will focus fire closest enemy when seen.\n A2 (0.5s): Holding at group; will focus fire on closest enemy once seen.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 8 15\", \"say\": \"Moving to group at (8,15); will focus fire closest enemy.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-b23986eec530787953462c2e.json b/examples/multi-agent-smax/results/llm-cache/ask-b23986eec530787953462c2e.json new file mode 100644 index 00000000..4039b55c --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-b23986eec530787953462c2e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.5 seconds into the battle.\nYou are A1, a marine at (6.5, 16.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.2, 15.7), 45/45 health, order: hold\n A2 marine at (7.1, 16.5), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (1.0s): A1 holding; will shoot closest enemy when seen, stay grouped.\n A2 (1.0s): A2 holding at (7,18); I'm slightly north, staying close to group.\n A0 (1.5s): A0 holding; no enemies yet. Focus closest when they appear.\n A1 (1.5s): A1 holding; no enemies yet. Focus closest when they appear.\n A2 (1.5s): A2 moving south to tighten up with the group; focus closest enemy.\n A0 (2.0s): A0 holding; no enemies seen. Focus closest when they appear.\n A1 (2.0s): A1 holding; no enemies visible. Focus closest when they appear.\n A2 (2.0s): A2 holding at (7,16.5), grouped with team; focus closest enemy.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A1 holding in formation; all focus fire on closest enemy when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-b25f2702511b2c1bdb3833a1.json b/examples/multi-agent-smax/results/llm-cache/ask-b25f2702511b2c1bdb3833a1.json new file mode 100644 index 00000000..1916b18d --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-b25f2702511b2c1bdb3833a1.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.5 seconds into the battle.\nYou are A1, a marine at (6.7, 14.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.9, 15.6), 45/45 health, order: hold\n A2 marine at (8.3, 17.3), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together; stay grouped and focus fire on the first enemy that appears.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together near (7,16); focus fire on whoever appears first.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A1 holding at (6.7,14.2); will focus the closest enemy that appears.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-b5ef7ae741f66d4a8b31ad78.json b/examples/multi-agent-smax/results/llm-cache/ask-b5ef7ae741f66d4a8b31ad78.json new file mode 100644 index 00000000..1c09e684 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-b5ef7ae741f66d4a8b31ad78.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.5 seconds into the battle.\nYou are A2, a marine at (7.0, 18.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.2, 15.8), 45/45 health, order: hold\n A1 marine at (6.5, 16.1), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.0s): Holding together; focus fire on closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A0 (0.5s): Staying grouped; focus fire on closest enemy when seen.\n A1 (0.5s): A1 holding; will focus closest enemy when seen.\n A2 (0.5s): A2 holding at (7,18); stay grouped, focus closest enemy when seen.\n A0 (1.0s): A0 holding; will focus closest enemy when it appears.\n A1 (1.0s): A1 holding; will shoot closest enemy when seen, stay grouped.\n A2 (1.0s): A2 holding at (7,18); I'm slightly north, staying close to group.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 7 16.5\", \"say\": \"A2 moving south to tighten up with the group; focus closest enemy.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-b799d0e362b2879fbfd98336.json b/examples/multi-agent-smax/results/llm-cache/ask-b799d0e362b2879fbfd98336.json new file mode 100644 index 00000000..5a092700 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-b799d0e362b2879fbfd98336.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.0 seconds into the battle.\nYou are A0, a marine at (10.3, 16.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 11 17.\nYour team:\n A1 marine at (10.1, 17.3), 45/45 health, order: move 11 17\n A2 marine at (9.9, 15.8), 45/45 health, order: move 11 17\nEnemies you can see:\n E0 marine at (17.7, 16.4), 45/45 health, 7.4 away\n E1 marine at (18.5, 17.3), 45/45 health, 8.3 away\n E2 marine at (19.1, 14.8), 45/45 health, 9.0 away\nTeam chat (most recent last):\n A1 (0.5s): A1 holding; will focus fire on closest enemy when spotted.\n A2 (0.5s): Holding; will focus fire on the closest enemy once in range.\n A0 (1.0s): Advancing east slowly to find enemies; stay close, focus fire on closest.\n A1 (1.0s): A1 holding; no enemies yet. Focus fire on closest when spotted.\n A2 (1.0s): A2 holding; still no enemies. Will focus fire on closest once in range.\n A0 (1.5s): Advancing slowly east; teammates please close up on me, focus closest.\n A1 (1.5s): A1 advancing east to stay with A0; keep grouped, focus closest.\n A2 (1.5s): Moving east to join A0; stay grouped, focus closest enemy.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding here, grouped. Focus fire on E0 (closest) when in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-b985aedb2c9539243d9e9a22.json b/examples/multi-agent-smax/results/llm-cache/ask-b985aedb2c9539243d9e9a22.json new file mode 100644 index 00000000..b4dc2548 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-b985aedb2c9539243d9e9a22.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.0 seconds into the battle.\nYou are A2, a marine at (7.5, 14.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.1, 14.5), 45/45 health, order: move 8.4 14.8\n A1 marine at (8.8, 14.6), 45/45 health, order: hold\nEnemies you can see:\n E1 marine at (16.4, 14.8), 45/45 health, 9.0 away\nTeam chat (most recent last):\n A1 (0.5s): Holding. A0 is a bit far west; tighten up on me.\n A2 (0.5s): A2 holding; will focus fire on closest enemy when seen.\n A0 (1.0s): Moving east to tighten up on A1 and A2.\n A1 (1.0s): Holding. A0, move closer to me; focus closest enemy when seen.\n A2 (1.0s): A2 holding. A0, close up toward A1 and me; focus closest enemy.\n A0 (1.5s): Closing on A1 and A2 now; will focus the closest enemy when seen.\n A1 (1.5s): A1 holding. A0 is close now; focus closest enemy when seen.\n A2 (1.5s): A2 holding. Group is tight now; focus closest enemy when it appears.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A2 holding. E1 is at 9 range; let it come, then focus E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-bb10817982d2dc1093aff16b.json b/examples/multi-agent-smax/results/llm-cache/ask-bb10817982d2dc1093aff16b.json new file mode 100644 index 00000000..f1b104eb --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-bb10817982d2dc1093aff16b.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.0 seconds into the battle.\nYou are A2, a marine at (8.7, 15.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.0, 15.5), 45/45 health, order: hold\n A1 marine at (6.7, 14.2), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (13.6, 16.8), 45/45 health, 5.0 away (in range)\n E1 marine at (15.3, 16.2), 45/45 health, 6.6 away\n E2 marine at (15.4, 17.3), 45/45 health, 6.8 away\nTeam chat (most recent last):\n A1 (1.5s): A1 holding; will focus fire on the first enemy in range.\n A2 (1.5s): A2 holding at (8.3,15.7); will focus closest enemy with team.\n A0 (2.0s): Advancing slowly east to scout; stay close, focus closest enemy when seen.\n A1 (2.0s): A1 holding; no enemies yet, will focus closest when one appears.\n A2 (2.0s): E0 at (16.8,16.8) approaching; hold and focus it when in range.\n A0 (2.5s): A0 holding with you; enemies approaching, focus E0 when in range.\n A1 (2.5s): A1 holding at (6.7,14.2); A0 fall back to us, focus E0 together.\n A2 (2.5s): A2 holding; enemies approaching, all focus E0 when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"A2 attacking E0 (in range); all focus E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-c044aef0d20390b06f43d799.json b/examples/multi-agent-smax/results/llm-cache/ask-c044aef0d20390b06f43d799.json new file mode 100644 index 00000000..5b940895 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-c044aef0d20390b06f43d799.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad just fought a battle on map 3m and lost. Here is how it went, one line per half second:\nour units' orders and health, the enemies' health, and what was said on team chat.\n\n 0.0s A0 hold (45hp) A1 hold (45hp) A2 hold (45hp) | E0 45hp E1 45hp E2 45hp\n A0 said: Holding together; focus fire on closest enemy once they appear.\n A1 said: Holding together; focus fire on the closest enemy when they appear.\n A2 said: Holding together as a group; focus fire on the closest enemy when they appear.\n 0.5s A0 hold (45hp) A1 hold (45hp) A2 hold (45hp) | E0 45hp E1 45hp E2 45hp\n A0 said: Holding. Will focus fire on the closest enemy once visible.\n A1 said: Holding. A0 is a bit far west; tighten up on me.\n A2 said: A2 holding; will focus fire on closest enemy when seen.\n 1.0s A0 move 8 15 (45hp) A1 hold (45hp) A2 hold (45hp) | E0 45hp E1 45hp E2 45hp\n A0 said: Moving east to tighten up on A1 and A2.\n A1 said: Holding. A0, move closer to me; focus closest enemy when seen.\n A2 said: A2 holding. A0, close up toward A1 and me; focus closest enemy.\n 1.5s A0 move 8.4 14.8 (45hp) A1 hold (45hp) A2 hold (45hp) | E0 45hp E1 45hp E2 45hp\n A0 said: Closing on A1 and A2 now; will focus the closest enemy when seen.\n A1 said: A1 holding. A0 is close now; focus closest enemy when seen.\n A2 said: A2 holding. Group is tight now; focus closest enemy when it appears.\n 2.0s A0 hold (45hp) A1 hold (45hp) A2 hold (45hp) | E0 45hp E1 45hp E2 45hp\n A0 said: A0 holding with the group; focus fire on closest enemy when in range.\n A1 said: Hold together. Focus fire E1 (closest) when in range.\n A2 said: A2 holding. E1 is at 9 range; let it come, then focus E1.\n 2.5s A0 hold (45hp) A1 hold (45hp) A2 hold (45hp) | E0 45hp E1 45hp E2 45hp\n A0 said: Holding. Focus fire E1 when it enters range 5.\n A1 said: Holding. Focus E1 when it enters range 5; all fire together.\n A2 said: A2 holding. Focus E1 when it enters range 5.\n 3.0s A0 hold (45hp) A1 attack E1 (45hp) A2 hold (45hp) | E0 45hp E1 45hp E2 45hp\n A0 said: Holding. Focus E1 the moment it enters range 5.\n A1 said: E1 in range at 4.5. All focus fire E1 now.\n A2 said: A2 holding. Focus E1 when it enters range 5; fire together.\n 3.5s A0 attack E1 (45hp) A1 attack E1 (36hp) A2 attack E1 (45hp) | E0 45hp E1 36hp E2 45hp\n A0 said: Attacking E1 (36hp), closing to range. Focus E1 together.\n A1 said: Firing E1 (36hp). A0, A2 attack E1 too; E1 is 4.5 from me, others closing.\n A2 said: A2 attacking E1 now, focus fire together.\n 4.0s A0 attack E1 (45hp) A1 attack E1 (18hp) A2 attack E1 (45hp) | E0 45hp E1 27hp E2 45hp\n A0 said: Firing E1 (27hp). Keep focus, A1 is hurt, stay behind us.\n A1 said: E1 at 27hp, finish it. I'm low at 18hp, so cover me.\n A2 said: Firing E1 (27hp), keep focus until dead.\n 4.5s A0 attack E1 (45hp) A1 dead A2 attack E1 (45hp) | E0 45hp E1 9hp E2 45hp\n A0 said: E1 at 9hp, finishing it. Then focus E2.\n A2 said: E1 at 9hp, finishing it now. Then focus E2, closest.\n 5.0s A0 attack E2 (27hp) A1 dead A2 attack E2 (45hp) | E0 45hp E1 dead E2 45hp\n A0 said: E1 dead. Focus E2, closest at 3.9. A2 fire too.\n A2 said: E1 down. Focus E2, closest at 4.5. A0, you're hurt, stay behind me.\n 5.5s A0 attack E2 (18hp) A1 dead A2 attack E2 (45hp) | E0 45hp E1 dead E2 27hp\n A0 said: Focus E2 (27hp), then E0. A2 keep firing.\n A2 said: Firing E2 (27hp). A0 stay back, I'm closest.\n 6.0s A0 dead A1 dead A2 attack E2 (45hp) | E0 45hp E1 dead E2 18hp\n A2 said: E2 at 18hp, finishing it. Then E0.\n 6.5s A0 dead A1 dead A2 attack E2 (36hp) | E0 45hp E1 dead E2 9hp\n A2 said: E2 at 9hp, finishing it. Then E0.\n 7.0s A0 dead A1 dead A2 attack E2 (18hp) | E0 45hp E1 dead E2 9hp\n A2 said: E2 at 9hp, finishing it. Then E0 alone.\n 7.5s A0 dead A1 dead A2 attack E0 (18hp) | E0 45hp E1 dead E2 dead\n A2 said: E2 down. Last enemy E0, 45hp, engaging.\n 8.0s A0 dead A1 dead A2 attack E0 (9hp) | E0 36hp E1 dead E2 dead\n A2 said: Last enemy E0 at 36hp. I'm at 9hp, fighting on.\n 8.5s A0 dead A1 dead A2 attack E0 (9hp) | E0 27hp E1 dead E2 dead\n A2 said: E0 at 27hp, I'm at 9hp. Last enemy, firing.\n 9.0s A0 dead A1 dead A2 dead | E0 27hp E1 dead E2 dead\n\nRULES.md is empty.\nWrite ONE new rule for your squad's RULES.md that would have helped you win this battle. Every unit in your\nsquad will read RULES.md before every order in later battles. Make it a concrete rule about what a unit should\ndo, in one sentence, and do not repeat a rule already there.\nReply with JSON only: {\"rule\": \"\"}", + "response": "{\"rule\": \"Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-c0757f5f1fe819d92a682aec.json b/examples/multi-agent-smax/results/llm-cache/ask-c0757f5f1fe819d92a682aec.json new file mode 100644 index 00000000..94447bb2 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-c0757f5f1fe819d92a682aec.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.0 seconds into the battle.\nYou are A1, a marine at (9.9, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 11 15.\nYour team:\n A0 marine at (8.1, 15.8), 45/45 health, order: hold\n A2 marine at (8.1, 14.9), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (17.6, 15.0), 45/45 health, 7.7 away\n E1 marine at (18.1, 16.2), 45/45 health, 8.5 away\n E2 marine at (17.6, 14.3), 45/45 health, 7.7 away\nTeam chat (most recent last):\n A1 (0.5s): Holding at (8,14); will focus fire closest enemy when seen.\n A2 (0.5s): Holding at group; will focus fire on closest enemy once seen.\n A0 (1.0s): Still holding at (8,15); no enemies yet. Focus fire closest when seen.\n A1 (1.0s): Holding at (8,14); focus fire closest enemy when seen.\n A2 (1.0s): Moving to group at (8,15); will focus fire closest enemy.\n A0 (1.5s): Holding at (8,16); grouped, focus fire closest enemy when seen.\n A1 (1.5s): Advancing east slowly to find enemies; stay grouped, focus closest.\n A2 (1.5s): In position at (8,15); holding, focus fire closest enemy when seen.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 8.5 15\", \"say\": \"Falling back to group; hold and focus fire when enemies enter range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-c208c97f3e3638d730e506b4.json b/examples/multi-agent-smax/results/llm-cache/ask-c208c97f3e3638d730e506b4.json new file mode 100644 index 00000000..b16ff81b --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-c208c97f3e3638d730e506b4.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.5 seconds into the battle.\nYou are A2, a marine at (7.0, 18.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.2, 15.8), 45/45 health, order: hold\n A1 marine at (6.5, 16.1), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A1 (0.0s): Holding together; focus fire on closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on the closest enemy when they appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A2 holding at (7,18); stay grouped, focus closest enemy when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-c306fa918ca95be55007b19d.json b/examples/multi-agent-smax/results/llm-cache/ask-c306fa918ca95be55007b19d.json new file mode 100644 index 00000000..d464bbb5 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-c306fa918ca95be55007b19d.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.0 seconds into the battle.\nYou are A2, a marine at (7.0, 18.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.2, 15.8), 45/45 health, order: hold\n A1 marine at (6.5, 16.1), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A1 (0.0s): Holding together; focus fire on closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A0 (0.5s): Staying grouped; focus fire on closest enemy when seen.\n A1 (0.5s): A1 holding; will focus closest enemy when seen.\n A2 (0.5s): A2 holding at (7,18); stay grouped, focus closest enemy when seen.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A2 holding at (7,18); I'm slightly north, staying close to group.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-c4137c72e4f32c8a1bb1cab9.json b/examples/multi-agent-smax/results/llm-cache/ask-c4137c72e4f32c8a1bb1cab9.json new file mode 100644 index 00000000..1b5b6d3e --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-c4137c72e4f32c8a1bb1cab9.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.5 seconds into the battle.\nYou are A2, a marine at (6.5, 14.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.1, 15.8), 45/45 health, order: move 8 15.5\n A1 marine at (8.3, 14.1), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Regrouping with you both at (8,15); hold together, focus fire once enemies appear.\n A1 (0.0s): Holding together; no enemies seen. Stay grouped, focus fire on the closest.\n A2 (0.0s): Holding together as a group; focus fire on the closest enemy once seen.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding at group; will focus fire on closest enemy once seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-c448fe9ceb41e8321f689bf7.json b/examples/multi-agent-smax/results/llm-cache/ask-c448fe9ceb41e8321f689bf7.json new file mode 100644 index 00000000..ff589334 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-c448fe9ceb41e8321f689bf7.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.0 seconds into the battle.\nYou are A1, a marine at (10.1, 17.3) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 11 17.\nYour team:\n A0 marine at (10.3, 16.5), 45/45 health, order: move 11 17\n A2 marine at (9.9, 15.8), 45/45 health, order: move 11 17\nEnemies you can see:\n E0 marine at (17.7, 16.4), 45/45 health, 7.7 away\n E1 marine at (18.5, 17.3), 45/45 health, 8.5 away\nTeam chat (most recent last):\n A1 (0.5s): A1 holding; will focus fire on closest enemy when spotted.\n A2 (0.5s): Holding; will focus fire on the closest enemy once in range.\n A0 (1.0s): Advancing east slowly to find enemies; stay close, focus fire on closest.\n A1 (1.0s): A1 holding; no enemies yet. Focus fire on closest when spotted.\n A2 (1.0s): A2 holding; still no enemies. Will focus fire on closest once in range.\n A0 (1.5s): Advancing slowly east; teammates please close up on me, focus closest.\n A1 (1.5s): A1 advancing east to stay with A0; keep grouped, focus closest.\n A2 (1.5s): Moving east to join A0; stay grouped, focus closest enemy.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Enemies E0,E1 east ~8 away. Hold together, focus E0 when in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-c453404863c5bac720735db3.json b/examples/multi-agent-smax/results/llm-cache/ask-c453404863c5bac720735db3.json new file mode 100644 index 00000000..ad2c0ca8 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-c453404863c5bac720735db3.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 0.5 seconds into the battle.\nYou are A1, a marine at (6.7, 14.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.9, 15.6), 45/45 health, order: hold\n A2 marine at (8.3, 17.3), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding per rules until enemy within 5 of all; then focus same target.\n A1 (0.0s): A1 holding. No enemies seen; wait until all in range 5, then focus same target.\n A2 (0.0s): A2 holding. Will attack together once enemy is within 5 of all of us.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A1 holding; no enemies visible yet. Will focus same target once all in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-c5a41ff8a5b7ec66fa3b9fef.json b/examples/multi-agent-smax/results/llm-cache/ask-c5a41ff8a5b7ec66fa3b9fef.json new file mode 100644 index 00000000..d3b5fb55 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-c5a41ff8a5b7ec66fa3b9fef.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.0 seconds into the battle.\nYou are A2, a marine at (8.4, 16.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.5, 18.0), 45/45 health, order: hold\n A1 marine at (8.6, 17.2), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): No enemies seen. Holding together; focus fire on the closest enemy once spotted.\n A1 (0.0s): Holding together as a group; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on the first enemy that enters range.\n A0 (0.5s): Still no enemies. Holding; will focus fire on first one in range.\n A1 (0.5s): A1 holding; will focus fire on closest enemy when spotted.\n A2 (0.5s): Holding; will focus fire on the closest enemy once in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A2 holding; still no enemies. Will focus fire on closest once in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-caaac786bed9a0605231a4a8.json b/examples/multi-agent-smax/results/llm-cache/ask-caaac786bed9a0605231a4a8.json new file mode 100644 index 00000000..a848491f --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-caaac786bed9a0605231a4a8.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.5 seconds into the battle.\nYou are A0, a marine at (10.3, 16.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (10.1, 17.3), 45/45 health, order: hold\n A2 marine at (9.9, 15.8), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (16.2, 16.4), 45/45 health, 5.9 away\n E1 marine at (17.0, 17.3), 45/45 health, 6.7 away\n E2 marine at (17.5, 14.8), 45/45 health, 7.4 away\nTeam chat (most recent last):\n A1 (1.0s): A1 holding; no enemies yet. Focus fire on closest when spotted.\n A2 (1.0s): A2 holding; still no enemies. Will focus fire on closest once in range.\n A0 (1.5s): Advancing slowly east; teammates please close up on me, focus closest.\n A1 (1.5s): A1 advancing east to stay with A0; keep grouped, focus closest.\n A2 (1.5s): Moving east to join A0; stay grouped, focus closest enemy.\n A0 (2.0s): Holding here, grouped. Focus fire on E0 (closest) when in range.\n A1 (2.0s): Enemies E0,E1 east ~8 away. Hold together, focus E0 when in range.\n A2 (2.0s): Holding here as a group; everyone focus fire on closest enemy, E0 first.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding. Enemies close in; all focus E0 when it enters range 5.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ccb797298531c8c924d0c9fb.json b/examples/multi-agent-smax/results/llm-cache/ask-ccb797298531c8c924d0c9fb.json new file mode 100644 index 00000000..1314487a --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ccb797298531c8c924d0c9fb.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.0 seconds into the battle.\nYou are A1, a marine at (8.3, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.1, 15.8), 45/45 health, order: hold\n A2 marine at (6.5, 14.9), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Regrouping with you both at (8,15); hold together, focus fire once enemies appear.\n A1 (0.0s): Holding together; no enemies seen. Stay grouped, focus fire on the closest.\n A2 (0.0s): Holding together as a group; focus fire on the closest enemy once seen.\n A0 (0.5s): Holding at (8,15); focus fire on closest enemy when seen.\n A1 (0.5s): Holding at (8,14); will focus fire closest enemy when seen.\n A2 (0.5s): Holding at group; will focus fire on closest enemy once seen.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding at (8,14); focus fire closest enemy when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-cdd8d44d00300e8188e6ae40.json b/examples/multi-agent-smax/results/llm-cache/ask-cdd8d44d00300e8188e6ae40.json new file mode 100644 index 00000000..108e0421 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-cdd8d44d00300e8188e6ae40.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 0.5 seconds into the battle.\nYou are A0, a marine at (6.9, 15.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (6.7, 14.2), 45/45 health, order: hold\n A2 marine at (8.3, 17.3), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding per rules until enemy within 5 of all; then focus same target.\n A1 (0.0s): A1 holding. No enemies seen; wait until all in range 5, then focus same target.\n A2 (0.0s): A2 holding. Will attack together once enemy is within 5 of all of us.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A0 holding. No enemies yet; will focus the same target once all in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-cff31db073b3840be44391d8.json b/examples/multi-agent-smax/results/llm-cache/ask-cff31db073b3840be44391d8.json new file mode 100644 index 00000000..0e7d7222 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-cff31db073b3840be44391d8.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.0 seconds into the battle.\nYou are A2, a marine at (8.1, 14.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.1, 15.8), 45/45 health, order: hold\n A1 marine at (9.9, 14.1), 45/45 health, order: move 11 15\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.5s): Holding at (8,14); will focus fire closest enemy when seen.\n A2 (0.5s): Holding at group; will focus fire on closest enemy once seen.\n A0 (1.0s): Still holding at (8,15); no enemies yet. Focus fire closest when seen.\n A1 (1.0s): Holding at (8,14); focus fire closest enemy when seen.\n A2 (1.0s): Moving to group at (8,15); will focus fire closest enemy.\n A0 (1.5s): Holding at (8,16); grouped, focus fire closest enemy when seen.\n A1 (1.5s): Advancing east slowly to find enemies; stay grouped, focus closest.\n A2 (1.5s): In position at (8,15); holding, focus fire closest enemy when seen.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A2 holding at (8,15); A1 is advancing east, stay close, focus closest.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-d46718bf55b552c6d9ed521b.json b/examples/multi-agent-smax/results/llm-cache/ask-d46718bf55b552c6d9ed521b.json new file mode 100644 index 00000000..93342c00 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-d46718bf55b552c6d9ed521b.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.5 seconds into the battle.\nYou are A0, a marine at (6.4, 15.4) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (8.6, 14.6), 45/45 health, order: hold\n A2 marine at (7.8, 14.7), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together; focus fire on closest enemy once they appear.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together as a group; focus fire on the closest enemy when they appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding. Will focus fire on the closest enemy once visible.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-d59e9a35baeb72285e900dd0.json b/examples/multi-agent-smax/results/llm-cache/ask-d59e9a35baeb72285e900dd0.json new file mode 100644 index 00000000..43aaf04c --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-d59e9a35baeb72285e900dd0.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.5 seconds into the battle.\nYou are A0, a marine at (8.1, 14.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (8.8, 14.6), 36/45 health, order: attack E1\n A2 marine at (7.4, 14.1), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (14.0, 17.2), 45/45 health, 6.5 away\n E1 marine at (13.3, 14.8), 36/45 health, 5.2 away\n E2 marine at (11.6, 17.6), 45/45 health, 4.7 away (in range)\nTeam chat (most recent last):\n A1 (2.0s): Hold together. Focus fire E1 (closest) when in range.\n A2 (2.0s): A2 holding. E1 is at 9 range; let it come, then focus E1.\n A0 (2.5s): Holding. Focus fire E1 when it enters range 5.\n A1 (2.5s): Holding. Focus E1 when it enters range 5; all fire together.\n A2 (2.5s): A2 holding. Focus E1 when it enters range 5.\n A0 (3.0s): Holding. Focus E1 the moment it enters range 5.\n A1 (3.0s): E1 in range at 4.5. All focus fire E1 now.\n A2 (3.0s): A2 holding. Focus E1 when it enters range 5; fire together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Attacking E1 (36hp), closing to range. Focus E1 together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-d5ddb70b3dfabba016d7dc56.json b/examples/multi-agent-smax/results/llm-cache/ask-d5ddb70b3dfabba016d7dc56.json new file mode 100644 index 00000000..4961a193 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-d5ddb70b3dfabba016d7dc56.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.5 seconds into the battle.\nYou are A2, a marine at (7.4, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.1, 14.5), 45/45 health, order: hold\n A1 marine at (8.8, 14.6), 36/45 health, order: attack E1\nEnemies you can see:\n E0 marine at (14.0, 17.2), 45/45 health, 7.2 away\n E1 marine at (13.3, 14.8), 36/45 health, 5.9 away\n E2 marine at (11.6, 17.6), 45/45 health, 5.4 away\nTeam chat (most recent last):\n A1 (2.0s): Hold together. Focus fire E1 (closest) when in range.\n A2 (2.0s): A2 holding. E1 is at 9 range; let it come, then focus E1.\n A0 (2.5s): Holding. Focus fire E1 when it enters range 5.\n A1 (2.5s): Holding. Focus E1 when it enters range 5; all fire together.\n A2 (2.5s): A2 holding. Focus E1 when it enters range 5.\n A0 (3.0s): Holding. Focus E1 the moment it enters range 5.\n A1 (3.0s): E1 in range at 4.5. All focus fire E1 now.\n A2 (3.0s): A2 holding. Focus E1 when it enters range 5; fire together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A2 attacking E1 now, focus fire together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-d65f153a05b134e9fcc22871.json b/examples/multi-agent-smax/results/llm-cache/ask-d65f153a05b134e9fcc22871.json new file mode 100644 index 00000000..4dc24af1 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-d65f153a05b134e9fcc22871.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.0 seconds into the battle.\nYou are A2, a marine at (6.5, 14.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.1, 17.4), 45/45 health, order: hold\n A1 marine at (8.3, 14.1), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding together as a group; focus fire on the closest enemy once seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-dabc5de41b5052d4765d468f.json b/examples/multi-agent-smax/results/llm-cache/ask-dabc5de41b5052d4765d468f.json new file mode 100644 index 00000000..29f8861b --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-dabc5de41b5052d4765d468f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.5 seconds into the battle.\nYou are A2, a marine at (7.8, 14.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.4, 15.4), 45/45 health, order: hold\n A1 marine at (8.6, 14.6), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together; focus fire on closest enemy once they appear.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together as a group; focus fire on the closest enemy when they appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A2 holding; will focus fire on closest enemy when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-de53961d0a4c886ae397852e.json b/examples/multi-agent-smax/results/llm-cache/ask-de53961d0a4c886ae397852e.json new file mode 100644 index 00000000..a7c55c01 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-de53961d0a4c886ae397852e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.0 seconds into the battle.\nYou are A2, a marine at (7.1, 16.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.2, 15.7), 45/45 health, order: hold\n A1 marine at (6.5, 16.0), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (15.4, 17.7), 45/45 health, 8.5 away\n E2 marine at (15.0, 14.7), 45/45 health, 8.1 away\nTeam chat (most recent last):\n A1 (1.5s): A1 holding; no enemies yet. Focus closest when they appear.\n A2 (1.5s): A2 moving south to tighten up with the group; focus closest enemy.\n A0 (2.0s): A0 holding; no enemies seen. Focus closest when they appear.\n A1 (2.0s): A1 holding; no enemies visible. Focus closest when they appear.\n A2 (2.0s): A2 holding at (7,16.5), grouped with team; focus closest enemy.\n A0 (2.5s): A0 holding; waiting for enemies to come into range, focus closest.\n A1 (2.5s): A1 holding in formation; all focus fire on closest enemy when seen.\n A2 (2.5s): A2 holding; will focus closest enemy when seen.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A2 holding; enemies at 8 range, let them come in, focus closest.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-dfdd72d87686022c6ad5e198.json b/examples/multi-agent-smax/results/llm-cache/ask-dfdd72d87686022c6ad5e198.json new file mode 100644 index 00000000..1507ec83 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-dfdd72d87686022c6ad5e198.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.5 seconds into the battle.\nYou are A1, a marine at (8.8, 14.6) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (8.1, 14.5), 45/45 health, order: hold\n A2 marine at (7.4, 14.1), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (14.0, 17.2), 45/45 health, 5.8 away\n E1 marine at (13.3, 14.8), 36/45 health, 4.5 away (in range)\n E2 marine at (11.6, 17.6), 45/45 health, 4.1 away (in range)\nTeam chat (most recent last):\n A1 (2.0s): Hold together. Focus fire E1 (closest) when in range.\n A2 (2.0s): A2 holding. E1 is at 9 range; let it come, then focus E1.\n A0 (2.5s): Holding. Focus fire E1 when it enters range 5.\n A1 (2.5s): Holding. Focus E1 when it enters range 5; all fire together.\n A2 (2.5s): A2 holding. Focus E1 when it enters range 5.\n A0 (3.0s): Holding. Focus E1 the moment it enters range 5.\n A1 (3.0s): E1 in range at 4.5. All focus fire E1 now.\n A2 (3.0s): A2 holding. Focus E1 when it enters range 5; fire together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Firing E1 (36hp). A0, A2 attack E1 too; E1 is 4.5 from me, others closing.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-e01f5d39e7b100a7a50ec147.json b/examples/multi-agent-smax/results/llm-cache/ask-e01f5d39e7b100a7a50ec147.json new file mode 100644 index 00000000..769df650 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-e01f5d39e7b100a7a50ec147.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.5 seconds into the battle.\nYou are A1, a marine at (8.6, 14.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.9, 15.5), 45/45 health, order: move 8 15\n A2 marine at (7.8, 14.7), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together as a group; focus fire on the closest enemy when they appear.\n A0 (0.5s): Holding. Will focus fire on the closest enemy once visible.\n A1 (0.5s): Holding. A0 is a bit far west; tighten up on me.\n A2 (0.5s): A2 holding; will focus fire on closest enemy when seen.\n A0 (1.0s): Moving east to tighten up on A1 and A2.\n A1 (1.0s): Holding. A0, move closer to me; focus closest enemy when seen.\n A2 (1.0s): A2 holding. A0, close up toward A1 and me; focus closest enemy.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A1 holding. A0 is close now; focus closest enemy when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-e4e69036b1b7a923de998631.json b/examples/multi-agent-smax/results/llm-cache/ask-e4e69036b1b7a923de998631.json new file mode 100644 index 00000000..f4192872 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-e4e69036b1b7a923de998631.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.0 seconds into the battle.\nYou are A1, a marine at (8.6, 17.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.5, 18.0), 45/45 health, order: hold\n A2 marine at (8.4, 16.0), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding together as a group; focus fire on the closest enemy when they appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-e7630efde281d51501457442.json b/examples/multi-agent-smax/results/llm-cache/ask-e7630efde281d51501457442.json new file mode 100644 index 00000000..12467a9c --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-e7630efde281d51501457442.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.5 seconds into the battle.\nYou are A0, a marine at (7.2, 15.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (6.5, 16.0), 45/45 health, order: hold\n A2 marine at (7.1, 16.5), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (13.9, 17.7), 45/45 health, 6.9 away\n E1 marine at (14.7, 16.0), 45/45 health, 7.5 away\n E2 marine at (13.4, 14.7), 45/45 health, 6.2 away\nTeam chat (most recent last):\n A1 (2.0s): A1 holding; no enemies visible. Focus closest when they appear.\n A2 (2.0s): A2 holding at (7,16.5), grouped with team; focus closest enemy.\n A0 (2.5s): A0 holding; waiting for enemies to come into range, focus closest.\n A1 (2.5s): A1 holding in formation; all focus fire on closest enemy when seen.\n A2 (2.5s): A2 holding; will focus closest enemy when seen.\n A0 (3.0s): Enemies approaching at ~8 range; hold together, fire on closest when in range.\n A1 (3.0s): A1 holding; E2 seen east at 8.6. Let them come into range, focus closest.\n A2 (3.0s): A2 holding; enemies at 8 range, let them come in, focus closest.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding; E2 closest at 6.2. Focus E2 when in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-e7b5859be2887c0c925b5e4d.json b/examples/multi-agent-smax/results/llm-cache/ask-e7b5859be2887c0c925b5e4d.json new file mode 100644 index 00000000..6771efe3 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-e7b5859be2887c0c925b5e4d.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.0 seconds into the battle.\nYou are A1, a marine at (6.5, 16.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.2, 15.7), 45/45 health, order: hold\n A2 marine at (7.1, 16.5), 45/45 health, order: hold\nEnemies you can see:\n E2 marine at (15.0, 14.7), 45/45 health, 8.6 away\nTeam chat (most recent last):\n A1 (1.5s): A1 holding; no enemies yet. Focus closest when they appear.\n A2 (1.5s): A2 moving south to tighten up with the group; focus closest enemy.\n A0 (2.0s): A0 holding; no enemies seen. Focus closest when they appear.\n A1 (2.0s): A1 holding; no enemies visible. Focus closest when they appear.\n A2 (2.0s): A2 holding at (7,16.5), grouped with team; focus closest enemy.\n A0 (2.5s): A0 holding; waiting for enemies to come into range, focus closest.\n A1 (2.5s): A1 holding in formation; all focus fire on closest enemy when seen.\n A2 (2.5s): A2 holding; will focus closest enemy when seen.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A1 holding; E2 seen east at 8.6. Let them come into range, focus closest.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ea4624cad8f01975311ad835.json b/examples/multi-agent-smax/results/llm-cache/ask-ea4624cad8f01975311ad835.json new file mode 100644 index 00000000..1c0ab685 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ea4624cad8f01975311ad835.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.5 seconds into the battle.\nYou are A2, a marine at (8.9, 14.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (8.9, 14.8), 45/45 health, order: attack E1\n A1: dead\nEnemies you can see:\n E0 marine at (12.4, 17.2), 45/45 health, 4.8 away (in range)\n E1 marine at (13.3, 14.8), 9/45 health, 4.5 away (in range)\n E2 marine at (11.6, 17.6), 45/45 health, 4.5 away (in range)\nTeam chat (most recent last):\n A1 (3.0s): E1 in range at 4.5. All focus fire E1 now.\n A2 (3.0s): A2 holding. Focus E1 when it enters range 5; fire together.\n A0 (3.5s): Attacking E1 (36hp), closing to range. Focus E1 together.\n A1 (3.5s): Firing E1 (36hp). A0, A2 attack E1 too; E1 is 4.5 from me, others closing.\n A2 (3.5s): A2 attacking E1 now, focus fire together.\n A0 (4.0s): Firing E1 (27hp). Keep focus, A1 is hurt, stay behind us.\n A1 (4.0s): E1 at 27hp, finish it. I'm low at 18hp, so cover me.\n A2 (4.0s): Firing E1 (27hp), keep focus until dead.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E1 at 9hp, finishing it now. Then focus E2, closest.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ea70fde18aee65263787091d.json b/examples/multi-agent-smax/results/llm-cache/ask-ea70fde18aee65263787091d.json new file mode 100644 index 00000000..f41e38b6 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ea70fde18aee65263787091d.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.5 seconds into the battle.\nYou are A2, a marine at (8.9, 14.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (8.9, 14.8), 18/45 health, order: attack E2\n A1: dead\nEnemies you can see:\n E0 marine at (12.4, 17.2), 45/45 health, 4.8 away (in range)\n E2 marine at (11.6, 17.6), 27/45 health, 4.5 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A2 (3.5s): A2 attacking E1 now, focus fire together.\n A0 (4.0s): Firing E1 (27hp). Keep focus, A1 is hurt, stay behind us.\n A1 (4.0s): E1 at 27hp, finish it. I'm low at 18hp, so cover me.\n A2 (4.0s): Firing E1 (27hp), keep focus until dead.\n A0 (4.5s): E1 at 9hp, finishing it. Then focus E2.\n A2 (4.5s): E1 at 9hp, finishing it now. Then focus E2, closest.\n A0 (5.0s): E1 dead. Focus E2, closest at 3.9. A2 fire too.\n A2 (5.0s): E1 down. Focus E2, closest at 4.5. A0, you're hurt, stay behind me.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Firing E2 (27hp). A0 stay back, I'm closest.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-eb5da34bb6a723554d43768d.json b/examples/multi-agent-smax/results/llm-cache/ask-eb5da34bb6a723554d43768d.json new file mode 100644 index 00000000..c8517d7b --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-eb5da34bb6a723554d43768d.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.5 seconds into the battle.\nYou are A0, a marine at (10.1, 18.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 17.\nYour team:\n A1 marine at (8.6, 17.2), 45/45 health, order: hold\n A2 marine at (8.4, 16.0), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.0s): Holding together as a group; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on the first enemy that enters range.\n A0 (0.5s): Still no enemies. Holding; will focus fire on first one in range.\n A1 (0.5s): A1 holding; will focus fire on closest enemy when spotted.\n A2 (0.5s): Holding; will focus fire on the closest enemy once in range.\n A0 (1.0s): Advancing east slowly to find enemies; stay close, focus fire on closest.\n A1 (1.0s): A1 holding; no enemies yet. Focus fire on closest when spotted.\n A2 (1.0s): A2 holding; still no enemies. Will focus fire on closest once in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 11 17\", \"say\": \"Advancing slowly east; teammates please close up on me, focus closest.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-eca4640265a157ad75751209.json b/examples/multi-agent-smax/results/llm-cache/ask-eca4640265a157ad75751209.json new file mode 100644 index 00000000..e2a711cd --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-eca4640265a157ad75751209.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.5 seconds into the battle.\nYou are A2, a marine at (8.3, 17.3) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.9, 15.6), 45/45 health, order: hold\n A1 marine at (6.7, 14.2), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together; stay grouped and focus fire on the first enemy that appears.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together near (7,16); focus fire on whoever appears first.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A2 holding at (8,17); shoot closest enemy together, stay grouped.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ed3dc445ee44b95b35c8f10c.json b/examples/multi-agent-smax/results/llm-cache/ask-ed3dc445ee44b95b35c8f10c.json new file mode 100644 index 00000000..dc0ddfcf --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ed3dc445ee44b95b35c8f10c.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.0 seconds into the battle.\nYou are A2, a marine at (8.9, 14.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (8.9, 14.8), 45/45 health, order: attack E1\n A1 marine at (9.6, 14.5), 18/45 health, order: attack E1\nEnemies you can see:\n E0 marine at (12.4, 17.2), 45/45 health, 4.8 away (in range)\n E1 marine at (13.3, 14.8), 27/45 health, 4.5 away (in range)\n E2 marine at (11.6, 17.6), 45/45 health, 4.5 away (in range)\nTeam chat (most recent last):\n A1 (2.5s): Holding. Focus E1 when it enters range 5; all fire together.\n A2 (2.5s): A2 holding. Focus E1 when it enters range 5.\n A0 (3.0s): Holding. Focus E1 the moment it enters range 5.\n A1 (3.0s): E1 in range at 4.5. All focus fire E1 now.\n A2 (3.0s): A2 holding. Focus E1 when it enters range 5; fire together.\n A0 (3.5s): Attacking E1 (36hp), closing to range. Focus E1 together.\n A1 (3.5s): Firing E1 (36hp). A0, A2 attack E1 too; E1 is 4.5 from me, others closing.\n A2 (3.5s): A2 attacking E1 now, focus fire together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Firing E1 (27hp), keep focus until dead.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-f05e3a33245d4f7242d67d55.json b/examples/multi-agent-smax/results/llm-cache/ask-f05e3a33245d4f7242d67d55.json new file mode 100644 index 00000000..c58abcaa --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-f05e3a33245d4f7242d67d55.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.0 seconds into the battle.\nYou are A2, a marine at (7.8, 14.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.4, 15.4), 45/45 health, order: hold\n A1 marine at (8.6, 14.6), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together; focus fire on closest enemy once they appear.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together as a group; focus fire on the closest enemy when they appear.\n A0 (0.5s): Holding. Will focus fire on the closest enemy once visible.\n A1 (0.5s): Holding. A0 is a bit far west; tighten up on me.\n A2 (0.5s): A2 holding; will focus fire on closest enemy when seen.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A2 holding. A0, close up toward A1 and me; focus closest enemy.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-f383a6d6f18835f47246307f.json b/examples/multi-agent-smax/results/llm-cache/ask-f383a6d6f18835f47246307f.json new file mode 100644 index 00000000..9454a1ee --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-f383a6d6f18835f47246307f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.0 seconds into the battle.\nYou are A0, a marine at (8.9, 14.8) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1: dead\n A2 marine at (8.9, 14.0), 45/45 health, order: attack E1\nEnemies you can see:\n E0 marine at (12.4, 17.2), 45/45 health, 4.2 away (in range)\n E2 marine at (11.6, 17.6), 45/45 health, 3.9 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (3.5s): Attacking E1 (36hp), closing to range. Focus E1 together.\n A1 (3.5s): Firing E1 (36hp). A0, A2 attack E1 too; E1 is 4.5 from me, others closing.\n A2 (3.5s): A2 attacking E1 now, focus fire together.\n A0 (4.0s): Firing E1 (27hp). Keep focus, A1 is hurt, stay behind us.\n A1 (4.0s): E1 at 27hp, finish it. I'm low at 18hp, so cover me.\n A2 (4.0s): Firing E1 (27hp), keep focus until dead.\n A0 (4.5s): E1 at 9hp, finishing it. Then focus E2.\n A2 (4.5s): E1 at 9hp, finishing it now. Then focus E2, closest.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E1 dead. Focus E2, closest at 3.9. A2 fire too.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-f579759a985e3d258af6443e.json b/examples/multi-agent-smax/results/llm-cache/ask-f579759a985e3d258af6443e.json new file mode 100644 index 00000000..864f4fa5 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-f579759a985e3d258af6443e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.5 seconds into the battle.\nYou are A2, a marine at (7.1, 16.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.2, 15.7), 45/45 health, order: hold\n A1 marine at (6.5, 16.0), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (1.0s): A1 holding; will shoot closest enemy when seen, stay grouped.\n A2 (1.0s): A2 holding at (7,18); I'm slightly north, staying close to group.\n A0 (1.5s): A0 holding; no enemies yet. Focus closest when they appear.\n A1 (1.5s): A1 holding; no enemies yet. Focus closest when they appear.\n A2 (1.5s): A2 moving south to tighten up with the group; focus closest enemy.\n A0 (2.0s): A0 holding; no enemies seen. Focus closest when they appear.\n A1 (2.0s): A1 holding; no enemies visible. Focus closest when they appear.\n A2 (2.0s): A2 holding at (7,16.5), grouped with team; focus closest enemy.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A2 holding; will focus closest enemy when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-f6ebab0ccf2730bbc812df8d.json b/examples/multi-agent-smax/results/llm-cache/ask-f6ebab0ccf2730bbc812df8d.json new file mode 100644 index 00000000..efa34ff0 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-f6ebab0ccf2730bbc812df8d.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.5 seconds into the battle.\nYou are A0, a marine at (8.9, 14.8) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1: dead\n A2 marine at (8.9, 14.0), 45/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (12.4, 17.2), 45/45 health, 4.2 away (in range)\n E2 marine at (11.6, 17.6), 27/45 health, 3.9 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A2 (3.5s): A2 attacking E1 now, focus fire together.\n A0 (4.0s): Firing E1 (27hp). Keep focus, A1 is hurt, stay behind us.\n A1 (4.0s): E1 at 27hp, finish it. I'm low at 18hp, so cover me.\n A2 (4.0s): Firing E1 (27hp), keep focus until dead.\n A0 (4.5s): E1 at 9hp, finishing it. Then focus E2.\n A2 (4.5s): E1 at 9hp, finishing it now. Then focus E2, closest.\n A0 (5.0s): E1 dead. Focus E2, closest at 3.9. A2 fire too.\n A2 (5.0s): E1 down. Focus E2, closest at 4.5. A0, you're hurt, stay behind me.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Focus E2 (27hp), then E0. A2 keep firing.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-fcf4f02ccff34bd75787d721.json b/examples/multi-agent-smax/results/llm-cache/ask-fcf4f02ccff34bd75787d721.json new file mode 100644 index 00000000..a1ba25bc --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-fcf4f02ccff34bd75787d721.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.5 seconds into the battle.\nYou are A1, a marine at (6.5, 16.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.2, 15.7), 45/45 health, order: hold\n A2 marine at (7.1, 16.5), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (13.9, 17.7), 45/45 health, 7.6 away\n E1 marine at (14.7, 16.0), 45/45 health, 8.3 away\n E2 marine at (13.4, 14.7), 45/45 health, 7.1 away\nTeam chat (most recent last):\n A1 (2.0s): A1 holding; no enemies visible. Focus closest when they appear.\n A2 (2.0s): A2 holding at (7,16.5), grouped with team; focus closest enemy.\n A0 (2.5s): A0 holding; waiting for enemies to come into range, focus closest.\n A1 (2.5s): A1 holding in formation; all focus fire on closest enemy when seen.\n A2 (2.5s): A2 holding; will focus closest enemy when seen.\n A0 (3.0s): Enemies approaching at ~8 range; hold together, fire on closest when in range.\n A1 (3.0s): A1 holding; E2 seen east at 8.6. Let them come into range, focus closest.\n A2 (3.0s): A2 holding; enemies at 8 range, let them come in, focus closest.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A1 holding; fire on closest enemy once in range, E2 first.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/smax_demo.py b/examples/multi-agent-smax/smax_demo.py new file mode 100644 index 00000000..96b73174 --- /dev/null +++ b/examples/multi-agent-smax/smax_demo.py @@ -0,0 +1,158 @@ +#!/usr/bin/env python3 +"""Multi-agent SMAX: one Claude agent per unit. + + python3 smax_demo.py play --scenario 3m --seed 0 + python3 smax_demo.py play --scenario 5m_vs_6m --seed 0 --team focus + python3 smax_demo.py campaign --world rules-md --scenario 3m --battles 12 + +Writes the battle, step by step, to out/--.json. +`--team` picks who commands our side: `chat` (Claude agents over team chat), +or one of the scripted baselines `closest`, `focus` and `hold`. + +A campaign is one battle per seed, 0 to --battles - 1. In the `chat` world the +battles are independent. In `rules-md`, after every battle the squad does not +win, one agent reads the battle's log and adds a rule to the squad's RULES.md, +which every unit sees in every later battle. Nothing checks the rules. +""" + +import argparse +import concurrent.futures +import json +import math +import pathlib +import time + +from battle import Battle + +HERE = pathlib.Path(__file__).resolve().parent + + +def scripted(kind): + def decide(battle): + units = battle.units() + ours = [u for u in units[: battle.allies] if u.alive] + enemies = [u for u in units[battle.allies:] if u.alive] + for u in ours: + if kind == "hold" or not enemies: + battle.orders[u.name] = "hold" + elif kind == "closest": + t = min(enemies, key=lambda e: math.hypot(e.x - u.x, e.y - u.y)) + battle.orders[u.name] = f"attack {t.name}" + else: # focus: everyone on the weakest enemy, nearest the squad on ties + cx = sum(a.x for a in ours) / len(ours) + cy = sum(a.y for a in ours) / len(ours) + t = min(enemies, key=lambda e: (e.health, math.hypot(e.x - cx, e.y - cy))) + battle.orders[u.name] = f"attack {t.name}" + return {} + return decide + + +def play(scenario, seed, team, out_dir, narrate=True, rules=(), name=None): + battle = Battle(scenario, seed) + if team == "chat": + from agents import LLM, ChatTeam + llm = LLM(HERE / "results" / "llm-cache") + commander = ChatTeam(llm, rules) + decide = commander.decide + else: + llm, commander, decide = None, None, scripted(team) + frames = [] + t0 = time.time() + while not battle.done: + decisions = decide(battle) + frame = battle.frame() + frame["decisions"] = decisions + frames.append(frame) + if narrate: + line = " ".join(f"{n}:{d['order']}" + ("" if d["valid"] else "(!)") for n, d in decisions.items()) + print(f"{battle.step_count * 0.5:5.1f}s {line}") + for n, d in decisions.items(): + if d["say"]: + print(f" {n} says: {d['say']}") + battle.step() + final = battle.frame() + frames.append(final) + record = { + "scenario": scenario, "seed": seed, "team": team, "outcome": battle.outcome(), + "seconds": battle.step_count * 0.5, "steps": battle.step_count, + "ours_alive": sum(u["alive"] for u in final["units"][: battle.allies]), + "theirs_alive": sum(u["alive"] for u in final["units"][battle.allies:]), + "rules": list(rules), "frames": frames, "chat": commander.messages if commander else [], + "llm_calls": llm.calls if llm else 0, "wall_seconds": round(time.time() - t0, 1), + } + out_dir.mkdir(parents=True, exist_ok=True) + path = out_dir / (name or f"{scenario}-{team}-{seed}.json") + path.write_text(json.dumps(record, indent=1)) + if narrate: + print(f"{record['outcome']} after {record['seconds']:.1f}s: {record['ours_alive']} of ours left, " + f"{record['theirs_alive']} of theirs; {record['llm_calls']} new Claude calls, " + f"{record['wall_seconds']}s; wrote {path}") + return record + + +def _play_quiet(args): + scenario, seed, out_dir = args + r = play(scenario, seed, "chat", out_dir, narrate=False, name=f"battle-{seed}.json") + return {k: r[k] for k in ("seed", "outcome", "seconds", "ours_alive", "theirs_alive")} + + +def campaign(world, scenario, battles, out_dir, jobs): + out_dir.mkdir(parents=True, exist_ok=True) + rows = [] + if world == "chat": + with concurrent.futures.ProcessPoolExecutor(jobs) as pool: + for row in pool.map(_play_quiet, [(scenario, s, out_dir) for s in range(battles)]): + rows.append(row) + print(f"battle {row['seed']}: {row['outcome']} ({row['ours_alive']} of ours left, " + f"{row['theirs_alive']} of theirs)", flush=True) + else: + from agents import LLM, write_rule + llm = LLM(HERE / "results" / "llm-cache") + rules = [] + for seed in range(battles): + r = play(scenario, seed, "chat", out_dir, narrate=False, rules=rules, name=f"battle-{seed}.json") + row = {k: r[k] for k in ("seed", "outcome", "seconds", "ours_alive", "theirs_alive")} + row["rules_before"] = len(rules) + if r["outcome"] != "won": + rule = write_rule(llm, r, rules) + if rule: + rules.append(rule) + row["new_rule"] = rule + rows.append(row) + print(f"battle {seed}: {row['outcome']} ({row['ours_alive']} of ours left, {row['theirs_alive']} " + f"of theirs) with {row['rules_before']} rules" + (f"; new rule: {row['new_rule']}" + if "new_rule" in row else ""), flush=True) + (out_dir / "RULES.md").write_text("# RULES.md\n\n" + "\n".join(f"{i}. {r}" for i, r in enumerate(rules, 1)) + + "\n") + won = sum(r["outcome"] == "won" for r in rows) + summary = {"world": world, "scenario": scenario, "battles": len(rows), "won": won, + "win_rate": won / max(1, len(rows)), "rows": rows} + (out_dir / "summary.json").write_text(json.dumps(summary, indent=1)) + print(f"{world} on {scenario}: won {won} of {len(rows)}") + return summary + + +def main(): + p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + sub = p.add_subparsers(dest="cmd", required=True) + pl = sub.add_parser("play") + pl.add_argument("--scenario", default="3m") + pl.add_argument("--seed", type=int, default=0) + pl.add_argument("--team", default="chat", choices=["chat", "closest", "focus", "hold"]) + pl.add_argument("--out", default=str(HERE / "out")) + ca = sub.add_parser("campaign") + ca.add_argument("--world", default="chat", choices=["chat", "rules-md"]) + ca.add_argument("--scenario", default="3m") + ca.add_argument("--battles", type=int, default=12) + ca.add_argument("--jobs", type=int, default=4) + ca.add_argument("--out", default=None) + args = p.parse_args() + if args.cmd == "play": + play(args.scenario, args.seed, args.team, pathlib.Path(args.out)) + else: + out = pathlib.Path(args.out or HERE / "out" / f"campaign-{args.world}-{args.scenario}") + campaign(args.world, args.scenario, args.battles, out, args.jobs) + + +if __name__ == "__main__": + main() diff --git a/rust/modality-common/src/model_governance.rs b/rust/modality-common/src/model_governance.rs index 52c8392c..db9b8dfe 100644 --- a/rust/modality-common/src/model_governance.rs +++ b/rust/modality-common/src/model_governance.rs @@ -3070,9 +3070,41 @@ impl CommitFacts { } } +/// Verdicts of `mined_header_holds`, by header, index and hash function. +/// +/// Checking a mint replays the MOD contract's whole log, and each replayed +/// mint grinds every one of its headers through RandomX again. At epoch 385 +/// that was about 15,000 RandomX hashes per mint, under the datastore lock, +/// and the node answered nothing for minutes. The check is a pure function +/// of its inputs, so each header is ground once per process. +static MINED_HEADER_VERDICTS: std::sync::OnceLock>> = + std::sync::OnceLock::new(); + +/// Verdicts kept before the memo starts over. +const MINED_HEADER_VERDICTS_MAX: usize = 1 << 20; + /// A posted miner header's own proof: the fields `mined_headers` reads, its /// data hash, and its nonce ground against its mining data. fn mined_header_holds(header: &Value, index: u64, hash_func: &str) -> bool { + let key = format!("{index}|{hash_func}|{header}"); + let memo = MINED_HEADER_VERDICTS.get_or_init(Default::default); + if let Some(verdict) = memo + .lock() + .unwrap_or_else(|poisoned| poisoned.into_inner()) + .get(&key) + { + return *verdict; + } + let verdict = mined_header_check(header, index, hash_func); + let mut verdicts = memo.lock().unwrap_or_else(|poisoned| poisoned.into_inner()); + if verdicts.len() >= MINED_HEADER_VERDICTS_MAX { + verdicts.clear(); + } + verdicts.insert(key, verdict); + verdict +} + +fn mined_header_check(header: &Value, index: u64, hash_func: &str) -> bool { let text = |name: &str| header.get(name).and_then(Value::as_str); let big = |name: &str| match header.get(name) { Some(Value::String(s)) => s.parse::().ok(), diff --git a/rust/modality-node/examples/replay_store.rs b/rust/modality-node/examples/replay_store.rs new file mode 100644 index 00000000..ad533605 --- /dev/null +++ b/rust/modality-node/examples/replay_store.rs @@ -0,0 +1,85 @@ +//! Time the fork-choice and startup reads a node makes, on a copied store. +//! +//! Usage: `cargo run -p modality-node --example replay_store -- ` +//! +//! Opens the store, then times the miner cache load, a tree sync, a select +//! pass, an adoption pass, the startup tip read, and one more select pass +//! (which should be cheap). Nothing leaves the machine. + +use modality_datastore::models::MinerBlock; +use modality_datastore::DatastoreManager; +use std::time::Instant; + +#[tokio::main] +async fn main() -> anyhow::Result<()> { + env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init(); + let dir = std::env::args() + .nth(1) + .ok_or_else(|| anyhow::anyhow!("usage: replay_store "))?; + let mut mgr = DatastoreManager::open(std::path::Path::new(&dir))?; + mgr.set_blocks_per_epoch(40); + + let t = Instant::now(); + let all = MinerBlock::find_all_blocks_multi(&mgr).await?; + let live = all.iter().filter(|b| !b.is_orphaned).count(); + let canonical = all.iter().filter(|b| b.is_canonical && !b.is_orphaned).count(); + println!( + "cache load: {} blocks ({live} live, {canonical} canonical) in {:?}", + all.len(), + t.elapsed() + ); + + let params = modality_node::chain::tree_choice::retarget_params(&mgr); + let t = Instant::now(); + let (best, cbest, leaves) = modality_node::chain::tree_choice::with_synced_tree(&mgr, params, |tree| { + ( + tree.best().map(|(b, w)| (b.index, b.hash[..12].to_string(), w)), + tree.canonical_best().map(|(b, w)| (b.index, b.hash[..12].to_string(), w)), + tree.linked_leaves().len(), + ) + })?; + println!("tree sync: {:?}\n winner {best:?}\n canonical {cbest:?}\n linked leaves {leaves}", t.elapsed()); + + let t = Instant::now(); + let switched = modality_node::chain::reorg::select_best_stored_chain(&mgr).await?; + println!("select: {switched} in {:?}", t.elapsed()); + let t = Instant::now(); + let adopted = modality_node::chain::reorg::adopt_connected_extensions(&mgr).await?; + println!("adopt: {adopted} in {:?}", t.elapsed()); + + let t = Instant::now(); + let tip = MinerBlock::verified_spine(&MinerBlock::find_all_canonical_multi(&mgr).await?) + .last() + .map(|b| b.index); + println!("startup tip read: {tip:?} in {:?}", t.elapsed()); + + let t = Instant::now(); + let switched = modality_node::chain::reorg::select_best_stored_chain(&mgr).await?; + println!("second select: {switched} in {:?}", t.elapsed()); + + // What parent-hash sync computes over every stored block. + let t = Instant::now(); + let all = MinerBlock::find_all_blocks_multi(&mgr).await?; + let missing = modality_node::chain::reorg::missing_parent_hashes(&all); + println!("missing_parent_hashes: {} gaps in {:?}", missing.len(), t.elapsed()); + + // The promotion task's first pass, as it runs at startup. + let epoch = MinerBlock::find_all_canonical_multi(&mgr) + .await? + .into_iter() + .max_by_key(|b| b.index) + .map(|b| b.epoch) + .unwrap_or(0); + let t = Instant::now(); + let promoted = MinerBlock::run_promotion(&mgr, epoch).await?; + println!("promotion: {promoted:?} in {:?}", t.elapsed()); + let t = Instant::now(); + let purged = MinerBlock::run_purge(&mgr, epoch).await?; + println!("purge: {purged} in {:?}", t.elapsed()); + let t = Instant::now(); + let pruned = + modality_node::actions::observer::chain_maintenance::prune_under_sequenced_prefix(&mgr) + .await?; + println!("prune: {pruned} in {:?}", t.elapsed()); + Ok(()) +} diff --git a/rust/modality-node/src/chain/tree_choice.rs b/rust/modality-node/src/chain/tree_choice.rs index 1ec1e16a..b192613b 100644 --- a/rust/modality-node/src/chain/tree_choice.rs +++ b/rust/modality-node/src/chain/tree_choice.rs @@ -29,7 +29,7 @@ use std::sync::Arc; /// archived instead of being scored again. pub(crate) const STALE_FORK_EPOCHS: u64 = 2; -pub(crate) fn retarget_params(mgr: &DatastoreManager) -> RetargetParams { +pub fn retarget_params(mgr: &DatastoreManager) -> RetargetParams { RetargetParams { blocks_per_epoch: mgr.epoch_config().blocks_per_epoch, target_block_time_secs: mgr.network_u64("target_block_time_secs").unwrap_or(60), @@ -41,7 +41,7 @@ pub(crate) fn retarget_params(mgr: &DatastoreManager) -> RetargetParams { /// Run `f` on the tree after syncing it with the store. The target check is /// the eligibility rule, as `select_best_stored_chain` filtered on it. -pub(crate) fn with_synced_tree( +pub fn with_synced_tree( mgr: &DatastoreManager, params: RetargetParams, f: impl FnOnce(&MinerTree) -> R, From c3f81097bd40c66e6349f361531b2759feaa044b Mon Sep 17 00:00:00 2001 From: Foy Savas Date: Sun, 18 Oct 2026 15:37:35 -0400 Subject: [PATCH 3/4] Grind each mined header once, and stop logging every swarm event Upgrading the testnet hosts to the previous commit left all three sequencers answering status with 503 for over ten minutes. A copy of node2's store, run offline, showed why: the MOD minter checks a mint by replaying the contract's whole log, and `mined_headers` grinds every header of every replayed mint through RandomX again. At epoch 385 that is about 15,000 RandomX hashes per mint, under the datastore lock, and it grows with every epoch. Fork choice on the same store took under a millisecond. - `mined_header_holds` is a pure function of the header, index and hash function, so its verdict is kept per process. A mint now grinds only its own headers. The first replay after a start still grinds each header once: about 16 s on the copied store in a release build (it never finished in a debug build before). - The networking loop logged every swarm event at info, pings and Identify included, to the journal and to `logs/node.log`. Those files reached 40-45 GB on the hosts and filled node0's disk. They are debug now. - `examples/replay_store.rs` times the fork-choice, startup, sync, and maintenance reads on a copied store; nothing leaves the machine. Co-Authored-By: Claude Opus 5.5 --- rust/modality-node/src/gossip/mod.rs | 2 +- rust/modality-node/src/node/mod.rs | 12 +++++++----- 2 files changed, 8 insertions(+), 6 deletions(-) diff --git a/rust/modality-node/src/gossip/mod.rs b/rust/modality-node/src/gossip/mod.rs index 0377ffb2..bb02582d 100644 --- a/rust/modality-node/src/gossip/mod.rs +++ b/rust/modality-node/src/gossip/mod.rs @@ -51,7 +51,7 @@ pub async fn handle_event( bootstrappers: Vec, minimum_block_timestamp: Option, ) -> Result<()> { - log::info!("handling gossip: {:?}", message); + log::debug!("handling gossip: {:?}", message); let data = String::from_utf8_lossy(&message.data).to_string(); let topic = message.topic.to_string(); let source_peer = message.source; diff --git a/rust/modality-node/src/node/mod.rs b/rust/modality-node/src/node/mod.rs index 397ec057..33d60a1c 100644 --- a/rust/modality-node/src/node/mod.rs +++ b/rust/modality-node/src/node/mod.rs @@ -602,7 +602,9 @@ impl Node { return Ok(()); }; - log::info!("{:?}", event); + // Every swarm event, pings and Identify included. At info this + // wrote tens of gigabytes a fortnight and filled a host's disk. + log::debug!("{:?}", event); match event { SwarmEvent::NewListenAddr { address, .. } => { let address_with_p2p = address.clone().with(Protocol::P2p(peerid)); @@ -623,7 +625,7 @@ impl Node { request_response::Message::Request { request, channel, .. } => { - log::info!("reqres request"); + log::debug!("reqres request"); let admitted = match push_admission.lock() { Ok(mut gate) => gate.admit( &peer.to_string(), @@ -716,7 +718,7 @@ impl Node { message, }, )) => { - log::info!("Gossip received {:?}", message.topic.to_string()); + log::debug!("Gossip received {:?}", message.topic.to_string()); if message.topic.as_str() == gossip::miner::block::TOPIC && !gossip::limits::admit_miner_block(propagation_source) { @@ -800,10 +802,10 @@ impl Node { } } SwarmEvent::Behaviour(event) => { - log::info!("SwarmEvent::Behaviour event {:?}", event); + log::debug!("SwarmEvent::Behaviour event {:?}", event); } event => { - log::info!("Other Node Event {:?}", event) + log::debug!("Other Node Event {:?}", event) } } } From ebc8ffc8f9160ef08d9edf7df26dcb56c7468273 Mon Sep 17 00:00:00 2001 From: Foy Savas Date: Mon, 19 Oct 2026 13:38:49 -0400 Subject: [PATCH 4/4] Optimize mined header processing and reduce logging overhead - Refactored the `mined_header_holds` function to improve efficiency by caching verdicts, minimizing redundant computations during mint checks. - Adjusted logging levels for swarm events to reduce disk usage, transitioning from info to debug level, preventing excessive log file growth. - Enhanced performance of header validation processes and reduced the impact of logging on system resources. These changes collectively improve the efficiency of header processing and resource management in the system. --- .../results/llm-cache/ask-000a56b17f8db2ca0321be4a.json | 5 +++++ .../results/llm-cache/ask-010f9b0f4dbe71d60bc9a772.json | 5 +++++ .../results/llm-cache/ask-012dc8ba7ed6e34a85f75170.json | 5 +++++ .../results/llm-cache/ask-01dbc532b9eabb1fca8a273c.json | 5 +++++ .../results/llm-cache/ask-020707e41424558bbec7a67f.json | 5 +++++ .../results/llm-cache/ask-024ee04bd72f916d5159ca78.json | 5 +++++ .../results/llm-cache/ask-02788019e7c2e436cfe6932e.json | 5 +++++ .../results/llm-cache/ask-0287437c7071b803790b2a03.json | 5 +++++ .../results/llm-cache/ask-0347f81080c210a23588e43c.json | 5 +++++ .../results/llm-cache/ask-0393602049acad80a749b899.json | 5 +++++ .../results/llm-cache/ask-03ecb7d37b907469d5c1bf75.json | 5 +++++ .../results/llm-cache/ask-03ee2f9f812ac836d8732089.json | 5 +++++ .../results/llm-cache/ask-04c6b431f425793a46ba0f12.json | 5 +++++ .../results/llm-cache/ask-04deda273d933177c34a77da.json | 5 +++++ .../results/llm-cache/ask-0508ccea52b60522a908a108.json | 5 +++++ .../results/llm-cache/ask-0531a575b19d2f6f827bb22c.json | 5 +++++ .../results/llm-cache/ask-053ebe38a507614123e16026.json | 5 +++++ .../results/llm-cache/ask-0576295511e270b1f62c85da.json | 5 +++++ .../results/llm-cache/ask-0579385ed91673d633be4584.json | 5 +++++ .../results/llm-cache/ask-05905dfaa628411b797ea65f.json | 5 +++++ .../results/llm-cache/ask-05e043f6c7e6121d5615917e.json | 5 +++++ .../results/llm-cache/ask-05e08f7c1731ec2f1803a2b1.json | 5 +++++ .../results/llm-cache/ask-064f488b5d47f26b1486a9bd.json | 5 +++++ .../results/llm-cache/ask-06a6c7c4fd3b1ec41cbab4f7.json | 5 +++++ .../results/llm-cache/ask-06b7e5a0ad685c915092f5f0.json | 5 +++++ .../results/llm-cache/ask-071290b25e221f417bddfb7e.json | 5 +++++ .../results/llm-cache/ask-0744cf90619517acaceefccc.json | 5 +++++ .../results/llm-cache/ask-0765f56b29ee24d3ac0d6fe4.json | 5 +++++ .../results/llm-cache/ask-07a57c55afc5110bbf4afffd.json | 5 +++++ .../results/llm-cache/ask-07d2d28a001285a44000081f.json | 5 +++++ .../results/llm-cache/ask-07d7eed6d1d21b72adb7eb89.json | 5 +++++ .../results/llm-cache/ask-07d81a7f5453601bb0d64d18.json | 5 +++++ .../results/llm-cache/ask-0854fb7311637309a9ef2736.json | 5 +++++ .../results/llm-cache/ask-08ab548eeb4337bdb07667a5.json | 5 +++++ .../results/llm-cache/ask-09f10091eb9d8ad0045e2c8c.json | 5 +++++ .../results/llm-cache/ask-0a62111a33a93371521028e8.json | 5 +++++ .../results/llm-cache/ask-0ae6c213818f492047ebb487.json | 5 +++++ .../results/llm-cache/ask-0b14c72f9b3c0bdbaa3205cc.json | 5 +++++ .../results/llm-cache/ask-0b65f6edb80539a3385cdddf.json | 5 +++++ .../results/llm-cache/ask-0b6c232ce8232c174392aeea.json | 5 +++++ .../results/llm-cache/ask-0b9567e8dd6e56af82d614ce.json | 5 +++++ .../results/llm-cache/ask-0ca5243ff0cf2ffebed6da59.json | 5 +++++ .../results/llm-cache/ask-0d06b9b4cd2626ae13b64aca.json | 5 +++++ .../results/llm-cache/ask-0d55f701cf694eced3e60d6d.json | 5 +++++ .../results/llm-cache/ask-0dd1afbb078b94c3bbaffd72.json | 5 +++++ .../results/llm-cache/ask-0ddb5a02e2925cb75138fea1.json | 5 +++++ .../results/llm-cache/ask-0e910a78a4812cc444c54236.json | 5 +++++ .../results/llm-cache/ask-0eaeddf7f71e6da7d0e4e4ba.json | 5 +++++ .../results/llm-cache/ask-0ec0ba47d42577309569a930.json | 5 +++++ .../results/llm-cache/ask-0f1693567474b9f0c366dd6a.json | 5 +++++ .../results/llm-cache/ask-0fd6e5bd48a13faa97533dcd.json | 5 +++++ .../results/llm-cache/ask-10117765bc0619be16346755.json | 5 +++++ .../results/llm-cache/ask-102062647428bba26f325b62.json | 5 +++++ .../results/llm-cache/ask-105ff1a8df30382e7138a6cc.json | 5 +++++ .../results/llm-cache/ask-10aaef3cb691a428f118cef0.json | 5 +++++ .../results/llm-cache/ask-10b8d0856d9581ce40528189.json | 5 +++++ .../results/llm-cache/ask-10cb5188a56a004d0f457376.json | 5 +++++ .../results/llm-cache/ask-11342bbccb9537b1ce8dd7a4.json | 5 +++++ .../results/llm-cache/ask-11a103a7d4fe37a0b2f157e6.json | 5 +++++ .../results/llm-cache/ask-122168b4d052b7789cf6f800.json | 5 +++++ .../results/llm-cache/ask-12359efc2febc92ff5a68c72.json | 5 +++++ .../results/llm-cache/ask-124fbb046e49b93e5d33b142.json | 5 +++++ .../results/llm-cache/ask-133e7c6d2cc3dd7e2a0e7ab3.json | 5 +++++ .../results/llm-cache/ask-1373bc8785c80ab9c1d6bee0.json | 5 +++++ .../results/llm-cache/ask-1382af5e1eadf000914e80eb.json | 5 +++++ .../results/llm-cache/ask-13d7cd3a7aedf93932710377.json | 5 +++++ .../results/llm-cache/ask-14039fedd63b490eb6da6b0c.json | 5 +++++ .../results/llm-cache/ask-165b52cb93902a7651d6220e.json | 5 +++++ .../results/llm-cache/ask-1669039dba0043ef962c7dcb.json | 5 +++++ .../results/llm-cache/ask-16717ed8c87dcbcceb58da4b.json | 5 +++++ .../results/llm-cache/ask-16df5ec500ff31c565c46e9d.json | 5 +++++ .../results/llm-cache/ask-17124d9ca73ac94c4ef94daa.json | 5 +++++ .../results/llm-cache/ask-1760690927795f2dbe84c1fa.json | 5 +++++ .../results/llm-cache/ask-1773c8a6ba16024334147f0f.json | 5 +++++ .../results/llm-cache/ask-17c6d6309e9fb72fc3ba4ca1.json | 5 +++++ .../results/llm-cache/ask-17ccf86f63097ae7f3856e4d.json | 5 +++++ .../results/llm-cache/ask-195b436716c6658de4e6deb1.json | 5 +++++ .../results/llm-cache/ask-19defe0a3c24db977b0d0ea7.json | 5 +++++ .../results/llm-cache/ask-1b36c3ccbe32c540d7be0997.json | 5 +++++ .../results/llm-cache/ask-1b76b099aa1e791b1bc01df9.json | 5 +++++ .../results/llm-cache/ask-1c034b5f6480cf469028bd95.json | 5 +++++ .../results/llm-cache/ask-1c267986a60f497095560141.json | 5 +++++ .../results/llm-cache/ask-1c439a4a932dd7bef1ec86c8.json | 5 +++++ .../results/llm-cache/ask-1c801bed7e8224da7bbb7481.json | 5 +++++ .../results/llm-cache/ask-1cc9ce2d669a779abe059b38.json | 5 +++++ .../results/llm-cache/ask-1d1273bd12cf79f2ab71db9f.json | 5 +++++ .../results/llm-cache/ask-1d2c0682864b42eb7ddb9386.json | 5 +++++ .../results/llm-cache/ask-1d471bb688b859ae2b221a10.json | 5 +++++ .../results/llm-cache/ask-1ddc45167b7aa47ff9523064.json | 5 +++++ .../results/llm-cache/ask-1e14c4754c9422e798c10641.json | 5 +++++ .../results/llm-cache/ask-1e45a1e8c09cbe6568253393.json | 5 +++++ .../results/llm-cache/ask-1e6ea9f887741a3cf06d2d89.json | 5 +++++ .../results/llm-cache/ask-1ede459ea611188b27fedbc1.json | 5 +++++ .../results/llm-cache/ask-1ef53ff29465495cbe96cea1.json | 5 +++++ .../results/llm-cache/ask-1efc32e33445660f58c1b7e2.json | 5 +++++ .../results/llm-cache/ask-1f16af71e69279a24285671a.json | 5 +++++ .../results/llm-cache/ask-1f487bfc0e0c070014356897.json | 5 +++++ .../results/llm-cache/ask-1f79c1477beef72c4e2e63f5.json | 5 +++++ .../results/llm-cache/ask-1f7decf3a298a6f222f3e67f.json | 5 +++++ .../results/llm-cache/ask-1f91417e97eaa190ba0dd717.json | 5 +++++ .../results/llm-cache/ask-1fe276a55396926047481516.json | 5 +++++ .../results/llm-cache/ask-205320454ba86af6cc730563.json | 5 +++++ .../results/llm-cache/ask-20a2f56a15af1aa5f22aba18.json | 5 +++++ .../results/llm-cache/ask-20c6f66f2c42b0ec53c8f493.json | 5 +++++ .../results/llm-cache/ask-20d2530f65b7dd59c6d0e53e.json | 5 +++++ .../results/llm-cache/ask-20e6fd53b9646e93dd0d7233.json | 5 +++++ .../results/llm-cache/ask-217b99393747086d39f160be.json | 5 +++++ .../results/llm-cache/ask-218b4649552a38c17e839d26.json | 5 +++++ .../results/llm-cache/ask-220044057239a787f3141fd6.json | 5 +++++ .../results/llm-cache/ask-22133ea355a9c9e998f6a86d.json | 5 +++++ .../results/llm-cache/ask-223e0ec95abefdfda9c5ff59.json | 5 +++++ .../results/llm-cache/ask-232b3a49dfed3cd93ce413f9.json | 5 +++++ .../results/llm-cache/ask-235c8dbee18e3a0724281ae8.json | 5 +++++ .../results/llm-cache/ask-235f3dfebb8eaa3440f5e87f.json | 5 +++++ .../results/llm-cache/ask-23db4dda4c96178f3ffe1cf6.json | 5 +++++ .../results/llm-cache/ask-241a59c9ceff3dffb7f68729.json | 5 +++++ .../results/llm-cache/ask-247c8678fe8ced03f24f5ab5.json | 5 +++++ .../results/llm-cache/ask-24828a7847e21f9aa4b6289e.json | 5 +++++ .../results/llm-cache/ask-2492e9fccd9b4caee5a51d55.json | 5 +++++ .../results/llm-cache/ask-24c39313db8146aee26c2d61.json | 5 +++++ .../results/llm-cache/ask-24df835417c954a3b66a46ff.json | 5 +++++ .../results/llm-cache/ask-24ec7953cacf7e115dee5e9f.json | 5 +++++ .../results/llm-cache/ask-24f21cf58c1bc6b0cc595266.json | 5 +++++ .../results/llm-cache/ask-25a6d511b7cc6faf1c261c01.json | 5 +++++ .../results/llm-cache/ask-26120497663aca6290336db5.json | 5 +++++ .../results/llm-cache/ask-2722851898ccb00a32aeeccb.json | 5 +++++ .../results/llm-cache/ask-27241fe73a62b4100a340ccd.json | 5 +++++ .../results/llm-cache/ask-2774f390b7ff951c2e7e5f86.json | 5 +++++ .../results/llm-cache/ask-278adcc1ba4b166836086391.json | 5 +++++ .../results/llm-cache/ask-278b8dbcb5a85e269051c6ac.json | 5 +++++ .../results/llm-cache/ask-27ea49964e4456eab9fcbc61.json | 5 +++++ .../results/llm-cache/ask-285f7d71b0e6bb7661c90f33.json | 5 +++++ .../results/llm-cache/ask-28823fb669b50a496c4abc36.json | 5 +++++ .../results/llm-cache/ask-288cbe5b48a615148acf16f6.json | 5 +++++ .../results/llm-cache/ask-28d56cbe609c405b16f9e080.json | 5 +++++ .../results/llm-cache/ask-2919ee3a8b05e579e5158636.json | 5 +++++ .../results/llm-cache/ask-298c0da4715b2af9cb3a8291.json | 5 +++++ .../results/llm-cache/ask-29f5e91cb21d639b56ee0252.json | 5 +++++ .../results/llm-cache/ask-2a4ab407a08b05de48930f74.json | 5 +++++ .../results/llm-cache/ask-2ac28a19e46875982454c844.json | 5 +++++ .../results/llm-cache/ask-2ae43f55a9080c8cf932c54c.json | 5 +++++ .../results/llm-cache/ask-2af127355d318c42ae398567.json | 5 +++++ .../results/llm-cache/ask-2b1a0b6125de9ae8c89ea294.json | 5 +++++ .../results/llm-cache/ask-2c8f1a9cf69f5bcc86c7f39a.json | 5 +++++ .../results/llm-cache/ask-2d07a9e94f87c5a976d1786a.json | 5 +++++ .../results/llm-cache/ask-2d634f118170fff0c86540e5.json | 5 +++++ .../results/llm-cache/ask-2df3b0e324fe62e11da4131b.json | 5 +++++ .../results/llm-cache/ask-2e6fa4e42708c2c2e10545a8.json | 5 +++++ .../results/llm-cache/ask-2ebff0e04a8c8f66593ba090.json | 5 +++++ .../results/llm-cache/ask-2f08bfe47f19e10c32e89434.json | 5 +++++ .../results/llm-cache/ask-2f5c4fb4c964f54452e6d8ef.json | 5 +++++ .../results/llm-cache/ask-2fe13e6d9b712854ff739bdc.json | 5 +++++ .../results/llm-cache/ask-30131d53d7d36082748cd07e.json | 5 +++++ .../results/llm-cache/ask-30142e3e0030a438de99994a.json | 5 +++++ .../results/llm-cache/ask-3035f6f9e85aa4855e726cec.json | 5 +++++ .../results/llm-cache/ask-30509250bca76362820ba808.json | 5 +++++ .../results/llm-cache/ask-30615ba65000580d684e5089.json | 5 +++++ .../results/llm-cache/ask-309120546dc96290cb346717.json | 5 +++++ .../results/llm-cache/ask-30e28a5a678a674a7e4d854f.json | 5 +++++ .../results/llm-cache/ask-30eb991d6b5b2aeffedf6ac9.json | 5 +++++ .../results/llm-cache/ask-30fb28ccda7b222b686e3453.json | 5 +++++ .../results/llm-cache/ask-3163e5d02e34060e410aaa9d.json | 5 +++++ .../results/llm-cache/ask-31956c6dbd83348610ecb821.json | 5 +++++ .../results/llm-cache/ask-31a53db3104dc5f7b0f212a6.json | 5 +++++ .../results/llm-cache/ask-31a5da9a85efcfc0d90cf158.json | 5 +++++ .../results/llm-cache/ask-31e322661e8c799a04005af0.json | 5 +++++ .../results/llm-cache/ask-31e993014c58cc66339c15e3.json | 5 +++++ .../results/llm-cache/ask-320071652e80475c67d7eabf.json | 5 +++++ .../results/llm-cache/ask-33981fc88e836b636fe00d30.json | 5 +++++ .../results/llm-cache/ask-33fcdcce3e8aca7107e9549e.json | 5 +++++ .../results/llm-cache/ask-344c56588c9f732a6dc40feb.json | 5 +++++ .../results/llm-cache/ask-346019ffa1d942f02d66d42b.json | 5 +++++ .../results/llm-cache/ask-351b5ef56807ee2bbaf1c312.json | 5 +++++ .../results/llm-cache/ask-351cfd1e701b5da1edce7bd4.json | 5 +++++ .../results/llm-cache/ask-35ee743a56a9f01c7c93f23f.json | 5 +++++ .../results/llm-cache/ask-366bb12ce65a1023d8eb1c59.json | 5 +++++ .../results/llm-cache/ask-37001e028c705874aba1c51c.json | 5 +++++ .../results/llm-cache/ask-379145ce573aca9b58d2e86a.json | 5 +++++ .../results/llm-cache/ask-37a2bafbe6b64a7635b170d5.json | 5 +++++ .../results/llm-cache/ask-37e890a88216af3fca0dfb10.json | 5 +++++ .../results/llm-cache/ask-385ab1b2c3651333f6507514.json | 5 +++++ .../results/llm-cache/ask-389da7f6c70655aadc8bc580.json | 5 +++++ .../results/llm-cache/ask-38a554e73b032297c6589e36.json | 5 +++++ .../results/llm-cache/ask-38cd767e1ddc91175ce57dc9.json | 5 +++++ .../results/llm-cache/ask-39387581e19937cfb9661af8.json | 5 +++++ .../results/llm-cache/ask-3974ba0bbcdf3a037c783eaf.json | 5 +++++ .../results/llm-cache/ask-39ddfaeb7db2b5c4f95a025c.json | 5 +++++ .../results/llm-cache/ask-3aeef057d8f295a9b82def4f.json | 5 +++++ .../results/llm-cache/ask-3b24592ebc961a7bbd8d580e.json | 5 +++++ .../results/llm-cache/ask-3baa21fbf635486c7e392171.json | 5 +++++ .../results/llm-cache/ask-3bab615b325f5a65689abe23.json | 5 +++++ .../results/llm-cache/ask-3be783a6518bc44693bb38f0.json | 5 +++++ .../results/llm-cache/ask-3c86c253ad56ca86ff6e6da6.json | 5 +++++ .../results/llm-cache/ask-3cfa79680a78ecb992eceb6f.json | 5 +++++ .../results/llm-cache/ask-3ddc4822e787b772a411aa0f.json | 5 +++++ .../results/llm-cache/ask-3e206b2321ced06b0f248fea.json | 5 +++++ .../results/llm-cache/ask-3e8a5424f8410fe0c52167af.json | 5 +++++ .../results/llm-cache/ask-3ea4218f781bc0a71855877f.json | 5 +++++ .../results/llm-cache/ask-3ff529077aee1fb53ff61b36.json | 5 +++++ .../results/llm-cache/ask-4090b5ab47d5fec50c9012b1.json | 5 +++++ .../results/llm-cache/ask-415a234629c972cf820d03da.json | 5 +++++ .../results/llm-cache/ask-41d339841d1fba7de0374474.json | 5 +++++ .../results/llm-cache/ask-42d6359332ec698b8dc2deeb.json | 5 +++++ .../results/llm-cache/ask-42dc37176df8032560785114.json | 5 +++++ .../results/llm-cache/ask-4351eb83134b3e3c94cf3381.json | 5 +++++ .../results/llm-cache/ask-43d9fc7872e799371abc4a8c.json | 5 +++++ .../results/llm-cache/ask-44642ce6039583ed62439074.json | 5 +++++ .../results/llm-cache/ask-4478080515385cc0f5ad883d.json | 5 +++++ .../results/llm-cache/ask-45575027e2b885969d5d9f4c.json | 5 +++++ .../results/llm-cache/ask-45ab18d6c2c6947a09395b71.json | 5 +++++ .../results/llm-cache/ask-466d5b553b93bda8d382b411.json | 5 +++++ .../results/llm-cache/ask-46e41ddc51ed948e186d438c.json | 5 +++++ .../results/llm-cache/ask-4713d99bd1e75a25a0f43650.json | 5 +++++ .../results/llm-cache/ask-4738095550fcfd05974995eb.json | 5 +++++ .../results/llm-cache/ask-477a4c497209c608bea7d306.json | 5 +++++ .../results/llm-cache/ask-47eb3bc9e1313823af5747c1.json | 5 +++++ .../results/llm-cache/ask-4858a23d10e518b1576553b3.json | 5 +++++ .../results/llm-cache/ask-48a9944c84fec86dee3ec53f.json | 5 +++++ .../results/llm-cache/ask-48f7827a83c20b8ce7bb91c6.json | 5 +++++ .../results/llm-cache/ask-49372d2c916137cc8dc048d5.json | 5 +++++ .../results/llm-cache/ask-4a188be5b8b505ad3748f559.json | 5 +++++ .../results/llm-cache/ask-4a23fdb935cd47cecb05b271.json | 5 +++++ .../results/llm-cache/ask-4bc1076ad57deb77bb15d027.json | 5 +++++ .../results/llm-cache/ask-4bdf32fc8dfb1bafe4342119.json | 5 +++++ .../results/llm-cache/ask-4bffc1efea9d23ffa769a10c.json | 5 +++++ .../results/llm-cache/ask-4c215643e6624f1a5d7460e3.json | 5 +++++ .../results/llm-cache/ask-4c990513178c308f9d9b42e5.json | 5 +++++ .../results/llm-cache/ask-4cda6453906279c087c654a1.json | 5 +++++ .../results/llm-cache/ask-4d77d300f79409631856da2e.json | 5 +++++ .../results/llm-cache/ask-4d9fa9f85f9f2809c4436721.json | 5 +++++ .../results/llm-cache/ask-4da50f796620c41b6ef014bb.json | 5 +++++ .../results/llm-cache/ask-4da62d261bece7bffeb1bc8e.json | 5 +++++ .../results/llm-cache/ask-4dae29d8e833094d3433fbb2.json | 5 +++++ .../results/llm-cache/ask-4e14619cc45578dd5b5f06e5.json | 5 +++++ .../results/llm-cache/ask-4e3626d2b6009520858e2b95.json | 5 +++++ .../results/llm-cache/ask-4e423ccb26243689b5a2b9c3.json | 5 +++++ .../results/llm-cache/ask-4ea82be0fdbc4e17b880d4cb.json | 5 +++++ .../results/llm-cache/ask-4f06b32ba6a9ff547b4c7d44.json | 5 +++++ .../results/llm-cache/ask-4f0ddd8a1b90b389628170be.json | 5 +++++ .../results/llm-cache/ask-4fb8097a896becebf373db2a.json | 5 +++++ .../results/llm-cache/ask-4fb9aa3a397617faafdfb4fd.json | 5 +++++ .../results/llm-cache/ask-4fe2478b30f5b3bfe74227c5.json | 5 +++++ .../results/llm-cache/ask-501f3d1015cfc31ac78e9777.json | 5 +++++ .../results/llm-cache/ask-509227431efdcd8cb26ad566.json | 5 +++++ .../results/llm-cache/ask-50ba337b4738e9a91ca0e63a.json | 5 +++++ .../results/llm-cache/ask-50f9bf85ca58a48e7a320fe2.json | 5 +++++ .../results/llm-cache/ask-50fae56f37c81bfc33fdc255.json | 5 +++++ .../results/llm-cache/ask-5147ee6e579f346259054554.json | 5 +++++ .../results/llm-cache/ask-520e20c669775472eca61b82.json | 5 +++++ .../results/llm-cache/ask-5217b7571e4a1c11c79b9e69.json | 5 +++++ .../results/llm-cache/ask-534a71aa8afb36d77cbb634b.json | 5 +++++ .../results/llm-cache/ask-538cc13ebcc7dc7dcad4c90a.json | 5 +++++ .../results/llm-cache/ask-53acc72ad17c5296871a0a64.json | 5 +++++ .../results/llm-cache/ask-53c7813d0ebff3442134f857.json | 5 +++++ .../results/llm-cache/ask-540203116acadea4636ae4ae.json | 5 +++++ .../results/llm-cache/ask-547789b3e5865e002aafb1bc.json | 5 +++++ .../results/llm-cache/ask-54b7f169c4edd8ad0166319c.json | 5 +++++ .../results/llm-cache/ask-54c2bb7819cfdd97130864b1.json | 5 +++++ .../results/llm-cache/ask-54e3b08ecefd14b9230ade1b.json | 5 +++++ .../results/llm-cache/ask-5597d3a505712acc51fc3225.json | 5 +++++ .../results/llm-cache/ask-55d00782882e16a9d99d60d1.json | 5 +++++ .../results/llm-cache/ask-55ee67a6a59a87b867b3c14d.json | 5 +++++ .../results/llm-cache/ask-56d8c3bf24a31f396d1f5820.json | 5 +++++ .../results/llm-cache/ask-56ec3ec12a1ce107a269b39d.json | 5 +++++ .../results/llm-cache/ask-572089502f2a0905921ea7e6.json | 5 +++++ .../results/llm-cache/ask-578b73e6f679aeee14b516be.json | 5 +++++ .../results/llm-cache/ask-58462cbcdb98d6a33f4af53b.json | 5 +++++ .../results/llm-cache/ask-58b0f26c35c266ccf98aef0b.json | 5 +++++ .../results/llm-cache/ask-58c4f7654d0aa83284439d84.json | 5 +++++ .../results/llm-cache/ask-58e581fb27092511f4d8fa55.json | 5 +++++ .../results/llm-cache/ask-59235b8f3ea06cadff11f1dd.json | 5 +++++ .../results/llm-cache/ask-59a797e0a22e234b9be87117.json | 5 +++++ .../results/llm-cache/ask-59eefc0ce0f1daf80429b997.json | 5 +++++ .../results/llm-cache/ask-5a0546a08d3e5ec58d1d2901.json | 5 +++++ .../results/llm-cache/ask-5a12f5c9933f18aeae358e60.json | 5 +++++ .../results/llm-cache/ask-5a45b5fd813335ccbae5b6e9.json | 5 +++++ .../results/llm-cache/ask-5a8d4a5e1c647d802107416f.json | 5 +++++ .../results/llm-cache/ask-5add05521cf1b57e9add2607.json | 5 +++++ .../results/llm-cache/ask-5af756e5ba1334f391d782d5.json | 5 +++++ .../results/llm-cache/ask-5b17efc53d4c126e4353f8d6.json | 5 +++++ .../results/llm-cache/ask-5b7b8e777f1b678d419d93a6.json | 5 +++++ .../results/llm-cache/ask-5bdd16bec79edbfa646464de.json | 5 +++++ .../results/llm-cache/ask-5bf2fc4bdb0f31d047303e97.json | 5 +++++ .../results/llm-cache/ask-5c2269f2e27314e5a547ed8a.json | 5 +++++ .../results/llm-cache/ask-5d1f66131f1ebb3f0d1d62e9.json | 5 +++++ .../results/llm-cache/ask-5d2c8e2627e69892b1f860ba.json | 5 +++++ .../results/llm-cache/ask-5d5822997d79a2efacda2d84.json | 5 +++++ .../results/llm-cache/ask-5db8c6dc66363709f0e3617e.json | 5 +++++ .../results/llm-cache/ask-5dc13d524d03d658ff561ced.json | 5 +++++ .../results/llm-cache/ask-5df661619fe94f03bae6b837.json | 5 +++++ .../results/llm-cache/ask-5e99c08dce9d529fac7c06e4.json | 5 +++++ .../results/llm-cache/ask-5ea3336e6ed733efe63f4208.json | 5 +++++ .../results/llm-cache/ask-5ed3275c040238f5b13ac5c9.json | 5 +++++ .../results/llm-cache/ask-5ed439ed45003654ab249d1e.json | 5 +++++ .../results/llm-cache/ask-5f05f4dcd4b5a8bb063532e5.json | 5 +++++ .../results/llm-cache/ask-5fcd740ab03840fdbddb5a01.json | 5 +++++ .../results/llm-cache/ask-5fe4e48c936600972909f64d.json | 5 +++++ .../results/llm-cache/ask-607f928dae4c95c40bdecddd.json | 5 +++++ .../results/llm-cache/ask-60bb8c4445e3b1a45904b90b.json | 5 +++++ .../results/llm-cache/ask-60ca535fe5af62aa34b390a1.json | 5 +++++ .../results/llm-cache/ask-61748b3318ae2aedd273f813.json | 5 +++++ .../results/llm-cache/ask-61967bc98529401dc4a12eb9.json | 5 +++++ .../results/llm-cache/ask-61f3786a383a77c000041a34.json | 5 +++++ .../results/llm-cache/ask-61f5e19728e4b64179149796.json | 5 +++++ .../results/llm-cache/ask-623d12b83983c9e4570ffc9a.json | 5 +++++ .../results/llm-cache/ask-627da881506200a9f4cef47f.json | 5 +++++ .../results/llm-cache/ask-63558305bc813ceeed6604f9.json | 5 +++++ .../results/llm-cache/ask-637a4cd6a1e5b8bee19db96f.json | 5 +++++ .../results/llm-cache/ask-63ff2d76737d402910980c4a.json | 5 +++++ .../results/llm-cache/ask-6459dfeb94a62fee50974dd0.json | 5 +++++ .../results/llm-cache/ask-6464062f20898836306c6e7b.json | 5 +++++ .../results/llm-cache/ask-64b91cdaab9c786f064ef0f8.json | 5 +++++ .../results/llm-cache/ask-64c02fd18266c653ac32d406.json | 5 +++++ .../results/llm-cache/ask-64cc6833502a209a39d5d5a1.json | 5 +++++ .../results/llm-cache/ask-65602d3759f34788e6b9502a.json | 5 +++++ .../results/llm-cache/ask-6608244cf4fb21a8e1a62d86.json | 5 +++++ .../results/llm-cache/ask-662cb11545662d8ce9970788.json | 5 +++++ .../results/llm-cache/ask-6643a369eea42ea9151b086e.json | 5 +++++ .../results/llm-cache/ask-6646a8a9cf7837298563a2d6.json | 5 +++++ .../results/llm-cache/ask-665a472cc7cf729865f95b83.json | 5 +++++ .../results/llm-cache/ask-665be50af9ee1560c8a7cd0a.json | 5 +++++ .../results/llm-cache/ask-6664121a232d04ec487662be.json | 5 +++++ .../results/llm-cache/ask-66b52d3873eda2678ebba78e.json | 5 +++++ .../results/llm-cache/ask-671665c3fa638f21c1744283.json | 5 +++++ .../results/llm-cache/ask-676785c2f6cb0b189fad86d6.json | 5 +++++ .../results/llm-cache/ask-6772ad13b08c00f528f2f367.json | 5 +++++ .../results/llm-cache/ask-67a0165f0d8750f7ca3aa4a2.json | 5 +++++ .../results/llm-cache/ask-67b12349b16e2dc63bcfaa2a.json | 5 +++++ .../results/llm-cache/ask-67db5edc50f0c538cd36adfa.json | 5 +++++ .../results/llm-cache/ask-683db049015f3bc181797251.json | 5 +++++ .../results/llm-cache/ask-684c1fe35a9c988de5a2d550.json | 5 +++++ .../results/llm-cache/ask-68a7bb5d24ba6411d430cb00.json | 5 +++++ .../results/llm-cache/ask-68e969d1c7afd437788de21f.json | 5 +++++ .../results/llm-cache/ask-692f0a4b10dd47cd63dbc264.json | 5 +++++ .../results/llm-cache/ask-6948be0eb23e8ecf418ec7c9.json | 5 +++++ .../results/llm-cache/ask-694d3bf29bcdf5c99bacdd44.json | 5 +++++ .../results/llm-cache/ask-698a0c626dd1fe33587f24a5.json | 5 +++++ .../results/llm-cache/ask-69a08f92e099e0497729b14f.json | 5 +++++ .../results/llm-cache/ask-69ce84adc8968a6db40c6cd9.json | 5 +++++ .../results/llm-cache/ask-69d11d9843dc21fc9da2bead.json | 5 +++++ .../results/llm-cache/ask-69d9a7b05c3b4bb84aa019ca.json | 5 +++++ .../results/llm-cache/ask-6a1b8f2fdc116bc5fcddf8dd.json | 5 +++++ .../results/llm-cache/ask-6a5f144a4d4b6232f47858ac.json | 5 +++++ .../results/llm-cache/ask-6b10b279b31a43fd973b0f84.json | 5 +++++ .../results/llm-cache/ask-6c3008642f97e7b5c3c0183d.json | 5 +++++ .../results/llm-cache/ask-6da42ccc65f7cc68313cd6e3.json | 5 +++++ .../results/llm-cache/ask-6e564744cfd80ee58f9425f7.json | 5 +++++ .../results/llm-cache/ask-6e64da16fb044982ca87390b.json | 5 +++++ .../results/llm-cache/ask-6e92f577163e56016f3aede8.json | 5 +++++ .../results/llm-cache/ask-6ea2b003e15551be634b0411.json | 5 +++++ .../results/llm-cache/ask-6ed30212e57753c836087fa1.json | 5 +++++ .../results/llm-cache/ask-6f20b875b13fe4c399dcc202.json | 5 +++++ .../results/llm-cache/ask-6f42757ce65cdaae84768aaf.json | 5 +++++ .../results/llm-cache/ask-6f84adfd5987910ab51ff264.json | 5 +++++ .../results/llm-cache/ask-6fd3efeda8627c9565a56cae.json | 5 +++++ .../results/llm-cache/ask-7040654239ca3c9096cad2b8.json | 5 +++++ .../results/llm-cache/ask-7055d51ebbe03efdd699dd00.json | 5 +++++ .../results/llm-cache/ask-7068a3e8308cbbf83b3f0617.json | 5 +++++ .../results/llm-cache/ask-70dc3fc306ae4b4ba2ddd77d.json | 5 +++++ .../results/llm-cache/ask-718b5b3dcde972bce8c09e31.json | 5 +++++ .../results/llm-cache/ask-71c0461674bc05c8f50ce817.json | 5 +++++ .../results/llm-cache/ask-71fa03e270a4070d0e8e2c91.json | 5 +++++ .../results/llm-cache/ask-720f30e3dafaf731f14837f0.json | 5 +++++ .../results/llm-cache/ask-721a0689eaba7f07e302e3c3.json | 5 +++++ .../results/llm-cache/ask-72e62e991f51fe6734ce22a4.json | 5 +++++ .../results/llm-cache/ask-72edf0485acf84530995a7a6.json | 5 +++++ .../results/llm-cache/ask-7338283f8d3e5c40c7cdef97.json | 5 +++++ .../results/llm-cache/ask-738b398b8fc793785c662df5.json | 5 +++++ .../results/llm-cache/ask-73ef58d2058b0f60817b14ce.json | 5 +++++ .../results/llm-cache/ask-7450bbe0625808dc67335f9e.json | 5 +++++ .../results/llm-cache/ask-745a977686a3ab1cb7149044.json | 5 +++++ .../results/llm-cache/ask-745c02d313cb2ab6f52e9de6.json | 5 +++++ .../results/llm-cache/ask-74fd1462ed5e93d6b5d5e854.json | 5 +++++ .../results/llm-cache/ask-7535371ab934d2a4e089f7cc.json | 5 +++++ .../results/llm-cache/ask-7582da67e6f22ae6afe6ec16.json | 5 +++++ .../results/llm-cache/ask-7595356dc49509583015a602.json | 5 +++++ .../results/llm-cache/ask-75c8703853d80112036ad7f9.json | 5 +++++ .../results/llm-cache/ask-76998f3c577fdb50b5c473ae.json | 5 +++++ .../results/llm-cache/ask-76f5da1753d0a7b987692f43.json | 5 +++++ .../results/llm-cache/ask-7741477518758f7e7fa2b5ec.json | 5 +++++ .../results/llm-cache/ask-7787bcad13505c69a74a3394.json | 5 +++++ .../results/llm-cache/ask-77c97096198b6cb88edb52f3.json | 5 +++++ .../results/llm-cache/ask-77ca415ff14836df263a680e.json | 5 +++++ .../results/llm-cache/ask-77fc1b092d613ac385184490.json | 5 +++++ .../results/llm-cache/ask-785f4c6b79b779ee1df9394c.json | 5 +++++ .../results/llm-cache/ask-788a8c2725ab1e5a416d7b57.json | 5 +++++ .../results/llm-cache/ask-78dcb2c82acab9250bfa08fe.json | 5 +++++ .../results/llm-cache/ask-790f82709437e5a4095ef4ba.json | 5 +++++ .../results/llm-cache/ask-7964da6d7dbcfd546e6edeb0.json | 5 +++++ .../results/llm-cache/ask-7a4b75ab04a05fa8125d4cc2.json | 5 +++++ .../results/llm-cache/ask-7a8d21fe082378e6b2908fb0.json | 5 +++++ .../results/llm-cache/ask-7aa5c02fbfb7177d96d07e06.json | 5 +++++ .../results/llm-cache/ask-7abc348a9966daae7ce7265f.json | 5 +++++ .../results/llm-cache/ask-7adc22b710cb3466174e1127.json | 5 +++++ .../results/llm-cache/ask-7afe6750dbc8e3489bbf3af9.json | 5 +++++ .../results/llm-cache/ask-7b3803d28ab5d03b9f2a3c4e.json | 5 +++++ .../results/llm-cache/ask-7b395a4a4a922f23f313fb3d.json | 5 +++++ .../results/llm-cache/ask-7b583cd35e9254e8182870f5.json | 5 +++++ .../results/llm-cache/ask-7bb3624da32b57be0d0f4f76.json | 5 +++++ .../results/llm-cache/ask-7bdcf0444ac31441ad03d1ca.json | 5 +++++ .../results/llm-cache/ask-7c18d125ebe58db42b53a924.json | 5 +++++ .../results/llm-cache/ask-7cd5dd892a62eb960d7130fe.json | 5 +++++ .../results/llm-cache/ask-7cdbf2c6f6747776f3c60b02.json | 5 +++++ .../results/llm-cache/ask-7cf5ffc87559403bf993554d.json | 5 +++++ .../results/llm-cache/ask-7d425ce907b2f72acc2bb33c.json | 5 +++++ .../results/llm-cache/ask-7d497034b50d44f0828382d0.json | 5 +++++ .../results/llm-cache/ask-7d507629bb2be0fe1dfee7e3.json | 5 +++++ .../results/llm-cache/ask-7d940dd28b5150d61eb1fb08.json | 5 +++++ .../results/llm-cache/ask-7edb6c77289fffbb0867237e.json | 5 +++++ .../results/llm-cache/ask-7fb2d3897d81cca9b7ed972e.json | 5 +++++ .../results/llm-cache/ask-7fd13f1c44a35b7336c3c88c.json | 5 +++++ .../results/llm-cache/ask-800e7d4c902a92467d25177a.json | 5 +++++ .../results/llm-cache/ask-8068fc0adfa26cf246c6c3a0.json | 5 +++++ .../results/llm-cache/ask-8069b303b0ecf1349a13b770.json | 5 +++++ .../results/llm-cache/ask-81410340f011b7f55ffee127.json | 5 +++++ .../results/llm-cache/ask-81a2bf897a043e4b77bee79f.json | 5 +++++ .../results/llm-cache/ask-81b9876c2126650a39014bf7.json | 5 +++++ .../results/llm-cache/ask-82737c91264c3cb99dce1fdd.json | 5 +++++ .../results/llm-cache/ask-8314328eb3cf3c02cd63ec5b.json | 5 +++++ .../results/llm-cache/ask-83998631d357b7836072b7f6.json | 5 +++++ .../results/llm-cache/ask-8496e106ad00582f2fa3996e.json | 5 +++++ .../results/llm-cache/ask-84ed0fc3235cc7a741c0e967.json | 5 +++++ .../results/llm-cache/ask-851e40253d07a5d0291ce7a7.json | 5 +++++ .../results/llm-cache/ask-85baf956c5d390573ae61112.json | 5 +++++ .../results/llm-cache/ask-85c6b09ff640e647ccc51e10.json | 5 +++++ .../results/llm-cache/ask-861b62af9830666f51ce5e5a.json | 5 +++++ .../results/llm-cache/ask-86943ab6b11a69621a481b4a.json | 5 +++++ .../results/llm-cache/ask-8710f5ad79c9d823d8dfe115.json | 5 +++++ .../results/llm-cache/ask-87762e57c60f5d77902fc4e4.json | 5 +++++ .../results/llm-cache/ask-87bda3e04ae77146537c81f3.json | 5 +++++ .../results/llm-cache/ask-87cd5a39b39065537471b336.json | 5 +++++ .../results/llm-cache/ask-87dc05c8b716496f687b36a1.json | 5 +++++ .../results/llm-cache/ask-87f3837de96bd2c0601f67f9.json | 5 +++++ .../results/llm-cache/ask-8807e594d94190d35200b4c6.json | 5 +++++ .../results/llm-cache/ask-8812a02af088bd436530b2fa.json | 5 +++++ .../results/llm-cache/ask-8828e14c60c73220a00fbc91.json | 5 +++++ .../results/llm-cache/ask-88a35581ee87c79dff0f288b.json | 5 +++++ .../results/llm-cache/ask-88a6199eb02124150c48f233.json | 5 +++++ .../results/llm-cache/ask-88ccd3134baceb5f532ce330.json | 5 +++++ .../results/llm-cache/ask-88d245d57cf06791df56187c.json | 5 +++++ .../results/llm-cache/ask-899084089c8696031ebbf948.json | 5 +++++ .../results/llm-cache/ask-8995d601b6af0c1d6c4d9b8d.json | 5 +++++ .../results/llm-cache/ask-89d530aaa0fcc304437d1e23.json | 5 +++++ .../results/llm-cache/ask-8a9c34bf53f2ca96413bded7.json | 5 +++++ .../results/llm-cache/ask-8b233a2d1971150e73e880c1.json | 5 +++++ .../results/llm-cache/ask-8b4bacc6c799b1df4d0c58ab.json | 5 +++++ .../results/llm-cache/ask-8b58a203eb777f3c3cea6e81.json | 5 +++++ .../results/llm-cache/ask-8b7966ba510abb5096ab1ad2.json | 5 +++++ .../results/llm-cache/ask-8c09bfcdebffc7c58a165c28.json | 5 +++++ .../results/llm-cache/ask-8c55384c41579835ff76695f.json | 5 +++++ .../results/llm-cache/ask-8c7a40b1e17e626f4fb31e0a.json | 5 +++++ .../results/llm-cache/ask-8cb07b913c4666e301fa126e.json | 5 +++++ .../results/llm-cache/ask-8cd933e55312e205336ffc27.json | 5 +++++ .../results/llm-cache/ask-8d8105aae58004820bbff3d7.json | 5 +++++ .../results/llm-cache/ask-8d8e63f194a77e968e7fedab.json | 5 +++++ .../results/llm-cache/ask-8e3a29d5b950a613eaea7eab.json | 5 +++++ .../results/llm-cache/ask-8e6fabf26f08956023d7c977.json | 5 +++++ .../results/llm-cache/ask-8e75cbf4c0cc92203fa358fc.json | 5 +++++ .../results/llm-cache/ask-8ec7d5167db70b4c1cb00f3e.json | 5 +++++ .../results/llm-cache/ask-8ee43d9a798c9c57ee3de26c.json | 5 +++++ .../results/llm-cache/ask-8ef5ff56738e5a88dfca76c6.json | 5 +++++ .../results/llm-cache/ask-8f8bb7e399bb57441529b1e4.json | 5 +++++ .../results/llm-cache/ask-8f93c32a7794d2d3f6ff4b26.json | 5 +++++ .../results/llm-cache/ask-8fb0b69b2ab7835bdf57a6fc.json | 5 +++++ .../results/llm-cache/ask-905ef517ffcae672539eb3c5.json | 5 +++++ .../results/llm-cache/ask-90aa66edef4093d9ba061f2e.json | 5 +++++ .../results/llm-cache/ask-91256a686ce09c7111eaa044.json | 5 +++++ .../results/llm-cache/ask-912ce579bcdae68f5c0d246f.json | 5 +++++ .../results/llm-cache/ask-91376c93a0ae0f32993cab65.json | 5 +++++ .../results/llm-cache/ask-913f0ef1c98f7b42c5be985a.json | 5 +++++ .../results/llm-cache/ask-91eff851de517c47b337547d.json | 5 +++++ .../results/llm-cache/ask-92541dedbb2c746f2aeb128a.json | 5 +++++ .../results/llm-cache/ask-925f851f70afe7e002b28cb9.json | 5 +++++ .../results/llm-cache/ask-92723088e32c1fd61a8ab3b2.json | 5 +++++ .../results/llm-cache/ask-92808ee3a83a1286efa2acc7.json | 5 +++++ .../results/llm-cache/ask-92a0b437ab3c3260a834afda.json | 5 +++++ .../results/llm-cache/ask-934f4d8a99c7ea91f733b783.json | 5 +++++ .../results/llm-cache/ask-93a1853ec2ffc733cbe8a0ed.json | 5 +++++ .../results/llm-cache/ask-93defdb077780b2555e4468c.json | 5 +++++ .../results/llm-cache/ask-93f5677b1911bf17f2a09e7d.json | 5 +++++ .../results/llm-cache/ask-93fbc9b67ba3669fdaf8518f.json | 5 +++++ .../results/llm-cache/ask-941203aabbee7d19514a1dbe.json | 5 +++++ .../results/llm-cache/ask-945b4080151536fc5d0f1e07.json | 5 +++++ .../results/llm-cache/ask-950901ad03adc2b8f39c428d.json | 5 +++++ .../results/llm-cache/ask-9582fb1af10b67f8325e06f7.json | 5 +++++ .../results/llm-cache/ask-967503d5044de409f7ebe058.json | 5 +++++ .../results/llm-cache/ask-96a26b93386e56d442f1f47f.json | 5 +++++ .../results/llm-cache/ask-9714e5017324452c6c99c480.json | 5 +++++ .../results/llm-cache/ask-97765be58d1b18f617f8ba45.json | 5 +++++ .../results/llm-cache/ask-978088459e6990d16acfc76b.json | 5 +++++ .../results/llm-cache/ask-97d45a6794e75e19564604f0.json | 5 +++++ .../results/llm-cache/ask-982b9e0a9948857ba303b855.json | 5 +++++ .../results/llm-cache/ask-98502ad16a6b6f7399c59d9b.json | 5 +++++ .../results/llm-cache/ask-98861c7989de174fdd6b6f3b.json | 5 +++++ .../results/llm-cache/ask-99798a5df3026d5e27ffb6a1.json | 5 +++++ .../results/llm-cache/ask-999d3c8a833fe5112221f210.json | 5 +++++ .../results/llm-cache/ask-99b49f22294e2dfb14586956.json | 5 +++++ .../results/llm-cache/ask-99bbb9db8aa767117dd3433c.json | 5 +++++ .../results/llm-cache/ask-99fd1782b946a13e7c117e0a.json | 5 +++++ .../results/llm-cache/ask-9afa134acc85d06c782ea7b4.json | 5 +++++ .../results/llm-cache/ask-9b5e0161cf22116000e943a2.json | 5 +++++ .../results/llm-cache/ask-9bccfe7c1b53c7a312fd26a4.json | 5 +++++ .../results/llm-cache/ask-9c4cec0271f63012f3670c7e.json | 5 +++++ .../results/llm-cache/ask-9c600114746c2ea6006dd729.json | 5 +++++ .../results/llm-cache/ask-9ccedf4e3a4bb0c591fd725d.json | 5 +++++ .../results/llm-cache/ask-9d30d3cabc03caffc912269e.json | 5 +++++ .../results/llm-cache/ask-9d51f61bebbd121d91e84a09.json | 5 +++++ .../results/llm-cache/ask-9d8df1f74f55b3ad10d8436e.json | 5 +++++ .../results/llm-cache/ask-9dafb93353559ce044c8d1f4.json | 5 +++++ .../results/llm-cache/ask-9e6e14b3e5eb738d087cf404.json | 5 +++++ .../results/llm-cache/ask-9eca6dd473fc157ce3b67c49.json | 5 +++++ .../results/llm-cache/ask-9ee52ccda799015f1489de98.json | 5 +++++ .../results/llm-cache/ask-9f0625221a06de392340adf4.json | 5 +++++ .../results/llm-cache/ask-9f44404bb7040383d916622e.json | 5 +++++ .../results/llm-cache/ask-9f4a6ef978f83e472aaec4c3.json | 5 +++++ .../results/llm-cache/ask-9fced432ea4d3346bc63f601.json | 5 +++++ .../results/llm-cache/ask-a07a0bd7afdf72f4b4197d05.json | 5 +++++ .../results/llm-cache/ask-a10266111f032b590536a06d.json | 5 +++++ .../results/llm-cache/ask-a130f6ae7fee64731b3708ef.json | 5 +++++ .../results/llm-cache/ask-a16df9131c5898c680d656a1.json | 5 +++++ .../results/llm-cache/ask-a19526ef2aa93b69474b68b7.json | 5 +++++ .../results/llm-cache/ask-a1d3f068fd5d5a44b1819bb7.json | 5 +++++ .../results/llm-cache/ask-a237d6dd405d4976b5fc0ebe.json | 5 +++++ .../results/llm-cache/ask-a26d895bc7a21be356c4265b.json | 5 +++++ .../results/llm-cache/ask-a28d2a06cccfe1acbbda06a9.json | 5 +++++ .../results/llm-cache/ask-a2f2e47ced677942a0609635.json | 5 +++++ .../results/llm-cache/ask-a325da8bc0a06ea493fd21a7.json | 5 +++++ .../results/llm-cache/ask-a3620416c8bed2b5ee09404d.json | 5 +++++ .../results/llm-cache/ask-a48f6fb1f5faa04f3c10c7e0.json | 5 +++++ .../results/llm-cache/ask-a4e8eed78d37de4bd129f8c1.json | 5 +++++ .../results/llm-cache/ask-a5886129754398290ee1ed8f.json | 5 +++++ .../results/llm-cache/ask-a5cba49ca6249e8fdadc4e49.json | 5 +++++ .../results/llm-cache/ask-a5dd3c59a7b9090abc96a9d3.json | 5 +++++ .../results/llm-cache/ask-a70eadc2a8959bb2dd0dcc13.json | 5 +++++ .../results/llm-cache/ask-a713dd9fc24f4558afb047b7.json | 5 +++++ .../results/llm-cache/ask-a73f6f6ddecf2b626b0a6cb4.json | 5 +++++ .../results/llm-cache/ask-a75f14de4fcd5eb053812b94.json | 5 +++++ .../results/llm-cache/ask-a7acd616cfe6531aa1dd5ba7.json | 5 +++++ .../results/llm-cache/ask-a81930b91ca30a45a3bf12e3.json | 5 +++++ .../results/llm-cache/ask-a86b64e5b6d53ee0867020b3.json | 5 +++++ .../results/llm-cache/ask-a8ebed735239077f6f50119c.json | 5 +++++ .../results/llm-cache/ask-a911c85e266bf269610b285d.json | 5 +++++ .../results/llm-cache/ask-a97c378ee8123feb7e7b29c8.json | 5 +++++ .../results/llm-cache/ask-a9d3b48d88f980d625b2616a.json | 5 +++++ .../results/llm-cache/ask-aa7235f10fc861f3ba049bb7.json | 5 +++++ .../results/llm-cache/ask-ab05d829fe3ef8ff5c3e43dc.json | 5 +++++ .../results/llm-cache/ask-ab16f7293f4d2383a1a3f398.json | 5 +++++ .../results/llm-cache/ask-ab2081c74cde1aac493e79e4.json | 5 +++++ .../results/llm-cache/ask-ab441ad195b88dc14ec7df21.json | 5 +++++ .../results/llm-cache/ask-ab5cd5ddf37ceb1dd0076c5e.json | 5 +++++ .../results/llm-cache/ask-ab6ab30fc2a0c8738ef78752.json | 5 +++++ .../results/llm-cache/ask-ab8e45615068b0211cc4983e.json | 5 +++++ .../results/llm-cache/ask-ab8eeea081535cd918057111.json | 5 +++++ .../results/llm-cache/ask-aba801605055f170ab849143.json | 5 +++++ .../results/llm-cache/ask-abc3579ddfcd9f54157389b5.json | 5 +++++ .../results/llm-cache/ask-abf14a1b84c033d9f44b0ebe.json | 5 +++++ .../results/llm-cache/ask-ac01390f645af9bb1e456f8a.json | 5 +++++ .../results/llm-cache/ask-ac529a4ff28fe1dcd00b18ab.json | 5 +++++ .../results/llm-cache/ask-ac671dc0f25b23619e1f8762.json | 5 +++++ .../results/llm-cache/ask-ac943c15d715c74b34baccd9.json | 5 +++++ .../results/llm-cache/ask-acb3e24a476b574ff8355b2c.json | 5 +++++ .../results/llm-cache/ask-acde9a29baa16a6d357fe739.json | 5 +++++ .../results/llm-cache/ask-ace6cba3c5048b3cb8ea66c0.json | 5 +++++ .../results/llm-cache/ask-adb3f02ac4f8a53ebb54122f.json | 5 +++++ .../results/llm-cache/ask-adb93601a64a5f589e6f476a.json | 5 +++++ .../results/llm-cache/ask-add2e0cf67d919d9ae16ecec.json | 5 +++++ .../results/llm-cache/ask-adee2311f65e1906b7ee6fb2.json | 5 +++++ .../results/llm-cache/ask-ae0305105f7674f505b1969e.json | 5 +++++ .../results/llm-cache/ask-ae612361a0950169163ff1f0.json | 5 +++++ .../results/llm-cache/ask-ae87872a4a85ff47f864d9c5.json | 5 +++++ .../results/llm-cache/ask-aeb1f9e77237d60c3482f1cb.json | 5 +++++ .../results/llm-cache/ask-af03efd2f4d1b3fabd6848e7.json | 5 +++++ .../results/llm-cache/ask-af2ae6985699470d3806b944.json | 5 +++++ .../results/llm-cache/ask-af886454416ca5b35a441788.json | 5 +++++ .../results/llm-cache/ask-afa897e497db6febc8b317ab.json | 5 +++++ .../results/llm-cache/ask-afbefac2feb745067a0ff79d.json | 5 +++++ .../results/llm-cache/ask-b05822ad29b43b2062577f83.json | 5 +++++ .../results/llm-cache/ask-b09d631f6d7284594a326428.json | 5 +++++ .../results/llm-cache/ask-b1dbf26fd8e613cbc9b79c0c.json | 5 +++++ .../results/llm-cache/ask-b1e47fb12abcd99fe25490d4.json | 5 +++++ .../results/llm-cache/ask-b2919657e1fc8b547e990e23.json | 5 +++++ .../results/llm-cache/ask-b3a9185ea61bd9fb285369ff.json | 5 +++++ .../results/llm-cache/ask-b3bf21b73d377ea1e4164f1a.json | 5 +++++ .../results/llm-cache/ask-b424788684f0bbc078c8f4e4.json | 5 +++++ .../results/llm-cache/ask-b44c4ca414b312a3f29885ff.json | 5 +++++ .../results/llm-cache/ask-b4554d0506d4fe07e87a9411.json | 5 +++++ .../results/llm-cache/ask-b4ddcea3e134c3800b7294a9.json | 5 +++++ .../results/llm-cache/ask-b545ff07ddfcea6c6ad34340.json | 5 +++++ .../results/llm-cache/ask-b54af94ca7a12144a909a89f.json | 5 +++++ .../results/llm-cache/ask-b66631c8d1663b6476baf25e.json | 5 +++++ .../results/llm-cache/ask-b690991fef194d8e78b0b04a.json | 5 +++++ .../results/llm-cache/ask-b69b896d99d81fdf24120048.json | 5 +++++ .../results/llm-cache/ask-b6b623bce58c7763adb25f90.json | 5 +++++ .../results/llm-cache/ask-b70164640df05392734f7702.json | 5 +++++ .../results/llm-cache/ask-b76b7251a0071b533c563eb3.json | 5 +++++ .../results/llm-cache/ask-b776e402d1da96c2b1c416e0.json | 5 +++++ .../results/llm-cache/ask-b7c0d5d9c20b6f2468985a6c.json | 5 +++++ .../results/llm-cache/ask-b7cfc4cd1125414ab0be8f7e.json | 5 +++++ .../results/llm-cache/ask-b923f1e6dcc0343dc3ea698b.json | 5 +++++ .../results/llm-cache/ask-bab5335c0546e854c6a770f6.json | 5 +++++ .../results/llm-cache/ask-bb9343ac20721c887b99786d.json | 5 +++++ .../results/llm-cache/ask-bcda562586a9163f8a193ca0.json | 5 +++++ .../results/llm-cache/ask-bcdd456d3198d0079e23cfbf.json | 5 +++++ .../results/llm-cache/ask-bebc6e5ee59ab3d4511ac6df.json | 5 +++++ .../results/llm-cache/ask-bf4ee11ed38bc1eb9876b365.json | 5 +++++ .../results/llm-cache/ask-bfc597dd308a719aa7071b9f.json | 5 +++++ .../results/llm-cache/ask-c032413a17c5c65b0b3df3fa.json | 5 +++++ .../results/llm-cache/ask-c03dc2f0863e638adac0d40b.json | 5 +++++ .../results/llm-cache/ask-c08d72a7db401f338b6c971a.json | 5 +++++ .../results/llm-cache/ask-c0d407b4033fa84a10df06bf.json | 5 +++++ .../results/llm-cache/ask-c0ec9273b113c43518bff18f.json | 5 +++++ .../results/llm-cache/ask-c0fbfa68637940887b57ba2b.json | 5 +++++ .../results/llm-cache/ask-c1207ff18279bae19c5642ca.json | 5 +++++ .../results/llm-cache/ask-c1244feee490658ac8616d02.json | 5 +++++ .../results/llm-cache/ask-c15e1d33bc10c3eba3a7cbc4.json | 5 +++++ .../results/llm-cache/ask-c1e63139d86f9b060d87978a.json | 5 +++++ .../results/llm-cache/ask-c2004472dbf4c32713776f35.json | 5 +++++ .../results/llm-cache/ask-c2272fecf092710487f94c05.json | 5 +++++ .../results/llm-cache/ask-c23d05f55cb228ad351c88b8.json | 5 +++++ .../results/llm-cache/ask-c362384973ca3f5184c8b6de.json | 5 +++++ .../results/llm-cache/ask-c3e8d0380bcba11f0c38478a.json | 5 +++++ .../results/llm-cache/ask-c40bed3b3173258bae1e3efd.json | 5 +++++ .../results/llm-cache/ask-c4280d4cfc3308ca4761fdd1.json | 5 +++++ .../results/llm-cache/ask-c489d0adef3d180ab5e6aa7f.json | 5 +++++ .../results/llm-cache/ask-c4a83dec3b1f20b4139d63c6.json | 5 +++++ .../results/llm-cache/ask-c4c21888dcc42ae416e10a5a.json | 5 +++++ .../results/llm-cache/ask-c50d7ca38fa4d8f3ac529cef.json | 5 +++++ .../results/llm-cache/ask-c55e52178f58192248475245.json | 5 +++++ .../results/llm-cache/ask-c5b894847d929e1e070ae9f4.json | 5 +++++ .../results/llm-cache/ask-c5ba3dc2356881d2c835b13f.json | 5 +++++ .../results/llm-cache/ask-c5c02c5360b64dfa28243c53.json | 5 +++++ .../results/llm-cache/ask-c5ca3b9f33915a2b90ea7444.json | 5 +++++ .../results/llm-cache/ask-c5ec1ac20e9d17538b99d967.json | 5 +++++ .../results/llm-cache/ask-c64a220a849f20bab14cecc4.json | 5 +++++ .../results/llm-cache/ask-c7344ebd6f986cb8044364f0.json | 5 +++++ .../results/llm-cache/ask-c76cd2fabba1b682e4322e14.json | 5 +++++ .../results/llm-cache/ask-c812e3c94fc0b2bbe480d4fe.json | 5 +++++ .../results/llm-cache/ask-c85ffa1a2c13f154bb54d0e6.json | 5 +++++ .../results/llm-cache/ask-c8c94a027448e501779becdb.json | 5 +++++ .../results/llm-cache/ask-ca2435f1cb2765e6508baaaf.json | 5 +++++ .../results/llm-cache/ask-ca4abf20b4c887f83826062e.json | 5 +++++ .../results/llm-cache/ask-ca6353b0c131fba2aa7395fa.json | 5 +++++ .../results/llm-cache/ask-cad5346e053eb04a96a1c6c7.json | 5 +++++ .../results/llm-cache/ask-cad601b39aba4677c74441f4.json | 5 +++++ .../results/llm-cache/ask-cadcb19767d8ef9314e102d4.json | 5 +++++ .../results/llm-cache/ask-cb04a3639f3fad485fb4c70e.json | 5 +++++ .../results/llm-cache/ask-cc97e5804dd47c7d515efd43.json | 5 +++++ .../results/llm-cache/ask-cd71837428c0a6e370c7d6b4.json | 5 +++++ .../results/llm-cache/ask-ce15a8a70a81f9c84284044e.json | 5 +++++ .../results/llm-cache/ask-ce2a28256addbe6bb9c78b0d.json | 5 +++++ .../results/llm-cache/ask-ce6332cdecc47cc7b874af6f.json | 5 +++++ .../results/llm-cache/ask-ce66ca16906862b940c81c65.json | 5 +++++ .../results/llm-cache/ask-ce7b9720a7a6af608770fd3f.json | 5 +++++ .../results/llm-cache/ask-ced6d9fbfa42b1564d3dd590.json | 5 +++++ .../results/llm-cache/ask-cf10bc1d92edbffa06b25ecb.json | 5 +++++ .../results/llm-cache/ask-cf90691350799a35053168ae.json | 5 +++++ .../results/llm-cache/ask-cfdda43d6abfbbbc24b8c83a.json | 5 +++++ .../results/llm-cache/ask-cff347e088714683a963f468.json | 5 +++++ .../results/llm-cache/ask-d00921e2832ed42b1a186b55.json | 5 +++++ .../results/llm-cache/ask-d028461ce82bce66ad6dbd34.json | 5 +++++ .../results/llm-cache/ask-d06c060410c305f5ea6dd665.json | 5 +++++ .../results/llm-cache/ask-d0743f1b41df61df0553f8be.json | 5 +++++ .../results/llm-cache/ask-d0a28f60d6b2b04b61e1aee7.json | 5 +++++ .../results/llm-cache/ask-d1206342777f77883dc204d2.json | 5 +++++ .../results/llm-cache/ask-d1420fcb25cb13a9b998371f.json | 5 +++++ .../results/llm-cache/ask-d20fb210485d63fcc8e1c328.json | 5 +++++ .../results/llm-cache/ask-d2225f3138e54922d0bd19b2.json | 5 +++++ .../results/llm-cache/ask-d2321a0b8dbfb617709c7aab.json | 5 +++++ .../results/llm-cache/ask-d27a49f3efeb8780ddb6da33.json | 5 +++++ .../results/llm-cache/ask-d27b215ada366fec899c0e26.json | 5 +++++ .../results/llm-cache/ask-d2dd88d5a8ddbf6a308510e2.json | 5 +++++ .../results/llm-cache/ask-d2eda8ec2fc7ce50e10087ab.json | 5 +++++ .../results/llm-cache/ask-d30e8137f600c72d7a174a67.json | 5 +++++ .../results/llm-cache/ask-d36e30c6bc3a2c491a041f93.json | 5 +++++ .../results/llm-cache/ask-d44386f6cc30095c73d5258a.json | 5 +++++ .../results/llm-cache/ask-d4757ff0bf4f7fd3af089f00.json | 5 +++++ .../results/llm-cache/ask-d4aaab44b3e358c465d90406.json | 5 +++++ .../results/llm-cache/ask-d53f3011a1117c2c3ab27d56.json | 5 +++++ .../results/llm-cache/ask-d55e216175813f0b8d27b9f6.json | 5 +++++ .../results/llm-cache/ask-d5ba533a93c29a83f5a47edf.json | 5 +++++ .../results/llm-cache/ask-d5edfb3f8458dbfbd6eb4219.json | 5 +++++ .../results/llm-cache/ask-d6200cf382d7016c79bddc13.json | 5 +++++ .../results/llm-cache/ask-d62a12f267f12db7329a4fd4.json | 5 +++++ .../results/llm-cache/ask-d663595dcb0fe4cbb44c8c91.json | 5 +++++ .../results/llm-cache/ask-d665c044bdfd56c0eb1a8bc3.json | 5 +++++ .../results/llm-cache/ask-d6748413333c50c47368fbe6.json | 5 +++++ .../results/llm-cache/ask-d6fabdd7878795f9db37b41d.json | 5 +++++ .../results/llm-cache/ask-d713ba761247a0081a29667c.json | 5 +++++ .../results/llm-cache/ask-d766ea1e5c3c26413b8d8712.json | 5 +++++ .../results/llm-cache/ask-d803686e75a11a2f8765486d.json | 5 +++++ .../results/llm-cache/ask-d82dc2f0ecbbdcdf43c2da24.json | 5 +++++ .../results/llm-cache/ask-d843192b0369884bdb0024d7.json | 5 +++++ .../results/llm-cache/ask-d879aa7458ea864efb51f9c0.json | 5 +++++ .../results/llm-cache/ask-d988a4d0f5ddd5ae8455f28a.json | 5 +++++ .../results/llm-cache/ask-da08ff29aa7d43b83cd238da.json | 5 +++++ .../results/llm-cache/ask-daaecab0f47993e654dbfe5d.json | 5 +++++ .../results/llm-cache/ask-db3c9a118a91c622938320db.json | 5 +++++ .../results/llm-cache/ask-dbc9c122257e27cfad999ffe.json | 5 +++++ .../results/llm-cache/ask-dbdf3bd8bc4c46fa3da67fbc.json | 5 +++++ .../results/llm-cache/ask-dc9d3de7e4fdaec411d3882a.json | 5 +++++ .../results/llm-cache/ask-dcb264cd9d9f11e297455896.json | 5 +++++ .../results/llm-cache/ask-dcb94f061f6099e368a11d2a.json | 5 +++++ .../results/llm-cache/ask-dd1eabfce3280c0434576489.json | 5 +++++ .../results/llm-cache/ask-dd534fba9549350ff6d63a25.json | 5 +++++ .../results/llm-cache/ask-dd5a88cee2df2a44e62c9498.json | 5 +++++ .../results/llm-cache/ask-dd79a18ac6ba9cb1dc204489.json | 5 +++++ .../results/llm-cache/ask-dd900dd601408fe0219a40b0.json | 5 +++++ .../results/llm-cache/ask-ddb5999cffb50f8b9e274de8.json | 5 +++++ .../results/llm-cache/ask-dde795ed090323a9cfee046a.json | 5 +++++ .../results/llm-cache/ask-de80040841d609b61e952d15.json | 5 +++++ .../results/llm-cache/ask-dee8d2d9f851baf9fada0e43.json | 5 +++++ .../results/llm-cache/ask-deef8f2658eb7b5ab5266c2f.json | 5 +++++ .../results/llm-cache/ask-df1cc4240d6c807ee15c3d72.json | 5 +++++ .../results/llm-cache/ask-df21a3505b83f54980142432.json | 5 +++++ .../results/llm-cache/ask-df628250f1f9262da02cb15f.json | 5 +++++ .../results/llm-cache/ask-dfa163eb6d3ed84cd94da633.json | 5 +++++ .../results/llm-cache/ask-dfd39d1485eb0e46277409e9.json | 5 +++++ .../results/llm-cache/ask-e0387824c144a8fc335e9409.json | 5 +++++ .../results/llm-cache/ask-e06209b0ea662af0d7d1bd74.json | 5 +++++ .../results/llm-cache/ask-e1bdf401dd33916fb1f62531.json | 5 +++++ .../results/llm-cache/ask-e1e7afcde660a86898d1a8cd.json | 5 +++++ .../results/llm-cache/ask-e2856b0c8621dafb91b6bf8c.json | 5 +++++ .../results/llm-cache/ask-e2afee58e8cc0f660b8bde7e.json | 5 +++++ .../results/llm-cache/ask-e2da9b38b4fa2ee492ff588b.json | 5 +++++ .../results/llm-cache/ask-e2ed3bf103a3d89697cb5ec6.json | 5 +++++ .../results/llm-cache/ask-e311fac78730ff1f91dc5984.json | 5 +++++ .../results/llm-cache/ask-e3933ecfeedf74ac3b9618fa.json | 5 +++++ .../results/llm-cache/ask-e3ecfda453a3d042a8d8f8e2.json | 5 +++++ .../results/llm-cache/ask-e3fff1cf9dbd5ea9b88ba26e.json | 5 +++++ .../results/llm-cache/ask-e4aa4deb8df53a66bb5fca81.json | 5 +++++ .../results/llm-cache/ask-e4b64264916939c09e718988.json | 5 +++++ .../results/llm-cache/ask-e4c03fed07c8c2eb98277fef.json | 5 +++++ .../results/llm-cache/ask-e5675f4c7208ba20d06989e3.json | 5 +++++ .../results/llm-cache/ask-e5683c0ffe99c8027e37b075.json | 5 +++++ .../results/llm-cache/ask-e57809f49c6ab3c315fc90b3.json | 5 +++++ .../results/llm-cache/ask-e5ace1ae05f1d64457097e06.json | 5 +++++ .../results/llm-cache/ask-e5f348e8c474808f2ad9213d.json | 5 +++++ .../results/llm-cache/ask-e6744a7059be663f154fc747.json | 5 +++++ .../results/llm-cache/ask-e6a80ae9f4257ac2049a665b.json | 5 +++++ .../results/llm-cache/ask-e6daab57328667318ef1caf2.json | 5 +++++ .../results/llm-cache/ask-e73c16ca1d8146c59b5741dd.json | 5 +++++ .../results/llm-cache/ask-e785b0c2183aa767b4e6f278.json | 5 +++++ .../results/llm-cache/ask-e788d2632c2228ef13742389.json | 5 +++++ .../results/llm-cache/ask-e7902cfeb5008f860231fc2e.json | 5 +++++ .../results/llm-cache/ask-e83c633cb97e22fa99a7be83.json | 5 +++++ .../results/llm-cache/ask-e909d87324a51a6e285e4a9f.json | 5 +++++ .../results/llm-cache/ask-e90d3995c503bae7a9cdbc57.json | 5 +++++ .../results/llm-cache/ask-e90d8ba78746b58d74448546.json | 5 +++++ .../results/llm-cache/ask-e92457c01ba06b6b60fc92b9.json | 5 +++++ .../results/llm-cache/ask-ea3cdc5f92f9c0e37edaf0a0.json | 5 +++++ .../results/llm-cache/ask-ea73979b3c730c69db4d326e.json | 5 +++++ .../results/llm-cache/ask-eaa79b2723d580d33593e49f.json | 5 +++++ .../results/llm-cache/ask-eb3b7468b14ee33b5aa918f4.json | 5 +++++ .../results/llm-cache/ask-eb6d6c1efbccf38890f84aee.json | 5 +++++ .../results/llm-cache/ask-eba72505f448f18df2fa20b3.json | 5 +++++ .../results/llm-cache/ask-ebd6b3514d10a77bda984601.json | 5 +++++ .../results/llm-cache/ask-ebd946d841a600db9e27da78.json | 5 +++++ .../results/llm-cache/ask-ebe2903124f79d0af9bcf89d.json | 5 +++++ .../results/llm-cache/ask-ec224704986402dfd134cbd2.json | 5 +++++ .../results/llm-cache/ask-ec3c6eeec40ce9dc539c6dce.json | 5 +++++ .../results/llm-cache/ask-ecd219d30ca6f0f1555cfee8.json | 5 +++++ .../results/llm-cache/ask-ecfe2a53f7e5ecabae89e005.json | 5 +++++ .../results/llm-cache/ask-ed49b1a4f41f66f1156fef84.json | 5 +++++ .../results/llm-cache/ask-ed690cc1c0c5da4fafdbf8d7.json | 5 +++++ .../results/llm-cache/ask-eda2798f88e7b9c60526a073.json | 5 +++++ .../results/llm-cache/ask-edb0b2a00717800ed47d02a7.json | 5 +++++ .../results/llm-cache/ask-edc9aae86665ed63cf7168da.json | 5 +++++ .../results/llm-cache/ask-edcea700b2906887f32766ac.json | 5 +++++ .../results/llm-cache/ask-ee3aa9dae35f0948bc7a8adb.json | 5 +++++ .../results/llm-cache/ask-eea425ce5d2f38fb95ad8e25.json | 5 +++++ .../results/llm-cache/ask-ef03fa0e6890d588d54e2583.json | 5 +++++ .../results/llm-cache/ask-ef31606acc412e177609e699.json | 5 +++++ .../results/llm-cache/ask-efa20e07104b7c06af6e2436.json | 5 +++++ .../results/llm-cache/ask-efada1b89ad642f5625cceba.json | 5 +++++ .../results/llm-cache/ask-f042dc1872feeb67d633a681.json | 5 +++++ .../results/llm-cache/ask-f0790914c6757cb70478e29f.json | 5 +++++ .../results/llm-cache/ask-f085b32c5f0d3bcce1304ac2.json | 5 +++++ .../results/llm-cache/ask-f0be4c2824713c4f3f844eb8.json | 5 +++++ .../results/llm-cache/ask-f11e8aff82787f319ba2aad9.json | 5 +++++ .../results/llm-cache/ask-f1ddac0c42c26840200b85d0.json | 5 +++++ .../results/llm-cache/ask-f1f35472272b32d52dca18f8.json | 5 +++++ .../results/llm-cache/ask-f271a90993d7a18af4601d0e.json | 5 +++++ .../results/llm-cache/ask-f29106c36017e65651041378.json | 5 +++++ .../results/llm-cache/ask-f291e1db29b17605f9a8ba2f.json | 5 +++++ .../results/llm-cache/ask-f2a5d96f15f6d16aa3631cf5.json | 5 +++++ .../results/llm-cache/ask-f2bc539a9f54cd1fb8e7aaae.json | 5 +++++ .../results/llm-cache/ask-f34bf9cf57fe2975f760f01d.json | 5 +++++ .../results/llm-cache/ask-f356cfb9f91893eeaaa8e080.json | 5 +++++ .../results/llm-cache/ask-f3d087811f30b509c3571a37.json | 5 +++++ .../results/llm-cache/ask-f418eb748c0d00949f5029a4.json | 5 +++++ .../results/llm-cache/ask-f491218317e9b533aceffd8c.json | 5 +++++ .../results/llm-cache/ask-f4bfbe8df90a4f6e3db5003e.json | 5 +++++ .../results/llm-cache/ask-f523f3829c1b32b82fbf8603.json | 5 +++++ .../results/llm-cache/ask-f55d68f5c2f747d06705a7cb.json | 5 +++++ .../results/llm-cache/ask-f5d9b7665521c807ef1f6a4e.json | 5 +++++ .../results/llm-cache/ask-f5f24cd3d48b36d65abc4b6a.json | 5 +++++ .../results/llm-cache/ask-f62120f01268e80a27fba3e4.json | 5 +++++ .../results/llm-cache/ask-f652dee05fb5aee1ce5b11df.json | 5 +++++ .../results/llm-cache/ask-f6f662e5b139c2231d1ba5ab.json | 5 +++++ .../results/llm-cache/ask-f778e48e6380f2958fb299f2.json | 5 +++++ .../results/llm-cache/ask-f82b419a7b4047c0c2277857.json | 5 +++++ .../results/llm-cache/ask-f8363043e79f65dd8fa2314c.json | 5 +++++ .../results/llm-cache/ask-f87b70fdedecbd35ea992352.json | 5 +++++ .../results/llm-cache/ask-f8923f9cbcfd97f73af6db38.json | 5 +++++ .../results/llm-cache/ask-f8b0a689106d9aed843c3421.json | 5 +++++ .../results/llm-cache/ask-f8ca34d9275520dc7acfffbb.json | 5 +++++ .../results/llm-cache/ask-f90d8c178032e6b14649fd2d.json | 5 +++++ .../results/llm-cache/ask-f929a982a50a27962204bf09.json | 5 +++++ .../results/llm-cache/ask-f955a9e0e10040c58704ac46.json | 5 +++++ .../results/llm-cache/ask-f9ab2a1aaa17864121592197.json | 5 +++++ .../results/llm-cache/ask-f9ac6b9e49da19835866ec30.json | 5 +++++ .../results/llm-cache/ask-fa0c944db1352a6a7cbbc4a6.json | 5 +++++ .../results/llm-cache/ask-fa8aff8503e1fef43070151a.json | 5 +++++ .../results/llm-cache/ask-fa9eac36d2d01b608496015f.json | 5 +++++ .../results/llm-cache/ask-fab6c556416e04473f1935ad.json | 5 +++++ .../results/llm-cache/ask-faf36b35048ed1db075d29c4.json | 5 +++++ .../results/llm-cache/ask-fb7962cc84ed97e8c04899b2.json | 5 +++++ .../results/llm-cache/ask-fbb9c84855b140f7b5f95f9c.json | 5 +++++ .../results/llm-cache/ask-fbeca3b741b020a2fcae8fc8.json | 5 +++++ .../results/llm-cache/ask-fc1b793cad8a9169da0acd0b.json | 5 +++++ .../results/llm-cache/ask-fc2de3ea2f32cd47436e814a.json | 5 +++++ .../results/llm-cache/ask-fc3e4a61c59ef4353c726119.json | 5 +++++ .../results/llm-cache/ask-fc41d30d023cc268ab52617b.json | 5 +++++ .../results/llm-cache/ask-fcb36197d933aab8f6bb199b.json | 5 +++++ .../results/llm-cache/ask-fcb8a0c1e66849f82998c37f.json | 5 +++++ .../results/llm-cache/ask-fce4ad9ff24fa862481a19c7.json | 5 +++++ .../results/llm-cache/ask-fcfa353bfb9e3e196b9edf48.json | 5 +++++ .../results/llm-cache/ask-fd266bae31a19125ca5a4b5f.json | 5 +++++ .../results/llm-cache/ask-fdcd37001cc3a1256072408f.json | 5 +++++ .../results/llm-cache/ask-fe318df8d46eac22cef4cd89.json | 5 +++++ .../results/llm-cache/ask-fe6ba69778a5324a72249d3b.json | 5 +++++ .../results/llm-cache/ask-fe94f8b6cc3f25cda9a48309.json | 5 +++++ .../results/llm-cache/ask-fea249af95c54a46b463925d.json | 5 +++++ .../results/llm-cache/ask-ff493545ac7bb5ee028b925f.json | 5 +++++ .../results/llm-cache/ask-ffc07dfe3b0cff23ea9b5af5.json | 5 +++++ .../results/llm-cache/ask-fff4080e392f1964b30b752f.json | 5 +++++ 836 files changed, 4180 insertions(+) create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-000a56b17f8db2ca0321be4a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-010f9b0f4dbe71d60bc9a772.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-012dc8ba7ed6e34a85f75170.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-01dbc532b9eabb1fca8a273c.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-020707e41424558bbec7a67f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-024ee04bd72f916d5159ca78.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-02788019e7c2e436cfe6932e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-0287437c7071b803790b2a03.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-0347f81080c210a23588e43c.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-0393602049acad80a749b899.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-03ecb7d37b907469d5c1bf75.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-03ee2f9f812ac836d8732089.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-04c6b431f425793a46ba0f12.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-04deda273d933177c34a77da.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-0508ccea52b60522a908a108.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-0531a575b19d2f6f827bb22c.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-053ebe38a507614123e16026.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-0576295511e270b1f62c85da.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-0579385ed91673d633be4584.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-05905dfaa628411b797ea65f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-05e043f6c7e6121d5615917e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-05e08f7c1731ec2f1803a2b1.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-064f488b5d47f26b1486a9bd.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-06a6c7c4fd3b1ec41cbab4f7.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-06b7e5a0ad685c915092f5f0.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-071290b25e221f417bddfb7e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-0744cf90619517acaceefccc.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-0765f56b29ee24d3ac0d6fe4.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-07a57c55afc5110bbf4afffd.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-07d2d28a001285a44000081f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-07d7eed6d1d21b72adb7eb89.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-07d81a7f5453601bb0d64d18.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-0854fb7311637309a9ef2736.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-08ab548eeb4337bdb07667a5.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-09f10091eb9d8ad0045e2c8c.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-0a62111a33a93371521028e8.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-0ae6c213818f492047ebb487.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-0b14c72f9b3c0bdbaa3205cc.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-0b65f6edb80539a3385cdddf.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-0b6c232ce8232c174392aeea.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-0b9567e8dd6e56af82d614ce.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-0ca5243ff0cf2ffebed6da59.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-0d06b9b4cd2626ae13b64aca.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-0d55f701cf694eced3e60d6d.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-0dd1afbb078b94c3bbaffd72.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-0ddb5a02e2925cb75138fea1.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-0e910a78a4812cc444c54236.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-0eaeddf7f71e6da7d0e4e4ba.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-0ec0ba47d42577309569a930.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-0f1693567474b9f0c366dd6a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-0fd6e5bd48a13faa97533dcd.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-10117765bc0619be16346755.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-102062647428bba26f325b62.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-105ff1a8df30382e7138a6cc.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-10aaef3cb691a428f118cef0.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-10b8d0856d9581ce40528189.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-10cb5188a56a004d0f457376.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-11342bbccb9537b1ce8dd7a4.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-11a103a7d4fe37a0b2f157e6.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-122168b4d052b7789cf6f800.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-12359efc2febc92ff5a68c72.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-124fbb046e49b93e5d33b142.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-133e7c6d2cc3dd7e2a0e7ab3.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-1373bc8785c80ab9c1d6bee0.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-1382af5e1eadf000914e80eb.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-13d7cd3a7aedf93932710377.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-14039fedd63b490eb6da6b0c.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-165b52cb93902a7651d6220e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-1669039dba0043ef962c7dcb.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-16717ed8c87dcbcceb58da4b.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-16df5ec500ff31c565c46e9d.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-17124d9ca73ac94c4ef94daa.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-1760690927795f2dbe84c1fa.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-1773c8a6ba16024334147f0f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-17c6d6309e9fb72fc3ba4ca1.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-17ccf86f63097ae7f3856e4d.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-195b436716c6658de4e6deb1.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-19defe0a3c24db977b0d0ea7.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-1b36c3ccbe32c540d7be0997.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-1b76b099aa1e791b1bc01df9.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-1c034b5f6480cf469028bd95.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-1c267986a60f497095560141.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-1c439a4a932dd7bef1ec86c8.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-1c801bed7e8224da7bbb7481.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-1cc9ce2d669a779abe059b38.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-1d1273bd12cf79f2ab71db9f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-1d2c0682864b42eb7ddb9386.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-1d471bb688b859ae2b221a10.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-1ddc45167b7aa47ff9523064.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-1e14c4754c9422e798c10641.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-1e45a1e8c09cbe6568253393.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-1e6ea9f887741a3cf06d2d89.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-1ede459ea611188b27fedbc1.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-1ef53ff29465495cbe96cea1.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-1efc32e33445660f58c1b7e2.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-1f16af71e69279a24285671a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-1f487bfc0e0c070014356897.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-1f79c1477beef72c4e2e63f5.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-1f7decf3a298a6f222f3e67f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-1f91417e97eaa190ba0dd717.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-1fe276a55396926047481516.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-205320454ba86af6cc730563.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-20a2f56a15af1aa5f22aba18.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-20c6f66f2c42b0ec53c8f493.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-20d2530f65b7dd59c6d0e53e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-20e6fd53b9646e93dd0d7233.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-217b99393747086d39f160be.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-218b4649552a38c17e839d26.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-220044057239a787f3141fd6.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-22133ea355a9c9e998f6a86d.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-223e0ec95abefdfda9c5ff59.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-232b3a49dfed3cd93ce413f9.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-235c8dbee18e3a0724281ae8.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-235f3dfebb8eaa3440f5e87f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-23db4dda4c96178f3ffe1cf6.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-241a59c9ceff3dffb7f68729.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-247c8678fe8ced03f24f5ab5.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-24828a7847e21f9aa4b6289e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-2492e9fccd9b4caee5a51d55.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-24c39313db8146aee26c2d61.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-24df835417c954a3b66a46ff.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-24ec7953cacf7e115dee5e9f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-24f21cf58c1bc6b0cc595266.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-25a6d511b7cc6faf1c261c01.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-26120497663aca6290336db5.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-2722851898ccb00a32aeeccb.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-27241fe73a62b4100a340ccd.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-2774f390b7ff951c2e7e5f86.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-278adcc1ba4b166836086391.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-278b8dbcb5a85e269051c6ac.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-27ea49964e4456eab9fcbc61.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-285f7d71b0e6bb7661c90f33.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-28823fb669b50a496c4abc36.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-288cbe5b48a615148acf16f6.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-28d56cbe609c405b16f9e080.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-2919ee3a8b05e579e5158636.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-298c0da4715b2af9cb3a8291.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-29f5e91cb21d639b56ee0252.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-2a4ab407a08b05de48930f74.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-2ac28a19e46875982454c844.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-2ae43f55a9080c8cf932c54c.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-2af127355d318c42ae398567.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-2b1a0b6125de9ae8c89ea294.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-2c8f1a9cf69f5bcc86c7f39a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-2d07a9e94f87c5a976d1786a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-2d634f118170fff0c86540e5.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-2df3b0e324fe62e11da4131b.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-2e6fa4e42708c2c2e10545a8.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-2ebff0e04a8c8f66593ba090.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-2f08bfe47f19e10c32e89434.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-2f5c4fb4c964f54452e6d8ef.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-2fe13e6d9b712854ff739bdc.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-30131d53d7d36082748cd07e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-30142e3e0030a438de99994a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-3035f6f9e85aa4855e726cec.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-30509250bca76362820ba808.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-30615ba65000580d684e5089.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-309120546dc96290cb346717.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-30e28a5a678a674a7e4d854f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-30eb991d6b5b2aeffedf6ac9.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-30fb28ccda7b222b686e3453.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-3163e5d02e34060e410aaa9d.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-31956c6dbd83348610ecb821.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-31a53db3104dc5f7b0f212a6.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-31a5da9a85efcfc0d90cf158.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-31e322661e8c799a04005af0.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-31e993014c58cc66339c15e3.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-320071652e80475c67d7eabf.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-33981fc88e836b636fe00d30.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-33fcdcce3e8aca7107e9549e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-344c56588c9f732a6dc40feb.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-346019ffa1d942f02d66d42b.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-351b5ef56807ee2bbaf1c312.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-351cfd1e701b5da1edce7bd4.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-35ee743a56a9f01c7c93f23f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-366bb12ce65a1023d8eb1c59.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-37001e028c705874aba1c51c.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-379145ce573aca9b58d2e86a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-37a2bafbe6b64a7635b170d5.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-37e890a88216af3fca0dfb10.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-385ab1b2c3651333f6507514.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-389da7f6c70655aadc8bc580.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-38a554e73b032297c6589e36.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-38cd767e1ddc91175ce57dc9.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-39387581e19937cfb9661af8.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-3974ba0bbcdf3a037c783eaf.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-39ddfaeb7db2b5c4f95a025c.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-3aeef057d8f295a9b82def4f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-3b24592ebc961a7bbd8d580e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-3baa21fbf635486c7e392171.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-3bab615b325f5a65689abe23.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-3be783a6518bc44693bb38f0.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-3c86c253ad56ca86ff6e6da6.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-3cfa79680a78ecb992eceb6f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-3ddc4822e787b772a411aa0f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-3e206b2321ced06b0f248fea.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-3e8a5424f8410fe0c52167af.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-3ea4218f781bc0a71855877f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-3ff529077aee1fb53ff61b36.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-4090b5ab47d5fec50c9012b1.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-415a234629c972cf820d03da.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-41d339841d1fba7de0374474.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-42d6359332ec698b8dc2deeb.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-42dc37176df8032560785114.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-4351eb83134b3e3c94cf3381.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-43d9fc7872e799371abc4a8c.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-44642ce6039583ed62439074.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-4478080515385cc0f5ad883d.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-45575027e2b885969d5d9f4c.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-45ab18d6c2c6947a09395b71.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-466d5b553b93bda8d382b411.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-46e41ddc51ed948e186d438c.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-4713d99bd1e75a25a0f43650.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-4738095550fcfd05974995eb.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-477a4c497209c608bea7d306.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-47eb3bc9e1313823af5747c1.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-4858a23d10e518b1576553b3.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-48a9944c84fec86dee3ec53f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-48f7827a83c20b8ce7bb91c6.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-49372d2c916137cc8dc048d5.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-4a188be5b8b505ad3748f559.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-4a23fdb935cd47cecb05b271.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-4bc1076ad57deb77bb15d027.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-4bdf32fc8dfb1bafe4342119.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-4bffc1efea9d23ffa769a10c.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-4c215643e6624f1a5d7460e3.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-4c990513178c308f9d9b42e5.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-4cda6453906279c087c654a1.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-4d77d300f79409631856da2e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-4d9fa9f85f9f2809c4436721.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-4da50f796620c41b6ef014bb.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-4da62d261bece7bffeb1bc8e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-4dae29d8e833094d3433fbb2.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-4e14619cc45578dd5b5f06e5.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-4e3626d2b6009520858e2b95.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-4e423ccb26243689b5a2b9c3.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-4ea82be0fdbc4e17b880d4cb.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-4f06b32ba6a9ff547b4c7d44.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-4f0ddd8a1b90b389628170be.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-4fb8097a896becebf373db2a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-4fb9aa3a397617faafdfb4fd.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-4fe2478b30f5b3bfe74227c5.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-501f3d1015cfc31ac78e9777.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-509227431efdcd8cb26ad566.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-50ba337b4738e9a91ca0e63a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-50f9bf85ca58a48e7a320fe2.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-50fae56f37c81bfc33fdc255.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-5147ee6e579f346259054554.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-520e20c669775472eca61b82.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-5217b7571e4a1c11c79b9e69.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-534a71aa8afb36d77cbb634b.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-538cc13ebcc7dc7dcad4c90a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-53acc72ad17c5296871a0a64.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-53c7813d0ebff3442134f857.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-540203116acadea4636ae4ae.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-547789b3e5865e002aafb1bc.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-54b7f169c4edd8ad0166319c.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-54c2bb7819cfdd97130864b1.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-54e3b08ecefd14b9230ade1b.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-5597d3a505712acc51fc3225.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-55d00782882e16a9d99d60d1.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-55ee67a6a59a87b867b3c14d.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-56d8c3bf24a31f396d1f5820.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-56ec3ec12a1ce107a269b39d.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-572089502f2a0905921ea7e6.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-578b73e6f679aeee14b516be.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-58462cbcdb98d6a33f4af53b.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-58b0f26c35c266ccf98aef0b.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-58c4f7654d0aa83284439d84.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-58e581fb27092511f4d8fa55.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-59235b8f3ea06cadff11f1dd.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-59a797e0a22e234b9be87117.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-59eefc0ce0f1daf80429b997.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-5a0546a08d3e5ec58d1d2901.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-5a12f5c9933f18aeae358e60.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-5a45b5fd813335ccbae5b6e9.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-5a8d4a5e1c647d802107416f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-5add05521cf1b57e9add2607.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-5af756e5ba1334f391d782d5.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-5b17efc53d4c126e4353f8d6.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-5b7b8e777f1b678d419d93a6.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-5bdd16bec79edbfa646464de.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-5bf2fc4bdb0f31d047303e97.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-5c2269f2e27314e5a547ed8a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-5d1f66131f1ebb3f0d1d62e9.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-5d2c8e2627e69892b1f860ba.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-5d5822997d79a2efacda2d84.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-5db8c6dc66363709f0e3617e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-5dc13d524d03d658ff561ced.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-5df661619fe94f03bae6b837.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-5e99c08dce9d529fac7c06e4.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-5ea3336e6ed733efe63f4208.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-5ed3275c040238f5b13ac5c9.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-5ed439ed45003654ab249d1e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-5f05f4dcd4b5a8bb063532e5.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-5fcd740ab03840fdbddb5a01.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-5fe4e48c936600972909f64d.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-607f928dae4c95c40bdecddd.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-60bb8c4445e3b1a45904b90b.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-60ca535fe5af62aa34b390a1.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-61748b3318ae2aedd273f813.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-61967bc98529401dc4a12eb9.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-61f3786a383a77c000041a34.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-61f5e19728e4b64179149796.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-623d12b83983c9e4570ffc9a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-627da881506200a9f4cef47f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-63558305bc813ceeed6604f9.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-637a4cd6a1e5b8bee19db96f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-63ff2d76737d402910980c4a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-6459dfeb94a62fee50974dd0.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-6464062f20898836306c6e7b.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-64b91cdaab9c786f064ef0f8.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-64c02fd18266c653ac32d406.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-64cc6833502a209a39d5d5a1.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-65602d3759f34788e6b9502a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-6608244cf4fb21a8e1a62d86.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-662cb11545662d8ce9970788.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-6643a369eea42ea9151b086e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-6646a8a9cf7837298563a2d6.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-665a472cc7cf729865f95b83.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-665be50af9ee1560c8a7cd0a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-6664121a232d04ec487662be.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-66b52d3873eda2678ebba78e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-671665c3fa638f21c1744283.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-676785c2f6cb0b189fad86d6.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-6772ad13b08c00f528f2f367.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-67a0165f0d8750f7ca3aa4a2.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-67b12349b16e2dc63bcfaa2a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-67db5edc50f0c538cd36adfa.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-683db049015f3bc181797251.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-684c1fe35a9c988de5a2d550.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-68a7bb5d24ba6411d430cb00.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-68e969d1c7afd437788de21f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-692f0a4b10dd47cd63dbc264.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-6948be0eb23e8ecf418ec7c9.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-694d3bf29bcdf5c99bacdd44.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-698a0c626dd1fe33587f24a5.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-69a08f92e099e0497729b14f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-69ce84adc8968a6db40c6cd9.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-69d11d9843dc21fc9da2bead.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-69d9a7b05c3b4bb84aa019ca.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-6a1b8f2fdc116bc5fcddf8dd.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-6a5f144a4d4b6232f47858ac.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-6b10b279b31a43fd973b0f84.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-6c3008642f97e7b5c3c0183d.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-6da42ccc65f7cc68313cd6e3.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-6e564744cfd80ee58f9425f7.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-6e64da16fb044982ca87390b.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-6e92f577163e56016f3aede8.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-6ea2b003e15551be634b0411.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-6ed30212e57753c836087fa1.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-6f20b875b13fe4c399dcc202.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-6f42757ce65cdaae84768aaf.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-6f84adfd5987910ab51ff264.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-6fd3efeda8627c9565a56cae.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-7040654239ca3c9096cad2b8.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-7055d51ebbe03efdd699dd00.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-7068a3e8308cbbf83b3f0617.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-70dc3fc306ae4b4ba2ddd77d.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-718b5b3dcde972bce8c09e31.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-71c0461674bc05c8f50ce817.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-71fa03e270a4070d0e8e2c91.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-720f30e3dafaf731f14837f0.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-721a0689eaba7f07e302e3c3.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-72e62e991f51fe6734ce22a4.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-72edf0485acf84530995a7a6.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-7338283f8d3e5c40c7cdef97.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-738b398b8fc793785c662df5.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-73ef58d2058b0f60817b14ce.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-7450bbe0625808dc67335f9e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-745a977686a3ab1cb7149044.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-745c02d313cb2ab6f52e9de6.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-74fd1462ed5e93d6b5d5e854.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-7535371ab934d2a4e089f7cc.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-7582da67e6f22ae6afe6ec16.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-7595356dc49509583015a602.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-75c8703853d80112036ad7f9.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-76998f3c577fdb50b5c473ae.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-76f5da1753d0a7b987692f43.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-7741477518758f7e7fa2b5ec.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-7787bcad13505c69a74a3394.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-77c97096198b6cb88edb52f3.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-77ca415ff14836df263a680e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-77fc1b092d613ac385184490.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-785f4c6b79b779ee1df9394c.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-788a8c2725ab1e5a416d7b57.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-78dcb2c82acab9250bfa08fe.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-790f82709437e5a4095ef4ba.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-7964da6d7dbcfd546e6edeb0.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-7a4b75ab04a05fa8125d4cc2.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-7a8d21fe082378e6b2908fb0.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-7aa5c02fbfb7177d96d07e06.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-7abc348a9966daae7ce7265f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-7adc22b710cb3466174e1127.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-7afe6750dbc8e3489bbf3af9.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-7b3803d28ab5d03b9f2a3c4e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-7b395a4a4a922f23f313fb3d.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-7b583cd35e9254e8182870f5.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-7bb3624da32b57be0d0f4f76.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-7bdcf0444ac31441ad03d1ca.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-7c18d125ebe58db42b53a924.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-7cd5dd892a62eb960d7130fe.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-7cdbf2c6f6747776f3c60b02.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-7cf5ffc87559403bf993554d.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-7d425ce907b2f72acc2bb33c.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-7d497034b50d44f0828382d0.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-7d507629bb2be0fe1dfee7e3.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-7d940dd28b5150d61eb1fb08.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-7edb6c77289fffbb0867237e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-7fb2d3897d81cca9b7ed972e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-7fd13f1c44a35b7336c3c88c.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-800e7d4c902a92467d25177a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-8068fc0adfa26cf246c6c3a0.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-8069b303b0ecf1349a13b770.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-81410340f011b7f55ffee127.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-81a2bf897a043e4b77bee79f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-81b9876c2126650a39014bf7.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-82737c91264c3cb99dce1fdd.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-8314328eb3cf3c02cd63ec5b.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-83998631d357b7836072b7f6.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-8496e106ad00582f2fa3996e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-84ed0fc3235cc7a741c0e967.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-851e40253d07a5d0291ce7a7.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-85baf956c5d390573ae61112.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-85c6b09ff640e647ccc51e10.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-861b62af9830666f51ce5e5a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-86943ab6b11a69621a481b4a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-8710f5ad79c9d823d8dfe115.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-87762e57c60f5d77902fc4e4.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-87bda3e04ae77146537c81f3.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-87cd5a39b39065537471b336.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-87dc05c8b716496f687b36a1.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-87f3837de96bd2c0601f67f9.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-8807e594d94190d35200b4c6.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-8812a02af088bd436530b2fa.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-8828e14c60c73220a00fbc91.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-88a35581ee87c79dff0f288b.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-88a6199eb02124150c48f233.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-88ccd3134baceb5f532ce330.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-88d245d57cf06791df56187c.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-899084089c8696031ebbf948.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-8995d601b6af0c1d6c4d9b8d.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-89d530aaa0fcc304437d1e23.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-8a9c34bf53f2ca96413bded7.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-8b233a2d1971150e73e880c1.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-8b4bacc6c799b1df4d0c58ab.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-8b58a203eb777f3c3cea6e81.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-8b7966ba510abb5096ab1ad2.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-8c09bfcdebffc7c58a165c28.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-8c55384c41579835ff76695f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-8c7a40b1e17e626f4fb31e0a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-8cb07b913c4666e301fa126e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-8cd933e55312e205336ffc27.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-8d8105aae58004820bbff3d7.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-8d8e63f194a77e968e7fedab.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-8e3a29d5b950a613eaea7eab.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-8e6fabf26f08956023d7c977.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-8e75cbf4c0cc92203fa358fc.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-8ec7d5167db70b4c1cb00f3e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-8ee43d9a798c9c57ee3de26c.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-8ef5ff56738e5a88dfca76c6.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-8f8bb7e399bb57441529b1e4.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-8f93c32a7794d2d3f6ff4b26.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-8fb0b69b2ab7835bdf57a6fc.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-905ef517ffcae672539eb3c5.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-90aa66edef4093d9ba061f2e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-91256a686ce09c7111eaa044.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-912ce579bcdae68f5c0d246f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-91376c93a0ae0f32993cab65.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-913f0ef1c98f7b42c5be985a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-91eff851de517c47b337547d.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-92541dedbb2c746f2aeb128a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-925f851f70afe7e002b28cb9.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-92723088e32c1fd61a8ab3b2.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-92808ee3a83a1286efa2acc7.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-92a0b437ab3c3260a834afda.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-934f4d8a99c7ea91f733b783.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-93a1853ec2ffc733cbe8a0ed.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-93defdb077780b2555e4468c.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-93f5677b1911bf17f2a09e7d.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-93fbc9b67ba3669fdaf8518f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-941203aabbee7d19514a1dbe.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-945b4080151536fc5d0f1e07.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-950901ad03adc2b8f39c428d.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-9582fb1af10b67f8325e06f7.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-967503d5044de409f7ebe058.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-96a26b93386e56d442f1f47f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-9714e5017324452c6c99c480.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-97765be58d1b18f617f8ba45.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-978088459e6990d16acfc76b.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-97d45a6794e75e19564604f0.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-982b9e0a9948857ba303b855.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-98502ad16a6b6f7399c59d9b.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-98861c7989de174fdd6b6f3b.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-99798a5df3026d5e27ffb6a1.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-999d3c8a833fe5112221f210.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-99b49f22294e2dfb14586956.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-99bbb9db8aa767117dd3433c.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-99fd1782b946a13e7c117e0a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-9afa134acc85d06c782ea7b4.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-9b5e0161cf22116000e943a2.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-9bccfe7c1b53c7a312fd26a4.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-9c4cec0271f63012f3670c7e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-9c600114746c2ea6006dd729.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-9ccedf4e3a4bb0c591fd725d.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-9d30d3cabc03caffc912269e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-9d51f61bebbd121d91e84a09.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-9d8df1f74f55b3ad10d8436e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-9dafb93353559ce044c8d1f4.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-9e6e14b3e5eb738d087cf404.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-9eca6dd473fc157ce3b67c49.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-9ee52ccda799015f1489de98.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-9f0625221a06de392340adf4.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-9f44404bb7040383d916622e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-9f4a6ef978f83e472aaec4c3.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-9fced432ea4d3346bc63f601.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-a07a0bd7afdf72f4b4197d05.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-a10266111f032b590536a06d.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-a130f6ae7fee64731b3708ef.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-a16df9131c5898c680d656a1.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-a19526ef2aa93b69474b68b7.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-a1d3f068fd5d5a44b1819bb7.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-a237d6dd405d4976b5fc0ebe.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-a26d895bc7a21be356c4265b.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-a28d2a06cccfe1acbbda06a9.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-a2f2e47ced677942a0609635.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-a325da8bc0a06ea493fd21a7.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-a3620416c8bed2b5ee09404d.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-a48f6fb1f5faa04f3c10c7e0.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-a4e8eed78d37de4bd129f8c1.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-a5886129754398290ee1ed8f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-a5cba49ca6249e8fdadc4e49.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-a5dd3c59a7b9090abc96a9d3.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-a70eadc2a8959bb2dd0dcc13.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-a713dd9fc24f4558afb047b7.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-a73f6f6ddecf2b626b0a6cb4.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-a75f14de4fcd5eb053812b94.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-a7acd616cfe6531aa1dd5ba7.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-a81930b91ca30a45a3bf12e3.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-a86b64e5b6d53ee0867020b3.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-a8ebed735239077f6f50119c.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-a911c85e266bf269610b285d.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-a97c378ee8123feb7e7b29c8.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-a9d3b48d88f980d625b2616a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-aa7235f10fc861f3ba049bb7.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ab05d829fe3ef8ff5c3e43dc.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ab16f7293f4d2383a1a3f398.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ab2081c74cde1aac493e79e4.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ab441ad195b88dc14ec7df21.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ab5cd5ddf37ceb1dd0076c5e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ab6ab30fc2a0c8738ef78752.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ab8e45615068b0211cc4983e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ab8eeea081535cd918057111.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-aba801605055f170ab849143.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-abc3579ddfcd9f54157389b5.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-abf14a1b84c033d9f44b0ebe.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ac01390f645af9bb1e456f8a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ac529a4ff28fe1dcd00b18ab.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ac671dc0f25b23619e1f8762.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ac943c15d715c74b34baccd9.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-acb3e24a476b574ff8355b2c.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-acde9a29baa16a6d357fe739.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ace6cba3c5048b3cb8ea66c0.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-adb3f02ac4f8a53ebb54122f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-adb93601a64a5f589e6f476a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-add2e0cf67d919d9ae16ecec.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-adee2311f65e1906b7ee6fb2.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ae0305105f7674f505b1969e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ae612361a0950169163ff1f0.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ae87872a4a85ff47f864d9c5.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-aeb1f9e77237d60c3482f1cb.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-af03efd2f4d1b3fabd6848e7.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-af2ae6985699470d3806b944.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-af886454416ca5b35a441788.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-afa897e497db6febc8b317ab.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-afbefac2feb745067a0ff79d.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-b05822ad29b43b2062577f83.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-b09d631f6d7284594a326428.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-b1dbf26fd8e613cbc9b79c0c.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-b1e47fb12abcd99fe25490d4.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-b2919657e1fc8b547e990e23.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-b3a9185ea61bd9fb285369ff.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-b3bf21b73d377ea1e4164f1a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-b424788684f0bbc078c8f4e4.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-b44c4ca414b312a3f29885ff.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-b4554d0506d4fe07e87a9411.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-b4ddcea3e134c3800b7294a9.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-b545ff07ddfcea6c6ad34340.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-b54af94ca7a12144a909a89f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-b66631c8d1663b6476baf25e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-b690991fef194d8e78b0b04a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-b69b896d99d81fdf24120048.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-b6b623bce58c7763adb25f90.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-b70164640df05392734f7702.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-b76b7251a0071b533c563eb3.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-b776e402d1da96c2b1c416e0.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-b7c0d5d9c20b6f2468985a6c.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-b7cfc4cd1125414ab0be8f7e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-b923f1e6dcc0343dc3ea698b.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-bab5335c0546e854c6a770f6.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-bb9343ac20721c887b99786d.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-bcda562586a9163f8a193ca0.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-bcdd456d3198d0079e23cfbf.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-bebc6e5ee59ab3d4511ac6df.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-bf4ee11ed38bc1eb9876b365.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-bfc597dd308a719aa7071b9f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-c032413a17c5c65b0b3df3fa.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-c03dc2f0863e638adac0d40b.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-c08d72a7db401f338b6c971a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-c0d407b4033fa84a10df06bf.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-c0ec9273b113c43518bff18f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-c0fbfa68637940887b57ba2b.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-c1207ff18279bae19c5642ca.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-c1244feee490658ac8616d02.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-c15e1d33bc10c3eba3a7cbc4.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-c1e63139d86f9b060d87978a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-c2004472dbf4c32713776f35.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-c2272fecf092710487f94c05.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-c23d05f55cb228ad351c88b8.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-c362384973ca3f5184c8b6de.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-c3e8d0380bcba11f0c38478a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-c40bed3b3173258bae1e3efd.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-c4280d4cfc3308ca4761fdd1.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-c489d0adef3d180ab5e6aa7f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-c4a83dec3b1f20b4139d63c6.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-c4c21888dcc42ae416e10a5a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-c50d7ca38fa4d8f3ac529cef.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-c55e52178f58192248475245.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-c5b894847d929e1e070ae9f4.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-c5ba3dc2356881d2c835b13f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-c5c02c5360b64dfa28243c53.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-c5ca3b9f33915a2b90ea7444.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-c5ec1ac20e9d17538b99d967.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-c64a220a849f20bab14cecc4.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-c7344ebd6f986cb8044364f0.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-c76cd2fabba1b682e4322e14.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-c812e3c94fc0b2bbe480d4fe.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-c85ffa1a2c13f154bb54d0e6.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-c8c94a027448e501779becdb.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ca2435f1cb2765e6508baaaf.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ca4abf20b4c887f83826062e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ca6353b0c131fba2aa7395fa.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-cad5346e053eb04a96a1c6c7.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-cad601b39aba4677c74441f4.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-cadcb19767d8ef9314e102d4.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-cb04a3639f3fad485fb4c70e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-cc97e5804dd47c7d515efd43.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-cd71837428c0a6e370c7d6b4.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ce15a8a70a81f9c84284044e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ce2a28256addbe6bb9c78b0d.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ce6332cdecc47cc7b874af6f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ce66ca16906862b940c81c65.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ce7b9720a7a6af608770fd3f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ced6d9fbfa42b1564d3dd590.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-cf10bc1d92edbffa06b25ecb.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-cf90691350799a35053168ae.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-cfdda43d6abfbbbc24b8c83a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-cff347e088714683a963f468.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-d00921e2832ed42b1a186b55.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-d028461ce82bce66ad6dbd34.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-d06c060410c305f5ea6dd665.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-d0743f1b41df61df0553f8be.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-d0a28f60d6b2b04b61e1aee7.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-d1206342777f77883dc204d2.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-d1420fcb25cb13a9b998371f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-d20fb210485d63fcc8e1c328.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-d2225f3138e54922d0bd19b2.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-d2321a0b8dbfb617709c7aab.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-d27a49f3efeb8780ddb6da33.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-d27b215ada366fec899c0e26.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-d2dd88d5a8ddbf6a308510e2.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-d2eda8ec2fc7ce50e10087ab.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-d30e8137f600c72d7a174a67.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-d36e30c6bc3a2c491a041f93.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-d44386f6cc30095c73d5258a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-d4757ff0bf4f7fd3af089f00.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-d4aaab44b3e358c465d90406.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-d53f3011a1117c2c3ab27d56.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-d55e216175813f0b8d27b9f6.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-d5ba533a93c29a83f5a47edf.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-d5edfb3f8458dbfbd6eb4219.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-d6200cf382d7016c79bddc13.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-d62a12f267f12db7329a4fd4.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-d663595dcb0fe4cbb44c8c91.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-d665c044bdfd56c0eb1a8bc3.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-d6748413333c50c47368fbe6.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-d6fabdd7878795f9db37b41d.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-d713ba761247a0081a29667c.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-d766ea1e5c3c26413b8d8712.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-d803686e75a11a2f8765486d.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-d82dc2f0ecbbdcdf43c2da24.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-d843192b0369884bdb0024d7.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-d879aa7458ea864efb51f9c0.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-d988a4d0f5ddd5ae8455f28a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-da08ff29aa7d43b83cd238da.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-daaecab0f47993e654dbfe5d.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-db3c9a118a91c622938320db.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-dbc9c122257e27cfad999ffe.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-dbdf3bd8bc4c46fa3da67fbc.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-dc9d3de7e4fdaec411d3882a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-dcb264cd9d9f11e297455896.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-dcb94f061f6099e368a11d2a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-dd1eabfce3280c0434576489.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-dd534fba9549350ff6d63a25.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-dd5a88cee2df2a44e62c9498.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-dd79a18ac6ba9cb1dc204489.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-dd900dd601408fe0219a40b0.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ddb5999cffb50f8b9e274de8.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-dde795ed090323a9cfee046a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-de80040841d609b61e952d15.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-dee8d2d9f851baf9fada0e43.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-deef8f2658eb7b5ab5266c2f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-df1cc4240d6c807ee15c3d72.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-df21a3505b83f54980142432.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-df628250f1f9262da02cb15f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-dfa163eb6d3ed84cd94da633.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-dfd39d1485eb0e46277409e9.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-e0387824c144a8fc335e9409.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-e06209b0ea662af0d7d1bd74.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-e1bdf401dd33916fb1f62531.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-e1e7afcde660a86898d1a8cd.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-e2856b0c8621dafb91b6bf8c.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-e2afee58e8cc0f660b8bde7e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-e2da9b38b4fa2ee492ff588b.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-e2ed3bf103a3d89697cb5ec6.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-e311fac78730ff1f91dc5984.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-e3933ecfeedf74ac3b9618fa.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-e3ecfda453a3d042a8d8f8e2.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-e3fff1cf9dbd5ea9b88ba26e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-e4aa4deb8df53a66bb5fca81.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-e4b64264916939c09e718988.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-e4c03fed07c8c2eb98277fef.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-e5675f4c7208ba20d06989e3.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-e5683c0ffe99c8027e37b075.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-e57809f49c6ab3c315fc90b3.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-e5ace1ae05f1d64457097e06.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-e5f348e8c474808f2ad9213d.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-e6744a7059be663f154fc747.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-e6a80ae9f4257ac2049a665b.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-e6daab57328667318ef1caf2.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-e73c16ca1d8146c59b5741dd.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-e785b0c2183aa767b4e6f278.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-e788d2632c2228ef13742389.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-e7902cfeb5008f860231fc2e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-e83c633cb97e22fa99a7be83.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-e909d87324a51a6e285e4a9f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-e90d3995c503bae7a9cdbc57.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-e90d8ba78746b58d74448546.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-e92457c01ba06b6b60fc92b9.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ea3cdc5f92f9c0e37edaf0a0.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ea73979b3c730c69db4d326e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-eaa79b2723d580d33593e49f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-eb3b7468b14ee33b5aa918f4.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-eb6d6c1efbccf38890f84aee.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-eba72505f448f18df2fa20b3.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ebd6b3514d10a77bda984601.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ebd946d841a600db9e27da78.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ebe2903124f79d0af9bcf89d.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ec224704986402dfd134cbd2.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ec3c6eeec40ce9dc539c6dce.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ecd219d30ca6f0f1555cfee8.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ecfe2a53f7e5ecabae89e005.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ed49b1a4f41f66f1156fef84.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ed690cc1c0c5da4fafdbf8d7.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-eda2798f88e7b9c60526a073.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-edb0b2a00717800ed47d02a7.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-edc9aae86665ed63cf7168da.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-edcea700b2906887f32766ac.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ee3aa9dae35f0948bc7a8adb.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-eea425ce5d2f38fb95ad8e25.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ef03fa0e6890d588d54e2583.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ef31606acc412e177609e699.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-efa20e07104b7c06af6e2436.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-efada1b89ad642f5625cceba.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-f042dc1872feeb67d633a681.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-f0790914c6757cb70478e29f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-f085b32c5f0d3bcce1304ac2.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-f0be4c2824713c4f3f844eb8.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-f11e8aff82787f319ba2aad9.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-f1ddac0c42c26840200b85d0.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-f1f35472272b32d52dca18f8.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-f271a90993d7a18af4601d0e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-f29106c36017e65651041378.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-f291e1db29b17605f9a8ba2f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-f2a5d96f15f6d16aa3631cf5.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-f2bc539a9f54cd1fb8e7aaae.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-f34bf9cf57fe2975f760f01d.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-f356cfb9f91893eeaaa8e080.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-f3d087811f30b509c3571a37.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-f418eb748c0d00949f5029a4.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-f491218317e9b533aceffd8c.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-f4bfbe8df90a4f6e3db5003e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-f523f3829c1b32b82fbf8603.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-f55d68f5c2f747d06705a7cb.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-f5d9b7665521c807ef1f6a4e.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-f5f24cd3d48b36d65abc4b6a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-f62120f01268e80a27fba3e4.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-f652dee05fb5aee1ce5b11df.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-f6f662e5b139c2231d1ba5ab.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-f778e48e6380f2958fb299f2.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-f82b419a7b4047c0c2277857.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-f8363043e79f65dd8fa2314c.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-f87b70fdedecbd35ea992352.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-f8923f9cbcfd97f73af6db38.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-f8b0a689106d9aed843c3421.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-f8ca34d9275520dc7acfffbb.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-f90d8c178032e6b14649fd2d.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-f929a982a50a27962204bf09.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-f955a9e0e10040c58704ac46.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-f9ab2a1aaa17864121592197.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-f9ac6b9e49da19835866ec30.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-fa0c944db1352a6a7cbbc4a6.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-fa8aff8503e1fef43070151a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-fa9eac36d2d01b608496015f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-fab6c556416e04473f1935ad.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-faf36b35048ed1db075d29c4.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-fb7962cc84ed97e8c04899b2.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-fbb9c84855b140f7b5f95f9c.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-fbeca3b741b020a2fcae8fc8.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-fc1b793cad8a9169da0acd0b.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-fc2de3ea2f32cd47436e814a.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-fc3e4a61c59ef4353c726119.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-fc41d30d023cc268ab52617b.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-fcb36197d933aab8f6bb199b.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-fcb8a0c1e66849f82998c37f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-fce4ad9ff24fa862481a19c7.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-fcfa353bfb9e3e196b9edf48.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-fd266bae31a19125ca5a4b5f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-fdcd37001cc3a1256072408f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-fe318df8d46eac22cef4cd89.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-fe6ba69778a5324a72249d3b.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-fe94f8b6cc3f25cda9a48309.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-fea249af95c54a46b463925d.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ff493545ac7bb5ee028b925f.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-ffc07dfe3b0cff23ea9b5af5.json create mode 100644 examples/multi-agent-smax/results/llm-cache/ask-fff4080e392f1964b30b752f.json diff --git a/examples/multi-agent-smax/results/llm-cache/ask-000a56b17f8db2ca0321be4a.json b/examples/multi-agent-smax/results/llm-cache/ask-000a56b17f8db2ca0321be4a.json new file mode 100644 index 00000000..61b1bdaa --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-000a56b17f8db2ca0321be4a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.0 seconds into the battle.\nYou are A2, a marine at (8.1, 14.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.1, 15.8), 45/45 health, order: move 8.5 15\n A1 marine at (8.3, 14.1), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (14.4, 15.0), 45/45 health, 6.3 away\n E1 marine at (15.0, 16.2), 45/45 health, 7.0 away\n E2 marine at (14.5, 14.3), 45/45 health, 6.4 away\nTeam chat (most recent last):\n A1 (1.5s): Advancing east slowly to find enemies; stay grouped, focus closest.\n A2 (1.5s): In position at (8,15); holding, focus fire closest enemy when seen.\n A0 (2.0s): Moving east to group with A1; focus closest enemy when seen.\n A1 (2.0s): Falling back to group; hold and focus fire when enemies enter range.\n A2 (2.0s): A2 holding at (8,15); A1 is advancing east, stay close, focus closest.\n A0 (2.5s): Enemies 3 at east x16. Pull back to group at (8.5,15), then focus E0 together.\n A1 (2.5s): Enemies east at 16,15. Hold grouped; focus fire on the closest, starting with E2 or E0.\n A2 (2.5s): Enemies ~8 east. Hold at range 5, focus closest when they approach.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding at (8,15). Focus E2 or E0 when in range 5.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-010f9b0f4dbe71d60bc9a772.json b/examples/multi-agent-smax/results/llm-cache/ask-010f9b0f4dbe71d60bc9a772.json new file mode 100644 index 00000000..8254bb20 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-010f9b0f4dbe71d60bc9a772.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 3.0 seconds into the battle.\nYou are A0, a marine at (13.8, 15.8) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1 marine at (13.5, 17.2), 45/45 health, order: attack E2\n A2 marine at (13.9, 17.8), 18/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (18.0, 17.1), 45/45 health, 4.4 away (in range)\n E1 marine at (17.3, 17.0), 45/45 health, 3.6 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (1.5s): Almost in range of E2; keep pace, all attack E2 together next tick.\n A2 (1.5s): Still closing together; E2 just outside range. Fire on E2 once all in range 5.\n A0 (2.0s): All in range of E2 now. Everyone fire on E2.\n A1 (2.0s): All in range of E2 (2.4 away). Attack E2 now, everyone focus fire.\n A2 (2.0s): E2 in range of me; all attack E2 now.\n A0 (2.5s): Firing on E2, it's at 18hp. Then focus E1 next.\n A1 (2.5s): Focusing E2, it's at 18hp. Keep firing, then switch to E1 together.\n A2 (2.5s): E2 at 18hp, keep firing on E2, then switch to E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E2 is dead. Everyone focus E1 now (3.6 away), then E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-012dc8ba7ed6e34a85f75170.json b/examples/multi-agent-smax/results/llm-cache/ask-012dc8ba7ed6e34a85f75170.json new file mode 100644 index 00000000..47238549 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-012dc8ba7ed6e34a85f75170.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 5.0 seconds into the battle.\nYou are A2, a marine at (14.6, 17.4) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (15.0, 18.1), 18/45 health, order: attack E1\n A1: dead\nEnemies you can see:\n E2 marine at (17.5, 14.8), 45/45 health, 3.9 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (3.0s): E0 dead. A2 attack E1 now, it's in my range. A1 stay back.\n A2 (3.0s): E0 dead. A0, A2 focus E1 together now; A1 stay back.\n A0 (3.5s): Focusing E1 together, A2 keep firing. A1 stay back.\n A2 (3.5s): Attacking E1 with A0. A1 stay back.\n A0 (4.0s): Keep focusing E1 (27hp), both firing together.\n A2 (4.0s): Focusing E1 (27hp), both in range. Keep firing, then E2.\n A0 (4.5s): E1 at 9hp, finish it now, then both focus E2.\n A2 (4.5s): E1 at 9hp, finishing it now. Then both on E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E1 down. Focus E2 together; I'm closest so I tank, A0 keep firing.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-01dbc532b9eabb1fca8a273c.json b/examples/multi-agent-smax/results/llm-cache/ask-01dbc532b9eabb1fca8a273c.json new file mode 100644 index 00000000..4b4533b4 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-01dbc532b9eabb1fca8a273c.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.0 seconds into the battle.\nYou are A2, a marine at (10.8, 14.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (10.6, 16.0), 45/45 health, order: attack E0\n A1 marine at (8.9, 14.1), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (12.4, 16.4), 45/45 health, 2.3 away (in range)\n E1 marine at (13.1, 16.8), 45/45 health, 3.0 away (in range)\n E2 marine at (13.1, 15.5), 45/45 health, 2.3 away (in range)\nTeam chat (most recent last):\n A1 (2.5s): Enemies E0, E2 east ~9 away. Holding grouped; focus E0 when in range.\n A2 (2.5s): Advancing east to join A0/A1; stay grouped, focus closest enemy.\n A0 (3.0s): Holding at range; focus E0 when it enters 5. Stay grouped.\n A1 (3.0s): Holding at range 5; focus E0 when in range. Stay grouped, don't advance alone.\n A2 (3.0s): Holding at range; focus fire E0 (closest) when in range.\n A0 (3.5s): E0 at range 5, firing. Everyone focus E0 now.\n A1 (3.5s): Holding at range 5. Let them approach, then everyone focus E0.\n A2 (3.5s): Focus E0 now, all fire on E0. Stay grouped.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Firing on E0 all together; A1 attack E0 too, not hold.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-020707e41424558bbec7a67f.json b/examples/multi-agent-smax/results/llm-cache/ask-020707e41424558bbec7a67f.json new file mode 100644 index 00000000..bc1c6697 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-020707e41424558bbec7a67f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.0 seconds into the battle.\nYou are A1, a marine at (8.5, 15.3) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0: dead\n A2 marine at (9.4, 16.4), 36/45 health, order: attack E2\nEnemies you can see:\n E2 marine at (12.8, 17.3), 36/45 health, 4.8 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (4.5s): E0 dead. A0 on E2, all focus E2 please.\n A1 (4.5s): E0 dead. Focus E1 (4.5 away), then E2.\n A2 (4.5s): E0 dead. A2 focusing E1, everyone focus E1 then E2.\n A0 (5.0s): A0 switching to E1 (27hp), focus fire. A2 is tanking.\n A1 (5.0s): A1 on E1 (27hp), focus fire. A0 hurt, fall back if needed.\n A2 (5.0s): A2 on E1 (27hp), in range. A0 retreat if low, A1 focus E1.\n A1 (5.5s): E1 down. All focus E2, 4.8 away, in range.\n A2 (5.5s): A2 on E2 (45hp, in range). A1 focus E2, last enemy.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"A1 on E2 (36hp), in range. Keep focus fire, last enemy.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-024ee04bd72f916d5159ca78.json b/examples/multi-agent-smax/results/llm-cache/ask-024ee04bd72f916d5159ca78.json new file mode 100644 index 00000000..a1ea2530 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-024ee04bd72f916d5159ca78.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.0 seconds into the battle.\nYou are A0, a marine at (10.6, 16.0) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1 marine at (8.9, 14.1), 45/45 health, order: attack E2\n A2 marine at (10.8, 14.8), 18/45 health, order: attack E2\nEnemies you can see:\n E1 marine at (13.1, 16.8), 45/45 health, 2.6 away (in range)\n E2 marine at (13.1, 15.5), 9/45 health, 2.5 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (4.5s): Firing on E0, 18 hp left. Next target E2 (closest).\n A2 (4.5s): E0 at 18 hp, keep firing. Then focus E2.\n A0 (5.0s): E0 dead. Focus E2 (closest), then E1. Stay grouped.\n A1 (5.0s): E0 is dead. Focus fire E2, closest at 4.4.\n A2 (5.0s): E0 down. Focus E2 (closest), then E1.\n A0 (5.5s): E2 at 18hp, all fire E2 now, then E1. I'm at 9hp.\n A1 (5.5s): Focus E2 (18 hp), then E1. Keep firing.\n A2 (5.5s): Focus E2 (18hp), then E1. Keep firing.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 at 9hp, all fire now. I'm at 9hp, finish E2 then E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-02788019e7c2e436cfe6932e.json b/examples/multi-agent-smax/results/llm-cache/ask-02788019e7c2e436cfe6932e.json new file mode 100644 index 00000000..42d50652 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-02788019e7c2e436cfe6932e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 3.5 seconds into the battle.\nYou are A0, a marine at (14.8, 16.4) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1: dead\n A2 marine at (13.9, 16.5), 45/45 health, order: attack E2\nEnemies you can see:\n E1 marine at (17.0, 15.6), 45/45 health, 2.3 away (in range)\n E2 marine at (16.6, 17.7), 45/45 health, 2.2 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (2.0s): E0 is within range 5 of all three of us. Everyone attack E0 now.\n A1 (2.0s): E0 is in range of all three of us. Everyone attack E0 now.\n A2 (2.0s): E0 is in range of all three; attacking E0 now, focus fire.\n A0 (2.5s): Keep focusing E0; A1 stay in fight until E0 dies, then retreat.\n A1 (2.5s): E0 at 18hp, keep focus fire; I'm at 18hp and will step back once it dies.\n A2 (2.5s): Focus E0, it's at 18hp. A1 is low; keep firing until E0 dies.\n A0 (3.0s): E0 dead. A2 stay close, all focus E2 together. A1 retreat.\n A2 (3.0s): E0 dead. A0 and I both attack E2 now, stay together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Both on E2, keep firing until it dies.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-0287437c7071b803790b2a03.json b/examples/multi-agent-smax/results/llm-cache/ask-0287437c7071b803790b2a03.json new file mode 100644 index 00000000..a6e48573 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-0287437c7071b803790b2a03.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.0 seconds into the battle.\nYou are A1, a marine at (10.1, 17.3) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (10.3, 16.5), 18/45 health, order: attack E0\n A2 marine at (9.9, 15.8), 45/45 health, order: attack E0\nEnemies you can see:\n E1 marine at (13.8, 17.3), 45/45 health, 3.7 away (in range)\n E2 marine at (14.4, 14.8), 45/45 health, 5.0 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (2.5s): Holding; enemies at 6+ range. Focus E0 when it enters range 5.\n A2 (2.5s): A2 holding; let them come into range, focus E0 together.\n A0 (3.0s): E0 in range, all focus fire E0 now.\n A1 (3.0s): E0 in range, attacking E0 now. Everyone focus E0.\n A2 (3.0s): Attacking E0 now, E0 in range. Everyone focus fire E0.\n A0 (3.5s): Keep focusing E0 (18hp), then E1.\n A1 (3.5s): Keep focusing E0, it's at 18 health. Then E1.\n A2 (3.5s): E0 at 18hp, keep focusing E0, then E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E0 dead. Focus E1 (closest, 3.7 away), then E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-0347f81080c210a23588e43c.json b/examples/multi-agent-smax/results/llm-cache/ask-0347f81080c210a23588e43c.json new file mode 100644 index 00000000..e934e421 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-0347f81080c210a23588e43c.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 0.0 seconds into the battle.\nYou are A0, a marine at (8.2, 16.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (9.8, 15.7), 45/45 health, order: hold\n A2 marine at (9.0, 16.2), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 11 16\", \"say\": \"Advancing east together to find enemies; keep within 2 of each other, then all attack same target.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-0393602049acad80a749b899.json b/examples/multi-agent-smax/results/llm-cache/ask-0393602049acad80a749b899.json new file mode 100644 index 00000000..f376380c --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-0393602049acad80a749b899.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.5 seconds into the battle.\nYou are A2, a marine at (8.1, 14.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.1, 15.8), 45/45 health, order: hold\n A1 marine at (8.3, 14.1), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (12.9, 15.0), 45/45 health, 4.8 away (in range)\n E1 marine at (13.4, 16.2), 45/45 health, 5.4 away\n E2 marine at (12.9, 14.3), 45/45 health, 4.8 away (in range)\nTeam chat (most recent last):\n A1 (2.0s): Falling back to group; hold and focus fire when enemies enter range.\n A2 (2.0s): A2 holding at (8,15); A1 is advancing east, stay close, focus closest.\n A0 (2.5s): Enemies 3 at east x16. Pull back to group at (8.5,15), then focus E0 together.\n A1 (2.5s): Enemies east at 16,15. Hold grouped; focus fire on the closest, starting with E2 or E0.\n A2 (2.5s): Enemies ~8 east. Hold at range 5, focus closest when they approach.\n A0 (3.0s): Holding at (8,15). Everyone hold; focus fire closest enemy when in range 5.\n A1 (3.0s): Holding at (8,14). Focus E2 first when in range, then E0.\n A2 (3.0s): Holding at (8,15). Focus E2 or E0 when in range 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Focusing E2 now, then E0. All fire E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-03ecb7d37b907469d5c1bf75.json b/examples/multi-agent-smax/results/llm-cache/ask-03ecb7d37b907469d5c1bf75.json new file mode 100644 index 00000000..b1a7d262 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-03ecb7d37b907469d5c1bf75.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 2.0 seconds into the battle.\nYou are A1, a marine at (12.8, 16.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 15 16.\nYour team:\n A0 marine at (13.5, 15.8), 45/45 health, order: move 15 16\n A2 marine at (13.3, 18.0), 45/45 health, order: move 15 17\nEnemies you can see:\n E0 marine at (18.6, 17.7), 45/45 health, 6.0 away\n E1 marine at (19.4, 16.0), 45/45 health, 6.6 away\n E2 marine at (18.1, 14.7), 45/45 health, 5.5 away\nTeam chat (most recent last):\n A1 (0.5s): Moving to (12,17) with A0; keep together, then focus same target.\n A2 (0.5s): Moving to (12,17) with A0; keep within 2, attack together when enemies appear.\n A0 (1.0s): Continuing to (12,17) together; no enemies yet, attack same target when seen.\n A1 (1.0s): Continuing to (12,17), staying within 2 of A0 and A2.\n A2 (1.0s): Continuing to (12,17); no enemies yet, stay within 2, attack together.\n A0 (1.5s): Enemies E0, E2 east at ~8. Advance together to (15,16), then focus E2 together.\n A1 (1.5s): Enemy E2 at (19.7,14.7). Advancing together to 15,16; attack E2 when all in range.\n A2 (1.5s): Enemies ~8 east. Advancing together to x=15; stay within 2, then focus E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 15 16\", \"say\": \"Moving with you to 15,16; next tick all attack E2 together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-03ee2f9f812ac836d8732089.json b/examples/multi-agent-smax/results/llm-cache/ask-03ee2f9f812ac836d8732089.json new file mode 100644 index 00000000..b6727d2b --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-03ee2f9f812ac836d8732089.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 5.5 seconds into the battle.\nYou are A1, a marine at (11.4, 15.5) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (12.7, 16.2), 9/45 health, order: retreat\n A2: dead\nEnemies you can see:\n E0 marine at (18.2, 17.3), 27/45 health, 7.0 away\n E2 marine at (18.4, 14.1), 45/45 health, 7.1 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (3.5s): E1 dead. A0 focusing E0; A1 under 20hp, retreat to pull fire.\n A1 (3.5s): A1 at 18hp retreating so A0 is closest; A0 focus E2, I return when safe.\n A0 (4.0s): Focusing E0 (36hp). A1 stay back; I'm tanking, then we take E2.\n A1 (4.0s): A1 18hp retreating; A0 you're closest, focus E0 (36hp), I'll return when safe.\n A0 (4.5s): A0 firing E0 (27hp), tanking. A1 stay back, then we take E2.\n A1 (4.5s): A1 18hp staying back; A0 kill E0 (27hp), then E2.\n A0 (5.0s): A0 at 9hp retreating. A1 you hold and shoot closest; we regroup and focus E0.\n A1 (5.0s): A1 joining now, both focus E0 (27hp) to split their fire.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"retreat\", \"say\": \"A1 18hp retreating with A0; regroup and focus E0 only when both in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-04c6b431f425793a46ba0f12.json b/examples/multi-agent-smax/results/llm-cache/ask-04c6b431f425793a46ba0f12.json new file mode 100644 index 00000000..b18d4910 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-04c6b431f425793a46ba0f12.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 0.5 seconds into the battle.\nYou are A0, a marine at (8.8, 15.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 17.\nYour team:\n A1 marine at (8.1, 16.1), 45/45 health, order: move 14 16\n A2 marine at (8.6, 18.0), 45/45 health, order: move 10 17\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Moving east together to (12,17); stay within 2 of each other, then all attack same target.\n A1 (0.0s): Moving east together toward the center; stay within 2 of each other.\n A2 (0.0s): Advancing east together, stay within 2 of each other; attack same target when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 17\", \"say\": \"Continuing to (12,17); keep within 2 of each other.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-04deda273d933177c34a77da.json b/examples/multi-agent-smax/results/llm-cache/ask-04deda273d933177c34a77da.json new file mode 100644 index 00000000..0bb7ebf8 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-04deda273d933177c34a77da.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 5.0 seconds into the battle.\nYou are A0, a marine at (12.8, 15.9) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1 marine at (13.0, 15.0), 9/45 health, order: attack E0\n A2 marine at (13.0, 14.3), 18/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (17.3, 15.0), 27/45 health, 4.6 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (3.5s): Attacking E1 (36hp), keep focus until it dies.\n A2 (3.5s): Keep firing on E1, 36hp left. All together until it dies.\n A0 (4.0s): E1 at 18hp, keep focusing it until it dies, then E0.\n A1 (4.0s): E1 at 18hp, keep firing together until it dies.\n A2 (4.0s): E1 at 18hp, keep firing together until it dies, then E0.\n A0 (4.5s): E1 down. All attack E0 together, it's in range 4.6.\n A1 (4.5s): E1 dead. All focus E0, 45hp, firing together now.\n A2 (4.5s): E1 dead. All focus E0, 4.4 away, in range. Fire together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 27hp, all fire together until it dies.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-0508ccea52b60522a908a108.json b/examples/multi-agent-smax/results/llm-cache/ask-0508ccea52b60522a908a108.json new file mode 100644 index 00000000..e7222d3c --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-0508ccea52b60522a908a108.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 2.5 seconds into the battle.\nYou are A0, a marine at (14.6, 14.4) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1 marine at (15.1, 13.7), 45/45 health, order: move 15 15\n A2 marine at (14.8, 15.1), 45/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (18.6, 16.2), 36/45 health, 4.4 away (in range)\n E1 marine at (18.0, 17.0), 45/45 health, 4.2 away (in range)\n E2 marine at (17.8, 15.5), 45/45 health, 3.3 away (in range)\nTeam chat (most recent last):\n A1 (1.0s): Continuing east together; will focus same target when enemies in range.\n A2 (1.0s): Continuing east to 14,15, staying close; will focus same target when enemies appear.\n A0 (1.5s): Enemies ~6.6 east. Closing up on me; attack E0 together once all in range.\n A1 (1.5s): Moving to 14,15 with A0 and A2; will focus same target at range 5.\n A2 (1.5s): Enemies 8 away; keep moving together, then all attack E0 at range 5.\n A0 (2.0s): Attacking E0 now. A1, A2, step in and focus E0 immediately.\n A1 (2.0s): Closing on E0 together; once all within 5, everyone attacks E0 same tick.\n A2 (2.0s): Attacking E0 now; A0 is already in range, A1 close up and focus E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Focusing E0; A1 attack E0 now, all in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-0531a575b19d2f6f827bb22c.json b/examples/multi-agent-smax/results/llm-cache/ask-0531a575b19d2f6f827bb22c.json new file mode 100644 index 00000000..8886fbc2 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-0531a575b19d2f6f827bb22c.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.5 seconds into the battle.\nYou are A2, a marine at (7.6, 17.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.9, 16.7), 45/45 health, order: hold\n A1 marine at (9.4, 14.9), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on closest enemy when they appear.\n A0 (0.5s): A0 holding; will focus fire on the closest enemy that appears.\n A1 (0.5s): A1 holding; will focus fire on closest enemy once visible.\n A2 (0.5s): Holding; staying clustered near A0 until enemies appear, then focus closest.\n A0 (1.0s): A0 holding; A1 move closer to cluster, focus closest enemy when seen.\n A1 (1.0s): A1 holding; will focus closest enemy. Staying near A0 and A2.\n A2 (1.0s): A2 holding; no enemies seen yet, will focus closest when they appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A2 holding; no enemies yet. Focus closest when they appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-053ebe38a507614123e16026.json b/examples/multi-agent-smax/results/llm-cache/ask-053ebe38a507614123e16026.json new file mode 100644 index 00000000..d6f02e8c --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-053ebe38a507614123e16026.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.0 seconds into the battle.\nYou are A1, a marine at (8.3, 14.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (9.3, 15.3), 9/45 health, order: attack E1\n A2: dead\nEnemies you can see:\n E1 marine at (12.2, 16.1), 9/45 health, 4.3 away (in range)\n E2 marine at (12.3, 17.5), 45/45 health, 5.3 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A2 (4.0s): A2 firing on E0 (27hp); finish it, then E1.\n A0 (4.5s): A0 firing E0 (18hp), finish it then E1.\n A1 (4.5s): A1 shooting E1 (36hp). E0 at 18hp, finish it, then all E1.\n A2 (4.5s): A2 9hp, still firing on E0 (18hp). A0 finish E0, then E1.\n A0 (5.0s): A0 firing E1 (27hp), A1 same. Focus E1 then E2.\n A1 (5.0s): A1 hitting E1 (27hp, in range). A0 switch to E1, then E2.\n A0 (5.5s): A0 18hp firing E1 (18hp). Finish E1, then all E2.\n A1 (5.5s): A1 on E1 (18hp). A0 keep firing E1, then E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A1 on E1 (9hp), finishing it. Then all E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-0576295511e270b1f62c85da.json b/examples/multi-agent-smax/results/llm-cache/ask-0576295511e270b1f62c85da.json new file mode 100644 index 00000000..a43436bd --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-0576295511e270b1f62c85da.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 2.5 seconds into the battle.\nYou are A0, a marine at (14.8, 18.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1 marine at (14.9, 17.2), 18/45 health, order: attack E0\n A2 marine at (13.2, 17.6), 45/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (17.7, 16.4), 18/45 health, 3.3 away (in range)\n E1 marine at (18.5, 17.3), 45/45 health, 3.8 away (in range)\n E2 marine at (19.1, 14.8), 45/45 health, 5.3 away\nTeam chat (most recent last):\n A1 (1.0s): Advancing east to 14,17 together; no one engages until all in range.\n A2 (1.0s): Moving east together to x=16; will attack same target once all in range.\n A0 (1.5s): Closing together toward E0; attack E0 once all three are within range 5.\n A1 (1.5s): Holding formation at 14,17; attack E0 together once all within range 5.\n A2 (1.5s): Regrouping at 14,17; closest enemy 6 away, hold formation, then attack E0 together.\n A0 (2.0s): E0 is within range 5 of all three of us. Everyone attack E0 now.\n A1 (2.0s): E0 is in range of all three. Attack E0 now, together.\n A2 (2.0s): E0 is within range 5 of all three of us. Attack E0 now.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Focus E0 (18hp). A1 at 18hp, retreat if under 20 per rules.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-0579385ed91673d633be4584.json b/examples/multi-agent-smax/results/llm-cache/ask-0579385ed91673d633be4584.json new file mode 100644 index 00000000..23877883 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-0579385ed91673d633be4584.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.5 seconds into the battle.\nYou are A2, a marine at (6.5, 16.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.6, 16.9), 45/45 health, order: attack E0\n A1 marine at (8.5, 15.3), 36/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (13.0, 15.1), 27/45 health, 6.7 away\n E1 marine at (13.0, 16.7), 45/45 health, 6.5 away\n E2 marine at (14.3, 17.1), 45/45 health, 7.8 away\nTeam chat (most recent last):\n A1 (2.0s): E0 east at 7.7 away. Holding grouped; focus E0 when in range.\n A2 (2.0s): A2 holding; will focus the closest enemy when it appears.\n A0 (2.5s): Holding grouped; let them walk into range, then all focus E0.\n A1 (2.5s): Holding grouped; let them walk into range, then focus E0.\n A2 (2.5s): A2 holding grouped; focus E0 when it enters range.\n A0 (3.0s): E0 in range, all attack E0 now.\n A1 (3.0s): E0 in range at 4.5, all focus fire E0 now.\n A2 (3.0s): A2 holding; focus E0 when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"A2 attacking E0, closing in to focus fire.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-05905dfaa628411b797ea65f.json b/examples/multi-agent-smax/results/llm-cache/ask-05905dfaa628411b797ea65f.json new file mode 100644 index 00000000..617a93f4 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-05905dfaa628411b797ea65f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 8.0 seconds into the battle.\nYou are A0, a marine at (7.8, 14.7) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1: dead\n A2: dead\nEnemies you can see:\n E1 marine at (11.9, 14.0), 36/45 health, 4.1 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A2 (5.0s): Focus E0 together, then E1.\n A0 (5.5s): Keep focusing E0 (27hp), then E1. Fire together.\n A2 (5.5s): Firing E0 (27hp), then E1. I'm low, keep fire together.\n A0 (6.0s): E0 at 9hp, kill it now, then E1. Fire together.\n A2 (6.0s): E0 at 9hp, finishing it now. Then all focus E1.\n A0 (6.5s): A0 alone vs E1, firing now.\n A0 (7.0s): A0 alone vs E1, firing. Last enemy.\n A0 (7.5s): A0 last unit, still firing on E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A0 last unit, 18hp vs E1 36hp, still firing.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-05e043f6c7e6121d5615917e.json b/examples/multi-agent-smax/results/llm-cache/ask-05e043f6c7e6121d5615917e.json new file mode 100644 index 00000000..95198a85 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-05e043f6c7e6121d5615917e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 1.0 seconds into the battle.\nYou are A0, a marine at (6.9, 15.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (6.7, 14.2), 45/45 health, order: hold\n A2 marine at (8.3, 17.3), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding per rules until enemy within 5 of all; then focus same target.\n A1 (0.0s): A1 holding. No enemies seen; wait until all in range 5, then focus same target.\n A2 (0.0s): A2 holding. Will attack together once enemy is within 5 of all of us.\n A0 (0.5s): A0 holding. No enemies yet; will focus the same target once all in range.\n A1 (0.5s): A1 holding; no enemies visible yet. Will focus same target once all in range.\n A2 (0.5s): A2 holding. No enemies visible yet; will focus fire when all in range 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A0 holding. No enemies visible; will focus same target once all within 5.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-05e08f7c1731ec2f1803a2b1.json b/examples/multi-agent-smax/results/llm-cache/ask-05e08f7c1731ec2f1803a2b1.json new file mode 100644 index 00000000..018cabdd --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-05e08f7c1731ec2f1803a2b1.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.0 seconds into the battle.\nYou are A2, a marine at (10.7, 16.8) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (9.9, 17.0), 45/45 health, order: attack E2\n A1: dead\nEnemies you can see:\n E0 marine at (14.6, 17.8), 45/45 health, 4.0 away (in range)\n E1 marine at (13.7, 14.5), 45/45 health, 3.8 away (in range)\n E2 marine at (14.4, 17.0), 18/45 health, 3.8 away (in range)\nTeam chat (most recent last):\n A1 (2.5s): Focus E2 now, all fire together.\n A2 (2.5s): Holding at x=9; E2 nearly in range, all focus E2.\n A0 (3.0s): Holding at x=9; focus E2 (36hp) first once any enemy enters range 5.\n A1 (3.0s): Firing on E2 (36hp, in range). A0, A2 step up and focus E2.\n A2 (3.0s): Attacking E2 (36hp) with A1; A0 join, focus E2 first.\n A0 (3.5s): Attacking E2 (27hp), closing in to focus fire with A2.\n A1 (3.5s): E2 at 27hp, keep focusing it. A0 attack E2 too.\n A2 (3.5s): Firing E2 (27hp), A0 step up and focus E2. A1 stay back.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 at 18hp, finish it now. A0 keep firing.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-064f488b5d47f26b1486a9bd.json b/examples/multi-agent-smax/results/llm-cache/ask-064f488b5d47f26b1486a9bd.json new file mode 100644 index 00000000..d84cff4d --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-064f488b5d47f26b1486a9bd.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 1.5 seconds into the battle.\nYou are A0, a marine at (12.3, 15.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 17.\nYour team:\n A1 marine at (11.9, 17.2), 45/45 health, order: move 14 17\n A2 marine at (12.3, 17.8), 45/45 health, order: move 14 17\nEnemies you can see:\n E0 marine at (20.6, 17.1), 45/45 health, 8.4 away\n E1 marine at (19.4, 17.1), 45/45 health, 7.3 away\n E2 marine at (17.3, 16.7), 45/45 health, 5.2 away\nTeam chat (most recent last):\n A1 (0.0s): Moving east together to find enemies; stay within 2 of each other, fire together.\n A2 (0.0s): Moving east together to find enemies; stay close, attack same target when in range.\n A0 (0.5s): Moving east in formation; will attack same target once all in range.\n A1 (0.5s): Moving east in a tight group; will attack same target together.\n A2 (0.5s): Moving east in formation; A0 and A1 keep pace, no one pull ahead.\n A0 (1.0s): Advancing together toward E2; hold pace, attack same target once all in range 5.\n A1 (1.0s): Advancing east together toward E2; keep within 2, attack same target at range.\n A2 (1.0s): Closing together toward E2; hold pace, all fire on E2 once in range 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 17\", \"say\": \"E2 is 5.2 away; one more step east, then all attack E2 together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-06a6c7c4fd3b1ec41cbab4f7.json b/examples/multi-agent-smax/results/llm-cache/ask-06a6c7c4fd3b1ec41cbab4f7.json new file mode 100644 index 00000000..43978d85 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-06a6c7c4fd3b1ec41cbab4f7.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.5 seconds into the battle.\nYou are A2, a marine at (8.1, 14.9) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (8.1, 15.8), 9/45 health, order: attack E1\n A1 marine at (3.6, 14.1), 9/45 health, order: hold\nEnemies you can see:\n E0 marine at (12.9, 15.0), 45/45 health, 4.8 away (in range)\n E1 marine at (11.8, 16.2), 9/45 health, 3.9 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (5.0s): A1 at 9hp staying back. Focus E1 then E0, keep grouped.\n A2 (5.0s): Firing E1 (closest). A0 focus E1 too, then E0. A1 stay back.\n A0 (5.5s): Firing E1 (27hp). A1 stay back. Then E0.\n A1 (5.5s): A1 at 9hp staying back; focus E1 then E0.\n A2 (5.5s): Firing E1 (27hp). A0 keep focus, then E0. A1 stay back.\n A0 (6.0s): Firing E1 (9hp), nearly dead. Then E0 together.\n A1 (6.0s): A1 9hp holding back; E1 is at 9hp, finish it then E0.\n A2 (6.0s): Firing E1 (9hp), nearly dead. Then E0 together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Finishing E1 (9hp) now, then all focus E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-06b7e5a0ad685c915092f5f0.json b/examples/multi-agent-smax/results/llm-cache/ask-06b7e5a0ad685c915092f5f0.json new file mode 100644 index 00000000..53a52fe9 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-06b7e5a0ad685c915092f5f0.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad just fought a battle on map 3m and lost. Here is how it went, one line per half second:\nour units' orders and health, the enemies' health, and what was said on team chat.\n\n 0.0s A0 move 11 16 (45hp) A1 move 14 16 (45hp) A2 move 14 16 (45hp) | E0 45hp E1 45hp E2 45hp\n A0 said: Advancing east together to find enemies; keep within 2 of each other, then all attack same target.\n A1 said: Moving east together toward enemies, stay within 2 of each other; attack same target on contact.\n A2 said: Moving east together to (14,16); stay within 2 of each other, attack together on contact.\n 0.5s A0 move 14 16 (45hp) A1 move 14 16 (45hp) A2 move 14 16 (45hp) | E0 45hp E1 45hp E2 45hp\n A0 said: Continuing east to (14,16); staying together, will attack same target on contact.\n A1 said: Continuing east in formation; will attack same target on contact.\n A2 said: A2 moving east to (14,16), staying close; attack same target on contact.\n 1.0s A0 move 14 16 (45hp) A1 move 15 16 (45hp) A2 move 14 16 (45hp) | E0 45hp E1 45hp E2 45hp\n A0 said: Continuing east to (14,16), staying together; no enemies seen yet.\n A1 said: Advancing together toward enemies; will all attack E1 once in range 5.\n A2 said: A2 continuing east to (14,16), staying together; attack same target on contact.\n 1.5s A0 move 15 16 (45hp) A1 move 14 16 (45hp) A2 move 15 16 (45hp) | E0 45hp E1 45hp E2 45hp\n A0 said: Advancing together east; attack E1 once all within range 5.\n A1 said: A1 holding near 14,16 so A0 and A2 catch up; all attack E1 together.\n A2 said: Advancing together to (15,16); all attack E1 once in range 5.\n 2.0s A0 attack E1 (45hp) A1 attack E1 (45hp) A2 attack E1 (45hp) | E0 45hp E1 45hp E2 45hp\n A0 said: Enemies in range now. All attack E1, A1 close in.\n A1 said: A1 attacking E1 now; A0 and A2 are in range, focus E1.\n A2 said: Enemies in range of me and A0. Attacking E1 now; A1 close in and fire on E1.\n 2.5s A0 attack E1 (45hp) A1 attack E1 (45hp) A2 retreat (18hp) | E0 45hp E1 27hp E2 45hp\n A0 said: Focus E1 (27hp). A2 low at 18hp, retreat if needed.\n A1 said: Firing on E1 (27hp). A2 at 18hp, retreat if under 20.\n A2 said: A2 at 18hp retreating to pull fire off me; A0, A1 keep focusing E1.\n 3.0s A0 attack E1 (45hp) A1 attack E1 (45hp) A2 dead | E0 45hp E1 9hp E2 45hp\n A0 said: E1 at 9hp, finish it now; then focus E0.\n A1 said: E1 at 9hp, finishing it now. A0 fire E1, then focus E2.\n 3.5s A0 attack E0 (45hp) A1 retreat (18hp) A2 dead | E0 45hp E1 dead E2 45hp\n A0 said: E1 dead. A0 focusing E0; A1 under 20hp, retreat to pull fire.\n A1 said: A1 at 18hp retreating so A0 is closest; A0 focus E2, I return when safe.\n 4.0s A0 attack E0 (45hp) A1 retreat (18hp) A2 dead | E0 36hp E1 dead E2 45hp\n A0 said: Focusing E0 (36hp). A1 stay back; I'm tanking, then we take E2.\n A1 said: A1 18hp retreating; A0 you're closest, focus E0 (36hp), I'll return when safe.\n 4.5s A0 attack E0 (27hp) A1 retreat (18hp) A2 dead | E0 27hp E1 dead E2 45hp\n A0 said: A0 firing E0 (27hp), tanking. A1 stay back, then we take E2.\n A1 said: A1 18hp staying back; A0 kill E0 (27hp), then E2.\n 5.0s A0 retreat (9hp) A1 attack E0 (18hp) A2 dead | E0 27hp E1 dead E2 45hp\n A0 said: A0 at 9hp retreating. A1 you hold and shoot closest; we regroup and focus E0.\n A1 said: A1 joining now, both focus E0 (27hp) to split their fire.\n 5.5s A0 retreat (9hp) A1 retreat (18hp) A2 dead | E0 27hp E1 dead E2 45hp\n A0 said: A0 9hp retreating; A1 focus E0 (27hp), I return if enemies shift.\n A1 said: A1 18hp retreating with A0; regroup and focus E0 only when both in range.\n 6.0s A0 retreat (9hp) A1 retreat (18hp) A2 dead | E0 27hp E1 dead E2 45hp\n A0 said: A0 9hp retreating west; A1 stay with me, regroup before engaging E0 (27hp).\n A1 said: A1 18hp retreating west; both out of range, regroup before re-engaging E0.\n 6.5s A0 retreat (9hp) A1 retreat (18hp) A2 dead | E0 27hp E1 dead E2 45hp\n A0 said: A0 9hp retreating west; A1 stay out of range, we regroup.\n A1 said: A1 18hp retreating west with A0; out of range, regroup before engaging.\n 7.0s A0 retreat (9hp) A1 retreat (18hp) A2 dead | E0 27hp E1 dead E2 45hp\n A0 said: A0 9hp still retreating west; A1 stay with me, out of range.\n A1 said: A1 18hp retreating west; enemies 7 away, out of range. Stay together.\n 7.5s A0 retreat (9hp) A1 retreat (18hp) A2 dead | E0 27hp E1 dead E2 45hp\n A0 said: A0 9hp retreating west; A1 stay with me, out of range of E0 and E2.\n A1 said: A1 18hp retreating west; staying with A0, out of range.\n 8.0s A0 retreat (9hp) A1 attack E0 (18hp) A2 dead | E0 27hp E1 dead E2 45hp\n A0 said: A0 9hp retreating west; A1 keep retreating, stay out of range.\n A1 said: Cornered at west edge. Both focus E0 (27hp) now, then E2.\n 8.5s A0 attack E0 (9hp) A1 attack E0 (18hp) A2 dead | E0 27hp E1 dead E2 45hp\n A0 said: A0 9hp joining: focus E0 (27hp) together, then E2.\n A1 said: Cornered. Focusing E0 (27hp), A0 fire E0 too, then E2.\n 9.0s A0 attack E0 (9hp) A1 dead A2 dead | E0 18hp E1 dead E2 45hp\n A0 said: A0 last alive, 9hp, finishing E0 (18hp).\n 9.5s A0 dead A1 dead A2 dead | E0 9hp E1 dead E2 45hp\n\nRULES.md now:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\nWrite ONE new rule for your squad's RULES.md that would have helped you win this battle. Every unit in your\nsquad will read RULES.md before every order in later battles. Make it a concrete rule about what a unit should\ndo, in one sentence, and do not repeat a rule already there.\nReply with JSON only: {\"rule\": \"\"}", + "response": "{\"rule\": \"Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-071290b25e221f417bddfb7e.json b/examples/multi-agent-smax/results/llm-cache/ask-071290b25e221f417bddfb7e.json new file mode 100644 index 00000000..314f6f7e --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-071290b25e221f417bddfb7e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.5 seconds into the battle.\nYou are A2, a marine at (10.8, 14.8) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (10.6, 16.0), 9/45 health, order: attack E2\n A1 marine at (8.9, 14.1), 45/45 health, order: attack E2\nEnemies you can see:\n E1 marine at (13.1, 16.8), 45/45 health, 3.0 away (in range)\n E2 marine at (13.1, 15.5), 18/45 health, 2.3 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (4.0s): Firing on E0 now, everyone focus E0.\n A2 (4.0s): Firing on E0 all together; A1 attack E0 too, not hold.\n A0 (4.5s): E0 at 18 hp, finish it, then switch to E2.\n A1 (4.5s): Firing E0 (18hp left), then switch to E2 together.\n A2 (4.5s): E0 at 18 hp, keep firing E0, then E2.\n A0 (5.0s): E0 dead. Focus E2 together, then E1.\n A1 (5.0s): E0 dead. Focus E2 (4.4 away, 45hp), everyone fire E2 together.\n A2 (5.0s): E0 dead. All focus E2, closest at 2.3, then E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Keep firing E2 (18hp), then E1 together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-0744cf90619517acaceefccc.json b/examples/multi-agent-smax/results/llm-cache/ask-0744cf90619517acaceefccc.json new file mode 100644 index 00000000..87d25fed --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-0744cf90619517acaceefccc.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.5 seconds into the battle.\nYou are A0, a marine at (8.8, 17.1) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1 marine at (8.5, 15.3), 27/45 health, order: attack E0\n A2 marine at (9.4, 16.4), 45/45 health, order: attack E0\nEnemies you can see:\n E1 marine at (12.9, 16.5), 45/45 health, 4.1 away (in range)\n E2 marine at (12.8, 17.3), 45/45 health, 4.0 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (3.0s): E0 in range at 4.5, all focus fire E0 now.\n A2 (3.0s): A2 holding; focus E0 when in range.\n A0 (3.5s): A0 focusing E0 (27hp). A2 attack E0 too, don't hold.\n A1 (3.5s): A1 focusing E0 (27hp), in range. A2 please attack E0 too.\n A2 (3.5s): A2 attacking E0, closing in to focus fire.\n A0 (4.0s): E0 at 9hp, finish it, then focus E2.\n A1 (4.0s): A1 attacking E0 (9hp), finish it then switch to E1.\n A2 (4.0s): A2 closing on E0 (9hp), then focus E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E0 dead. A0 on E2, all focus E2 please.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-0765f56b29ee24d3ac0d6fe4.json b/examples/multi-agent-smax/results/llm-cache/ask-0765f56b29ee24d3ac0d6fe4.json new file mode 100644 index 00000000..91f5f58c --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-0765f56b29ee24d3ac0d6fe4.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 3.0 seconds into the battle.\nYou are A2, a marine at (8.3, 17.3) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.9, 15.6), 45/45 health, order: hold\n A1 marine at (6.7, 14.2), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (13.6, 16.8), 45/45 health, 5.3 away\n E1 marine at (15.3, 16.2), 45/45 health, 7.1 away\n E2 marine at (15.4, 17.3), 45/45 health, 7.1 away\nTeam chat (most recent last):\n A1 (1.5s): A1 holding. Still no enemies; will focus same target once all in range 5.\n A2 (1.5s): A2 holding. No enemies visible; will focus fire when all within 5.\n A0 (2.0s): A0 holding; no enemies yet. Will focus same target once all within 5.\n A1 (2.0s): A1 holding; no enemies yet. Will attack together once all within 5.\n A2 (2.0s): A2 holding. E0 spotted at (16.8,16.8), 8.5 away. Wait until it's in range 5 of all.\n A0 (2.5s): A0 holding. E0 at 8.4 away; wait until within 5 of all, then focus E0.\n A1 (2.5s): A1 holding. E0 at 8.9 away; wait until in range 5 of all.\n A2 (2.5s): A2 holding. Nearest enemy E0 at 6.9; wait until within 5 of all.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A2 holding. E0 at 5.3 from me, 6.8+ from A0/A1. Wait for range 5.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-07a57c55afc5110bbf4afffd.json b/examples/multi-agent-smax/results/llm-cache/ask-07a57c55afc5110bbf4afffd.json new file mode 100644 index 00000000..9e64cbd7 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-07a57c55afc5110bbf4afffd.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 3.5 seconds into the battle.\nYou are A1, a marine at (14.2, 16.3) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (13.7, 15.6), 27/45 health, order: attack E2\n A2 marine at (14.9, 18.0), 9/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (17.0, 17.7), 45/45 health, 3.1 away (in range)\n E1 marine at (17.9, 16.0), 45/45 health, 3.7 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (2.0s): Moving with you to 15,16; next tick all attack E2 together.\n A2 (2.0s): Closing to 15,17 together; once all in range 5, everyone attack E0 same tick.\n A0 (2.5s): All in range now. Everyone attack E2 this tick.\n A1 (2.5s): All in range now. Everyone focus E2, it's at 36hp.\n A2 (2.5s): All in range now. Focus E2 (36hp), everyone attack E2 this tick.\n A0 (3.0s): E2 at 9hp, finish it now, then focus E1.\n A1 (3.0s): E2 at 9hp, finish it now, then focus E0.\n A2 (3.0s): E2 at 9hp, finish it now, then focus E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E2 dead. All focus E0 now, then E1. A2 retreat, you're at 9hp.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-07d2d28a001285a44000081f.json b/examples/multi-agent-smax/results/llm-cache/ask-07d2d28a001285a44000081f.json new file mode 100644 index 00000000..3b6672ae --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-07d2d28a001285a44000081f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.0 seconds into the battle.\nYou are A1, a marine at (8.5, 14.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.8, 14.7), 45/45 health, order: hold\n A2 marine at (8.2, 14.1), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (14.2, 15.0), 45/45 health, 5.6 away\n E1 marine at (15.0, 14.0), 45/45 health, 6.5 away\n E2 marine at (13.4, 16.8), 45/45 health, 5.3 away\nTeam chat (most recent last):\n A1 (1.5s): A1 holding at cluster; focus fire on closest enemy when seen.\n A2 (1.5s): A2 holding at (8,14). Clustered; focus fire on closest enemy.\n A0 (2.0s): A0 holding; no enemies seen. Focus closest when they appear.\n A1 (2.0s): Holding cluster; let them walk into range, then focus closest enemy.\n A2 (2.0s): E2 spotted east at 8.7 range. Holding cluster; let them come, focus first in range.\n A0 (2.5s): Enemies approaching; hold cluster, all focus whichever enemy enters range first.\n A1 (2.5s): Holding. Enemies closing; all focus closest enemy once in range 5.\n A2 (2.5s): A2 holding. Enemies approaching; focus closest once in range 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding. E2 closest at 5.3; focus E2 when in range, then E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-07d7eed6d1d21b72adb7eb89.json b/examples/multi-agent-smax/results/llm-cache/ask-07d7eed6d1d21b72adb7eb89.json new file mode 100644 index 00000000..7ad96937 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-07d7eed6d1d21b72adb7eb89.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 7.5 seconds into the battle.\nYou are A0, a marine at (7.8, 14.7) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1: dead\n A2: dead\nEnemies you can see:\n E1 marine at (11.9, 14.0), 36/45 health, 4.1 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (5.0s): Focus E0 together, then E1. A2 keep firing.\n A2 (5.0s): Focus E0 together, then E1.\n A0 (5.5s): Keep focusing E0 (27hp), then E1. Fire together.\n A2 (5.5s): Firing E0 (27hp), then E1. I'm low, keep fire together.\n A0 (6.0s): E0 at 9hp, kill it now, then E1. Fire together.\n A2 (6.0s): E0 at 9hp, finishing it now. Then all focus E1.\n A0 (6.5s): A0 alone vs E1, firing now.\n A0 (7.0s): A0 alone vs E1, firing. Last enemy.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A0 last unit, still firing on E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-07d81a7f5453601bb0d64d18.json b/examples/multi-agent-smax/results/llm-cache/ask-07d81a7f5453601bb0d64d18.json new file mode 100644 index 00000000..28639716 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-07d81a7f5453601bb0d64d18.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 5.5 seconds into the battle.\nYou are A2, a marine at (14.6, 17.4) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (15.0, 18.1), 18/45 health, order: attack E2\n A1: dead\nEnemies you can see:\n E2 marine at (17.5, 14.8), 45/45 health, 3.9 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (3.5s): Focusing E1 together, A2 keep firing. A1 stay back.\n A2 (3.5s): Attacking E1 with A0. A1 stay back.\n A0 (4.0s): Keep focusing E1 (27hp), both firing together.\n A2 (4.0s): Focusing E1 (27hp), both in range. Keep firing, then E2.\n A0 (4.5s): E1 at 9hp, finish it now, then both focus E2.\n A2 (4.5s): E1 at 9hp, finishing it now. Then both on E2.\n A0 (5.0s): E1 dead. Both attack E2 now, A2 is closest so keep firing.\n A2 (5.0s): E1 down. Focus E2 together; I'm closest so I tank, A0 keep firing.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Both firing on E2 now, keep attacking until it dies.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-0854fb7311637309a9ef2736.json b/examples/multi-agent-smax/results/llm-cache/ask-0854fb7311637309a9ef2736.json new file mode 100644 index 00000000..173b11d0 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-0854fb7311637309a9ef2736.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 2.5 seconds into the battle.\nYou are A0, a marine at (12.8, 15.9) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1 marine at (13.0, 15.0), 36/45 health, order: attack E2\n A2 marine at (13.0, 14.3), 45/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (17.3, 15.0), 45/45 health, 4.6 away (in range)\n E1 marine at (16.6, 14.0), 45/45 health, 4.3 away (in range)\n E2 marine at (16.6, 16.8), 18/45 health, 3.9 away (in range)\nTeam chat (most recent last):\n A1 (1.0s): A1 continuing to (12,15), staying close; attack same target on contact.\n A2 (1.0s): Holding formation at (12,15); will advance together, then all attack E2 at once.\n A0 (1.5s): A0 closing on group at (12,16); then all advance together on E2.\n A1 (1.5s): Moving to (14,16) with A0; enemies close, then all attack E2 together.\n A2 (1.5s): Moving to (14,16) with A0; enemies ~5 away next, then all attack E2 together.\n A0 (2.0s): E2 in range of all three. Attack E2 now, together.\n A1 (2.0s): All in range of E2 now. Attack E2 together.\n A2 (2.0s): E2 in range of all three. Attack E2 now, together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Firing on E2, 18hp left. Keep attacking together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-08ab548eeb4337bdb07667a5.json b/examples/multi-agent-smax/results/llm-cache/ask-08ab548eeb4337bdb07667a5.json new file mode 100644 index 00000000..b269f912 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-08ab548eeb4337bdb07667a5.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.0 seconds into the battle.\nYou are A2, a marine at (7.1, 16.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.2, 15.7), 45/45 health, order: hold\n A1 marine at (6.5, 16.0), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (12.3, 17.7), 45/45 health, 5.4 away\n E1 marine at (13.1, 16.0), 45/45 health, 6.1 away\n E2 marine at (11.8, 14.7), 45/45 health, 5.1 away\nTeam chat (most recent last):\n A1 (2.5s): A1 holding in formation; all focus fire on closest enemy when seen.\n A2 (2.5s): A2 holding; will focus closest enemy when seen.\n A0 (3.0s): Enemies approaching at ~8 range; hold together, fire on closest when in range.\n A1 (3.0s): A1 holding; E2 seen east at 8.6. Let them come into range, focus closest.\n A2 (3.0s): A2 holding; enemies at 8 range, let them come in, focus closest.\n A0 (3.5s): Holding; E2 closest at 6.2. Focus E2 when in range.\n A1 (3.5s): A1 holding; fire on closest enemy once in range, E2 first.\n A2 (3.5s): A2 holding; enemies closing, fire on closest E2 when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding. E2 at 5.1, about to enter range. Focus E2 together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-09f10091eb9d8ad0045e2c8c.json b/examples/multi-agent-smax/results/llm-cache/ask-09f10091eb9d8ad0045e2c8c.json new file mode 100644 index 00000000..e7ebc6df --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-09f10091eb9d8ad0045e2c8c.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 2.0 seconds into the battle.\nYou are A1, a marine at (12.9, 17.5) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (13.3, 15.6), 45/45 health, order: move 14 16.5\n A2 marine at (13.7, 16.7), 45/45 health, order: move 14 16.5\nEnemies you can see:\n E0 marine at (19.1, 17.6), 45/45 health, 6.3 away\n E1 marine at (16.9, 14.5), 45/45 health, 5.0 away (in range)\n E2 marine at (17.8, 17.2), 36/45 health, 4.9 away (in range)\nTeam chat (most recent last):\n A1 (0.5s): Continuing east together; will all attack same enemy on contact.\n A2 (0.5s): Continuing east together; no enemies seen yet, will focus same target on contact.\n A0 (1.0s): Continuing east together; no enemies yet, will focus same target on contact.\n A1 (1.0s): Moving to 14,16.5 with the group; will attack E2 together when in range.\n A2 (1.0s): Enemy E2 seen at 19.3,17.2. Keep formation, advance together, then all attack E2.\n A0 (1.5s): Enemies 6-7 away; keep advancing together, then all attack E2 at range 5.\n A1 (1.5s): E2 in my range; A0, A2 close in and focus E2 now.\n A2 (1.5s): Staying together; E2 nearly in range. All attack E2 once everyone is within 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"All three in range of E2 now. Attack E2 together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-0a62111a33a93371521028e8.json b/examples/multi-agent-smax/results/llm-cache/ask-0a62111a33a93371521028e8.json new file mode 100644 index 00000000..ce6f653c --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-0a62111a33a93371521028e8.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 4.5 seconds into the battle.\nYou are A1, a marine at (12.9, 17.5) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (13.3, 15.6), 18/45 health, order: attack E1\n A2 marine at (13.7, 16.7), 18/45 health, order: attack E1\nEnemies you can see:\n E0 marine at (17.7, 17.8), 45/45 health, 4.9 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (3.0s): E2 dead. Everyone focus E1 now, then E0.\n A2 (3.0s): E2 dead. Everyone focus E1 now, closest at 3.9.\n A0 (3.5s): Focus E1 (27hp). Keep attacking until dead, then E0.\n A1 (3.5s): Focusing E1 (27hp). A0 at 18hp, keep firing until E1 dies.\n A2 (3.5s): Focusing E1 (27hp), then E0. A0 at 18hp, keep firing.\n A0 (4.0s): E1 at 9hp, finishing it now, then E0.\n A1 (4.0s): E1 at 9hp, all keep firing until dead, then E0.\n A2 (4.0s): E1 at 9hp, keep firing until dead, then E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E1 dead. All attack E0 now, it's in range 4.9.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-0ae6c213818f492047ebb487.json b/examples/multi-agent-smax/results/llm-cache/ask-0ae6c213818f492047ebb487.json new file mode 100644 index 00000000..1dce340d --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-0ae6c213818f492047ebb487.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.0 seconds into the battle.\nYou are A0, a marine at (7.5, 15.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (7.2, 17.2), 45/45 health, order: hold\n A2 marine at (7.6, 17.8), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (15.9, 17.1), 45/45 health, 8.4 away\n E1 marine at (14.7, 17.1), 45/45 health, 7.3 away\n E2 marine at (12.6, 16.7), 45/45 health, 5.2 away\nTeam chat (most recent last):\n A1 (1.5s): A1 holding; no enemies yet. Focus closest when seen.\n A2 (1.5s): A2 holding; no enemies visible. Focus closest when they appear.\n A0 (2.0s): E2 spotted at (15.8,16.7). Holding grouped; focus fire on whoever closes first.\n A1 (2.0s): E2 spotted east at 8.6 range. Holding grouped; focus E2 when in range.\n A2 (2.0s): E2 spotted at (15.8,16.7), 8 away. Holding grouped; focus E2 when in range.\n A0 (2.5s): E1, E2 approaching. Holding grouped; focus E2 when within 5.\n A1 (2.5s): E2 at 7 range. Holding grouped; focus E2 once in range.\n A2 (2.5s): E2 at 6.7, E1 behind. Holding grouped; focus closest when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A0 holding; E2 at 5.2, focus E2 the moment it enters range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-0b14c72f9b3c0bdbaa3205cc.json b/examples/multi-agent-smax/results/llm-cache/ask-0b14c72f9b3c0bdbaa3205cc.json new file mode 100644 index 00000000..2ff342cb --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-0b14c72f9b3c0bdbaa3205cc.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 7.5 seconds into the battle.\nYou are A0, a marine at (7.5, 15.8) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1 marine at (7.2, 17.2), 45/45 health, order: attack E0\n A2: dead\nEnemies you can see:\n E0 marine at (11.7, 17.0), 9/45 health, 4.4 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (5.5s): Firing E1 (18hp), then E0.\n A1 (5.5s): Firing E1 (18hp), then E0.\n A0 (6.0s): E1 at 9hp, finishing it. Then focus E0.\n A1 (6.0s): Firing E1 (9hp), then E0.\n A0 (6.5s): E1 down. Focusing E0, 4.4 away, all fire.\n A1 (6.5s): E1 down. All focus E0, 4.6 away, 45hp.\n A0 (7.0s): E0 at 27hp, keep firing. I'm at 9hp.\n A1 (7.0s): Focusing E0 at 27hp, keep firing. A0 stay behind me.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 at 9hp, in range. Finishing it now.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-0b65f6edb80539a3385cdddf.json b/examples/multi-agent-smax/results/llm-cache/ask-0b65f6edb80539a3385cdddf.json new file mode 100644 index 00000000..8ab5626a --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-0b65f6edb80539a3385cdddf.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 0.0 seconds into the battle.\nYou are A1, a marine at (8.6, 17.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.5, 18.0), 45/45 health, order: hold\n A2 marine at (8.4, 16.0), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 17\", \"say\": \"Moving east together toward enemies; keep within 2 of each other, attack together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-0b6c232ce8232c174392aeea.json b/examples/multi-agent-smax/results/llm-cache/ask-0b6c232ce8232c174392aeea.json new file mode 100644 index 00000000..a43fc061 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-0b6c232ce8232c174392aeea.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 3.0 seconds into the battle.\nYou are A0, a marine at (13.6, 17.1) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1 marine at (13.2, 15.3), 27/45 health, order: attack E0\n A2 marine at (14.1, 16.4), 36/45 health, order: attack E0\nEnemies you can see:\n E1 marine at (17.6, 16.5), 45/45 health, 4.1 away (in range)\n E2 marine at (17.5, 17.3), 45/45 health, 4.0 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (1.5s): E0 in range of A1 and A0. A2 close in, everyone focus E0 now.\n A2 (1.5s): E0 at 6.7, not in range yet. Moving up together; attack E0 on same tick.\n A0 (2.0s): Focus E0 (27hp) now; A2 close in and fire.\n A1 (2.0s): Focusing E0 (27hp). A2 get in range and attack E0.\n A2 (2.0s): Attacking E0 now, closing in with you both.\n A0 (2.5s): E0 at 9hp, finish it now; then focus E2.\n A1 (2.5s): E0 at 9hp, finishing it now; then everyone focus E1.\n A2 (2.5s): E0 at 9hp in range, firing on E0 now.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E0 dead. Everyone focus E1 now, same target, no retreating.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-0b9567e8dd6e56af82d614ce.json b/examples/multi-agent-smax/results/llm-cache/ask-0b9567e8dd6e56af82d614ce.json new file mode 100644 index 00000000..f56c756c --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-0b9567e8dd6e56af82d614ce.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 7.5 seconds into the battle.\nYou are A0, a marine at (6.4, 16.2) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: retreat.\nYour team:\n A1 marine at (5.1, 15.5), 18/45 health, order: retreat\n A2: dead\nEnemies you can see:\n E0 marine at (11.9, 17.3), 27/45 health, 5.7 away\n E2 marine at (12.1, 14.1), 45/45 health, 6.1 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (5.5s): A0 9hp retreating; A1 focus E0 (27hp), I return if enemies shift.\n A1 (5.5s): A1 18hp retreating with A0; regroup and focus E0 only when both in range.\n A0 (6.0s): A0 9hp retreating west; A1 stay with me, regroup before engaging E0 (27hp).\n A1 (6.0s): A1 18hp retreating west; both out of range, regroup before re-engaging E0.\n A0 (6.5s): A0 9hp retreating west; A1 stay out of range, we regroup.\n A1 (6.5s): A1 18hp retreating west with A0; out of range, regroup before engaging.\n A0 (7.0s): A0 9hp still retreating west; A1 stay with me, out of range.\n A1 (7.0s): A1 18hp retreating west; enemies 7 away, out of range. Stay together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"retreat\", \"say\": \"A0 9hp retreating west; A1 stay with me, out of range of E0 and E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-0ca5243ff0cf2ffebed6da59.json b/examples/multi-agent-smax/results/llm-cache/ask-0ca5243ff0cf2ffebed6da59.json new file mode 100644 index 00000000..db99cfe6 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-0ca5243ff0cf2ffebed6da59.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 3.0 seconds into the battle.\nYou are A2, a marine at (14.8, 15.1) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (14.6, 14.4), 27/45 health, order: attack E0\n A1 marine at (15.1, 13.7), 45/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (18.6, 16.2), 9/45 health, 4.0 away (in range)\n E1 marine at (18.0, 17.0), 45/45 health, 3.7 away (in range)\n E2 marine at (17.8, 15.5), 45/45 health, 3.0 away (in range)\nTeam chat (most recent last):\n A1 (1.5s): Moving to 14,15 with A0 and A2; will focus same target at range 5.\n A2 (1.5s): Enemies 8 away; keep moving together, then all attack E0 at range 5.\n A0 (2.0s): Attacking E0 now. A1, A2, step in and focus E0 immediately.\n A1 (2.0s): Closing on E0 together; once all within 5, everyone attacks E0 same tick.\n A2 (2.0s): Attacking E0 now; A0 is already in range, A1 close up and focus E0.\n A0 (2.5s): Focusing E0; A1 attack E0 now, all in range.\n A1 (2.5s): In range of all; attacking E0 now.\n A2 (2.5s): Focusing E0 (36hp). A1 attack E0 now, all in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 at 9hp, finishing it now; then focus E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-0d06b9b4cd2626ae13b64aca.json b/examples/multi-agent-smax/results/llm-cache/ask-0d06b9b4cd2626ae13b64aca.json new file mode 100644 index 00000000..73ecf485 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-0d06b9b4cd2626ae13b64aca.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 1.0 seconds into the battle.\nYou are A0, a marine at (10.1, 15.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 16.5.\nYour team:\n A1 marine at (11.3, 17.5), 45/45 health, order: move 14 17\n A2 marine at (10.5, 16.7), 45/45 health, order: move 14 16.5\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Moving east together toward center; stay within 2 of each other, attack same target.\n A1 (0.0s): Moving east together toward center, stay within 2 of each other.\n A2 (0.0s): Moving east together toward center, stay close, all engage same enemy on contact.\n A0 (0.5s): Continuing east together; hold formation, all attack same target on contact.\n A1 (0.5s): Continuing east together; will all attack same enemy on contact.\n A2 (0.5s): Continuing east together; no enemies seen yet, will focus same target on contact.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 16.5\", \"say\": \"Continuing east together; no enemies yet, will focus same target on contact.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-0d55f701cf694eced3e60d6d.json b/examples/multi-agent-smax/results/llm-cache/ask-0d55f701cf694eced3e60d6d.json new file mode 100644 index 00000000..730c87a4 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-0d55f701cf694eced3e60d6d.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 2.0 seconds into the battle.\nYou are A0, a marine at (14.5, 16.3) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 15 16.\nYour team:\n A1 marine at (13.0, 15.5), 45/45 health, order: move 14 16\n A2 marine at (15.3, 16.3), 45/45 health, order: move 15 16\nEnemies you can see:\n E0 marine at (18.2, 17.3), 45/45 health, 3.8 away (in range)\n E1 marine at (18.2, 16.6), 45/45 health, 3.7 away (in range)\n E2 marine at (18.4, 14.1), 45/45 health, 4.4 away (in range)\nTeam chat (most recent last):\n A1 (0.5s): Continuing east in formation; will attack same target on contact.\n A2 (0.5s): A2 moving east to (14,16), staying close; attack same target on contact.\n A0 (1.0s): Continuing east to (14,16), staying together; no enemies seen yet.\n A1 (1.0s): Advancing together toward enemies; will all attack E1 once in range 5.\n A2 (1.0s): A2 continuing east to (14,16), staying together; attack same target on contact.\n A0 (1.5s): Advancing together east; attack E1 once all within range 5.\n A1 (1.5s): A1 holding near 14,16 so A0 and A2 catch up; all attack E1 together.\n A2 (1.5s): Advancing together to (15,16); all attack E1 once in range 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Enemies in range now. All attack E1, A1 close in.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-0dd1afbb078b94c3bbaffd72.json b/examples/multi-agent-smax/results/llm-cache/ask-0dd1afbb078b94c3bbaffd72.json new file mode 100644 index 00000000..7fde82af --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-0dd1afbb078b94c3bbaffd72.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.5 seconds into the battle.\nYou are A0, a marine at (10.6, 16.0) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1 marine at (8.9, 14.1), 45/45 health, order: attack E0\n A2 marine at (10.8, 14.8), 36/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (12.4, 16.4), 18/45 health, 1.9 away (in range)\n E1 marine at (13.1, 16.8), 45/45 health, 2.6 away (in range)\n E2 marine at (13.1, 15.5), 45/45 health, 2.5 away (in range)\nTeam chat (most recent last):\n A1 (3.0s): Holding at range 5; focus E0 when in range. Stay grouped, don't advance alone.\n A2 (3.0s): Holding at range; focus fire E0 (closest) when in range.\n A0 (3.5s): E0 at range 5, firing. Everyone focus E0 now.\n A1 (3.5s): Holding at range 5. Let them approach, then everyone focus E0.\n A2 (3.5s): Focus E0 now, all fire on E0. Stay grouped.\n A0 (4.0s): E0 in range at 1.9, all fire E0. A1 attack E0 too.\n A1 (4.0s): Firing on E0 now, everyone focus E0.\n A2 (4.0s): Firing on E0 all together; A1 attack E0 too, not hold.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 at 18 hp, finish it, then switch to E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-0ddb5a02e2925cb75138fea1.json b/examples/multi-agent-smax/results/llm-cache/ask-0ddb5a02e2925cb75138fea1.json new file mode 100644 index 00000000..6b764e2a --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-0ddb5a02e2925cb75138fea1.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 9.0 seconds into the battle.\nYou are A1, a marine at (9.8, 14.2) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E2 marine at (10.8, 17.5), 18/45 health, 3.5 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (5.5s): A1 on E1 (18hp). A0 keep firing E1, then E2.\n A0 (6.0s): A0 9hp, finishing E1 (9hp). Then focus E2 together.\n A1 (6.0s): A1 on E1 (9hp), finishing it. Then all E2.\n A1 (6.5s): A1 alone vs E2 (45hp), engaging.\n A1 (7.0s): A1 alone vs E2 (45hp), still firing.\n A1 (7.5s): A1 36hp vs E2 36hp, still firing.\n A1 (8.0s): A1 27hp vs E2 27hp, still firing.\n A1 (8.5s): A1 27hp vs E2 18hp, still firing. Last enemy.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"A1 18hp vs E2 18hp, still firing. Last enemy.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-0e910a78a4812cc444c54236.json b/examples/multi-agent-smax/results/llm-cache/ask-0e910a78a4812cc444c54236.json new file mode 100644 index 00000000..0b7bab2e --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-0e910a78a4812cc444c54236.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 6.5 seconds into the battle.\nYou are A0, a marine at (13.7, 15.6) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1: dead\n A2: dead\nEnemies you can see:\n E1 marine at (17.9, 16.0), 27/45 health, 4.2 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (4.5s): E0 at 18hp, keep focusing it, then E1. I'm 27hp, staying in.\n A1 (4.5s): E0 at 18hp, keep focusing it, then E1. A0 retreat if under 20.\n A0 (5.0s): E0 dead. Focus E1 now, it's in range 4.2.\n A1 (5.0s): E0 down. Both focus E1 now, it's the last one.\n A0 (5.5s): Focusing E1. A1 at 9hp, retreat if you're targeted; I'm 27hp, staying in.\n A1 (5.5s): Attacking E1. I'm 9hp and will soak a shot. A0 keep firing, finish it.\n A0 (6.0s): Firing on E1 (27hp). A1 retreat if targeted; I'm 27hp, staying in.\n A1 (6.0s): A1 at 9hp retreating so I'm not the target. A0 finish E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Firing on E1, last enemy. A0 27hp, staying in.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-0eaeddf7f71e6da7d0e4e4ba.json b/examples/multi-agent-smax/results/llm-cache/ask-0eaeddf7f71e6da7d0e4e4ba.json new file mode 100644 index 00000000..e1502008 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-0eaeddf7f71e6da7d0e4e4ba.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.0 seconds into the battle.\nYou are A0, a marine at (7.8, 14.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1: dead\n A2 marine at (8.2, 14.1), 9/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (12.6, 15.0), 9/45 health, 4.8 away (in range)\n E1 marine at (11.9, 14.0), 45/45 health, 4.1 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (4.0s): E2 at 18 HP, finish it now, then E0.\n A2 (4.0s): Firing on E2 (18hp), then E0. Keep A1 behind us.\n A0 (4.5s): E2 down. Focus E0 now, then E1. Fire together.\n A2 (4.5s): E2 down. Focus E0 (4.5 away), then E1.\n A0 (5.0s): Focus E0 together, then E1. A2 keep firing.\n A2 (5.0s): Focus E0 together, then E1.\n A0 (5.5s): Keep focusing E0 (27hp), then E1. Fire together.\n A2 (5.5s): Firing E0 (27hp), then E1. I'm low, keep fire together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 at 9hp, kill it now, then E1. Fire together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-0ec0ba47d42577309569a930.json b/examples/multi-agent-smax/results/llm-cache/ask-0ec0ba47d42577309569a930.json new file mode 100644 index 00000000..e91f9b95 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-0ec0ba47d42577309569a930.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 7.0 seconds into the battle.\nYou are A1, a marine at (8.3, 14.2) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (5.3, 15.6), 9/45 health, order: retreat\n A2: dead\nEnemies you can see:\n E1 marine at (12.2, 16.1), 27/45 health, 4.4 away (in range)\n E2 marine at (10.7, 17.4), 45/45 health, 4.1 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (5.0s): E0 at 9hp, finishing it now. A1 focus E0.\n A1 (5.0s): A1 firing on E0 (9hp), finish it then focus E1.\n A0 (5.5s): E0 dead. Both focus E1 now, then E2.\n A1 (5.5s): E0 down. Focus E1 (4.4 away, in range) now, both of us.\n A0 (6.0s): A0 at 18hp retreating to pull fire off. A1 focus E1, I'll rejoin if safe.\n A1 (6.0s): A1 attacking E1 (45hp). A0 at 18hp, retreat if under 20 to shed aggro.\n A0 (6.5s): A0 at 9hp, staying out of range. A1 focus E1, 36hp left.\n A1 (6.5s): A1 attacking E1 (36hp), in range. A0 stay back, keep out of range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A1 on E1 (27hp), 3 shots left. A0 stay out of range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-0f1693567474b9f0c366dd6a.json b/examples/multi-agent-smax/results/llm-cache/ask-0f1693567474b9f0c366dd6a.json new file mode 100644 index 00000000..0a482b02 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-0f1693567474b9f0c366dd6a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.5 seconds into the battle.\nYou are A0, a marine at (8.2, 16.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (9.8, 15.7), 45/45 health, order: hold\n A2 marine at (9.0, 16.2), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together as a group; focus fire on the closest enemy when they appear.\n A0 (0.5s): No enemies yet; staying grouped, will focus the closest enemy when seen.\n A1 (0.5s): Holding position; will focus fire on closest enemy once visible.\n A2 (0.5s): Holding. Will focus fire on the closest enemy once visible.\n A0 (1.0s): Still no enemies; holding grouped, focus closest when seen.\n A1 (1.0s): Still no enemies; holding grouped, will focus closest when seen.\n A2 (1.0s): Still no enemies. Holding; will focus the closest enemy when seen.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Still no enemies; holding grouped, focus closest when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-0fd6e5bd48a13faa97533dcd.json b/examples/multi-agent-smax/results/llm-cache/ask-0fd6e5bd48a13faa97533dcd.json new file mode 100644 index 00000000..06896b8f --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-0fd6e5bd48a13faa97533dcd.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.5 seconds into the battle.\nYou are A0, a marine at (8.2, 16.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (9.9, 15.6), 45/45 health, order: hold\n A2 marine at (10.5, 16.3), 27/45 health, order: attack E1\nEnemies you can see:\n E0 marine at (15.1, 17.3), 45/45 health, 6.9 away\n E1 marine at (15.1, 16.6), 36/45 health, 6.9 away\n E2 marine at (13.7, 14.1), 45/45 health, 5.8 away\nTeam chat (most recent last):\n A1 (2.0s): Enemies at 8.5 east. Hold grouped; all focus the closest when in range.\n A2 (2.0s): No contact after 2s. Advancing east together to (14,16); stay close, focus closest.\n A0 (2.5s): A2 advancing alone is risky; hold grouped at range 5, focus E1 when in range.\n A1 (2.5s): Enemies 7 east. A2 fall back to group; hold and focus E1 when in range.\n A2 (2.5s): Cancel advance. Holding at 10.5; enemies 6 east, focus E1 when in range.\n A0 (3.0s): Holding. Enemies at 7; focus E1 when in range, stay grouped.\n A1 (3.0s): Holding. E1 is closest at 5.3; focus E1 as soon as it's in range.\n A2 (3.0s): Enemies in range. Focus E1 now, everyone fire on E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Moving up to fire on E1; A2 is taking fire, everyone commit.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-10117765bc0619be16346755.json b/examples/multi-agent-smax/results/llm-cache/ask-10117765bc0619be16346755.json new file mode 100644 index 00000000..81231c97 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-10117765bc0619be16346755.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 3.0 seconds into the battle.\nYou are A2, a marine at (12.3, 16.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (13.3, 16.4), 45/45 health, order: attack E0\n A1: dead\nEnemies you can see:\n E1 marine at (18.6, 15.6), 45/45 health, 6.3 away\n E2 marine at (18.2, 17.7), 45/45 health, 6.0 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (1.5s): Advancing together east to (14,16); then all attack E0 at once.\n A2 (1.5s): Advancing together toward E0; all attack E0 once everyone is within range 5.\n A0 (2.0s): E0 is within range 5 of all three of us. Everyone attack E0 now.\n A1 (2.0s): E0 is in range of all three of us. Everyone attack E0 now.\n A2 (2.0s): E0 is in range of all three; attacking E0 now, focus fire.\n A0 (2.5s): Keep focusing E0; A1 stay in fight until E0 dies, then retreat.\n A1 (2.5s): E0 at 18hp, keep focus fire; I'm at 18hp and will step back once it dies.\n A2 (2.5s): Focus E0, it's at 18hp. A1 is low; keep firing until E0 dies.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E0 dead. A0 and I both attack E2 now, stay together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-102062647428bba26f325b62.json b/examples/multi-agent-smax/results/llm-cache/ask-102062647428bba26f325b62.json new file mode 100644 index 00000000..64f9c917 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-102062647428bba26f325b62.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 2.5 seconds into the battle.\nYou are A2, a marine at (12.8, 14.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (12.7, 16.0), 45/45 health, order: attack E0\n A1 marine at (13.3, 15.5), 18/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (17.6, 15.0), 18/45 health, 4.8 away (in range)\n E1 marine at (18.1, 16.2), 45/45 health, 5.5 away\n E2 marine at (17.6, 14.3), 45/45 health, 4.8 away (in range)\nTeam chat (most recent last):\n A1 (1.0s): Continuing to (12,15) together; will attack same target when enemies appear.\n A2 (1.0s): A2 continuing to (12,15); will attack together when enemies appear.\n A0 (1.5s): Advancing together toward E0; all attack E0 once everyone is in range.\n A1 (1.5s): Advancing together to (14,15); all attack E0 once in range.\n A2 (1.5s): Advancing east together to (15,15); all attack E2 once in range 5.\n A0 (2.0s): All in range of E0 now. Everyone attack E0 together.\n A1 (2.0s): All in range now: everyone attack E0 together.\n A2 (2.0s): Enemies in range now. Everyone attack E0 together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"A2 attacking E0 now; focus it down, then E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-105ff1a8df30382e7138a6cc.json b/examples/multi-agent-smax/results/llm-cache/ask-105ff1a8df30382e7138a6cc.json new file mode 100644 index 00000000..811ba519 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-105ff1a8df30382e7138a6cc.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 2.5 seconds into the battle.\nYou are A1, a marine at (12.9, 17.5) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (13.3, 15.6), 36/45 health, order: attack E2\n A2 marine at (13.7, 16.7), 45/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (17.7, 17.8), 45/45 health, 4.9 away (in range)\n E1 marine at (16.9, 14.5), 45/45 health, 5.0 away (in range)\n E2 marine at (17.6, 17.0), 9/45 health, 4.7 away (in range)\nTeam chat (most recent last):\n A1 (1.0s): Moving to 14,16.5 with the group; will attack E2 together when in range.\n A2 (1.0s): Enemy E2 seen at 19.3,17.2. Keep formation, advance together, then all attack E2.\n A0 (1.5s): Enemies 6-7 away; keep advancing together, then all attack E2 at range 5.\n A1 (1.5s): E2 in my range; A0, A2 close in and focus E2 now.\n A2 (1.5s): Staying together; E2 nearly in range. All attack E2 once everyone is within 5.\n A0 (2.0s): E2 in my range 4.8; attacking E2 now, everyone focus E2.\n A1 (2.0s): All three in range of E2 now. Attack E2 together.\n A2 (2.0s): E2 and E1 in my range; attacking E2 now, everyone focus E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Focusing E2 (9hp), it dies soon; then we focus E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-10aaef3cb691a428f118cef0.json b/examples/multi-agent-smax/results/llm-cache/ask-10aaef3cb691a428f118cef0.json new file mode 100644 index 00000000..cf3e4db8 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-10aaef3cb691a428f118cef0.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 4.5 seconds into the battle.\nYou are A1, a marine at (13.2, 15.3) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (13.6, 17.1), 18/45 health, order: attack E2\n A2 marine at (14.1, 16.4), 18/45 health, order: attack E2\nEnemies you can see:\n E2 marine at (17.5, 17.3), 27/45 health, 4.8 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (3.0s): E0 dead. Everyone focus E1 now, same tick; then E2.\n A2 (3.0s): E0 dead. Everyone focus E1 now, then E2.\n A0 (3.5s): Focusing E1 (18hp), same target; then E2.\n A1 (3.5s): Attacking E1 (18hp), all keep firing; then E2.\n A2 (3.5s): Attacking E1 (18hp) now, then E2.\n A0 (4.0s): E1 dead. All focus E2 now, no retreating.\n A1 (4.0s): E1 down. All focus E2 now, same target, no retreating.\n A2 (4.0s): E1 dead. All attack E2 now, same target, keep firing.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Keep firing E2, last enemy, no retreating.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-10b8d0856d9581ce40528189.json b/examples/multi-agent-smax/results/llm-cache/ask-10b8d0856d9581ce40528189.json new file mode 100644 index 00000000..8c379028 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-10b8d0856d9581ce40528189.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.0 seconds into the battle.\nYou are A1, a marine at (8.3, 14.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (9.3, 15.3), 45/45 health, order: attack E0\n A2 marine at (9.0, 16.0), 27/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (13.4, 16.8), 27/45 health, 5.8 away\n E1 marine at (12.2, 16.1), 45/45 health, 4.3 away (in range)\n E2 marine at (12.3, 17.5), 45/45 health, 5.3 away\nTeam chat (most recent last):\n A1 (2.5s): A1 holding at (6.7,14.2); A0 fall back to us, focus E0 together.\n A2 (2.5s): A2 holding; enemies approaching, all focus E0 when in range.\n A0 (3.0s): A0 holding; focus E0 when in range 5.\n A1 (3.0s): A1 holding; focus E0 when it enters range 5.\n A2 (3.0s): A2 attacking E0 (in range); all focus E0.\n A0 (3.5s): A0 attacking E0 now; focus E0 together.\n A1 (3.5s): A1 advancing, focusing E0 with A2. A0 join fire on E0.\n A2 (3.5s): A2 attacking E0 (36hp, in range); all focus E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E0 out of my range; hitting E1 (in range). A0, A2 finish E0, then all E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-10cb5188a56a004d0f457376.json b/examples/multi-agent-smax/results/llm-cache/ask-10cb5188a56a004d0f457376.json new file mode 100644 index 00000000..7944e2ab --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-10cb5188a56a004d0f457376.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.5 seconds into the battle.\nYou are A1, a marine at (8.5, 15.3) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.6, 16.9), 45/45 health, order: hold\n A2 marine at (6.5, 16.6), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together here; focus fire on the closest enemy when they appear.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together as a group; focus fire on the closest enemy once seen.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A1 holding; will focus fire on the closest enemy that appears.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-11342bbccb9537b1ce8dd7a4.json b/examples/multi-agent-smax/results/llm-cache/ask-11342bbccb9537b1ce8dd7a4.json new file mode 100644 index 00000000..26f4f471 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-11342bbccb9537b1ce8dd7a4.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.0 seconds into the battle.\nYou are A0, a marine at (8.6, 16.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (8.5, 15.3), 45/45 health, order: hold\n A2 marine at (6.5, 16.6), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (16.2, 15.1), 45/45 health, 7.8 away\nTeam chat (most recent last):\n A1 (0.5s): A1 holding; will focus fire on the closest enemy that appears.\n A2 (0.5s): No enemies yet; staying grouped, will focus the closest one when seen.\n A0 (1.0s): Still no enemies; holding grouped, focus closest when seen.\n A1 (1.0s): A1 holding; no enemies yet, will focus the closest when seen.\n A2 (1.0s): A2 holding; will focus the closest enemy when it appears.\n A0 (1.5s): A0 holding; still no enemies. Focus the closest when they appear.\n A1 (1.5s): A1 holding; no enemies yet, focus closest when seen.\n A2 (1.5s): A2 holding; will focus fire on the closest enemy when seen.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"E0 spotted at distance 7.8. Holding grouped; focus E0 when in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-11a103a7d4fe37a0b2f157e6.json b/examples/multi-agent-smax/results/llm-cache/ask-11a103a7d4fe37a0b2f157e6.json new file mode 100644 index 00000000..7062b8ea --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-11a103a7d4fe37a0b2f157e6.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 4.0 seconds into the battle.\nYou are A1, a marine at (15.1, 13.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (14.6, 14.4), 27/45 health, order: attack E2\n A2: dead\nEnemies you can see:\n E1 marine at (18.0, 17.0), 45/45 health, 4.3 away (in range)\n E2 marine at (17.8, 15.5), 18/45 health, 3.2 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (2.5s): In range of all; attacking E0 now.\n A2 (2.5s): Focusing E0 (36hp). A1 attack E0 now, all in range.\n A0 (3.0s): E0 at 9hp, finishing it now. Everyone keep focusing E0.\n A1 (3.0s): Attacking E0 (9hp), finish it then focus E2.\n A2 (3.0s): E0 at 9hp, finishing it now; then focus E2.\n A0 (3.5s): E0 dead. All focus E2 now, then E1.\n A1 (3.5s): E0 down. Everyone focus E2 (closest), then E1.\n A2 (3.5s): E0 down. Everyone focus E2 (3.0 away), then E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 at 18hp, keep focusing E2 then E1. Nobody retreat.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-122168b4d052b7789cf6f800.json b/examples/multi-agent-smax/results/llm-cache/ask-122168b4d052b7789cf6f800.json new file mode 100644 index 00000000..76ce3cb5 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-122168b4d052b7789cf6f800.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 4.5 seconds into the battle.\nYou are A0, a marine at (13.6, 17.1) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1 marine at (13.2, 15.3), 27/45 health, order: attack E2\n A2 marine at (14.1, 16.4), 18/45 health, order: attack E2\nEnemies you can see:\n E2 marine at (17.5, 17.3), 27/45 health, 4.0 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (3.0s): E0 dead. Everyone focus E1 now, same tick; then E2.\n A2 (3.0s): E0 dead. Everyone focus E1 now, then E2.\n A0 (3.5s): Focusing E1 (18hp), same target; then E2.\n A1 (3.5s): Attacking E1 (18hp), all keep firing; then E2.\n A2 (3.5s): Attacking E1 (18hp) now, then E2.\n A0 (4.0s): E1 dead. All focus E2 now, no retreating.\n A1 (4.0s): E1 down. All focus E2 now, same target, no retreating.\n A2 (4.0s): E1 dead. All attack E2 now, same target, keep firing.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Keep firing E2, last enemy, no retreating.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-12359efc2febc92ff5a68c72.json b/examples/multi-agent-smax/results/llm-cache/ask-12359efc2febc92ff5a68c72.json new file mode 100644 index 00000000..2d57b1dd --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-12359efc2febc92ff5a68c72.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 2.5 seconds into the battle.\nYou are A2, a marine at (14.8, 15.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (14.6, 14.4), 36/45 health, order: attack E0\n A1 marine at (15.1, 13.7), 45/45 health, order: move 15 15\nEnemies you can see:\n E0 marine at (18.6, 16.2), 36/45 health, 4.0 away (in range)\n E1 marine at (18.0, 17.0), 45/45 health, 3.7 away (in range)\n E2 marine at (17.8, 15.5), 45/45 health, 3.0 away (in range)\nTeam chat (most recent last):\n A1 (1.0s): Continuing east together; will focus same target when enemies in range.\n A2 (1.0s): Continuing east to 14,15, staying close; will focus same target when enemies appear.\n A0 (1.5s): Enemies ~6.6 east. Closing up on me; attack E0 together once all in range.\n A1 (1.5s): Moving to 14,15 with A0 and A2; will focus same target at range 5.\n A2 (1.5s): Enemies 8 away; keep moving together, then all attack E0 at range 5.\n A0 (2.0s): Attacking E0 now. A1, A2, step in and focus E0 immediately.\n A1 (2.0s): Closing on E0 together; once all within 5, everyone attacks E0 same tick.\n A2 (2.0s): Attacking E0 now; A0 is already in range, A1 close up and focus E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Focusing E0 (36hp). A1 attack E0 now, all in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-124fbb046e49b93e5d33b142.json b/examples/multi-agent-smax/results/llm-cache/ask-124fbb046e49b93e5d33b142.json new file mode 100644 index 00000000..6e34d778 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-124fbb046e49b93e5d33b142.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 5.0 seconds into the battle.\nYou are A2, a marine at (13.0, 14.3) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (12.8, 15.9), 27/45 health, order: attack E0\n A1 marine at (13.0, 15.0), 9/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (17.3, 15.0), 27/45 health, 4.4 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (3.5s): Attacking E1 (36hp), keep focus until it dies.\n A2 (3.5s): Keep firing on E1, 36hp left. All together until it dies.\n A0 (4.0s): E1 at 18hp, keep focusing it until it dies, then E0.\n A1 (4.0s): E1 at 18hp, keep firing together until it dies.\n A2 (4.0s): E1 at 18hp, keep firing together until it dies, then E0.\n A0 (4.5s): E1 down. All attack E0 together, it's in range 4.6.\n A1 (4.5s): E1 dead. All focus E0, 45hp, firing together now.\n A2 (4.5s): E1 dead. All focus E0, 4.4 away, in range. Fire together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 27hp, keep firing together until it dies.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-133e7c6d2cc3dd7e2a0e7ab3.json b/examples/multi-agent-smax/results/llm-cache/ask-133e7c6d2cc3dd7e2a0e7ab3.json new file mode 100644 index 00000000..12e889a3 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-133e7c6d2cc3dd7e2a0e7ab3.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 2.0 seconds into the battle.\nYou are A0, a marine at (13.3, 16.4) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 16.\nYour team:\n A1 marine at (14.1, 16.4), 45/45 health, order: move 14 16\n A2 marine at (12.3, 16.5), 45/45 health, order: move 13 16\nEnemies you can see:\n E0 marine at (16.0, 15.3), 45/45 health, 3.0 away (in range)\n E1 marine at (18.6, 15.6), 45/45 health, 5.4 away\n E2 marine at (18.2, 17.7), 45/45 health, 5.1 away\nTeam chat (most recent last):\n A1 (0.5s): Joining A0 and A2 at (12,16); staying grouped, then advance together.\n A2 (0.5s): A2 moving to (12,16) with team; will attack together on contact.\n A0 (1.0s): Continuing to (12,16); stay grouped, attack same target on contact.\n A1 (1.0s): Holding formation at (12,16); then all advance and attack E0 together.\n A2 (1.0s): Continuing to (12,16) together; will attack same target once all in range 5.\n A0 (1.5s): Advancing together toward E0; all attack E0 once everyone is within range 5.\n A1 (1.5s): Advancing together east to (14,16); then all attack E0 at once.\n A2 (1.5s): Advancing together toward E0; all attack E0 once everyone is within range 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 is within range 5 of all three of us. Everyone attack E0 now.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-1373bc8785c80ab9c1d6bee0.json b/examples/multi-agent-smax/results/llm-cache/ask-1373bc8785c80ab9c1d6bee0.json new file mode 100644 index 00000000..22276cee --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-1373bc8785c80ab9c1d6bee0.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.0 seconds into the battle.\nYou are A0, a marine at (6.9, 16.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (7.8, 14.9), 45/45 health, order: hold\n A2 marine at (7.6, 17.8), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (12.9, 15.3), 45/45 health, 6.1 away\n E1 marine at (15.4, 15.6), 45/45 health, 8.5 away\n E2 marine at (15.0, 17.7), 45/45 health, 8.2 away\nTeam chat (most recent last):\n A1 (1.5s): A1 moving to cluster with A0/A2; holding together, focus closest enemy.\n A2 (1.5s): A2 holding; no enemies yet. Focus closest when they appear.\n A0 (2.0s): A0 holding. Focus closest enemy when seen; stay tight.\n A1 (2.0s): A1 holding near cluster; E0 spotted east at (16,15.3). Focus E0 when in range.\n A2 (2.0s): E0 seen east at 16,15. Holding clustered; focus E0 when in range.\n A0 (2.5s): A0 holding. Only E0 seen; let it come into range, focus fire together.\n A1 (2.5s): A1 holding; E0 approaching, focus fire when in range.\n A2 (2.5s): A2 holding; E0 approaching, focus it when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A0 holding; all 3 enemies visible. Focus E0 when in range, stay tight.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-1382af5e1eadf000914e80eb.json b/examples/multi-agent-smax/results/llm-cache/ask-1382af5e1eadf000914e80eb.json new file mode 100644 index 00000000..fd9ad313 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-1382af5e1eadf000914e80eb.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 1.5 seconds into the battle.\nYou are A1, a marine at (11.9, 17.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 17.\nYour team:\n A0 marine at (12.3, 15.8), 45/45 health, order: move 14 17\n A2 marine at (12.3, 17.8), 45/45 health, order: move 14 17\nEnemies you can see:\n E0 marine at (20.6, 17.1), 45/45 health, 8.7 away\n E1 marine at (19.4, 17.1), 45/45 health, 7.5 away\n E2 marine at (17.3, 16.7), 45/45 health, 5.5 away\nTeam chat (most recent last):\n A1 (0.0s): Moving east together to find enemies; stay within 2 of each other, fire together.\n A2 (0.0s): Moving east together to find enemies; stay close, attack same target when in range.\n A0 (0.5s): Moving east in formation; will attack same target once all in range.\n A1 (0.5s): Moving east in a tight group; will attack same target together.\n A2 (0.5s): Moving east in formation; A0 and A1 keep pace, no one pull ahead.\n A0 (1.0s): Advancing together toward E2; hold pace, attack same target once all in range 5.\n A1 (1.0s): Advancing east together toward E2; keep within 2, attack same target at range.\n A2 (1.0s): Closing together toward E2; hold pace, all fire on E2 once in range 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 17\", \"say\": \"Almost in range of E2; keep pace, all attack E2 together next tick.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-13d7cd3a7aedf93932710377.json b/examples/multi-agent-smax/results/llm-cache/ask-13d7cd3a7aedf93932710377.json new file mode 100644 index 00000000..01e872d0 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-13d7cd3a7aedf93932710377.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 9.0 seconds into the battle.\nYou are A0, a marine at (2.1, 15.6) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: retreat.\nYour team:\n A1: dead\n A2: dead\nEnemies you can see:\n E1 marine at (10.6, 16.1), 9/45 health, 8.5 away\n E2 marine at (9.2, 17.4), 45/45 health, 7.3 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (6.5s): A1 attacking E1 (36hp), in range. A0 stay back, keep out of range.\n A0 (7.0s): A0 9hp, staying out of range. A1 focus E1 (27hp), then E2.\n A1 (7.0s): A1 on E1 (27hp), 3 shots left. A0 stay out of range.\n A0 (7.5s): A0 9hp staying out of range. A1 finish E1 (18hp), then E2.\n A1 (7.5s): A1 on E1 (18hp), finishing it, then E2. A0 stay back.\n A0 (8.0s): A0 9hp joining on E1 to finish it fast, then focus E2 together.\n A1 (8.0s): A1 9hp, finishing E1 (18hp). A0 stay back, then we focus E2.\n A0 (8.5s): A0 9hp alone, retreating out of range; E1 has 9hp left.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"retreat\", \"say\": \"A0 9hp, last unit. Retreating out of range; enemies E1 9hp, E2 45hp.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-14039fedd63b490eb6da6b0c.json b/examples/multi-agent-smax/results/llm-cache/ask-14039fedd63b490eb6da6b0c.json new file mode 100644 index 00000000..2f0bb32a --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-14039fedd63b490eb6da6b0c.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.0 seconds into the battle.\nYou are A1, a marine at (7.4, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (9.0, 16.0), 45/45 health, order: hold\n A2 marine at (7.7, 14.8), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.5s): Holding; will focus fire on closest enemy once in range.\n A2 (0.5s): Holding position; focus fire on closest enemy once in range.\n A0 (1.0s): Holding; still no enemies. Focus fire closest when they appear.\n A1 (1.0s): Holding; no enemies in sight. Focus fire closest when they appear.\n A2 (1.0s): Still holding; no enemies visible. Focus fire on closest when they appear.\n A0 (1.5s): Holding near A1/A2; focus fire closest enemy when in range.\n A1 (1.5s): Still holding; will focus fire on closest enemy when visible.\n A2 (1.5s): Holding grouped; focus fire on closest enemy when it appears.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 15\", \"say\": \"No contact; advancing east together to find enemies. Stay grouped, focus closest.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-165b52cb93902a7651d6220e.json b/examples/multi-agent-smax/results/llm-cache/ask-165b52cb93902a7651d6220e.json new file mode 100644 index 00000000..267d5f0b --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-165b52cb93902a7651d6220e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.0 seconds into the battle.\nYou are A1, a marine at (8.2, 15.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 8 15.\nYour team:\n A0 marine at (8.1, 15.9), 45/45 health, order: hold\n A2 marine at (8.2, 14.3), 45/45 health, order: move 8 15\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Regroup near (8,15) so we fight together; focus fire on closest enemy.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A0 (0.5s): At (8,15), holding. Focus fire on the closest enemy that appears.\n A1 (0.5s): Closing to (8,15) to cluster; will focus closest enemy.\n A2 (0.5s): Moving to regroup at (8,15); will focus fire closest enemy.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A1 at (8,15) holding. Focus fire on closest enemy.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-1669039dba0043ef962c7dcb.json b/examples/multi-agent-smax/results/llm-cache/ask-1669039dba0043ef962c7dcb.json new file mode 100644 index 00000000..6572e17f --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-1669039dba0043ef962c7dcb.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 8.0 seconds into the battle.\nYou are A2, a marine at (13.9, 16.5) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0: dead\n A1: dead\nEnemies you can see:\n E1 marine at (17.0, 15.6), 18/45 health, 3.2 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (4.5s): E2 at 9hp, finish it together, then both on E1.\n A2 (4.5s): E2 at 9hp, finish it now. A0 stay put, then both on E1.\n A2 (5.0s): A2 alone now. Finishing E2 at 9hp, then E1.\n A2 (5.5s): E2 dead. A2 alone, attacking E1 at 3.2 range.\n A2 (6.0s): A2 alone, 36hp vs E1 36hp, focusing E1.\n A2 (6.5s): A2 alone, 27hp vs E1 36hp, still focusing E1.\n A2 (7.0s): A2 27hp vs E1 27hp, still focusing E1.\n A2 (7.5s): A2 18hp vs E1 18hp, last enemy, all-in on E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A2 9hp vs E1 18hp, last stand, all-in on E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-16717ed8c87dcbcceb58da4b.json b/examples/multi-agent-smax/results/llm-cache/ask-16717ed8c87dcbcceb58da4b.json new file mode 100644 index 00000000..7453c9c6 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-16717ed8c87dcbcceb58da4b.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 0.0 seconds into the battle.\nYou are A0, a marine at (8.1, 17.4) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (8.3, 14.1), 45/45 health, order: hold\n A2 marine at (6.5, 14.9), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 16\", \"say\": \"Moving east together to (12,16); stay within 2 of each other, then attack same target.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-16df5ec500ff31c565c46e9d.json b/examples/multi-agent-smax/results/llm-cache/ask-16df5ec500ff31c565c46e9d.json new file mode 100644 index 00000000..4e4a8f0f --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-16df5ec500ff31c565c46e9d.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 2.5 seconds into the battle.\nYou are A0, a marine at (13.7, 15.6) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1 marine at (14.2, 16.3), 45/45 health, order: move 15 16\n A2 marine at (14.9, 18.0), 45/45 health, order: move 15 17\nEnemies you can see:\n E0 marine at (17.0, 17.7), 45/45 health, 3.9 away (in range)\n E1 marine at (17.9, 16.0), 45/45 health, 4.2 away (in range)\n E2 marine at (18.1, 14.7), 36/45 health, 4.5 away (in range)\nTeam chat (most recent last):\n A1 (1.0s): Continuing to (12,17), staying within 2 of A0 and A2.\n A2 (1.0s): Continuing to (12,17); no enemies yet, stay within 2, attack together.\n A0 (1.5s): Enemies E0, E2 east at ~8. Advance together to (15,16), then focus E2 together.\n A1 (1.5s): Enemy E2 at (19.7,14.7). Advancing together to 15,16; attack E2 when all in range.\n A2 (1.5s): Enemies ~8 east. Advancing together to x=15; stay within 2, then focus E0.\n A0 (2.0s): E2 in my range, firing now. A1, A2 close in and focus E2.\n A1 (2.0s): Moving with you to 15,16; next tick all attack E2 together.\n A2 (2.0s): Closing to 15,17 together; once all in range 5, everyone attack E0 same tick.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"All in range now. Everyone attack E2 this tick.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-17124d9ca73ac94c4ef94daa.json b/examples/multi-agent-smax/results/llm-cache/ask-17124d9ca73ac94c4ef94daa.json new file mode 100644 index 00000000..5ee6ec88 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-17124d9ca73ac94c4ef94daa.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 1.5 seconds into the battle.\nYou are A1, a marine at (6.7, 14.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.9, 15.6), 45/45 health, order: hold\n A2 marine at (8.3, 17.3), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.0s): A1 holding. No enemies seen; wait until all in range 5, then focus same target.\n A2 (0.0s): A2 holding. Will attack together once enemy is within 5 of all of us.\n A0 (0.5s): A0 holding. No enemies yet; will focus the same target once all in range.\n A1 (0.5s): A1 holding; no enemies visible yet. Will focus same target once all in range.\n A2 (0.5s): A2 holding. No enemies visible yet; will focus fire when all in range 5.\n A0 (1.0s): A0 holding. No enemies visible; will focus same target once all within 5.\n A1 (1.0s): A1 holding. No enemies visible; will focus same target once all in range 5.\n A2 (1.0s): A2 holding. Still no enemies; waiting until all in range 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A1 holding. Still no enemies; will focus same target once all in range 5.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-1760690927795f2dbe84c1fa.json b/examples/multi-agent-smax/results/llm-cache/ask-1760690927795f2dbe84c1fa.json new file mode 100644 index 00000000..300ca7df --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-1760690927795f2dbe84c1fa.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 1.5 seconds into the battle.\nYou are A1, a marine at (11.7, 15.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 15.\nYour team:\n A0 marine at (11.1, 16.0), 45/45 health, order: move 12 15\n A2 marine at (11.2, 14.9), 45/45 health, order: move 12 15\nEnemies you can see:\n E0 marine at (19.2, 15.0), 45/45 health, 7.5 away\n E1 marine at (19.7, 16.2), 45/45 health, 8.0 away\n E2 marine at (19.2, 14.3), 45/45 health, 7.6 away\nTeam chat (most recent last):\n A1 (0.0s): Moving east together toward enemies; stay within 2 of each other, attack same target.\n A2 (0.0s): Advancing east together to (12,15); stay within 2 of each other.\n A0 (0.5s): Converging on (12,15) with A1/A2; will attack same target together.\n A1 (0.5s): Moving to (12,15) with team; will attack same target together.\n A2 (0.5s): A2 moving to (12,15), staying close; will attack same target when enemies appear.\n A0 (1.0s): Continuing to (12,15); will attack together once enemies appear.\n A1 (1.0s): Continuing to (12,15) together; will attack same target when enemies appear.\n A2 (1.0s): A2 continuing to (12,15); will attack together when enemies appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 15\", \"say\": \"Advancing together to (14,15); all attack E0 once in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-1773c8a6ba16024334147f0f.json b/examples/multi-agent-smax/results/llm-cache/ask-1773c8a6ba16024334147f0f.json new file mode 100644 index 00000000..c2b5debd --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-1773c8a6ba16024334147f0f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 4.5 seconds into the battle.\nYou are A2, a marine at (13.0, 14.3) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (12.8, 15.9), 27/45 health, order: attack E1\n A1 marine at (13.0, 15.0), 9/45 health, order: attack E1\nEnemies you can see:\n E0 marine at (17.3, 15.0), 45/45 health, 4.4 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (3.0s): E2 dead. Focus E1 (closest, 3.8 away), all attack E1 together.\n A2 (3.0s): E2 is dead. Focus E1 (closest, 3.6 away), all together.\n A0 (3.5s): Attacking E1 (36hp), keep focusing until it dies.\n A1 (3.5s): Attacking E1 (36hp), keep focus until it dies.\n A2 (3.5s): Keep firing on E1, 36hp left. All together until it dies.\n A0 (4.0s): E1 at 18hp, keep focusing it until it dies, then E0.\n A1 (4.0s): E1 at 18hp, keep firing together until it dies.\n A2 (4.0s): E1 at 18hp, keep firing together until it dies, then E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E1 dead. All focus E0, 4.4 away, in range. Fire together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-17c6d6309e9fb72fc3ba4ca1.json b/examples/multi-agent-smax/results/llm-cache/ask-17c6d6309e9fb72fc3ba4ca1.json new file mode 100644 index 00000000..8827fcf2 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-17c6d6309e9fb72fc3ba4ca1.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.5 seconds into the battle.\nYou are A2, a marine at (7.1, 16.5) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (7.2, 15.7), 9/45 health, order: attack E0\n A1 marine at (6.5, 16.0), 45/45 health, order: attack E0\nEnemies you can see:\n E1 marine at (11.6, 16.0), 45/45 health, 4.5 away (in range)\n E2 marine at (11.8, 14.7), 27/45 health, 5.1 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (4.0s): Holding; E2 closest at 5.5, focus E2 once in range.\n A2 (4.0s): Holding. E2 at 5.1, about to enter range. Focus E2 together.\n A0 (4.5s): Firing E2 now, it's at 36 health. Everyone focus E2.\n A1 (4.5s): E0 in range at 4.6, I'm firing on E0. Focus E0 if in range.\n A2 (4.5s): E0 in range at 3.8; I focus E0, A0 on E2. Kill fast.\n A0 (5.0s): Switching to E0 with you both. Focus E0 down, then E2.\n A1 (5.0s): Focusing E0 (27hp) with A2; A0 on E2 is fine, then E1.\n A2 (5.0s): A2 firing E0 (27hp). A1 and I kill E0, A0 stays on E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E0 dead. Focus E2 (27hp) together, then E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-17ccf86f63097ae7f3856e4d.json b/examples/multi-agent-smax/results/llm-cache/ask-17ccf86f63097ae7f3856e4d.json new file mode 100644 index 00000000..9cbf65b3 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-17ccf86f63097ae7f3856e4d.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 5.5 seconds into the battle.\nYou are A2, a marine at (13.0, 14.3) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (12.8, 15.9), 27/45 health, order: attack E0\n A1: dead\nEnemies you can see:\n E0 marine at (17.3, 15.0), 18/45 health, 4.4 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (4.0s): E1 at 18hp, keep firing together until it dies.\n A2 (4.0s): E1 at 18hp, keep firing together until it dies, then E0.\n A0 (4.5s): E1 down. All attack E0 together, it's in range 4.6.\n A1 (4.5s): E1 dead. All focus E0, 45hp, firing together now.\n A2 (4.5s): E1 dead. All focus E0, 4.4 away, in range. Fire together.\n A0 (5.0s): E0 27hp, all fire together until it dies.\n A1 (5.0s): E0 at 27hp, keep firing together until it dies.\n A2 (5.0s): E0 27hp, keep firing together until it dies.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 at 18hp, keep firing together until it dies.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-195b436716c6658de4e6deb1.json b/examples/multi-agent-smax/results/llm-cache/ask-195b436716c6658de4e6deb1.json new file mode 100644 index 00000000..689e5ce5 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-195b436716c6658de4e6deb1.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 4.5 seconds into the battle.\nYou are A1, a marine at (8.3, 14.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (8.4, 15.6), 45/45 health, order: attack E0\n A2 marine at (8.3, 17.3), 9/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (11.9, 16.8), 27/45 health, 4.5 away (in range)\n E1 marine at (12.2, 16.1), 45/45 health, 4.4 away (in range)\n E2 marine at (12.3, 17.4), 45/45 health, 5.2 away\nTeam chat (most recent last):\n A1 (3.0s): A1 holding. E0 at 7.4; attack E0 together once within 5 of all.\n A2 (3.0s): A2 holding. E0 at 5.3 from me, 6.8+ from A0/A1. Wait for range 5.\n A0 (3.5s): A0 holding. E0 5.3 away; attack E0 together once within 5 of all.\n A1 (3.5s): A1 holding. E0 at 6.0; attack E0 together once within 5 of all.\n A2 (3.5s): E0 in range of me, firing now. A0/A1 close in and focus E0.\n A0 (4.0s): A2 engaged, A0 attacking E0 now. A1 attack E0 too, focus fire.\n A1 (4.0s): A2 is engaged; A1 attacking E0 now. A0 join and focus E0.\n A2 (4.0s): Engaged, all 3 enemies on me. A0 A1 attack E0 now, focus fire.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"A1 focusing E0 (27hp). A2 retreat, you're at 9hp.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-19defe0a3c24db977b0d0ea7.json b/examples/multi-agent-smax/results/llm-cache/ask-19defe0a3c24db977b0d0ea7.json new file mode 100644 index 00000000..f11efd02 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-19defe0a3c24db977b0d0ea7.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 5.0 seconds into the battle.\nYou are A2, a marine at (12.8, 14.9) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (14.3, 16.0), 18/45 health, order: attack E2\n A1: dead\nEnemies you can see:\n E1 marine at (16.5, 16.2), 45/45 health, 4.0 away (in range)\n E2 marine at (17.6, 14.3), 9/45 health, 4.8 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (3.0s): E0 is dead. Both attack E2 together, closest enemy; stay level with me.\n A2 (3.0s): E0 is dead. Everyone attack E2, it's in range.\n A0 (3.5s): Both on E2 together, then E1. Keep firing, no retreat.\n A2 (3.5s): Attacking E2 together; keep firing until it dies.\n A0 (4.0s): Keep firing on E2, then E1. No retreat.\n A2 (4.0s): Keep firing on E2 until dead, then E1.\n A0 (4.5s): E2 at 9hp, keep firing together, then E1.\n A2 (4.5s): E2 at 9hp, finish it now, then E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 at 9hp, keep firing together, then E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-1b36c3ccbe32c540d7be0997.json b/examples/multi-agent-smax/results/llm-cache/ask-1b36c3ccbe32c540d7be0997.json new file mode 100644 index 00000000..7d7c7e9a --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-1b36c3ccbe32c540d7be0997.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 2.0 seconds into the battle.\nYou are A2, a marine at (13.2, 17.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 17.\nYour team:\n A0 marine at (14.8, 18.0), 45/45 health, order: move 15 17\n A1 marine at (14.9, 17.2), 45/45 health, order: move 14 17\nEnemies you can see:\n E0 marine at (17.7, 16.4), 45/45 health, 4.7 away (in range)\n E1 marine at (18.5, 17.3), 45/45 health, 5.4 away\n E2 marine at (19.1, 14.8), 45/45 health, 6.6 away\nTeam chat (most recent last):\n A1 (0.5s): Moving east in formation at x=12; no one engages alone.\n A2 (0.5s): Moving east, staying close; A0 at 12,17 is my anchor point.\n A0 (1.0s): Advancing east together to x=14; will call attack when enemies appear.\n A1 (1.0s): Advancing east to 14,17 together; no one engages until all in range.\n A2 (1.0s): Moving east together to x=16; will attack same target once all in range.\n A0 (1.5s): Closing together toward E0; attack E0 once all three are within range 5.\n A1 (1.5s): Holding formation at 14,17; attack E0 together once all within range 5.\n A2 (1.5s): Regrouping at 14,17; closest enemy 6 away, hold formation, then attack E0 together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 is within range 5 of all three of us. Attack E0 now.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-1b76b099aa1e791b1bc01df9.json b/examples/multi-agent-smax/results/llm-cache/ask-1b76b099aa1e791b1bc01df9.json new file mode 100644 index 00000000..2f122ad6 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-1b76b099aa1e791b1bc01df9.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 6.0 seconds into the battle.\nYou are A0, a marine at (15.0, 18.1) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1: dead\n A2 marine at (14.6, 17.4), 9/45 health, order: attack E2\nEnemies you can see:\n E2 marine at (17.5, 14.8), 27/45 health, 4.2 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (4.0s): Keep focusing E1 (27hp), both firing together.\n A2 (4.0s): Focusing E1 (27hp), both in range. Keep firing, then E2.\n A0 (4.5s): E1 at 9hp, finish it now, then both focus E2.\n A2 (4.5s): E1 at 9hp, finishing it now. Then both on E2.\n A0 (5.0s): E1 dead. Both attack E2 now, A2 is closest so keep firing.\n A2 (5.0s): E1 down. Focus E2 together; I'm closest so I tank, A0 keep firing.\n A0 (5.5s): Attacking E2. A2 is closest and tanking, so keep firing until it dies.\n A2 (5.5s): Both firing on E2 now, keep attacking until it dies.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Attacking E2 (27hp). A2 is closest and tanking, so I keep firing.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-1c034b5f6480cf469028bd95.json b/examples/multi-agent-smax/results/llm-cache/ask-1c034b5f6480cf469028bd95.json new file mode 100644 index 00000000..490afb2b --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-1c034b5f6480cf469028bd95.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 6.0 seconds into the battle.\nYou are A2, a marine at (13.9, 16.5) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0: dead\n A1: dead\nEnemies you can see:\n E1 marine at (17.0, 15.6), 36/45 health, 3.2 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (3.5s): Both on E2, keep firing until it dies.\n A2 (3.5s): Attacking E2 with A0, keep focus until it dies.\n A0 (4.0s): Keep focus on E2, 27hp left, then E1 together.\n A2 (4.0s): E2 at 27hp, keep focus until dead, then E1.\n A0 (4.5s): E2 at 9hp, finish it together, then both on E1.\n A2 (4.5s): E2 at 9hp, finish it now. A0 stay put, then both on E1.\n A2 (5.0s): A2 alone now. Finishing E2 at 9hp, then E1.\n A2 (5.5s): E2 dead. A2 alone, attacking E1 at 3.2 range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A2 alone, 36hp vs E1 36hp, focusing E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-1c267986a60f497095560141.json b/examples/multi-agent-smax/results/llm-cache/ask-1c267986a60f497095560141.json new file mode 100644 index 00000000..ec73c8a5 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-1c267986a60f497095560141.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 7.0 seconds into the battle.\nYou are A1, a marine at (8.9, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E1 marine at (13.1, 16.8), 36/45 health, 5.0 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (5.5s): E2 at 18hp, all fire E2 now, then E1.\n A1 (5.5s): Firing E2 (18hp), then E1 together.\n A2 (5.5s): Keep firing E2 (18hp), then E1 together.\n A0 (6.0s): E2 at 9hp, finish it now, then E1. I'm low, 9hp.\n A1 (6.0s): E2 at 9hp, finish it now, then E1.\n A2 (6.0s): E2 at 9hp, finish it, then all on E1.\n A1 (6.5s): E2 dead. All focus E1, it's at 45hp, 5.0 away.\n A2 (6.5s): E2 dead. I'm at 9hp, backing off. A1 focus E1, I'll rejoin.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Engaging E1 at 36hp, in range. A2 stay back and heal up.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-1c439a4a932dd7bef1ec86c8.json b/examples/multi-agent-smax/results/llm-cache/ask-1c439a4a932dd7bef1ec86c8.json new file mode 100644 index 00000000..4654704b --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-1c439a4a932dd7bef1ec86c8.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 4.5 seconds into the battle.\nYou are A0, a marine at (14.6, 14.4) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1 marine at (15.1, 13.7), 45/45 health, order: attack E2\n A2: dead\nEnemies you can see:\n E1 marine at (18.0, 17.0), 45/45 health, 4.2 away (in range)\n E2 marine at (17.8, 15.5), 9/45 health, 3.3 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (3.0s): E0 at 9hp, finishing it now. Everyone keep focusing E0.\n A1 (3.0s): Attacking E0 (9hp), finish it then focus E2.\n A2 (3.0s): E0 at 9hp, finishing it now; then focus E2.\n A0 (3.5s): E0 dead. All focus E2 now, then E1.\n A1 (3.5s): E0 down. Everyone focus E2 (closest), then E1.\n A2 (3.5s): E0 down. Everyone focus E2 (3.0 away), then E1.\n A0 (4.0s): E2 at 18hp, keep focusing E2 then E1.\n A1 (4.0s): E2 at 18hp, keep focusing E2 then E1. Nobody retreat.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 at 9hp, finish it now, then E1. I'm low but still firing.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-1c801bed7e8224da7bbb7481.json b/examples/multi-agent-smax/results/llm-cache/ask-1c801bed7e8224da7bbb7481.json new file mode 100644 index 00000000..b65fded6 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-1c801bed7e8224da7bbb7481.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 7.5 seconds into the battle.\nYou are A1, a marine at (8.9, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E1 marine at (13.1, 16.8), 36/45 health, 5.0 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (5.5s): Focus E2 (18 hp), then E1. Keep firing.\n A2 (5.5s): Focus E2 (18hp), then E1. Keep firing.\n A0 (6.0s): E2 at 9hp, all fire now. I'm at 9hp, finish E2 then E1.\n A1 (6.0s): Firing E2 (9hp), then E1. A0 stay back, low hp.\n A2 (6.0s): E2 at 9hp, all fire E2 now, then E1.\n A1 (6.5s): E2 down. All fire E1, 45hp. A2 stay back, low hp.\n A2 (6.5s): E2 dead. Only E1 left. A1 tank and focus E1, I'm at 9hp and falling back.\n A1 (7.0s): Engaging E1 alone, 36hp. I'm at full health, firing.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Keep firing E1 at 36hp. I'm full health, holding the line.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-1cc9ce2d669a779abe059b38.json b/examples/multi-agent-smax/results/llm-cache/ask-1cc9ce2d669a779abe059b38.json new file mode 100644 index 00000000..70cab03e --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-1cc9ce2d669a779abe059b38.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 0.0 seconds into the battle.\nYou are A2, a marine at (7.4, 16.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.0, 15.6), 45/45 health, order: hold\n A1 marine at (8.1, 17.5), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 16.5\", \"say\": \"Moving east together toward center, stay close, all engage same enemy on contact.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-1d1273bd12cf79f2ab71db9f.json b/examples/multi-agent-smax/results/llm-cache/ask-1d1273bd12cf79f2ab71db9f.json new file mode 100644 index 00000000..c582ef4b --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-1d1273bd12cf79f2ab71db9f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.0 seconds into the battle.\nYou are A0, a marine at (7.2, 15.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (6.5, 16.0), 45/45 health, order: hold\n A2 marine at (7.1, 16.5), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (12.3, 17.7), 45/45 health, 5.4 away\n E1 marine at (13.1, 16.0), 45/45 health, 5.9 away\n E2 marine at (11.8, 14.7), 45/45 health, 4.7 away (in range)\nTeam chat (most recent last):\n A1 (2.5s): A1 holding in formation; all focus fire on closest enemy when seen.\n A2 (2.5s): A2 holding; will focus closest enemy when seen.\n A0 (3.0s): Enemies approaching at ~8 range; hold together, fire on closest when in range.\n A1 (3.0s): A1 holding; E2 seen east at 8.6. Let them come into range, focus closest.\n A2 (3.0s): A2 holding; enemies at 8 range, let them come in, focus closest.\n A0 (3.5s): Holding; E2 closest at 6.2. Focus E2 when in range.\n A1 (3.5s): A1 holding; fire on closest enemy once in range, E2 first.\n A2 (3.5s): A2 holding; enemies closing, fire on closest E2 when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 in range at 4.7; all focus fire E2 now.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-1d2c0682864b42eb7ddb9386.json b/examples/multi-agent-smax/results/llm-cache/ask-1d2c0682864b42eb7ddb9386.json new file mode 100644 index 00000000..3c239558 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-1d2c0682864b42eb7ddb9386.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 1.0 seconds into the battle.\nYou are A0, a marine at (10.7, 15.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 17.\nYour team:\n A1 marine at (10.3, 17.2), 45/45 health, order: move 12 17\n A2 marine at (10.7, 17.8), 45/45 health, order: move 12 17\nEnemies you can see:\n E2 marine at (18.9, 16.7), 45/45 health, 8.3 away\nTeam chat (most recent last):\n A0 (0.0s): Moving east together to find enemies; stay within 2 of each other, attack together.\n A1 (0.0s): Moving east together to find enemies; stay within 2 of each other, fire together.\n A2 (0.0s): Moving east together to find enemies; stay close, attack same target when in range.\n A0 (0.5s): Moving east in formation; will attack same target once all in range.\n A1 (0.5s): Moving east in a tight group; will attack same target together.\n A2 (0.5s): Moving east in formation; A0 and A1 keep pace, no one pull ahead.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 17\", \"say\": \"Advancing together toward E2; hold pace, attack same target once all in range 5.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-1d471bb688b859ae2b221a10.json b/examples/multi-agent-smax/results/llm-cache/ask-1d471bb688b859ae2b221a10.json new file mode 100644 index 00000000..434b67f5 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-1d471bb688b859ae2b221a10.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.5 seconds into the battle.\nYou are A2, a marine at (9.9, 15.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0: dead\n A1 marine at (10.1, 17.3), 45/45 health, order: attack E1\nEnemies you can see:\n E1 marine at (13.8, 17.3), 27/45 health, 4.2 away (in range)\n E2 marine at (14.4, 14.8), 45/45 health, 4.6 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (3.0s): E0 in range, attacking E0 now. Everyone focus E0.\n A2 (3.0s): Attacking E0 now, E0 in range. Everyone focus fire E0.\n A0 (3.5s): Keep focusing E0 (18hp), then E1.\n A1 (3.5s): Keep focusing E0, it's at 18 health. Then E1.\n A2 (3.5s): E0 at 18hp, keep focusing E0, then E2.\n A0 (4.0s): E0 dead. Focus E1 (3.6 away), then E2. I'm at 18hp.\n A1 (4.0s): E0 dead. Focus E1 (closest, 3.7 away), then E2.\n A2 (4.0s): E0 dead. Focus E1 (4.2 away), then E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Focusing E1 (27hp), then E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-1ddc45167b7aa47ff9523064.json b/examples/multi-agent-smax/results/llm-cache/ask-1ddc45167b7aa47ff9523064.json new file mode 100644 index 00000000..d443f50a --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-1ddc45167b7aa47ff9523064.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 9.0 seconds into the battle.\nYou are A1, a marine at (9.8, 14.2) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E2 marine at (10.8, 17.5), 18/45 health, 3.5 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (5.5s): A1 on E1 (18hp), in range. A0 keep firing, then both E2.\n A0 (6.0s): A0 9hp, finishing E1 (9hp). Then both E2.\n A1 (6.0s): A1 on E1 (9hp), finishing it. Then both on E2.\n A1 (6.5s): A1 alone vs E2 (45hp), engaging.\n A1 (7.0s): A1 last unit, fighting E2 (45hp) alone.\n A1 (7.5s): A1 last unit, 36hp vs E2 36hp, fighting to the end.\n A1 (8.0s): A1 last unit, 27hp vs E2 27hp, fighting to the end.\n A1 (8.5s): A1 27hp vs E2 18hp, fighting on, one enemy left.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"A1 18hp vs E2 18hp, last unit, finishing E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-1e14c4754c9422e798c10641.json b/examples/multi-agent-smax/results/llm-cache/ask-1e14c4754c9422e798c10641.json new file mode 100644 index 00000000..f561d906 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-1e14c4754c9422e798c10641.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.5 seconds into the battle.\nYou are A0, a marine at (8.5, 16.7) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1: dead\n A2 marine at (7.6, 17.8), 9/45 health, order: attack E2\nEnemies you can see:\n E1 marine at (12.3, 15.6), 36/45 health, 3.9 away (in range)\n E2 marine at (11.9, 17.7), 9/45 health, 3.5 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (5.0s): A0 on E2 (full hp). A1 stay back, low. A2 keep firing E2.\n A1 (5.0s): A1 low, shooting E2 from back. A0 you're tanking, focus E2.\n A2 (5.0s): A2 on E2, in range. A0 and A2 focus E2; A1 stay back.\n A0 (5.5s): A0 on E2 (27hp). Keep firing E2, then E1. A1 stay back.\n A1 (5.5s): A1 firing E2 from back; A0 is closest, keep tanking. Focus E2.\n A2 (5.5s): A2 on E2 (27hp), keep focusing. A1 stay back.\n A0 (6.0s): A0 on E2 (9hp), finishing it. Then all E1.\n A2 (6.0s): A2 on E2 (9hp), nearly dead. Then E1 together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"A0 finishing E2 now. Then all on E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-1e45a1e8c09cbe6568253393.json b/examples/multi-agent-smax/results/llm-cache/ask-1e45a1e8c09cbe6568253393.json new file mode 100644 index 00000000..08e1b6de --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-1e45a1e8c09cbe6568253393.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.5 seconds into the battle.\nYou are A0, a marine at (7.5, 15.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (7.2, 17.2), 45/45 health, order: hold\n A2 marine at (7.6, 17.8), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (14.3, 17.1), 45/45 health, 6.9 away\n E1 marine at (13.1, 17.1), 45/45 health, 5.7 away\n E2 marine at (11.0, 16.7), 45/45 health, 3.6 away (in range)\nTeam chat (most recent last):\n A1 (2.0s): E2 spotted east at 8.6 range. Holding grouped; focus E2 when in range.\n A2 (2.0s): E2 spotted at (15.8,16.7), 8 away. Holding grouped; focus E2 when in range.\n A0 (2.5s): E1, E2 approaching. Holding grouped; focus E2 when within 5.\n A1 (2.5s): E2 at 7 range. Holding grouped; focus E2 once in range.\n A2 (2.5s): E2 at 6.7, E1 behind. Holding grouped; focus closest when in range.\n A0 (3.0s): A0 holding; E2 at 5.2, focus E2 the moment it enters range.\n A1 (3.0s): E2 at 5.5, nearly in range. Holding; all focus E2 when it enters 5.\n A2 (3.0s): E2 at 5.1, nearly in range. Holding, all fire on E2 first.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 in range, all fire E2 now.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-1e6ea9f887741a3cf06d2d89.json b/examples/multi-agent-smax/results/llm-cache/ask-1e6ea9f887741a3cf06d2d89.json new file mode 100644 index 00000000..de2ca4fd --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-1e6ea9f887741a3cf06d2d89.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 0.5 seconds into the battle.\nYou are A0, a marine at (8.5, 16.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 16.\nYour team:\n A1 marine at (10.9, 14.9), 45/45 health, order: move 15 16\n A2 marine at (9.2, 17.8), 45/45 health, order: move 12 16\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Moving east together to (12,16); stay close, no one run ahead.\n A1 (0.0s): Moving together east to (15,16); stay within 2 of each other, attack same target.\n A2 (0.0s): Moving east together toward center, stay within 2 of each other; attack same target on contact.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 16\", \"say\": \"A1 please converge on (12,16) with us; A1 is ahead, stay within 2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-1ede459ea611188b27fedbc1.json b/examples/multi-agent-smax/results/llm-cache/ask-1ede459ea611188b27fedbc1.json new file mode 100644 index 00000000..e550a87c --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-1ede459ea611188b27fedbc1.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.0 seconds into the battle.\nYou are A1, a marine at (9.7, 17.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.4, 17.0), 45/45 health, order: hold\n A2 marine at (9.1, 16.8), 45/45 health, order: hold\nEnemies you can see:\n E1 marine at (16.9, 14.5), 45/45 health, 7.7 away\n E2 marine at (16.2, 17.2), 45/45 health, 6.5 away\nTeam chat (most recent last):\n A1 (0.5s): Falling back to cluster; hold together and focus the closest enemy.\n A2 (0.5s): A1 is ahead alone; moving up to group with A1, then focus nearest enemy.\n A0 (1.0s): Grouped at x=9; hold here and focus the closest enemy when seen.\n A1 (1.0s): Grouping at x=9; focus fire on nearest enemy when seen.\n A2 (1.0s): Holding at cluster near (9,16.7); focus fire on the closest enemy.\n A0 (1.5s): Holding at x=9 with cluster; focus fire on closest enemy when seen.\n A1 (1.5s): Holding at x=9; enemy E2 approaching, all focus the closest one.\n A2 (1.5s): E2 spotted east at 8.7 range; holding together, focus whatever enters range first.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding at x=9; shoot E2 when it enters range 5.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-1ef53ff29465495cbe96cea1.json b/examples/multi-agent-smax/results/llm-cache/ask-1ef53ff29465495cbe96cea1.json new file mode 100644 index 00000000..ca184d0b --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-1ef53ff29465495cbe96cea1.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 1.0 seconds into the battle.\nYou are A0, a marine at (10.4, 15.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 17.\nYour team:\n A1 marine at (9.7, 16.1), 45/45 health, order: move 12 17\n A2 marine at (10.1, 18.0), 45/45 health, order: move 12 17\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Moving east together to (12,17); stay within 2 of each other, then all attack same target.\n A1 (0.0s): Moving east together toward the center; stay within 2 of each other.\n A2 (0.0s): Advancing east together, stay within 2 of each other; attack same target when in range.\n A0 (0.5s): Continuing to (12,17); keep within 2 of each other.\n A1 (0.5s): Moving to (12,17) with A0; keep together, then focus same target.\n A2 (0.5s): Moving to (12,17) with A0; keep within 2, attack together when enemies appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 17\", \"say\": \"Continuing to (12,17) together; no enemies yet, attack same target when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-1efc32e33445660f58c1b7e2.json b/examples/multi-agent-smax/results/llm-cache/ask-1efc32e33445660f58c1b7e2.json new file mode 100644 index 00000000..03e888c6 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-1efc32e33445660f58c1b7e2.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 6.5 seconds into the battle.\nYou are A0, a marine at (15.0, 18.1) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1: dead\n A2 marine at (14.6, 17.4), 9/45 health, order: attack E2\nEnemies you can see:\n E2 marine at (17.5, 14.8), 18/45 health, 4.2 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (4.5s): E1 at 9hp, finish it now, then both focus E2.\n A2 (4.5s): E1 at 9hp, finishing it now. Then both on E2.\n A0 (5.0s): E1 dead. Both attack E2 now, A2 is closest so keep firing.\n A2 (5.0s): E1 down. Focus E2 together; I'm closest so I tank, A0 keep firing.\n A0 (5.5s): Attacking E2. A2 is closest and tanking, so keep firing until it dies.\n A2 (5.5s): Both firing on E2 now, keep attacking until it dies.\n A0 (6.0s): Attacking E2 (27hp). A2 is closest and tanking, so I keep firing.\n A2 (6.0s): E2 at 27hp. Both keep firing, two volleys should kill it.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 at 18hp, keep firing, one or two volleys finishes it.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-1f16af71e69279a24285671a.json b/examples/multi-agent-smax/results/llm-cache/ask-1f16af71e69279a24285671a.json new file mode 100644 index 00000000..73c327e8 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-1f16af71e69279a24285671a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.0 seconds into the battle.\nYou are A1, a marine at (8.5, 15.3) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.6, 16.9), 45/45 health, order: hold\n A2 marine at (6.5, 16.6), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (16.2, 15.1), 45/45 health, 7.7 away\nTeam chat (most recent last):\n A1 (0.5s): A1 holding; will focus fire on the closest enemy that appears.\n A2 (0.5s): No enemies yet; staying grouped, will focus the closest one when seen.\n A0 (1.0s): Still no enemies; holding grouped, focus closest when seen.\n A1 (1.0s): A1 holding; no enemies yet, will focus the closest when seen.\n A2 (1.0s): A2 holding; will focus the closest enemy when it appears.\n A0 (1.5s): A0 holding; still no enemies. Focus the closest when they appear.\n A1 (1.5s): A1 holding; no enemies yet, focus closest when seen.\n A2 (1.5s): A2 holding; will focus fire on the closest enemy when seen.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"E0 east at 7.7 away. Holding grouped; focus E0 when in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-1f487bfc0e0c070014356897.json b/examples/multi-agent-smax/results/llm-cache/ask-1f487bfc0e0c070014356897.json new file mode 100644 index 00000000..5c14c25f --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-1f487bfc0e0c070014356897.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.5 seconds into the battle.\nYou are A0, a marine at (9.3, 15.3) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1 marine at (8.3, 14.2), 45/45 health, order: attack E1\n A2: dead\nEnemies you can see:\n E1 marine at (12.2, 16.1), 18/45 health, 3.0 away (in range)\n E2 marine at (12.3, 17.5), 45/45 health, 3.8 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (4.0s): A0 attacking E0 (27hp); everyone keep focusing E0.\n A1 (4.0s): E0 out of my range; hitting E1 (in range). A0, A2 finish E0, then all E1.\n A2 (4.0s): A2 firing on E0 (27hp); finish it, then E1.\n A0 (4.5s): A0 firing E0 (18hp), finish it then E1.\n A1 (4.5s): A1 shooting E1 (36hp). E0 at 18hp, finish it, then all E1.\n A2 (4.5s): A2 9hp, still firing on E0 (18hp). A0 finish E0, then E1.\n A0 (5.0s): A0 firing E1 (27hp), A1 same. Focus E1 then E2.\n A1 (5.0s): A1 hitting E1 (27hp, in range). A0 switch to E1, then E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A0 18hp firing E1 (18hp). Finish E1, then all E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-1f79c1477beef72c4e2e63f5.json b/examples/multi-agent-smax/results/llm-cache/ask-1f79c1477beef72c4e2e63f5.json new file mode 100644 index 00000000..c43f1232 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-1f79c1477beef72c4e2e63f5.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 7.5 seconds into the battle.\nYou are A1, a marine at (8.0, 16.0) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E1 marine at (11.6, 16.0), 45/45 health, 3.5 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (5.5s): E0 is dead. Focus E2 (27hp), then E1. I'm at 9hp.\n A1 (5.5s): E0 down. Focus E2 (27hp), then E1. A0, stay back, you're low.\n A2 (5.5s): E0 dead. Focus E2 (27hp) together, then E1.\n A1 (6.0s): Focusing E2 (27hp), then E1. A2 stay behind me.\n A2 (6.0s): Focusing E2 (27hp), then E1. A1 keep firing.\n A1 (6.5s): Finishing E2 (9hp) now, then E1. A2 stay behind me.\n A2 (6.5s): E2 at 9hp, finishing it. A1 then focus E1.\n A1 (7.0s): E2 dead, A0 and A2 down. I'm alone on E1, 45hp each.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Last fight: A1 vs E1, 36hp vs 45hp. Fighting on.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-1f7decf3a298a6f222f3e67f.json b/examples/multi-agent-smax/results/llm-cache/ask-1f7decf3a298a6f222f3e67f.json new file mode 100644 index 00000000..ed3912b6 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-1f7decf3a298a6f222f3e67f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 8.5 seconds into the battle.\nYou are A1, a marine at (8.9, 14.1) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E1 marine at (13.1, 16.8), 18/45 health, 5.0 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (6.0s): E2 at 9hp, all fire now. I'm at 9hp, finish E2 then E1.\n A1 (6.0s): Firing E2 (9hp), then E1. A0 stay back, low hp.\n A2 (6.0s): E2 at 9hp, all fire E2 now, then E1.\n A1 (6.5s): E2 down. All fire E1, 45hp. A2 stay back, low hp.\n A2 (6.5s): E2 dead. Only E1 left. A1 tank and focus E1, I'm at 9hp and falling back.\n A1 (7.0s): Engaging E1 alone, 36hp. I'm at full health, firing.\n A1 (7.5s): Keep firing E1 at 36hp. I'm full health, holding the line.\n A1 (8.0s): A1 firing E1 at 27hp, last enemy. A0 and A2 stay back.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E1 at 18hp, still firing. Last enemy, A1 holding.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-1f91417e97eaa190ba0dd717.json b/examples/multi-agent-smax/results/llm-cache/ask-1f91417e97eaa190ba0dd717.json new file mode 100644 index 00000000..fab14063 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-1f91417e97eaa190ba0dd717.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.0 seconds into the battle.\nYou are A2, a marine at (7.1, 16.5) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (7.2, 15.7), 18/45 health, order: attack E2\n A1 marine at (6.5, 16.0), 45/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (10.7, 17.7), 27/45 health, 3.8 away (in range)\n E1 marine at (11.6, 16.0), 45/45 health, 4.5 away (in range)\n E2 marine at (11.8, 14.7), 27/45 health, 5.1 away\nTeam chat (most recent last):\n A1 (3.5s): A1 holding; fire on closest enemy once in range, E2 first.\n A2 (3.5s): A2 holding; enemies closing, fire on closest E2 when in range.\n A0 (4.0s): E2 in range at 4.7; all focus fire E2 now.\n A1 (4.0s): Holding; E2 closest at 5.5, focus E2 once in range.\n A2 (4.0s): Holding. E2 at 5.1, about to enter range. Focus E2 together.\n A0 (4.5s): Firing E2 now, it's at 36 health. Everyone focus E2.\n A1 (4.5s): E0 in range at 4.6, I'm firing on E0. Focus E0 if in range.\n A2 (4.5s): E0 in range at 3.8; I focus E0, A0 on E2. Kill fast.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"A2 firing E0 (27hp). A1 and I kill E0, A0 stays on E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-1fe276a55396926047481516.json b/examples/multi-agent-smax/results/llm-cache/ask-1fe276a55396926047481516.json new file mode 100644 index 00000000..654cde67 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-1fe276a55396926047481516.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 2.5 seconds into the battle.\nYou are A2, a marine at (14.9, 18.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 15 17.\nYour team:\n A0 marine at (13.7, 15.6), 36/45 health, order: attack E2\n A1 marine at (14.2, 16.3), 45/45 health, order: move 15 16\nEnemies you can see:\n E0 marine at (17.0, 17.7), 45/45 health, 2.1 away (in range)\n E1 marine at (17.9, 16.0), 45/45 health, 3.6 away (in range)\n E2 marine at (18.1, 14.7), 36/45 health, 4.6 away (in range)\nTeam chat (most recent last):\n A1 (1.0s): Continuing to (12,17), staying within 2 of A0 and A2.\n A2 (1.0s): Continuing to (12,17); no enemies yet, stay within 2, attack together.\n A0 (1.5s): Enemies E0, E2 east at ~8. Advance together to (15,16), then focus E2 together.\n A1 (1.5s): Enemy E2 at (19.7,14.7). Advancing together to 15,16; attack E2 when all in range.\n A2 (1.5s): Enemies ~8 east. Advancing together to x=15; stay within 2, then focus E0.\n A0 (2.0s): E2 in my range, firing now. A1, A2 close in and focus E2.\n A1 (2.0s): Moving with you to 15,16; next tick all attack E2 together.\n A2 (2.0s): Closing to 15,17 together; once all in range 5, everyone attack E0 same tick.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"All in range now. Focus E2 (36hp), everyone attack E2 this tick.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-205320454ba86af6cc730563.json b/examples/multi-agent-smax/results/llm-cache/ask-205320454ba86af6cc730563.json new file mode 100644 index 00000000..bab8efae --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-205320454ba86af6cc730563.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.0 seconds into the battle.\nYou are A1, a marine at (8.9, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (9.0, 16.0), 45/45 health, order: move 9.3 15\n A2 marine at (9.3, 14.8), 45/45 health, order: move 11 15\nEnemies you can see:\n E0 marine at (15.6, 16.4), 45/45 health, 7.1 away\n E1 marine at (16.2, 16.8), 45/45 health, 7.8 away\n E2 marine at (16.2, 15.5), 45/45 health, 7.4 away\nTeam chat (most recent last):\n A1 (1.5s): Still holding; will focus fire on closest enemy when visible.\n A2 (1.5s): Holding grouped; focus fire on closest enemy when it appears.\n A0 (2.0s): No contact; advancing east to center together. Stay close, focus closest enemy.\n A1 (2.0s): No contact; advancing east together to find enemies. Stay grouped, focus closest.\n A2 (2.0s): Holding grouped; focus fire closest enemy when it appears.\n A0 (2.5s): Enemies 3 at east, ~7 away. Falling back to group; hold and focus E0 when in range.\n A1 (2.5s): Enemies E0, E2 east ~9 away. Holding grouped; focus E0 when in range.\n A2 (2.5s): Advancing east to join A0/A1; stay grouped, focus closest enemy.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding grouped. Enemies ~7 away; let them come into range, focus E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-20a2f56a15af1aa5f22aba18.json b/examples/multi-agent-smax/results/llm-cache/ask-20a2f56a15af1aa5f22aba18.json new file mode 100644 index 00000000..ac494225 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-20a2f56a15af1aa5f22aba18.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 3.5 seconds into the battle.\nYou are A2, a marine at (14.1, 16.4) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (13.6, 17.1), 18/45 health, order: attack E1\n A1 marine at (13.2, 15.3), 27/45 health, order: attack E1\nEnemies you can see:\n E1 marine at (17.6, 16.5), 18/45 health, 3.5 away (in range)\n E2 marine at (17.5, 17.3), 45/45 health, 3.5 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (2.0s): Focusing E0 (27hp). A2 get in range and attack E0.\n A2 (2.0s): Attacking E0 now, closing in with you both.\n A0 (2.5s): E0 at 9hp, finish it now; then focus E2.\n A1 (2.5s): E0 at 9hp, finishing it now; then everyone focus E1.\n A2 (2.5s): E0 at 9hp in range, firing on E0 now.\n A0 (3.0s): E0 dead. Everyone focus E1 now, same target, no retreating.\n A1 (3.0s): E0 dead. Everyone focus E1 now, same tick; then E2.\n A2 (3.0s): E0 dead. Everyone focus E1 now, then E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Attacking E1 (18hp) now, then E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-20c6f66f2c42b0ec53c8f493.json b/examples/multi-agent-smax/results/llm-cache/ask-20c6f66f2c42b0ec53c8f493.json new file mode 100644 index 00000000..f9f09684 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-20c6f66f2c42b0ec53c8f493.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.5 seconds into the battle.\nYou are A0, a marine at (7.5, 15.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1 marine at (7.2, 17.2), 45/45 health, order: attack E2\n A2 marine at (7.6, 17.8), 18/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (11.7, 17.0), 45/45 health, 4.4 away (in range)\n E1 marine at (11.0, 17.2), 45/45 health, 3.8 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (3.0s): E2 at 5.5, nearly in range. Holding; all focus E2 when it enters 5.\n A2 (3.0s): E2 at 5.1, nearly in range. Holding, all fire on E2 first.\n A0 (3.5s): E2 in range, all fire E2 now.\n A1 (3.5s): E2 in range at 3.9. Everyone fire on E2.\n A2 (3.5s): E2 in range at 3.6, all fire E2 now.\n A0 (4.0s): Firing E2 (18hp left); then E1.\n A1 (4.0s): Keep firing E2 (18hp), then E1.\n A2 (4.0s): Keep firing E2, it's at 18 HP. Then focus E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E2 down. Focus E1 (closest), then E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-20d2530f65b7dd59c6d0e53e.json b/examples/multi-agent-smax/results/llm-cache/ask-20d2530f65b7dd59c6d0e53e.json new file mode 100644 index 00000000..c3ba59b6 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-20d2530f65b7dd59c6d0e53e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 5.5 seconds into the battle.\nYou are A0, a marine at (15.0, 18.1) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1: dead\n A2 marine at (14.6, 17.4), 18/45 health, order: attack E2\nEnemies you can see:\n E2 marine at (17.5, 14.8), 45/45 health, 4.2 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (3.5s): Focusing E1 together, A2 keep firing. A1 stay back.\n A2 (3.5s): Attacking E1 with A0. A1 stay back.\n A0 (4.0s): Keep focusing E1 (27hp), both firing together.\n A2 (4.0s): Focusing E1 (27hp), both in range. Keep firing, then E2.\n A0 (4.5s): E1 at 9hp, finish it now, then both focus E2.\n A2 (4.5s): E1 at 9hp, finishing it now. Then both on E2.\n A0 (5.0s): E1 dead. Both attack E2 now, A2 is closest so keep firing.\n A2 (5.0s): E1 down. Focus E2 together; I'm closest so I tank, A0 keep firing.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Attacking E2. A2 is closest and tanking, so keep firing until it dies.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-20e6fd53b9646e93dd0d7233.json b/examples/multi-agent-smax/results/llm-cache/ask-20e6fd53b9646e93dd0d7233.json new file mode 100644 index 00000000..587d5093 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-20e6fd53b9646e93dd0d7233.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 0.0 seconds into the battle.\nYou are A2, a marine at (6.5, 14.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.1, 17.4), 45/45 health, order: hold\n A1 marine at (8.3, 14.1), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 15\", \"say\": \"Advancing east together to (12,15); stay within 2 of each other.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-217b99393747086d39f160be.json b/examples/multi-agent-smax/results/llm-cache/ask-217b99393747086d39f160be.json new file mode 100644 index 00000000..28c19630 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-217b99393747086d39f160be.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.0 seconds into the battle.\nYou are A2, a marine at (8.2, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.8, 14.7), 45/45 health, order: hold\n A1 marine at (8.5, 14.8), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (14.2, 15.0), 45/45 health, 6.0 away\n E1 marine at (15.0, 14.0), 45/45 health, 6.8 away\n E2 marine at (13.4, 16.8), 45/45 health, 5.8 away\nTeam chat (most recent last):\n A1 (1.5s): A1 holding at cluster; focus fire on closest enemy when seen.\n A2 (1.5s): A2 holding at (8,14). Clustered; focus fire on closest enemy.\n A0 (2.0s): A0 holding; no enemies seen. Focus closest when they appear.\n A1 (2.0s): Holding cluster; let them walk into range, then focus closest enemy.\n A2 (2.0s): E2 spotted east at 8.7 range. Holding cluster; let them come, focus first in range.\n A0 (2.5s): Enemies approaching; hold cluster, all focus whichever enemy enters range first.\n A1 (2.5s): Holding. Enemies closing; all focus closest enemy once in range 5.\n A2 (2.5s): A2 holding. Enemies approaching; focus closest once in range 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding. E2 closest at 5.8; focus whoever enters range 5 first.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-218b4649552a38c17e839d26.json b/examples/multi-agent-smax/results/llm-cache/ask-218b4649552a38c17e839d26.json new file mode 100644 index 00000000..7e16777a --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-218b4649552a38c17e839d26.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.0 seconds into the battle.\nYou are A1, a marine at (6.8, 14.1) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: retreat.\nYour team:\n A0 marine at (8.1, 15.8), 27/45 health, order: attack E1\n A2 marine at (8.1, 14.9), 45/45 health, order: attack E1\nEnemies you can see:\n E0 marine at (12.9, 15.0), 45/45 health, 6.2 away\n E1 marine at (11.8, 16.2), 45/45 health, 5.5 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (3.5s): Focus E2 now, then E0. Everyone fire.\n A2 (3.5s): Focusing E2 now, then E0. All fire E2.\n A0 (4.0s): E2 is at 18 HP, finish it, then E1.\n A1 (4.0s): Firing E2 (18hp). Then E0. I'm at 27hp.\n A2 (4.0s): Firing E2 (18 hp left), then E0. Stay grouped.\n A0 (4.5s): E2 is down. Focus E1 (closest), then E0. A1 fall back if hurt.\n A1 (4.5s): A1 at 9hp, falling back. Focus E1 (closest to A0), then E0.\n A2 (4.5s): E2 is dead. Focus E1 (closest, 3.9 away), then E0. A1 is at 9hp, so stay behind.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"retreat\", \"say\": \"A1 at 9hp staying back. Focus E1 then E0, keep grouped.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-220044057239a787f3141fd6.json b/examples/multi-agent-smax/results/llm-cache/ask-220044057239a787f3141fd6.json new file mode 100644 index 00000000..1e3c5646 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-220044057239a787f3141fd6.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 3.5 seconds into the battle.\nYou are A2, a marine at (14.6, 17.4) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (15.0, 18.1), 36/45 health, order: attack E1\n A1: dead\nEnemies you can see:\n E1 marine at (18.5, 17.3), 45/45 health, 3.9 away (in range)\n E2 marine at (17.5, 14.8), 45/45 health, 3.9 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (2.0s): E0 is within range 5 of all three of us. Everyone attack E0 now.\n A1 (2.0s): E0 is in range of all three. Attack E0 now, together.\n A2 (2.0s): E0 is within range 5 of all three of us. Attack E0 now.\n A0 (2.5s): Focus E0 (18hp). A1 at 18hp, retreat if under 20 per rules.\n A1 (2.5s): A1 at 18hp, retreating to stop being the closest target. A0, A2 focus E0.\n A2 (2.5s): Attacking E0 now; A1 under 20hp, retreat if needed.\n A0 (3.0s): E0 dead. A2 attack E1 now, it's in my range. A1 stay back.\n A2 (3.0s): E0 dead. A0, A2 focus E1 together now; A1 stay back.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Attacking E1 with A0. A1 stay back.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-22133ea355a9c9e998f6a86d.json b/examples/multi-agent-smax/results/llm-cache/ask-22133ea355a9c9e998f6a86d.json new file mode 100644 index 00000000..58ebec71 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-22133ea355a9c9e998f6a86d.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 0.0 seconds into the battle.\nYou are A1, a marine at (7.4, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (9.0, 16.0), 45/45 health, order: hold\n A2 marine at (7.7, 14.8), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 15\", \"say\": \"Moving east together toward center, stay within 2 of each other.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-223e0ec95abefdfda9c5ff59.json b/examples/multi-agent-smax/results/llm-cache/ask-223e0ec95abefdfda9c5ff59.json new file mode 100644 index 00000000..dfe03fd4 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-223e0ec95abefdfda9c5ff59.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 5.5 seconds into the battle.\nYou are A0, a marine at (12.8, 15.9) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1: dead\n A2 marine at (13.0, 14.3), 18/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (17.3, 15.0), 18/45 health, 4.6 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (4.0s): E1 at 18hp, keep firing together until it dies.\n A2 (4.0s): E1 at 18hp, keep firing together until it dies, then E0.\n A0 (4.5s): E1 down. All attack E0 together, it's in range 4.6.\n A1 (4.5s): E1 dead. All focus E0, 45hp, firing together now.\n A2 (4.5s): E1 dead. All focus E0, 4.4 away, in range. Fire together.\n A0 (5.0s): E0 27hp, all fire together until it dies.\n A1 (5.0s): E0 at 27hp, keep firing together until it dies.\n A2 (5.0s): E0 27hp, keep firing together until it dies.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 18hp, keep firing together until it dies.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-232b3a49dfed3cd93ce413f9.json b/examples/multi-agent-smax/results/llm-cache/ask-232b3a49dfed3cd93ce413f9.json new file mode 100644 index 00000000..e778b429 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-232b3a49dfed3cd93ce413f9.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 9.5 seconds into the battle.\nYou are A1, a marine at (8.9, 14.1) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E1 marine at (13.1, 16.8), 9/45 health, 5.0 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A2 (6.0s): E2 at 9hp, all fire E2 now, then E1.\n A1 (6.5s): E2 down. All fire E1, 45hp. A2 stay back, low hp.\n A2 (6.5s): E2 dead. Only E1 left. A1 tank and focus E1, I'm at 9hp and falling back.\n A1 (7.0s): Engaging E1 alone, 36hp. I'm at full health, firing.\n A1 (7.5s): Keep firing E1 at 36hp. I'm full health, holding the line.\n A1 (8.0s): A1 firing E1 at 27hp, last enemy. A0 and A2 stay back.\n A1 (8.5s): E1 at 18hp, still firing. Last enemy, A1 holding.\n A1 (9.0s): A1 firing E1 at 18hp, last enemy. Staying on it.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A1 at 18hp, E1 at 9hp, last enemy. Still firing.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-235c8dbee18e3a0724281ae8.json b/examples/multi-agent-smax/results/llm-cache/ask-235c8dbee18e3a0724281ae8.json new file mode 100644 index 00000000..17f8e683 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-235c8dbee18e3a0724281ae8.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.5 seconds into the battle.\nYou are A1, a marine at (8.3, 14.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E2 marine at (12.3, 17.5), 45/45 health, 5.3 away\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (4.5s): A1 shooting E1 (36hp). E0 at 18hp, finish it, then all E1.\n A2 (4.5s): A2 9hp, still firing on E0 (18hp). A0 finish E0, then E1.\n A0 (5.0s): A0 firing E1 (27hp), A1 same. Focus E1 then E2.\n A1 (5.0s): A1 hitting E1 (27hp, in range). A0 switch to E1, then E2.\n A0 (5.5s): A0 18hp firing E1 (18hp). Finish E1, then all E2.\n A1 (5.5s): A1 on E1 (18hp). A0 keep firing E1, then E2.\n A0 (6.0s): A0 9hp, finishing E1 (9hp). Then focus E2 together.\n A1 (6.0s): A1 on E1 (9hp), finishing it. Then all E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"A1 alone vs E2 (45hp), engaging.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-235f3dfebb8eaa3440f5e87f.json b/examples/multi-agent-smax/results/llm-cache/ask-235f3dfebb8eaa3440f5e87f.json new file mode 100644 index 00000000..d87a0d23 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-235f3dfebb8eaa3440f5e87f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.0 seconds into the battle.\nYou are A2, a marine at (7.4, 16.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.0, 15.6), 45/45 health, order: hold\n A1 marine at (8.1, 17.5), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding together; focus fire on the closest enemy when they appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-23db4dda4c96178f3ffe1cf6.json b/examples/multi-agent-smax/results/llm-cache/ask-23db4dda4c96178f3ffe1cf6.json new file mode 100644 index 00000000..e9581959 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-23db4dda4c96178f3ffe1cf6.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.0 seconds into the battle.\nYou are A1, a marine at (10.1, 17.3) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0: dead\n A2 marine at (9.9, 15.8), 27/45 health, order: attack E2\nEnemies you can see:\n E2 marine at (14.4, 14.8), 36/45 health, 5.0 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (4.0s): E0 dead. Focus E1 (closest, 3.7 away), then E2.\n A2 (4.0s): E0 dead. Focus E1 (4.2 away), then E2.\n A1 (4.5s): Focusing E1 (27hp), then E2.\n A2 (4.5s): Focusing E1 (27hp), then E2.\n A1 (5.0s): Focusing E1 (18hp), almost dead. Then E2.\n A2 (5.0s): Attacking E1 (18hp), then E2.\n A1 (5.5s): E1 down. All focus E2 (45hp), 5.0 away.\n A2 (5.5s): E1 down. All focus E2, 4.6 away, 45hp.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Focusing E2 (36hp), keep firing.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-241a59c9ceff3dffb7f68729.json b/examples/multi-agent-smax/results/llm-cache/ask-241a59c9ceff3dffb7f68729.json new file mode 100644 index 00000000..efa6562f --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-241a59c9ceff3dffb7f68729.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.0 seconds into the battle.\nYou are A2, a marine at (9.4, 16.4) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0: dead\n A1 marine at (8.5, 15.3), 27/45 health, order: attack E2\nEnemies you can see:\n E2 marine at (12.8, 17.3), 36/45 health, 3.5 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (4.5s): E0 dead. A0 on E2, all focus E2 please.\n A1 (4.5s): E0 dead. Focus E1 (4.5 away), then E2.\n A2 (4.5s): E0 dead. A2 focusing E1, everyone focus E1 then E2.\n A0 (5.0s): A0 switching to E1 (27hp), focus fire. A2 is tanking.\n A1 (5.0s): A1 on E1 (27hp), focus fire. A0 hurt, fall back if needed.\n A2 (5.0s): A2 on E1 (27hp), in range. A0 retreat if low, A1 focus E1.\n A1 (5.5s): E1 down. All focus E2, 4.8 away, in range.\n A2 (5.5s): A2 on E2 (45hp, in range). A1 focus E2, last enemy.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"A2 on E2 (36hp), in range. A1 keep firing, last enemy.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-247c8678fe8ced03f24f5ab5.json b/examples/multi-agent-smax/results/llm-cache/ask-247c8678fe8ced03f24f5ab5.json new file mode 100644 index 00000000..2923b8e3 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-247c8678fe8ced03f24f5ab5.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.0 seconds into the battle.\nYou are A2, a marine at (7.6, 17.8) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (7.5, 15.8), 45/45 health, order: attack E2\n A1 marine at (7.2, 17.2), 45/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (12.7, 17.1), 45/45 health, 5.2 away\n E1 marine at (11.6, 17.1), 45/45 health, 4.0 away (in range)\n E2 marine at (11.0, 16.7), 18/45 health, 3.6 away (in range)\nTeam chat (most recent last):\n A1 (2.5s): E2 at 7 range. Holding grouped; focus E2 once in range.\n A2 (2.5s): E2 at 6.7, E1 behind. Holding grouped; focus closest when in range.\n A0 (3.0s): A0 holding; E2 at 5.2, focus E2 the moment it enters range.\n A1 (3.0s): E2 at 5.5, nearly in range. Holding; all focus E2 when it enters 5.\n A2 (3.0s): E2 at 5.1, nearly in range. Holding, all fire on E2 first.\n A0 (3.5s): E2 in range, all fire E2 now.\n A1 (3.5s): E2 in range at 3.9. Everyone fire on E2.\n A2 (3.5s): E2 in range at 3.6, all fire E2 now.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Keep firing E2, it's at 18 HP. Then focus E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-24828a7847e21f9aa4b6289e.json b/examples/multi-agent-smax/results/llm-cache/ask-24828a7847e21f9aa4b6289e.json new file mode 100644 index 00000000..52867340 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-24828a7847e21f9aa4b6289e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 3.5 seconds into the battle.\nYou are A1, a marine at (15.1, 13.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (14.6, 14.4), 27/45 health, order: attack E0\n A2 marine at (14.8, 15.1), 9/45 health, order: attack E0\nEnemies you can see:\n E1 marine at (18.0, 17.0), 45/45 health, 4.3 away (in range)\n E2 marine at (17.8, 15.5), 45/45 health, 3.2 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (2.0s): Closing on E0 together; once all within 5, everyone attacks E0 same tick.\n A2 (2.0s): Attacking E0 now; A0 is already in range, A1 close up and focus E0.\n A0 (2.5s): Focusing E0; A1 attack E0 now, all in range.\n A1 (2.5s): In range of all; attacking E0 now.\n A2 (2.5s): Focusing E0 (36hp). A1 attack E0 now, all in range.\n A0 (3.0s): E0 at 9hp, finishing it now. Everyone keep focusing E0.\n A1 (3.0s): Attacking E0 (9hp), finish it then focus E2.\n A2 (3.0s): E0 at 9hp, finishing it now; then focus E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E0 down. Everyone focus E2 (closest), then E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-2492e9fccd9b4caee5a51d55.json b/examples/multi-agent-smax/results/llm-cache/ask-2492e9fccd9b4caee5a51d55.json new file mode 100644 index 00000000..86820412 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-2492e9fccd9b4caee5a51d55.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.0 seconds into the battle.\nYou are A1, a marine at (7.2, 17.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (7.5, 15.8), 45/45 health, order: attack E1\n A2: dead\nEnemies you can see:\n E0 marine at (11.7, 17.0), 45/45 health, 4.6 away (in range)\n E1 marine at (11.0, 17.2), 27/45 health, 3.9 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (3.5s): E2 in range at 3.9. Everyone fire on E2.\n A2 (3.5s): E2 in range at 3.6, all fire E2 now.\n A0 (4.0s): Firing E2 (18hp left); then E1.\n A1 (4.0s): Keep firing E2 (18hp), then E1.\n A2 (4.0s): Keep firing E2, it's at 18 HP. Then focus E1.\n A0 (4.5s): E2 down. Focus E1 (closest), then E0.\n A1 (4.5s): E2 down. Focus E1 (closest, 3.9 away), then E0.\n A2 (4.5s): E2 down. Focus E1 (closest, 3.5 away), then E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Firing E1 (27hp), then E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-24c39313db8146aee26c2d61.json b/examples/multi-agent-smax/results/llm-cache/ask-24c39313db8146aee26c2d61.json new file mode 100644 index 00000000..a1782dbd --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-24c39313db8146aee26c2d61.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 0.0 seconds into the battle.\nYou are A1, a marine at (9.8, 15.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.2, 16.2), 45/45 health, order: hold\n A2 marine at (9.0, 16.2), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 16\", \"say\": \"Moving east together toward enemies, stay within 2 of each other; attack same target on contact.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-24df835417c954a3b66a46ff.json b/examples/multi-agent-smax/results/llm-cache/ask-24df835417c954a3b66a46ff.json new file mode 100644 index 00000000..2f5bdff9 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-24df835417c954a3b66a46ff.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 2.0 seconds into the battle.\nYou are A2, a marine at (12.7, 16.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 16.\nYour team:\n A0 marine at (13.4, 16.9), 45/45 health, order: attack E0\n A1 marine at (13.2, 15.3), 36/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (17.8, 15.1), 27/45 health, 5.3 away\n E1 marine at (17.7, 16.7), 45/45 health, 5.0 away\n E2 marine at (19.0, 17.1), 45/45 health, 6.3 away\nTeam chat (most recent last):\n A1 (0.5s): Continuing east to (14,16), staying close to A0 and A2.\n A2 (0.5s): Moving to (14,16) with A0 and A1, staying close; will focus the first enemy seen.\n A0 (1.0s): Enemy E0 seen east at 7.8. Keep grouped; attack E0 together when within range.\n A1 (1.0s): E0 spotted east at (19.3,15.1). Keep moving together; attack when in range 5 of all.\n A2 (1.0s): A2 continuing to (14,16), staying close; will focus first enemy seen.\n A0 (1.5s): E0 in range of A0 and A1. Attack E0 now; A2 close in and focus E0.\n A1 (1.5s): E0 in range of A1 and A0. A2 close in, everyone focus E0 now.\n A2 (1.5s): E0 at 6.7, not in range yet. Moving up together; attack E0 on same tick.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Attacking E0 now, closing in with you both.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-24ec7953cacf7e115dee5e9f.json b/examples/multi-agent-smax/results/llm-cache/ask-24ec7953cacf7e115dee5e9f.json new file mode 100644 index 00000000..a800c1b3 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-24ec7953cacf7e115dee5e9f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.0 seconds into the battle.\nYou are A2, a marine at (8.6, 16.5) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0: dead\n A1 marine at (8.0, 16.0), 45/45 health, order: attack E2\nEnemies you can see:\n E1 marine at (11.6, 16.0), 45/45 health, 3.0 away (in range)\n E2 marine at (11.8, 14.7), 27/45 health, 3.7 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (4.5s): E0 in range at 4.6, I'm firing on E0. Focus E0 if in range.\n A2 (4.5s): E0 in range at 3.8; I focus E0, A0 on E2. Kill fast.\n A0 (5.0s): Switching to E0 with you both. Focus E0 down, then E2.\n A1 (5.0s): Focusing E0 (27hp) with A2; A0 on E2 is fine, then E1.\n A2 (5.0s): A2 firing E0 (27hp). A1 and I kill E0, A0 stays on E2.\n A0 (5.5s): E0 is dead. Focus E2 (27hp), then E1. I'm at 9hp.\n A1 (5.5s): E0 down. Focus E2 (27hp), then E1. A0, stay back, you're low.\n A2 (5.5s): E0 dead. Focus E2 (27hp) together, then E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Focusing E2 (27hp), then E1. A1 keep firing.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-24f21cf58c1bc6b0cc595266.json b/examples/multi-agent-smax/results/llm-cache/ask-24f21cf58c1bc6b0cc595266.json new file mode 100644 index 00000000..78127570 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-24f21cf58c1bc6b0cc595266.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.5 seconds into the battle.\nYou are A1, a marine at (7.8, 14.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.9, 16.7), 45/45 health, order: hold\n A2 marine at (7.6, 17.8), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (14.5, 15.3), 45/45 health, 6.7 away\nTeam chat (most recent last):\n A1 (1.0s): A1 holding; will focus closest enemy. Staying near A0 and A2.\n A2 (1.0s): A2 holding; no enemies seen yet, will focus closest when they appear.\n A0 (1.5s): A0 holding. Stay clustered; focus fire on closest enemy when seen.\n A1 (1.5s): A1 moving to cluster with A0/A2; holding together, focus closest enemy.\n A2 (1.5s): A2 holding; no enemies yet. Focus closest when they appear.\n A0 (2.0s): A0 holding. Focus closest enemy when seen; stay tight.\n A1 (2.0s): A1 holding near cluster; E0 spotted east at (16,15.3). Focus E0 when in range.\n A2 (2.0s): E0 seen east at 16,15. Holding clustered; focus E0 when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A1 holding; E0 approaching, focus fire when in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-25a6d511b7cc6faf1c261c01.json b/examples/multi-agent-smax/results/llm-cache/ask-25a6d511b7cc6faf1c261c01.json new file mode 100644 index 00000000..81055df1 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-25a6d511b7cc6faf1c261c01.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 5.5 seconds into the battle.\nYou are A1, a marine at (8.3, 14.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (8.4, 15.6), 27/45 health, order: attack E0\n A2: dead\nEnemies you can see:\n E1 marine at (12.2, 16.1), 45/45 health, 4.4 away (in range)\n E2 marine at (12.3, 17.4), 45/45 health, 5.2 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (4.0s): A2 engaged, A0 attacking E0 now. A1 attack E0 too, focus fire.\n A1 (4.0s): A2 is engaged; A1 attacking E0 now. A0 join and focus E0.\n A2 (4.0s): Engaged, all 3 enemies on me. A0 A1 attack E0 now, focus fire.\n A0 (4.5s): Focus E0 (27hp). A2 at 9hp, retreat to draw fire away if possible.\n A1 (4.5s): A1 focusing E0 (27hp). A2 retreat, you're at 9hp.\n A2 (4.5s): A2 at 9hp retreating. A0 A1 keep focus on E0, it has 27hp.\n A0 (5.0s): E0 at 9hp, finishing it now. A1 focus E0.\n A1 (5.0s): A1 firing on E0 (9hp), finish it then focus E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E0 down. Focus E1 (4.4 away, in range) now, both of us.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-26120497663aca6290336db5.json b/examples/multi-agent-smax/results/llm-cache/ask-26120497663aca6290336db5.json new file mode 100644 index 00000000..9c4ff694 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-26120497663aca6290336db5.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 4.5 seconds into the battle.\nYou are A1, a marine at (15.1, 13.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (14.6, 14.4), 18/45 health, order: attack E2\n A2: dead\nEnemies you can see:\n E1 marine at (18.0, 17.0), 45/45 health, 4.3 away (in range)\n E2 marine at (17.8, 15.5), 9/45 health, 3.2 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (3.0s): E0 at 9hp, finishing it now. Everyone keep focusing E0.\n A1 (3.0s): Attacking E0 (9hp), finish it then focus E2.\n A2 (3.0s): E0 at 9hp, finishing it now; then focus E2.\n A0 (3.5s): E0 dead. All focus E2 now, then E1.\n A1 (3.5s): E0 down. Everyone focus E2 (closest), then E1.\n A2 (3.5s): E0 down. Everyone focus E2 (3.0 away), then E1.\n A0 (4.0s): E2 at 18hp, keep focusing E2 then E1.\n A1 (4.0s): E2 at 18hp, keep focusing E2 then E1. Nobody retreat.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 at 9hp, finishing it. Then E1. A0 stay in, no retreat.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-2722851898ccb00a32aeeccb.json b/examples/multi-agent-smax/results/llm-cache/ask-2722851898ccb00a32aeeccb.json new file mode 100644 index 00000000..274b4cad --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-2722851898ccb00a32aeeccb.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 4.5 seconds into the battle.\nYou are A1, a marine at (13.0, 15.0) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (12.8, 15.9), 27/45 health, order: attack E1\n A2 marine at (13.0, 14.3), 18/45 health, order: attack E1\nEnemies you can see:\n E0 marine at (17.3, 15.0), 45/45 health, 4.4 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (3.0s): E2 dead. Focus E1 (closest, 3.8 away), all attack E1 together.\n A2 (3.0s): E2 is dead. Focus E1 (closest, 3.6 away), all together.\n A0 (3.5s): Attacking E1 (36hp), keep focusing until it dies.\n A1 (3.5s): Attacking E1 (36hp), keep focus until it dies.\n A2 (3.5s): Keep firing on E1, 36hp left. All together until it dies.\n A0 (4.0s): E1 at 18hp, keep focusing it until it dies, then E0.\n A1 (4.0s): E1 at 18hp, keep firing together until it dies.\n A2 (4.0s): E1 at 18hp, keep firing together until it dies, then E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E1 dead. All focus E0, 45hp, firing together now.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-27241fe73a62b4100a340ccd.json b/examples/multi-agent-smax/results/llm-cache/ask-27241fe73a62b4100a340ccd.json new file mode 100644 index 00000000..ea58de42 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-27241fe73a62b4100a340ccd.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 7.5 seconds into the battle.\nYou are A1, a marine at (5.1, 15.5) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: retreat.\nYour team:\n A0 marine at (6.4, 16.2), 9/45 health, order: retreat\n A2: dead\nEnemies you can see:\n E0 marine at (11.9, 17.3), 27/45 health, 7.0 away\n E2 marine at (12.1, 14.1), 45/45 health, 7.1 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (5.5s): A0 9hp retreating; A1 focus E0 (27hp), I return if enemies shift.\n A1 (5.5s): A1 18hp retreating with A0; regroup and focus E0 only when both in range.\n A0 (6.0s): A0 9hp retreating west; A1 stay with me, regroup before engaging E0 (27hp).\n A1 (6.0s): A1 18hp retreating west; both out of range, regroup before re-engaging E0.\n A0 (6.5s): A0 9hp retreating west; A1 stay out of range, we regroup.\n A1 (6.5s): A1 18hp retreating west with A0; out of range, regroup before engaging.\n A0 (7.0s): A0 9hp still retreating west; A1 stay with me, out of range.\n A1 (7.0s): A1 18hp retreating west; enemies 7 away, out of range. Stay together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"retreat\", \"say\": \"A1 18hp retreating west; staying with A0, out of range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-2774f390b7ff951c2e7e5f86.json b/examples/multi-agent-smax/results/llm-cache/ask-2774f390b7ff951c2e7e5f86.json new file mode 100644 index 00000000..c511b5c1 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-2774f390b7ff951c2e7e5f86.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 6.5 seconds into the battle.\nYou are A0, a marine at (9.5, 16.2) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: retreat.\nYour team:\n A1 marine at (8.3, 15.5), 18/45 health, order: retreat\n A2: dead\nEnemies you can see:\n E0 marine at (15.1, 17.3), 27/45 health, 5.7 away\n E2 marine at (15.3, 14.1), 45/45 health, 6.1 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (4.5s): A0 firing E0 (27hp), tanking. A1 stay back, then we take E2.\n A1 (4.5s): A1 18hp staying back; A0 kill E0 (27hp), then E2.\n A0 (5.0s): A0 at 9hp retreating. A1 you hold and shoot closest; we regroup and focus E0.\n A1 (5.0s): A1 joining now, both focus E0 (27hp) to split their fire.\n A0 (5.5s): A0 9hp retreating; A1 focus E0 (27hp), I return if enemies shift.\n A1 (5.5s): A1 18hp retreating with A0; regroup and focus E0 only when both in range.\n A0 (6.0s): A0 9hp retreating west; A1 stay with me, regroup before engaging E0 (27hp).\n A1 (6.0s): A1 18hp retreating west; both out of range, regroup before re-engaging E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"retreat\", \"say\": \"A0 9hp retreating west; A1 stay out of range, we regroup.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-278adcc1ba4b166836086391.json b/examples/multi-agent-smax/results/llm-cache/ask-278adcc1ba4b166836086391.json new file mode 100644 index 00000000..aeeee1d0 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-278adcc1ba4b166836086391.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.0 seconds into the battle.\nYou are A1, a marine at (7.2, 17.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (7.5, 15.8), 27/45 health, order: attack E1\n A2: dead\nEnemies you can see:\n E0 marine at (11.7, 17.0), 45/45 health, 4.6 away (in range)\n E1 marine at (11.0, 17.2), 9/45 health, 3.9 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A2 (4.0s): Keep firing E2, it's at 18 HP. Then focus E1.\n A0 (4.5s): E2 down. Focus E1 (closest), then E0.\n A1 (4.5s): E2 down. Focus E1 (closest, 3.9 away), then E0.\n A2 (4.5s): E2 down. Focus E1 (closest, 3.5 away), then E0.\n A0 (5.0s): Firing E1 (27hp), then E0.\n A1 (5.0s): Firing E1 (27hp), then E0.\n A0 (5.5s): Firing E1 (18hp), then E0.\n A1 (5.5s): Firing E1 (18hp), then E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Firing E1 (9hp), then E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-278b8dbcb5a85e269051c6ac.json b/examples/multi-agent-smax/results/llm-cache/ask-278b8dbcb5a85e269051c6ac.json new file mode 100644 index 00000000..70acf2c8 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-278b8dbcb5a85e269051c6ac.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 0.5 seconds into the battle.\nYou are A1, a marine at (9.7, 17.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 17.\nYour team:\n A0 marine at (8.5, 15.6), 45/45 health, order: move 14 16.5\n A2 marine at (8.9, 16.7), 45/45 health, order: move 14 16.5\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Moving east together toward center; stay within 2 of each other, attack same target.\n A1 (0.0s): Moving east together toward center, stay within 2 of each other.\n A2 (0.0s): Moving east together toward center, stay close, all engage same enemy on contact.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 17\", \"say\": \"Continuing east together; will all attack same enemy on contact.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-27ea49964e4456eab9fcbc61.json b/examples/multi-agent-smax/results/llm-cache/ask-27ea49964e4456eab9fcbc61.json new file mode 100644 index 00000000..7b56ad7d --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-27ea49964e4456eab9fcbc61.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.5 seconds into the battle.\nYou are A0, a marine at (7.5, 15.8) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1 marine at (7.2, 17.2), 45/45 health, order: attack E1\n A2: dead\nEnemies you can see:\n E0 marine at (11.7, 17.0), 45/45 health, 4.4 away (in range)\n E1 marine at (11.0, 17.2), 18/45 health, 3.8 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (4.0s): Firing E2 (18hp left); then E1.\n A1 (4.0s): Keep firing E2 (18hp), then E1.\n A2 (4.0s): Keep firing E2, it's at 18 HP. Then focus E1.\n A0 (4.5s): E2 down. Focus E1 (closest), then E0.\n A1 (4.5s): E2 down. Focus E1 (closest, 3.9 away), then E0.\n A2 (4.5s): E2 down. Focus E1 (closest, 3.5 away), then E0.\n A0 (5.0s): Firing E1 (27hp), then E0.\n A1 (5.0s): Firing E1 (27hp), then E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Firing E1 (18hp), then E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-285f7d71b0e6bb7661c90f33.json b/examples/multi-agent-smax/results/llm-cache/ask-285f7d71b0e6bb7661c90f33.json new file mode 100644 index 00000000..b5d63573 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-285f7d71b0e6bb7661c90f33.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 6.0 seconds into the battle.\nYou are A2, a marine at (12.8, 14.9) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (14.3, 16.0), 9/45 health, order: attack E1\n A1: dead\nEnemies you can see:\n E1 marine at (16.5, 16.2), 27/45 health, 4.0 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (4.0s): Keep firing on E2, then E1. No retreat.\n A2 (4.0s): Keep firing on E2 until dead, then E1.\n A0 (4.5s): E2 at 9hp, keep firing together, then E1.\n A2 (4.5s): E2 at 9hp, finish it now, then E1.\n A0 (5.0s): E2 at 9hp, finish it now together, then E1.\n A2 (5.0s): E2 at 9hp, keep firing together, then E1.\n A0 (5.5s): E2 is dead. Both attack E1 now, keep firing.\n A2 (5.5s): E2 dead. Both attack E1 now, keep firing together, no retreat.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Attacking E1 (27hp), keep firing together, last enemy.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-28823fb669b50a496c4abc36.json b/examples/multi-agent-smax/results/llm-cache/ask-28823fb669b50a496c4abc36.json new file mode 100644 index 00000000..e8480d0f --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-28823fb669b50a496c4abc36.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.5 seconds into the battle.\nYou are A1, a marine at (8.5, 15.3) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.6, 16.9), 45/45 health, order: hold\n A2 marine at (6.5, 16.6), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together as a group; focus fire on the closest enemy once seen.\n A0 (0.5s): No enemies yet. Holding; focus the closest when they appear.\n A1 (0.5s): A1 holding; will focus fire on the closest enemy that appears.\n A2 (0.5s): No enemies yet; staying grouped, will focus the closest one when seen.\n A0 (1.0s): Still no enemies; holding grouped, focus closest when seen.\n A1 (1.0s): A1 holding; no enemies yet, will focus the closest when seen.\n A2 (1.0s): A2 holding; will focus the closest enemy when it appears.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A1 holding; no enemies yet, focus closest when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-288cbe5b48a615148acf16f6.json b/examples/multi-agent-smax/results/llm-cache/ask-288cbe5b48a615148acf16f6.json new file mode 100644 index 00000000..35f28e1c --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-288cbe5b48a615148acf16f6.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.5 seconds into the battle.\nYou are A1, a marine at (10.0, 15.5) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (9.3, 15.9), 45/45 health, order: attack E1\n A2: dead\nEnemies you can see:\n E0 marine at (13.5, 17.3), 45/45 health, 4.0 away (in range)\n E1 marine at (13.5, 16.6), 18/45 health, 3.7 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (4.0s): Switching to E2, in range at 4.7. A1 and I focus E2.\n A1 (4.0s): Firing on E2 (36hp, in range). A0 switch to E2. A2 stay back.\n A2 (4.0s): A2 hurt but farthest back, firing on E2 from range. Focus E2.\n A0 (4.5s): E2 at 18hp, finishing it now. Then focus E1 (36hp).\n A1 (4.5s): E2 at 18hp, finish it now, then E1.\n A2 (4.5s): Firing on E2 (18hp), one more volley kills it. Then E1.\n A0 (5.0s): E2 down. Focus E1 (36hp), then E0.\n A1 (5.0s): E2 down. Focus E1 (36hp), then E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Focusing E1 (18hp), both fire. Then E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-28d56cbe609c405b16f9e080.json b/examples/multi-agent-smax/results/llm-cache/ask-28d56cbe609c405b16f9e080.json new file mode 100644 index 00000000..41f65e86 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-28d56cbe609c405b16f9e080.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.5 seconds into the battle.\nYou are A2, a marine at (9.3, 14.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (9.0, 16.0), 45/45 health, order: hold\n A1 marine at (8.9, 14.1), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (14.0, 16.4), 45/45 health, 5.0 away\n E1 marine at (14.7, 16.8), 45/45 health, 5.8 away\n E2 marine at (14.6, 15.5), 45/45 health, 5.4 away\nTeam chat (most recent last):\n A1 (2.0s): No contact; advancing east together to find enemies. Stay grouped, focus closest.\n A2 (2.0s): Holding grouped; focus fire closest enemy when it appears.\n A0 (2.5s): Enemies 3 at east, ~7 away. Falling back to group; hold and focus E0 when in range.\n A1 (2.5s): Enemies E0, E2 east ~9 away. Holding grouped; focus E0 when in range.\n A2 (2.5s): Advancing east to join A0/A1; stay grouped, focus closest enemy.\n A0 (3.0s): Holding at (9,16). Let them come into range, then all focus the closest enemy.\n A1 (3.0s): Holding grouped. Enemies ~7 away; let them come into range, focus E0.\n A2 (3.0s): Holding at range; all focus E0 when it enters 5 range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 at range 5. Everyone attack E0 now, focus fire.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-2919ee3a8b05e579e5158636.json b/examples/multi-agent-smax/results/llm-cache/ask-2919ee3a8b05e579e5158636.json new file mode 100644 index 00000000..db24f3ff --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-2919ee3a8b05e579e5158636.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.0 seconds into the battle.\nYou are A2, a marine at (7.6, 17.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.9, 16.7), 45/45 health, order: hold\n A1 marine at (9.4, 14.9), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together; focus fire on closest enemy once seen.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on closest enemy when they appear.\n A0 (0.5s): A0 holding; will focus fire on the closest enemy that appears.\n A1 (0.5s): A1 holding; will focus fire on closest enemy once visible.\n A2 (0.5s): Holding; staying clustered near A0 until enemies appear, then focus closest.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A2 holding; no enemies seen yet, will focus closest when they appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-298c0da4715b2af9cb3a8291.json b/examples/multi-agent-smax/results/llm-cache/ask-298c0da4715b2af9cb3a8291.json new file mode 100644 index 00000000..8f073bc2 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-298c0da4715b2af9cb3a8291.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.0 seconds into the battle.\nYou are A0, a marine at (10.6, 16.0) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1 marine at (8.9, 14.1), 45/45 health, order: attack E2\n A2 marine at (10.8, 14.8), 18/45 health, order: attack E2\nEnemies you can see:\n E1 marine at (13.1, 16.8), 45/45 health, 2.6 away (in range)\n E2 marine at (13.1, 15.5), 9/45 health, 2.5 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (4.5s): Firing E0 (18hp left), then switch to E2 together.\n A2 (4.5s): E0 at 18 hp, keep firing E0, then E2.\n A0 (5.0s): E0 dead. Focus E2 together, then E1.\n A1 (5.0s): E0 dead. Focus E2 (4.4 away, 45hp), everyone fire E2 together.\n A2 (5.0s): E0 dead. All focus E2, closest at 2.3, then E1.\n A0 (5.5s): E2 at 18hp, all fire E2 now, then E1.\n A1 (5.5s): Firing E2 (18hp), then E1 together.\n A2 (5.5s): Keep firing E2 (18hp), then E1 together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 at 9hp, finish it now, then E1. I'm low, 9hp.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-29f5e91cb21d639b56ee0252.json b/examples/multi-agent-smax/results/llm-cache/ask-29f5e91cb21d639b56ee0252.json new file mode 100644 index 00000000..ca3b6a83 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-29f5e91cb21d639b56ee0252.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.5 seconds into the battle.\nYou are A0, a marine at (9.3, 15.3) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1 marine at (8.3, 14.2), 45/45 health, order: attack E1\n A2 marine at (9.0, 16.0), 9/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (13.4, 16.8), 18/45 health, 4.4 away (in range)\n E1 marine at (12.2, 16.1), 36/45 health, 3.0 away (in range)\n E2 marine at (12.3, 17.5), 45/45 health, 3.8 away (in range)\nTeam chat (most recent last):\n A1 (3.0s): A1 holding; focus E0 when it enters range 5.\n A2 (3.0s): A2 attacking E0 (in range); all focus E0.\n A0 (3.5s): A0 attacking E0 now; focus E0 together.\n A1 (3.5s): A1 advancing, focusing E0 with A2. A0 join fire on E0.\n A2 (3.5s): A2 attacking E0 (36hp, in range); all focus E0.\n A0 (4.0s): A0 attacking E0 (27hp); everyone keep focusing E0.\n A1 (4.0s): E0 out of my range; hitting E1 (in range). A0, A2 finish E0, then all E1.\n A2 (4.0s): A2 firing on E0 (27hp); finish it, then E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"A0 firing E0 (18hp), nearly dead. Then all E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-2a4ab407a08b05de48930f74.json b/examples/multi-agent-smax/results/llm-cache/ask-2a4ab407a08b05de48930f74.json new file mode 100644 index 00000000..add74407 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-2a4ab407a08b05de48930f74.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.0 seconds into the battle.\nYou are A0, a marine at (7.5, 15.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1 marine at (7.2, 17.2), 45/45 health, order: attack E2\n A2 marine at (7.6, 17.8), 36/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (12.7, 17.1), 45/45 health, 5.3 away\n E1 marine at (11.6, 17.1), 45/45 health, 4.3 away (in range)\n E2 marine at (11.0, 16.7), 18/45 health, 3.6 away (in range)\nTeam chat (most recent last):\n A1 (2.5s): E2 at 7 range. Holding grouped; focus E2 once in range.\n A2 (2.5s): E2 at 6.7, E1 behind. Holding grouped; focus closest when in range.\n A0 (3.0s): A0 holding; E2 at 5.2, focus E2 the moment it enters range.\n A1 (3.0s): E2 at 5.5, nearly in range. Holding; all focus E2 when it enters 5.\n A2 (3.0s): E2 at 5.1, nearly in range. Holding, all fire on E2 first.\n A0 (3.5s): E2 in range, all fire E2 now.\n A1 (3.5s): E2 in range at 3.9. Everyone fire on E2.\n A2 (3.5s): E2 in range at 3.6, all fire E2 now.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Firing E2 (18hp left); then E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-2ac28a19e46875982454c844.json b/examples/multi-agent-smax/results/llm-cache/ask-2ac28a19e46875982454c844.json new file mode 100644 index 00000000..973f8ee3 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-2ac28a19e46875982454c844.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.5 seconds into the battle.\nYou are A0, a marine at (9.9, 17.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1: dead\n A2: dead\nEnemies you can see:\n E0 marine at (14.6, 17.8), 45/45 health, 4.7 away (in range)\n E1 marine at (13.7, 14.5), 18/45 health, 4.5 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (3.5s): E2 at 27hp, keep focusing it. A0 attack E2 too.\n A2 (3.5s): Firing E2 (27hp), A0 step up and focus E2. A1 stay back.\n A0 (4.0s): E2 at 18hp, in range. Finish it now, then E1.\n A2 (4.0s): E2 at 18hp, finish it now. A0 keep firing.\n A0 (4.5s): E2 is down. Focus E1 (closest, 45hp), then E0.\n A2 (4.5s): E2 down. Focus E1 (closest, 3.8 away), then E0.\n A0 (5.0s): Focusing E1 (36hp), both in range. A2 stay behind me, you're low.\n A2 (5.0s): Focus E1 (36hp), I'm low at 18hp. A0 keep firing, then E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A0 on E1 (18hp), almost dead. Then E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-2ae43f55a9080c8cf932c54c.json b/examples/multi-agent-smax/results/llm-cache/ask-2ae43f55a9080c8cf932c54c.json new file mode 100644 index 00000000..cfe94278 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-2ae43f55a9080c8cf932c54c.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 5.0 seconds into the battle.\nYou are A0, a marine at (14.6, 14.4) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1 marine at (15.1, 13.7), 36/45 health, order: attack E2\n A2: dead\nEnemies you can see:\n E1 marine at (18.0, 17.0), 45/45 health, 4.2 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A2 (3.0s): E0 at 9hp, finishing it now; then focus E2.\n A0 (3.5s): E0 dead. All focus E2 now, then E1.\n A1 (3.5s): E0 down. Everyone focus E2 (closest), then E1.\n A2 (3.5s): E0 down. Everyone focus E2 (3.0 away), then E1.\n A0 (4.0s): E2 at 18hp, keep focusing E2 then E1.\n A1 (4.0s): E2 at 18hp, keep focusing E2 then E1. Nobody retreat.\n A0 (4.5s): E2 at 9hp, finish it now, then E1. I'm low but still firing.\n A1 (4.5s): E2 at 9hp, finishing it. Then E1. A0 stay in, no retreat.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E2 dead. Focus E1 now, 4.2 away, both fire together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-2af127355d318c42ae398567.json b/examples/multi-agent-smax/results/llm-cache/ask-2af127355d318c42ae398567.json new file mode 100644 index 00000000..929f4a77 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-2af127355d318c42ae398567.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.5 seconds into the battle.\nYou are A1, a marine at (8.3, 14.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (9.3, 15.3), 36/45 health, order: attack E0\n A2 marine at (9.0, 16.0), 9/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (13.4, 16.8), 18/45 health, 5.8 away\n E1 marine at (12.2, 16.1), 36/45 health, 4.3 away (in range)\n E2 marine at (12.3, 17.5), 45/45 health, 5.3 away\nTeam chat (most recent last):\n A1 (3.0s): A1 holding; focus E0 when it enters range 5.\n A2 (3.0s): A2 attacking E0 (in range); all focus E0.\n A0 (3.5s): A0 attacking E0 now; focus E0 together.\n A1 (3.5s): A1 advancing, focusing E0 with A2. A0 join fire on E0.\n A2 (3.5s): A2 attacking E0 (36hp, in range); all focus E0.\n A0 (4.0s): A0 attacking E0 (27hp); everyone keep focusing E0.\n A1 (4.0s): E0 out of my range; hitting E1 (in range). A0, A2 finish E0, then all E1.\n A2 (4.0s): A2 firing on E0 (27hp); finish it, then E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A1 shooting E1 (36hp). E0 at 18hp, finish it, then all E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-2b1a0b6125de9ae8c89ea294.json b/examples/multi-agent-smax/results/llm-cache/ask-2b1a0b6125de9ae8c89ea294.json new file mode 100644 index 00000000..cc8f7232 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-2b1a0b6125de9ae8c89ea294.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 5.0 seconds into the battle.\nYou are A1, a marine at (13.0, 15.0) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (12.8, 15.9), 27/45 health, order: attack E0\n A2 marine at (13.0, 14.3), 18/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (17.3, 15.0), 27/45 health, 4.4 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (3.5s): Attacking E1 (36hp), keep focus until it dies.\n A2 (3.5s): Keep firing on E1, 36hp left. All together until it dies.\n A0 (4.0s): E1 at 18hp, keep focusing it until it dies, then E0.\n A1 (4.0s): E1 at 18hp, keep firing together until it dies.\n A2 (4.0s): E1 at 18hp, keep firing together until it dies, then E0.\n A0 (4.5s): E1 down. All attack E0 together, it's in range 4.6.\n A1 (4.5s): E1 dead. All focus E0, 45hp, firing together now.\n A2 (4.5s): E1 dead. All focus E0, 4.4 away, in range. Fire together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 at 27hp, keep firing together until it dies.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-2c8f1a9cf69f5bcc86c7f39a.json b/examples/multi-agent-smax/results/llm-cache/ask-2c8f1a9cf69f5bcc86c7f39a.json new file mode 100644 index 00000000..830201bb --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-2c8f1a9cf69f5bcc86c7f39a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.0 seconds into the battle.\nYou are A0, a marine at (7.8, 14.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (8.5, 14.8), 45/45 health, order: hold\n A2 marine at (8.2, 14.1), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (14.2, 15.0), 45/45 health, 6.4 away\n E1 marine at (15.0, 14.0), 45/45 health, 7.3 away\n E2 marine at (13.4, 16.8), 45/45 health, 6.0 away\nTeam chat (most recent last):\n A1 (1.5s): A1 holding at cluster; focus fire on closest enemy when seen.\n A2 (1.5s): A2 holding at (8,14). Clustered; focus fire on closest enemy.\n A0 (2.0s): A0 holding; no enemies seen. Focus closest when they appear.\n A1 (2.0s): Holding cluster; let them walk into range, then focus closest enemy.\n A2 (2.0s): E2 spotted east at 8.7 range. Holding cluster; let them come, focus first in range.\n A0 (2.5s): Enemies approaching; hold cluster, all focus whichever enemy enters range first.\n A1 (2.5s): Holding. Enemies closing; all focus closest enemy once in range 5.\n A2 (2.5s): A2 holding. Enemies approaching; focus closest once in range 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding. Focus closest enemy E2 when in range 5, fire together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-2d07a9e94f87c5a976d1786a.json b/examples/multi-agent-smax/results/llm-cache/ask-2d07a9e94f87c5a976d1786a.json new file mode 100644 index 00000000..d957769a --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-2d07a9e94f87c5a976d1786a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.5 seconds into the battle.\nYou are A2, a marine at (10.5, 16.3) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (8.2, 16.2), 45/45 health, order: hold\n A1 marine at (9.9, 15.6), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (15.1, 17.3), 45/45 health, 4.7 away (in range)\n E1 marine at (15.1, 16.6), 36/45 health, 4.6 away (in range)\n E2 marine at (13.7, 14.1), 45/45 health, 3.9 away (in range)\nTeam chat (most recent last):\n A1 (2.0s): Enemies at 8.5 east. Hold grouped; all focus the closest when in range.\n A2 (2.0s): No contact after 2s. Advancing east together to (14,16); stay close, focus closest.\n A0 (2.5s): A2 advancing alone is risky; hold grouped at range 5, focus E1 when in range.\n A1 (2.5s): Enemies 7 east. A2 fall back to group; hold and focus E1 when in range.\n A2 (2.5s): Cancel advance. Holding at 10.5; enemies 6 east, focus E1 when in range.\n A0 (3.0s): Holding. Enemies at 7; focus E1 when in range, stay grouped.\n A1 (3.0s): Holding. E1 is closest at 5.3; focus E1 as soon as it's in range.\n A2 (3.0s): Enemies in range. Focus E1 now, everyone fire on E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"retreat\", \"say\": \"A2 hurt, pulling back west to you. Fire on E1 when they follow into range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-2d634f118170fff0c86540e5.json b/examples/multi-agent-smax/results/llm-cache/ask-2d634f118170fff0c86540e5.json new file mode 100644 index 00000000..3055b9e9 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-2d634f118170fff0c86540e5.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 2.5 seconds into the battle.\nYou are A0, a marine at (13.3, 15.6) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1 marine at (12.9, 17.5), 27/45 health, order: attack E2\n A2 marine at (13.7, 16.7), 45/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (17.7, 17.8), 45/45 health, 5.0 away (in range)\n E1 marine at (16.9, 14.5), 45/45 health, 3.7 away (in range)\n E2 marine at (17.6, 17.0), 9/45 health, 4.6 away (in range)\nTeam chat (most recent last):\n A1 (1.0s): Moving to 14,16.5 with the group; will attack E2 together when in range.\n A2 (1.0s): Enemy E2 seen at 19.3,17.2. Keep formation, advance together, then all attack E2.\n A0 (1.5s): Enemies 6-7 away; keep advancing together, then all attack E2 at range 5.\n A1 (1.5s): E2 in my range; A0, A2 close in and focus E2 now.\n A2 (1.5s): Staying together; E2 nearly in range. All attack E2 once everyone is within 5.\n A0 (2.0s): E2 in my range 4.8; attacking E2 now, everyone focus E2.\n A1 (2.0s): All three in range of E2 now. Attack E2 together.\n A2 (2.0s): E2 and E1 in my range; attacking E2 now, everyone focus E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 at 9hp, finish it now; then focus E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-2df3b0e324fe62e11da4131b.json b/examples/multi-agent-smax/results/llm-cache/ask-2df3b0e324fe62e11da4131b.json new file mode 100644 index 00000000..aeb4f6e2 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-2df3b0e324fe62e11da4131b.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.0 seconds into the battle.\nYou are A1, a marine at (10.0, 15.5) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (9.3, 15.9), 45/45 health, order: attack E1\n A2: dead\nEnemies you can see:\n E0 marine at (13.5, 17.3), 45/45 health, 4.0 away (in range)\n E1 marine at (13.5, 16.6), 9/45 health, 3.7 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A2 (4.0s): A2 hurt but farthest back, firing on E2 from range. Focus E2.\n A0 (4.5s): E2 at 18hp, finishing it now. Then focus E1 (36hp).\n A1 (4.5s): E2 at 18hp, finish it now, then E1.\n A2 (4.5s): Firing on E2 (18hp), one more volley kills it. Then E1.\n A0 (5.0s): E2 down. Focus E1 (36hp), then E0.\n A1 (5.0s): E2 down. Focus E1 (36hp), then E0.\n A0 (5.5s): Focusing E1 (18hp), both of us fire. Then E0.\n A1 (5.5s): Focusing E1 (18hp), both fire. Then E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E1 at 9hp, finishing it now. Then E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-2e6fa4e42708c2c2e10545a8.json b/examples/multi-agent-smax/results/llm-cache/ask-2e6fa4e42708c2c2e10545a8.json new file mode 100644 index 00000000..6dc7c4f8 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-2e6fa4e42708c2c2e10545a8.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 3.5 seconds into the battle.\nYou are A1, a marine at (13.2, 15.3) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (13.6, 17.1), 18/45 health, order: attack E1\n A2 marine at (14.1, 16.4), 27/45 health, order: attack E1\nEnemies you can see:\n E1 marine at (17.6, 16.5), 18/45 health, 4.5 away (in range)\n E2 marine at (17.5, 17.3), 45/45 health, 4.8 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (2.0s): Focusing E0 (27hp). A2 get in range and attack E0.\n A2 (2.0s): Attacking E0 now, closing in with you both.\n A0 (2.5s): E0 at 9hp, finish it now; then focus E2.\n A1 (2.5s): E0 at 9hp, finishing it now; then everyone focus E1.\n A2 (2.5s): E0 at 9hp in range, firing on E0 now.\n A0 (3.0s): E0 dead. Everyone focus E1 now, same target, no retreating.\n A1 (3.0s): E0 dead. Everyone focus E1 now, same tick; then E2.\n A2 (3.0s): E0 dead. Everyone focus E1 now, then E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Attacking E1 (18hp), all keep firing; then E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-2ebff0e04a8c8f66593ba090.json b/examples/multi-agent-smax/results/llm-cache/ask-2ebff0e04a8c8f66593ba090.json new file mode 100644 index 00000000..149a2aa9 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-2ebff0e04a8c8f66593ba090.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 4.5 seconds into the battle.\nYou are A0, a marine at (12.8, 15.9) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1 marine at (13.0, 15.0), 9/45 health, order: attack E1\n A2 marine at (13.0, 14.3), 18/45 health, order: attack E1\nEnemies you can see:\n E0 marine at (17.3, 15.0), 45/45 health, 4.6 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (3.0s): E2 dead. Focus E1 (closest, 3.8 away), all attack E1 together.\n A2 (3.0s): E2 is dead. Focus E1 (closest, 3.6 away), all together.\n A0 (3.5s): Attacking E1 (36hp), keep focusing until it dies.\n A1 (3.5s): Attacking E1 (36hp), keep focus until it dies.\n A2 (3.5s): Keep firing on E1, 36hp left. All together until it dies.\n A0 (4.0s): E1 at 18hp, keep focusing it until it dies, then E0.\n A1 (4.0s): E1 at 18hp, keep firing together until it dies.\n A2 (4.0s): E1 at 18hp, keep firing together until it dies, then E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E1 down. All attack E0 together, it's in range 4.6.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-2f08bfe47f19e10c32e89434.json b/examples/multi-agent-smax/results/llm-cache/ask-2f08bfe47f19e10c32e89434.json new file mode 100644 index 00000000..0a81d43e --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-2f08bfe47f19e10c32e89434.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 1.5 seconds into the battle.\nYou are A0, a marine at (11.9, 15.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 17.\nYour team:\n A1 marine at (11.3, 16.1), 45/45 health, order: move 12 17\n A2 marine at (11.7, 18.0), 45/45 health, order: move 12 17\nEnemies you can see:\n E0 marine at (20.2, 17.7), 45/45 health, 8.4 away\n E2 marine at (19.7, 14.7), 45/45 health, 7.8 away\nTeam chat (most recent last):\n A1 (0.0s): Moving east together toward the center; stay within 2 of each other.\n A2 (0.0s): Advancing east together, stay within 2 of each other; attack same target when in range.\n A0 (0.5s): Continuing to (12,17); keep within 2 of each other.\n A1 (0.5s): Moving to (12,17) with A0; keep together, then focus same target.\n A2 (0.5s): Moving to (12,17) with A0; keep within 2, attack together when enemies appear.\n A0 (1.0s): Continuing to (12,17) together; no enemies yet, attack same target when seen.\n A1 (1.0s): Continuing to (12,17), staying within 2 of A0 and A2.\n A2 (1.0s): Continuing to (12,17); no enemies yet, stay within 2, attack together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 15 16\", \"say\": \"Enemies E0, E2 east at ~8. Advance together to (15,16), then focus E2 together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-2f5c4fb4c964f54452e6d8ef.json b/examples/multi-agent-smax/results/llm-cache/ask-2f5c4fb4c964f54452e6d8ef.json new file mode 100644 index 00000000..06e4b56d --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-2f5c4fb4c964f54452e6d8ef.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 0.5 seconds into the battle.\nYou are A2, a marine at (8.3, 17.3) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.9, 15.6), 45/45 health, order: hold\n A1 marine at (6.7, 14.2), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding per rules until enemy within 5 of all; then focus same target.\n A1 (0.0s): A1 holding. No enemies seen; wait until all in range 5, then focus same target.\n A2 (0.0s): A2 holding. Will attack together once enemy is within 5 of all of us.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A2 holding. No enemies visible yet; will focus fire when all in range 5.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-2fe13e6d9b712854ff739bdc.json b/examples/multi-agent-smax/results/llm-cache/ask-2fe13e6d9b712854ff739bdc.json new file mode 100644 index 00000000..ce60d089 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-2fe13e6d9b712854ff739bdc.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 1.0 seconds into the battle.\nYou are A1, a marine at (9.7, 16.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 17.\nYour team:\n A0 marine at (10.4, 15.8), 45/45 health, order: move 12 17\n A2 marine at (10.1, 18.0), 45/45 health, order: move 12 17\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Moving east together to (12,17); stay within 2 of each other, then all attack same target.\n A1 (0.0s): Moving east together toward the center; stay within 2 of each other.\n A2 (0.0s): Advancing east together, stay within 2 of each other; attack same target when in range.\n A0 (0.5s): Continuing to (12,17); keep within 2 of each other.\n A1 (0.5s): Moving to (12,17) with A0; keep together, then focus same target.\n A2 (0.5s): Moving to (12,17) with A0; keep within 2, attack together when enemies appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 17\", \"say\": \"Continuing to (12,17), staying within 2 of A0 and A2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-30131d53d7d36082748cd07e.json b/examples/multi-agent-smax/results/llm-cache/ask-30131d53d7d36082748cd07e.json new file mode 100644 index 00000000..08ff5a70 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-30131d53d7d36082748cd07e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.5 seconds into the battle.\nYou are A1, a marine at (9.7, 17.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 9 16.8.\nYour team:\n A0 marine at (8.4, 17.0), 45/45 health, order: move 9 16.5\n A2 marine at (9.1, 16.8), 45/45 health, order: hold\nEnemies you can see:\n E2 marine at (17.8, 17.2), 45/45 health, 8.0 away\nTeam chat (most recent last):\n A1 (0.0s): Advancing east together; stay close and focus fire on the nearest enemy.\n A2 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A0 (0.5s): A1 fell back toward cluster; I'm moving to x=9 so we stay grouped.\n A1 (0.5s): Falling back to cluster; hold together and focus the closest enemy.\n A2 (0.5s): A1 is ahead alone; moving up to group with A1, then focus nearest enemy.\n A0 (1.0s): Grouped at x=9; hold here and focus the closest enemy when seen.\n A1 (1.0s): Grouping at x=9; focus fire on nearest enemy when seen.\n A2 (1.0s): Holding at cluster near (9,16.7); focus fire on the closest enemy.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding at x=9; enemy E2 approaching, all focus the closest one.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-30142e3e0030a438de99994a.json b/examples/multi-agent-smax/results/llm-cache/ask-30142e3e0030a438de99994a.json new file mode 100644 index 00000000..255fab34 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-30142e3e0030a438de99994a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.5 seconds into the battle.\nYou are A1, a marine at (8.9, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (10.6, 16.0), 27/45 health, order: attack E0\n A2 marine at (10.8, 14.8), 36/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (12.4, 16.4), 18/45 health, 4.2 away (in range)\n E1 marine at (13.1, 16.8), 45/45 health, 5.0 away (in range)\n E2 marine at (13.1, 15.5), 45/45 health, 4.4 away (in range)\nTeam chat (most recent last):\n A1 (3.0s): Holding at range 5; focus E0 when in range. Stay grouped, don't advance alone.\n A2 (3.0s): Holding at range; focus fire E0 (closest) when in range.\n A0 (3.5s): E0 at range 5, firing. Everyone focus E0 now.\n A1 (3.5s): Holding at range 5. Let them approach, then everyone focus E0.\n A2 (3.5s): Focus E0 now, all fire on E0. Stay grouped.\n A0 (4.0s): E0 in range at 1.9, all fire E0. A1 attack E0 too.\n A1 (4.0s): Firing on E0 now, everyone focus E0.\n A2 (4.0s): Firing on E0 all together; A1 attack E0 too, not hold.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Firing E0 (18hp left), then switch to E2 together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-3035f6f9e85aa4855e726cec.json b/examples/multi-agent-smax/results/llm-cache/ask-3035f6f9e85aa4855e726cec.json new file mode 100644 index 00000000..f066cf39 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-3035f6f9e85aa4855e726cec.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 9.0 seconds into the battle.\nYou are A1, a marine at (8.0, 16.0) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E1 marine at (11.6, 16.0), 27/45 health, 3.5 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (6.0s): Focusing E2 (27hp), then E1. A2 stay behind me.\n A2 (6.0s): Focusing E2 (27hp), then E1. A1 keep firing.\n A1 (6.5s): Finishing E2 (9hp) now, then E1. A2 stay behind me.\n A2 (6.5s): E2 at 9hp, finishing it. A1 then focus E1.\n A1 (7.0s): E2 dead, A0 and A2 down. I'm alone on E1, 45hp each.\n A1 (7.5s): Last fight: A1 vs E1, 36hp vs 45hp. Fighting on.\n A1 (8.0s): Last fight, A1 vs E1. Keep firing.\n A1 (8.5s): A1 vs E1, both 27hp. Fighting on.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A1 18hp vs E1 27hp, last fight. Keep firing.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-30509250bca76362820ba808.json b/examples/multi-agent-smax/results/llm-cache/ask-30509250bca76362820ba808.json new file mode 100644 index 00000000..f76d7e94 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-30509250bca76362820ba808.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 1.5 seconds into the battle.\nYou are A2, a marine at (12.1, 16.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 16.8.\nYour team:\n A0 marine at (11.7, 15.6), 45/45 health, order: move 14 16.5\n A1 marine at (12.9, 17.5), 45/45 health, order: move 14 16.5\nEnemies you can see:\n E0 marine at (20.7, 17.6), 45/45 health, 8.7 away\n E1 marine at (18.4, 14.5), 45/45 health, 6.7 away\n E2 marine at (17.8, 17.2), 45/45 health, 5.7 away\nTeam chat (most recent last):\n A1 (0.0s): Moving east together toward center, stay within 2 of each other.\n A2 (0.0s): Moving east together toward center, stay close, all engage same enemy on contact.\n A0 (0.5s): Continuing east together; hold formation, all attack same target on contact.\n A1 (0.5s): Continuing east together; will all attack same enemy on contact.\n A2 (0.5s): Continuing east together; no enemies seen yet, will focus same target on contact.\n A0 (1.0s): Continuing east together; no enemies yet, will focus same target on contact.\n A1 (1.0s): Moving to 14,16.5 with the group; will attack E2 together when in range.\n A2 (1.0s): Enemy E2 seen at 19.3,17.2. Keep formation, advance together, then all attack E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 16.5\", \"say\": \"Staying together; E2 nearly in range. All attack E2 once everyone is within 5.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-30615ba65000580d684e5089.json b/examples/multi-agent-smax/results/llm-cache/ask-30615ba65000580d684e5089.json new file mode 100644 index 00000000..89f9c664 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-30615ba65000580d684e5089.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 2.0 seconds into the battle.\nYou are A1, a marine at (13.0, 15.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 16.\nYour team:\n A0 marine at (12.8, 15.9), 45/45 health, order: move 12 16\n A2 marine at (13.0, 14.3), 45/45 health, order: move 14 16\nEnemies you can see:\n E0 marine at (17.3, 15.0), 45/45 health, 4.4 away (in range)\n E1 marine at (18.2, 14.0), 45/45 health, 5.3 away\n E2 marine at (16.6, 16.8), 45/45 health, 4.0 away (in range)\nTeam chat (most recent last):\n A1 (0.5s): A1 advancing to (12,15), staying close; will attack same target on contact.\n A2 (0.5s): A2 advancing to (12,15), staying close; will attack same target on contact.\n A0 (1.0s): Moving together east to (14,16); stay grouped, attack same target on contact.\n A1 (1.0s): A1 continuing to (12,15), staying close; attack same target on contact.\n A2 (1.0s): Holding formation at (12,15); will advance together, then all attack E2 at once.\n A0 (1.5s): A0 closing on group at (12,16); then all advance together on E2.\n A1 (1.5s): Moving to (14,16) with A0; enemies close, then all attack E2 together.\n A2 (1.5s): Moving to (14,16) with A0; enemies ~5 away next, then all attack E2 together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"All in range of E2 now. Attack E2 together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-309120546dc96290cb346717.json b/examples/multi-agent-smax/results/llm-cache/ask-309120546dc96290cb346717.json new file mode 100644 index 00000000..09ac4cb1 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-309120546dc96290cb346717.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.0 seconds into the battle.\nYou are A1, a marine at (9.8, 15.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.2, 16.2), 45/45 health, order: hold\n A2 marine at (9.0, 16.2), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together as a group; focus fire on the closest enemy when they appear.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together as a group; focus fire on the closest enemy when they appear.\n A0 (0.5s): No enemies yet; staying grouped, will focus the closest enemy when seen.\n A1 (0.5s): Holding position; will focus fire on closest enemy once visible.\n A2 (0.5s): Holding. Will focus fire on the closest enemy once visible.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Still no enemies; holding grouped, will focus closest when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-30e28a5a678a674a7e4d854f.json b/examples/multi-agent-smax/results/llm-cache/ask-30e28a5a678a674a7e4d854f.json new file mode 100644 index 00000000..04af0d48 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-30e28a5a678a674a7e4d854f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.5 seconds into the battle.\nYou are A0, a marine at (8.1, 15.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (8.3, 14.1), 45/45 health, order: hold\n A2 marine at (8.1, 14.9), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (12.9, 15.0), 45/45 health, 4.8 away (in range)\n E1 marine at (13.4, 16.2), 45/45 health, 5.3 away\n E2 marine at (12.9, 14.3), 45/45 health, 5.0 away (in range)\nTeam chat (most recent last):\n A1 (2.0s): Falling back to group; hold and focus fire when enemies enter range.\n A2 (2.0s): A2 holding at (8,15); A1 is advancing east, stay close, focus closest.\n A0 (2.5s): Enemies 3 at east x16. Pull back to group at (8.5,15), then focus E0 together.\n A1 (2.5s): Enemies east at 16,15. Hold grouped; focus fire on the closest, starting with E2 or E0.\n A2 (2.5s): Enemies ~8 east. Hold at range 5, focus closest when they approach.\n A0 (3.0s): Holding at (8,15). Everyone hold; focus fire closest enemy when in range 5.\n A1 (3.0s): Holding at (8,14). Focus E2 first when in range, then E0.\n A2 (3.0s): Holding at (8,15). Focus E2 or E0 when in range 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Focus E2 now, then E0. Stay grouped.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-30eb991d6b5b2aeffedf6ac9.json b/examples/multi-agent-smax/results/llm-cache/ask-30eb991d6b5b2aeffedf6ac9.json new file mode 100644 index 00000000..490e143d --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-30eb991d6b5b2aeffedf6ac9.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.5 seconds into the battle.\nYou are A1, a marine at (7.2, 17.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (7.5, 15.8), 18/45 health, order: attack E1\n A2: dead\nEnemies you can see:\n E0 marine at (11.7, 17.0), 45/45 health, 4.6 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (4.5s): E2 down. Focus E1 (closest, 3.9 away), then E0.\n A2 (4.5s): E2 down. Focus E1 (closest, 3.5 away), then E0.\n A0 (5.0s): Firing E1 (27hp), then E0.\n A1 (5.0s): Firing E1 (27hp), then E0.\n A0 (5.5s): Firing E1 (18hp), then E0.\n A1 (5.5s): Firing E1 (18hp), then E0.\n A0 (6.0s): E1 at 9hp, finishing it. Then focus E0.\n A1 (6.0s): Firing E1 (9hp), then E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E1 down. All focus E0, 4.6 away, 45hp.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-30fb28ccda7b222b686e3453.json b/examples/multi-agent-smax/results/llm-cache/ask-30fb28ccda7b222b686e3453.json new file mode 100644 index 00000000..8df798d2 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-30fb28ccda7b222b686e3453.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.5 seconds into the battle.\nYou are A2, a marine at (7.6, 17.8) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (8.5, 16.7), 45/45 health, order: attack E2\n A1 marine at (7.8, 14.9), 9/45 health, order: attack E2\nEnemies you can see:\n E1 marine at (12.3, 15.6), 36/45 health, 5.1 away\n E2 marine at (11.9, 17.7), 27/45 health, 4.3 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (4.0s): E0 at 18 hp, keep focusing E0 then E1.\n A2 (4.0s): A2 firing on E0, 18 hp left, finish it then E2.\n A0 (4.5s): E0 dead. Focus E2 together, then E1. A1 stay back, you're low.\n A1 (4.5s): E0 dead. A1 on E1 at 4.5, focus E1 together; A2 close in.\n A2 (4.5s): E0 is down; all focus E2 (in range, closest), then E1.\n A0 (5.0s): A0 on E2 (full hp). A1 stay back, low. A2 keep firing E2.\n A1 (5.0s): A1 low, shooting E2 from back. A0 you're tanking, focus E2.\n A2 (5.0s): A2 on E2, in range. A0 and A2 focus E2; A1 stay back.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"A2 on E2 (27hp), keep focusing. A1 stay back.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-3163e5d02e34060e410aaa9d.json b/examples/multi-agent-smax/results/llm-cache/ask-3163e5d02e34060e410aaa9d.json new file mode 100644 index 00000000..c99d19b2 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-3163e5d02e34060e410aaa9d.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.0 seconds into the battle.\nYou are A2, a marine at (7.6, 17.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.5, 15.8), 45/45 health, order: hold\n A1 marine at (7.2, 17.2), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (15.9, 17.1), 45/45 health, 8.3 away\n E1 marine at (14.7, 17.1), 45/45 health, 7.1 away\n E2 marine at (12.6, 16.7), 45/45 health, 5.1 away\nTeam chat (most recent last):\n A1 (1.5s): A1 holding; no enemies yet. Focus closest when seen.\n A2 (1.5s): A2 holding; no enemies visible. Focus closest when they appear.\n A0 (2.0s): E2 spotted at (15.8,16.7). Holding grouped; focus fire on whoever closes first.\n A1 (2.0s): E2 spotted east at 8.6 range. Holding grouped; focus E2 when in range.\n A2 (2.0s): E2 spotted at (15.8,16.7), 8 away. Holding grouped; focus E2 when in range.\n A0 (2.5s): E1, E2 approaching. Holding grouped; focus E2 when within 5.\n A1 (2.5s): E2 at 7 range. Holding grouped; focus E2 once in range.\n A2 (2.5s): E2 at 6.7, E1 behind. Holding grouped; focus closest when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"E2 at 5.1, nearly in range. Holding, all fire on E2 first.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-31956c6dbd83348610ecb821.json b/examples/multi-agent-smax/results/llm-cache/ask-31956c6dbd83348610ecb821.json new file mode 100644 index 00000000..aa5ce922 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-31956c6dbd83348610ecb821.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.0 seconds into the battle.\nYou are A0, a marine at (7.8, 14.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (8.5, 14.8), 45/45 health, order: hold\n A2 marine at (8.2, 14.1), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.5s): Closing to (8,15) to cluster; will focus closest enemy.\n A2 (0.5s): Moving to regroup at (8,15); will focus fire closest enemy.\n A0 (1.0s): Moving to cluster at (8,15); will focus fire closest enemy.\n A1 (1.0s): A1 at (8,15) holding. Focus fire on closest enemy.\n A2 (1.0s): A2 at (8,14) holding; will focus the closest enemy when it appears.\n A0 (1.5s): A0 holding at (8,15); focus fire on the closest enemy when seen.\n A1 (1.5s): A1 holding at cluster; focus fire on closest enemy when seen.\n A2 (1.5s): A2 holding at (8,14). Clustered; focus fire on closest enemy.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A0 holding; no enemies seen. Focus closest when they appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-31a53db3104dc5f7b0f212a6.json b/examples/multi-agent-smax/results/llm-cache/ask-31a53db3104dc5f7b0f212a6.json new file mode 100644 index 00000000..488f9dca --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-31a53db3104dc5f7b0f212a6.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 1.0 seconds into the battle.\nYou are A0, a marine at (9.7, 15.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 15.\nYour team:\n A1 marine at (11.5, 14.1), 45/45 health, order: move 12 15\n A2 marine at (9.7, 14.9), 45/45 health, order: move 12 15\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Moving east together to (12,16); stay within 2 of each other, then attack same target.\n A1 (0.0s): Moving east together toward enemies; stay within 2 of each other, attack same target.\n A2 (0.0s): Advancing east together to (12,15); stay within 2 of each other.\n A0 (0.5s): Converging on (12,15) with A1/A2; will attack same target together.\n A1 (0.5s): Moving to (12,15) with team; will attack same target together.\n A2 (0.5s): A2 moving to (12,15), staying close; will attack same target when enemies appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 15\", \"say\": \"Continuing to (12,15); will attack together once enemies appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-31a5da9a85efcfc0d90cf158.json b/examples/multi-agent-smax/results/llm-cache/ask-31a5da9a85efcfc0d90cf158.json new file mode 100644 index 00000000..22424929 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-31a5da9a85efcfc0d90cf158.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.5 seconds into the battle.\nYou are A2, a marine at (7.7, 14.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (10.6, 16.0), 45/45 health, order: move 12 16\n A1 marine at (8.9, 14.1), 45/45 health, order: move 12 15\nYou see no enemies.\nTeam chat (most recent last):\n A1 (1.0s): Holding; no enemies in sight. Focus fire closest when they appear.\n A2 (1.0s): Still holding; no enemies visible. Focus fire on closest when they appear.\n A0 (1.5s): Holding near A1/A2; focus fire closest enemy when in range.\n A1 (1.5s): Still holding; will focus fire on closest enemy when visible.\n A2 (1.5s): Holding grouped; focus fire on closest enemy when it appears.\n A0 (2.0s): No contact; advancing east to center together. Stay close, focus closest enemy.\n A1 (2.0s): No contact; advancing east together to find enemies. Stay grouped, focus closest.\n A2 (2.0s): Holding grouped; focus fire closest enemy when it appears.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 11 15\", \"say\": \"Advancing east to join A0/A1; stay grouped, focus closest enemy.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-31e322661e8c799a04005af0.json b/examples/multi-agent-smax/results/llm-cache/ask-31e322661e8c799a04005af0.json new file mode 100644 index 00000000..85f6a262 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-31e322661e8c799a04005af0.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 2.5 seconds into the battle.\nYou are A2, a marine at (13.2, 17.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (14.8, 18.0), 45/45 health, order: attack E0\n A1 marine at (14.9, 17.2), 18/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (17.7, 16.4), 18/45 health, 4.7 away (in range)\n E1 marine at (18.5, 17.3), 45/45 health, 5.4 away\n E2 marine at (19.1, 14.8), 45/45 health, 6.6 away\nTeam chat (most recent last):\n A1 (1.0s): Advancing east to 14,17 together; no one engages until all in range.\n A2 (1.0s): Moving east together to x=16; will attack same target once all in range.\n A0 (1.5s): Closing together toward E0; attack E0 once all three are within range 5.\n A1 (1.5s): Holding formation at 14,17; attack E0 together once all within range 5.\n A2 (1.5s): Regrouping at 14,17; closest enemy 6 away, hold formation, then attack E0 together.\n A0 (2.0s): E0 is within range 5 of all three of us. Everyone attack E0 now.\n A1 (2.0s): E0 is in range of all three. Attack E0 now, together.\n A2 (2.0s): E0 is within range 5 of all three of us. Attack E0 now.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Attacking E0 now; A1 under 20hp, retreat if needed.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-31e993014c58cc66339c15e3.json b/examples/multi-agent-smax/results/llm-cache/ask-31e993014c58cc66339c15e3.json new file mode 100644 index 00000000..81772b5b --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-31e993014c58cc66339c15e3.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 2.5 seconds into the battle.\nYou are A1, a marine at (13.2, 15.3) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (13.6, 17.1), 36/45 health, order: attack E0\n A2 marine at (14.1, 16.4), 45/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (17.8, 15.1), 9/45 health, 4.5 away (in range)\n E1 marine at (17.6, 16.5), 45/45 health, 4.5 away (in range)\n E2 marine at (17.5, 17.3), 45/45 health, 4.8 away (in range)\nTeam chat (most recent last):\n A1 (1.0s): E0 spotted east at (19.3,15.1). Keep moving together; attack when in range 5 of all.\n A2 (1.0s): A2 continuing to (14,16), staying close; will focus first enemy seen.\n A0 (1.5s): E0 in range of A0 and A1. Attack E0 now; A2 close in and focus E0.\n A1 (1.5s): E0 in range of A1 and A0. A2 close in, everyone focus E0 now.\n A2 (1.5s): E0 at 6.7, not in range yet. Moving up together; attack E0 on same tick.\n A0 (2.0s): Focus E0 (27hp) now; A2 close in and fire.\n A1 (2.0s): Focusing E0 (27hp). A2 get in range and attack E0.\n A2 (2.0s): Attacking E0 now, closing in with you both.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 at 9hp, finishing it now; then everyone focus E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-320071652e80475c67d7eabf.json b/examples/multi-agent-smax/results/llm-cache/ask-320071652e80475c67d7eabf.json new file mode 100644 index 00000000..0e3d98ab --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-320071652e80475c67d7eabf.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.0 seconds into the battle.\nYou are A2, a marine at (7.6, 17.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.9, 16.7), 45/45 health, order: hold\n A1 marine at (7.8, 14.9), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (12.9, 15.3), 45/45 health, 5.8 away\n E1 marine at (15.4, 15.6), 45/45 health, 8.1 away\n E2 marine at (15.0, 17.7), 45/45 health, 7.4 away\nTeam chat (most recent last):\n A1 (1.5s): A1 moving to cluster with A0/A2; holding together, focus closest enemy.\n A2 (1.5s): A2 holding; no enemies yet. Focus closest when they appear.\n A0 (2.0s): A0 holding. Focus closest enemy when seen; stay tight.\n A1 (2.0s): A1 holding near cluster; E0 spotted east at (16,15.3). Focus E0 when in range.\n A2 (2.0s): E0 seen east at 16,15. Holding clustered; focus E0 when in range.\n A0 (2.5s): A0 holding. Only E0 seen; let it come into range, focus fire together.\n A1 (2.5s): A1 holding; E0 approaching, focus fire when in range.\n A2 (2.5s): A2 holding; E0 approaching, focus it when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A2 holding; E0 closest at 5.8, focus E0 together when in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-33981fc88e836b636fe00d30.json b/examples/multi-agent-smax/results/llm-cache/ask-33981fc88e836b636fe00d30.json new file mode 100644 index 00000000..4276c8fa --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-33981fc88e836b636fe00d30.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.0 seconds into the battle.\nYou are A0, a marine at (8.5, 15.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 9 16.5.\nYour team:\n A1 marine at (8.1, 17.5), 45/45 health, order: move 8 16.5\n A2 marine at (8.9, 16.7), 45/45 health, order: move 10 17\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together at the cluster; focus fire on the closest enemy when they appear.\n A1 (0.0s): Advancing east together; stay close and focus fire on the nearest enemy.\n A2 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A0 (0.5s): A1 fell back toward cluster; I'm moving to x=9 so we stay grouped.\n A1 (0.5s): Falling back to cluster; hold together and focus the closest enemy.\n A2 (0.5s): A1 is ahead alone; moving up to group with A1, then focus nearest enemy.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 9 16.5\", \"say\": \"Grouped at x=9; hold here and focus the closest enemy when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-33fcdcce3e8aca7107e9549e.json b/examples/multi-agent-smax/results/llm-cache/ask-33fcdcce3e8aca7107e9549e.json new file mode 100644 index 00000000..69846d48 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-33fcdcce3e8aca7107e9549e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.5 seconds into the battle.\nYou are A1, a marine at (10.1, 17.3) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0: dead\n A2 marine at (9.9, 15.8), 45/45 health, order: attack E1\nEnemies you can see:\n E1 marine at (13.8, 17.3), 27/45 health, 3.7 away (in range)\n E2 marine at (14.4, 14.8), 45/45 health, 5.0 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (3.0s): E0 in range, attacking E0 now. Everyone focus E0.\n A2 (3.0s): Attacking E0 now, E0 in range. Everyone focus fire E0.\n A0 (3.5s): Keep focusing E0 (18hp), then E1.\n A1 (3.5s): Keep focusing E0, it's at 18 health. Then E1.\n A2 (3.5s): E0 at 18hp, keep focusing E0, then E2.\n A0 (4.0s): E0 dead. Focus E1 (3.6 away), then E2. I'm at 18hp.\n A1 (4.0s): E0 dead. Focus E1 (closest, 3.7 away), then E2.\n A2 (4.0s): E0 dead. Focus E1 (4.2 away), then E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Focusing E1 (27hp), then E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-344c56588c9f732a6dc40feb.json b/examples/multi-agent-smax/results/llm-cache/ask-344c56588c9f732a6dc40feb.json new file mode 100644 index 00000000..78c14e20 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-344c56588c9f732a6dc40feb.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.5 seconds into the battle.\nYou are A0, a marine at (9.3, 15.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1 marine at (10.0, 15.5), 18/45 health, order: attack E1\n A2: dead\nEnemies you can see:\n E0 marine at (13.5, 17.3), 45/45 health, 4.4 away (in range)\n E1 marine at (13.5, 16.6), 18/45 health, 4.2 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (4.0s): Switching to E2, in range at 4.7. A1 and I focus E2.\n A1 (4.0s): Firing on E2 (36hp, in range). A0 switch to E2. A2 stay back.\n A2 (4.0s): A2 hurt but farthest back, firing on E2 from range. Focus E2.\n A0 (4.5s): E2 at 18hp, finishing it now. Then focus E1 (36hp).\n A1 (4.5s): E2 at 18hp, finish it now, then E1.\n A2 (4.5s): Firing on E2 (18hp), one more volley kills it. Then E1.\n A0 (5.0s): E2 down. Focus E1 (36hp), then E0.\n A1 (5.0s): E2 down. Focus E1 (36hp), then E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Focusing E1 (18hp), both of us fire. Then E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-346019ffa1d942f02d66d42b.json b/examples/multi-agent-smax/results/llm-cache/ask-346019ffa1d942f02d66d42b.json new file mode 100644 index 00000000..be7296b7 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-346019ffa1d942f02d66d42b.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 0.5 seconds into the battle.\nYou are A2, a marine at (9.2, 14.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 16 16.\nYour team:\n A0 marine at (10.6, 16.0), 45/45 health, order: move 11 16\n A1 marine at (8.9, 14.1), 45/45 health, order: move 14 15\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Advancing east together; stay within 2 of each other, A1 and A2 keep pace.\n A1 (0.0s): Moving east together toward center, stay within 2 of each other.\n A2 (0.0s): Moving together to center, stay within 2 of each other; attack same target when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 15\", \"say\": \"Keeping pace east, staying close; will focus same target once in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-351b5ef56807ee2bbaf1c312.json b/examples/multi-agent-smax/results/llm-cache/ask-351b5ef56807ee2bbaf1c312.json new file mode 100644 index 00000000..7ac819cb --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-351b5ef56807ee2bbaf1c312.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 4.0 seconds into the battle.\nYou are A1, a marine at (14.2, 16.3) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (13.7, 15.6), 27/45 health, order: attack E0\n A2: dead\nEnemies you can see:\n E0 marine at (17.0, 17.7), 36/45 health, 3.1 away (in range)\n E1 marine at (17.9, 16.0), 45/45 health, 3.7 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (2.5s): All in range now. Everyone focus E2, it's at 36hp.\n A2 (2.5s): All in range now. Focus E2 (36hp), everyone attack E2 this tick.\n A0 (3.0s): E2 at 9hp, finish it now, then focus E1.\n A1 (3.0s): E2 at 9hp, finish it now, then focus E0.\n A2 (3.0s): E2 at 9hp, finish it now, then focus E0.\n A0 (3.5s): E2 dead. Everyone focus E0 now. A2 at 9hp, retreat.\n A1 (3.5s): E2 dead. All focus E0 now, then E1. A2 retreat, you're at 9hp.\n A2 (3.5s): A2 at 9hp retreating. A0, A1 focus E0 now.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Focus E0 (36hp), then E1. A0 at 27hp, stay in unless under 20.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-351cfd1e701b5da1edce7bd4.json b/examples/multi-agent-smax/results/llm-cache/ask-351cfd1e701b5da1edce7bd4.json new file mode 100644 index 00000000..66b8d6aa --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-351cfd1e701b5da1edce7bd4.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 2.5 seconds into the battle.\nYou are A1, a marine at (13.0, 15.0) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (12.8, 15.9), 36/45 health, order: attack E2\n A2 marine at (13.0, 14.3), 45/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (17.3, 15.0), 45/45 health, 4.4 away (in range)\n E1 marine at (16.6, 14.0), 45/45 health, 3.8 away (in range)\n E2 marine at (16.6, 16.8), 18/45 health, 4.0 away (in range)\nTeam chat (most recent last):\n A1 (1.0s): A1 continuing to (12,15), staying close; attack same target on contact.\n A2 (1.0s): Holding formation at (12,15); will advance together, then all attack E2 at once.\n A0 (1.5s): A0 closing on group at (12,16); then all advance together on E2.\n A1 (1.5s): Moving to (14,16) with A0; enemies close, then all attack E2 together.\n A2 (1.5s): Moving to (14,16) with A0; enemies ~5 away next, then all attack E2 together.\n A0 (2.0s): E2 in range of all three. Attack E2 now, together.\n A1 (2.0s): All in range of E2 now. Attack E2 together.\n A2 (2.0s): E2 in range of all three. Attack E2 now, together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Firing on E2 (18hp), keep attacking until it dies.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-35ee743a56a9f01c7c93f23f.json b/examples/multi-agent-smax/results/llm-cache/ask-35ee743a56a9f01c7c93f23f.json new file mode 100644 index 00000000..dd703719 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-35ee743a56a9f01c7c93f23f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.5 seconds into the battle.\nYou are A1, a marine at (7.8, 14.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.9, 16.7), 45/45 health, order: hold\n A2 marine at (7.6, 17.8), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (11.3, 15.3), 45/45 health, 3.5 away (in range)\n E1 marine at (13.8, 15.6), 45/45 health, 6.1 away\n E2 marine at (13.5, 17.7), 45/45 health, 6.3 away\nTeam chat (most recent last):\n A1 (2.0s): A1 holding near cluster; E0 spotted east at (16,15.3). Focus E0 when in range.\n A2 (2.0s): E0 seen east at 16,15. Holding clustered; focus E0 when in range.\n A0 (2.5s): A0 holding. Only E0 seen; let it come into range, focus fire together.\n A1 (2.5s): A1 holding; E0 approaching, focus fire when in range.\n A2 (2.5s): A2 holding; E0 approaching, focus it when in range.\n A0 (3.0s): A0 holding; all 3 enemies visible. Focus E0 when in range, stay tight.\n A1 (3.0s): A1 holding; E0 at 5.1, focus E0 when in range, stay tight.\n A2 (3.0s): A2 holding; E0 closest at 5.8, focus E0 together when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"A1 attacking E0 now, everyone focus E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-366bb12ce65a1023d8eb1c59.json b/examples/multi-agent-smax/results/llm-cache/ask-366bb12ce65a1023d8eb1c59.json new file mode 100644 index 00000000..37e4b886 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-366bb12ce65a1023d8eb1c59.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 9.5 seconds into the battle.\nYou are A1, a marine at (8.9, 14.1) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E1 marine at (13.1, 16.8), 9/45 health, 5.0 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A2 (6.0s): E2 at 9hp, finish it, then all on E1.\n A1 (6.5s): E2 dead. All focus E1, it's at 45hp, 5.0 away.\n A2 (6.5s): E2 dead. I'm at 9hp, backing off. A1 focus E1, I'll rejoin.\n A1 (7.0s): Engaging E1 at 36hp, in range. A2 stay back and heal up.\n A1 (7.5s): Still on E1, 36hp. A2 stay back and heal.\n A1 (8.0s): E1 at 27hp, still firing. A2 stay back.\n A1 (8.5s): E1 at 18hp, still firing. Last enemy, I'm at 27hp.\n A1 (9.0s): E1 at 18hp, still firing. I'm at 27hp, keep going.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E1 at 9hp, I'm at 18hp. Finishing it.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-37001e028c705874aba1c51c.json b/examples/multi-agent-smax/results/llm-cache/ask-37001e028c705874aba1c51c.json new file mode 100644 index 00000000..ca431632 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-37001e028c705874aba1c51c.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.5 seconds into the battle.\nYou are A2, a marine at (9.0, 16.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.2, 16.2), 45/45 health, order: hold\n A1 marine at (9.8, 15.7), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together as a group; focus fire on the closest enemy when they appear.\n A0 (0.5s): No enemies yet; staying grouped, will focus the closest enemy when seen.\n A1 (0.5s): Holding position; will focus fire on closest enemy once visible.\n A2 (0.5s): Holding. Will focus fire on the closest enemy once visible.\n A0 (1.0s): Still no enemies; holding grouped, focus closest when seen.\n A1 (1.0s): Still no enemies; holding grouped, will focus closest when seen.\n A2 (1.0s): Still no enemies. Holding; will focus the closest enemy when seen.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Still holding grouped; will focus the closest enemy when it appears.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-379145ce573aca9b58d2e86a.json b/examples/multi-agent-smax/results/llm-cache/ask-379145ce573aca9b58d2e86a.json new file mode 100644 index 00000000..194559ca --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-379145ce573aca9b58d2e86a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.0 seconds into the battle.\nYou are A2, a marine at (8.2, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.8, 14.7), 45/45 health, order: hold\n A1 marine at (8.5, 14.8), 45/45 health, order: hold\nEnemies you can see:\n E2 marine at (16.6, 16.8), 45/45 health, 8.7 away\nTeam chat (most recent last):\n A1 (0.5s): Closing to (8,15) to cluster; will focus closest enemy.\n A2 (0.5s): Moving to regroup at (8,15); will focus fire closest enemy.\n A0 (1.0s): Moving to cluster at (8,15); will focus fire closest enemy.\n A1 (1.0s): A1 at (8,15) holding. Focus fire on closest enemy.\n A2 (1.0s): A2 at (8,14) holding; will focus the closest enemy when it appears.\n A0 (1.5s): A0 holding at (8,15); focus fire on the closest enemy when seen.\n A1 (1.5s): A1 holding at cluster; focus fire on closest enemy when seen.\n A2 (1.5s): A2 holding at (8,14). Clustered; focus fire on closest enemy.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"E2 spotted east at 8.7 range. Holding cluster; let them come, focus first in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-37a2bafbe6b64a7635b170d5.json b/examples/multi-agent-smax/results/llm-cache/ask-37a2bafbe6b64a7635b170d5.json new file mode 100644 index 00000000..40178187 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-37a2bafbe6b64a7635b170d5.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.0 seconds into the battle.\nYou are A2, a marine at (8.1, 14.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (8.1, 15.8), 27/45 health, order: attack E1\n A1 marine at (6.8, 14.1), 9/45 health, order: retreat\nEnemies you can see:\n E0 marine at (12.9, 15.0), 45/45 health, 4.8 away (in range)\n E1 marine at (11.8, 16.2), 45/45 health, 3.9 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (3.5s): Focus E2 now, then E0. Everyone fire.\n A2 (3.5s): Focusing E2 now, then E0. All fire E2.\n A0 (4.0s): E2 is at 18 HP, finish it, then E1.\n A1 (4.0s): Firing E2 (18hp). Then E0. I'm at 27hp.\n A2 (4.0s): Firing E2 (18 hp left), then E0. Stay grouped.\n A0 (4.5s): E2 is down. Focus E1 (closest), then E0. A1 fall back if hurt.\n A1 (4.5s): A1 at 9hp, falling back. Focus E1 (closest to A0), then E0.\n A2 (4.5s): E2 is dead. Focus E1 (closest, 3.9 away), then E0. A1 is at 9hp, so stay behind.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Firing E1 (closest). A0 focus E1 too, then E0. A1 stay back.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-37e890a88216af3fca0dfb10.json b/examples/multi-agent-smax/results/llm-cache/ask-37e890a88216af3fca0dfb10.json new file mode 100644 index 00000000..188ce691 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-37e890a88216af3fca0dfb10.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.0 seconds into the battle.\nYou are A1, a marine at (9.8, 15.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.2, 16.2), 45/45 health, order: hold\n A2 marine at (9.0, 16.2), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding together; focus fire on the closest enemy when they appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-385ab1b2c3651333f6507514.json b/examples/multi-agent-smax/results/llm-cache/ask-385ab1b2c3651333f6507514.json new file mode 100644 index 00000000..2c0b1a8e --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-385ab1b2c3651333f6507514.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.0 seconds into the battle.\nYou are A2, a marine at (8.1, 14.9) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (8.1, 15.8), 18/45 health, order: attack E1\n A1 marine at (3.6, 14.1), 9/45 health, order: retreat\nEnemies you can see:\n E0 marine at (12.9, 15.0), 45/45 health, 4.8 away (in range)\n E1 marine at (11.8, 16.2), 9/45 health, 3.9 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (4.5s): A1 at 9hp, falling back. Focus E1 (closest to A0), then E0.\n A2 (4.5s): E2 is dead. Focus E1 (closest, 3.9 away), then E0. A1 is at 9hp, so stay behind.\n A0 (5.0s): Focus E1 (3.7 away). A1 stay back. Then E0.\n A1 (5.0s): A1 at 9hp staying back. Focus E1 then E0, keep grouped.\n A2 (5.0s): Firing E1 (closest). A0 focus E1 too, then E0. A1 stay back.\n A0 (5.5s): Firing E1 (27hp). A1 stay back. Then E0.\n A1 (5.5s): A1 at 9hp staying back; focus E1 then E0.\n A2 (5.5s): Firing E1 (27hp). A0 keep focus, then E0. A1 stay back.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Firing E1 (9hp), nearly dead. Then E0 together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-389da7f6c70655aadc8bc580.json b/examples/multi-agent-smax/results/llm-cache/ask-389da7f6c70655aadc8bc580.json new file mode 100644 index 00000000..fc42fcbf --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-389da7f6c70655aadc8bc580.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 9.0 seconds into the battle.\nYou are A1, a marine at (8.9, 14.1) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E1 marine at (13.1, 16.8), 18/45 health, 5.0 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (6.0s): Firing E2 (9hp), then E1. A0 stay back, low hp.\n A2 (6.0s): E2 at 9hp, all fire E2 now, then E1.\n A1 (6.5s): E2 down. All fire E1, 45hp. A2 stay back, low hp.\n A2 (6.5s): E2 dead. Only E1 left. A1 tank and focus E1, I'm at 9hp and falling back.\n A1 (7.0s): Engaging E1 alone, 36hp. I'm at full health, firing.\n A1 (7.5s): Keep firing E1 at 36hp. I'm full health, holding the line.\n A1 (8.0s): A1 firing E1 at 27hp, last enemy. A0 and A2 stay back.\n A1 (8.5s): E1 at 18hp, still firing. Last enemy, A1 holding.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A1 firing E1 at 18hp, last enemy. Staying on it.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-38a554e73b032297c6589e36.json b/examples/multi-agent-smax/results/llm-cache/ask-38a554e73b032297c6589e36.json new file mode 100644 index 00000000..dde5cd88 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-38a554e73b032297c6589e36.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.5 seconds into the battle.\nYou are A1, a marine at (8.9, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (10.6, 16.0), 27/45 health, order: attack E0\n A2 marine at (10.8, 14.8), 36/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (12.4, 16.4), 18/45 health, 4.2 away (in range)\n E1 marine at (13.1, 16.8), 45/45 health, 5.0 away (in range)\n E2 marine at (13.1, 15.5), 45/45 health, 4.4 away (in range)\nTeam chat (most recent last):\n A1 (3.0s): Holding grouped. Enemies ~7 away; let them come into range, focus E0.\n A2 (3.0s): Holding at range; all focus E0 when it enters 5 range.\n A0 (3.5s): E0 at 5 range. All focus E0 now.\n A1 (3.5s): Holding. Focus E0 when in range; stay grouped.\n A2 (3.5s): E0 at range 5. Everyone attack E0 now, focus fire.\n A0 (4.0s): Focusing E0 now. A1 please attack E0 too, all fire together.\n A1 (4.0s): Attacking E0 now, focus fire.\n A2 (4.0s): All attack E0 now, in range. A1 switch from hold to attack E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Firing on E0, 18 hp left. Next target E2 (closest).\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-38cd767e1ddc91175ce57dc9.json b/examples/multi-agent-smax/results/llm-cache/ask-38cd767e1ddc91175ce57dc9.json new file mode 100644 index 00000000..ab98171c --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-38cd767e1ddc91175ce57dc9.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 8.5 seconds into the battle.\nYou are A0, a marine at (5.2, 17.0) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: retreat.\nYour team:\n A1: dead\n A2: dead\nEnemies you can see:\n E0 marine at (11.4, 17.8), 45/45 health, 6.3 away\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (5.0s): Focusing E1 (36hp), both in range. A2 stay behind me, you're low.\n A2 (5.0s): Focus E1 (36hp), I'm low at 18hp. A0 keep firing, then E0.\n A0 (5.5s): A0 on E1 (18hp), almost dead. Then E0.\n A0 (6.0s): Finishing E1 (18hp), then E0. A2 stay back.\n A0 (6.5s): E1 at 9hp, finishing it now, then E0. A0 at 27hp.\n A0 (7.0s): E1 down. A0 at 9hp, E0 at 45hp left. Pulling out of range.\n A0 (7.5s): A0 at 9hp, last one alive. Kiting away from E0.\n A0 (8.0s): A0 last alive, 9hp, kiting E0 out of its range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"retreat\", \"say\": \"A0 last alive, 9hp, still kiting E0 away from its range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-39387581e19937cfb9661af8.json b/examples/multi-agent-smax/results/llm-cache/ask-39387581e19937cfb9661af8.json new file mode 100644 index 00000000..3e7f254d --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-39387581e19937cfb9661af8.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 3.0 seconds into the battle.\nYou are A1, a marine at (14.2, 16.3) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (13.7, 15.6), 27/45 health, order: attack E2\n A2 marine at (14.9, 18.0), 27/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (17.0, 17.7), 45/45 health, 3.1 away (in range)\n E1 marine at (17.9, 16.0), 45/45 health, 3.7 away (in range)\n E2 marine at (18.1, 14.7), 9/45 health, 4.3 away (in range)\nTeam chat (most recent last):\n A1 (1.5s): Enemy E2 at (19.7,14.7). Advancing together to 15,16; attack E2 when all in range.\n A2 (1.5s): Enemies ~8 east. Advancing together to x=15; stay within 2, then focus E0.\n A0 (2.0s): E2 in my range, firing now. A1, A2 close in and focus E2.\n A1 (2.0s): Moving with you to 15,16; next tick all attack E2 together.\n A2 (2.0s): Closing to 15,17 together; once all in range 5, everyone attack E0 same tick.\n A0 (2.5s): All in range now. Everyone attack E2 this tick.\n A1 (2.5s): All in range now. Everyone focus E2, it's at 36hp.\n A2 (2.5s): All in range now. Focus E2 (36hp), everyone attack E2 this tick.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 at 9hp, finish it now, then focus E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-3974ba0bbcdf3a037c783eaf.json b/examples/multi-agent-smax/results/llm-cache/ask-3974ba0bbcdf3a037c783eaf.json new file mode 100644 index 00000000..c4fb89a5 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-3974ba0bbcdf3a037c783eaf.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.0 seconds into the battle.\nYou are A1, a marine at (7.8, 14.9) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (8.5, 16.7), 45/45 health, order: attack E2\n A2 marine at (7.6, 17.8), 27/45 health, order: attack E2\nEnemies you can see:\n E1 marine at (12.3, 15.6), 36/45 health, 4.5 away (in range)\n E2 marine at (11.9, 17.7), 45/45 health, 5.0 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (3.5s): A1 attacking E0 now, everyone focus E0.\n A2 (3.5s): A2 attacking E0 now, everyone focus E0 together.\n A0 (4.0s): A0 firing E0 (18hp left), finish it then switch to E2.\n A1 (4.0s): E0 at 18 hp, keep focusing E0 then E1.\n A2 (4.0s): A2 firing on E0, 18 hp left, finish it then E2.\n A0 (4.5s): E0 dead. Focus E2 together, then E1. A1 stay back, you're low.\n A1 (4.5s): E0 dead. A1 on E1 at 4.5, focus E1 together; A2 close in.\n A2 (4.5s): E0 is down; all focus E2 (in range, closest), then E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"A1 low, shooting E2 from back. A0 you're tanking, focus E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-39ddfaeb7db2b5c4f95a025c.json b/examples/multi-agent-smax/results/llm-cache/ask-39ddfaeb7db2b5c4f95a025c.json new file mode 100644 index 00000000..dd7dd623 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-39ddfaeb7db2b5c4f95a025c.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.5 seconds into the battle.\nYou are A0, a marine at (6.9, 16.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (9.4, 14.9), 45/45 health, order: hold\n A2 marine at (7.6, 17.8), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on closest enemy when they appear.\n A0 (0.5s): A0 holding; will focus fire on the closest enemy that appears.\n A1 (0.5s): A1 holding; will focus fire on closest enemy once visible.\n A2 (0.5s): Holding; staying clustered near A0 until enemies appear, then focus closest.\n A0 (1.0s): A0 holding; A1 move closer to cluster, focus closest enemy when seen.\n A1 (1.0s): A1 holding; will focus closest enemy. Staying near A0 and A2.\n A2 (1.0s): A2 holding; no enemies seen yet, will focus closest when they appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A0 holding. Stay clustered; focus fire on closest enemy when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-3aeef057d8f295a9b82def4f.json b/examples/multi-agent-smax/results/llm-cache/ask-3aeef057d8f295a9b82def4f.json new file mode 100644 index 00000000..6968e391 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-3aeef057d8f295a9b82def4f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 4.5 seconds into the battle.\nYou are A0, a marine at (13.7, 15.6) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1 marine at (14.2, 16.3), 36/45 health, order: attack E0\n A2: dead\nEnemies you can see:\n E0 marine at (17.0, 17.7), 18/45 health, 3.9 away (in range)\n E1 marine at (17.9, 16.0), 45/45 health, 4.2 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (3.0s): E2 at 9hp, finish it now, then focus E1.\n A1 (3.0s): E2 at 9hp, finish it now, then focus E0.\n A2 (3.0s): E2 at 9hp, finish it now, then focus E0.\n A0 (3.5s): E2 dead. Everyone focus E0 now. A2 at 9hp, retreat.\n A1 (3.5s): E2 dead. All focus E0 now, then E1. A2 retreat, you're at 9hp.\n A2 (3.5s): A2 at 9hp retreating. A0, A1 focus E0 now.\n A0 (4.0s): Focus E0 (36hp), then E1. I'm 27hp, staying in.\n A1 (4.0s): Focus E0 (36hp), then E1. A0 at 27hp, stay in unless under 20.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 at 18hp, keep focusing it, then E1. I'm 27hp, staying in.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-3b24592ebc961a7bbd8d580e.json b/examples/multi-agent-smax/results/llm-cache/ask-3b24592ebc961a7bbd8d580e.json new file mode 100644 index 00000000..1c5400cb --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-3b24592ebc961a7bbd8d580e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 1.0 seconds into the battle.\nYou are A1, a marine at (10.9, 16.4) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 16.\nYour team:\n A0 marine at (10.1, 16.7), 45/45 health, order: move 12 16\n A2 marine at (10.7, 17.8), 45/45 health, order: move 12 16\nEnemies you can see:\n E0 marine at (19.2, 15.3), 45/45 health, 8.3 away\nTeam chat (most recent last):\n A0 (0.0s): Moving east together to (12,16); stay close, no one run ahead.\n A1 (0.0s): Moving together east to (15,16); stay within 2 of each other, attack same target.\n A2 (0.0s): Moving east together toward center, stay within 2 of each other; attack same target on contact.\n A0 (0.5s): A1 please converge on (12,16) with us; A1 is ahead, stay within 2.\n A1 (0.5s): Joining A0 and A2 at (12,16); staying grouped, then advance together.\n A2 (0.5s): A2 moving to (12,16) with team; will attack together on contact.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 16\", \"say\": \"Holding formation at (12,16); then all advance and attack E0 together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-3baa21fbf635486c7e392171.json b/examples/multi-agent-smax/results/llm-cache/ask-3baa21fbf635486c7e392171.json new file mode 100644 index 00000000..e05c15fb --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-3baa21fbf635486c7e392171.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 3.0 seconds into the battle.\nYou are A1, a marine at (14.6, 15.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (14.2, 16.2), 45/45 health, order: attack E1\n A2: dead\nEnemies you can see:\n E0 marine at (18.2, 17.3), 45/45 health, 4.1 away (in range)\n E1 marine at (18.2, 16.6), 9/45 health, 3.8 away (in range)\n E2 marine at (18.4, 14.1), 45/45 health, 4.1 away (in range)\nTeam chat (most recent last):\n A1 (1.5s): A1 holding near 14,16 so A0 and A2 catch up; all attack E1 together.\n A2 (1.5s): Advancing together to (15,16); all attack E1 once in range 5.\n A0 (2.0s): Enemies in range now. All attack E1, A1 close in.\n A1 (2.0s): A1 attacking E1 now; A0 and A2 are in range, focus E1.\n A2 (2.0s): Enemies in range of me and A0. Attacking E1 now; A1 close in and fire on E1.\n A0 (2.5s): Focus E1 (27hp). A2 low at 18hp, retreat if needed.\n A1 (2.5s): Firing on E1 (27hp). A2 at 18hp, retreat if under 20.\n A2 (2.5s): A2 at 18hp retreating to pull fire off me; A0, A1 keep focusing E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E1 at 9hp, finishing it now. A0 fire E1, then focus E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-3bab615b325f5a65689abe23.json b/examples/multi-agent-smax/results/llm-cache/ask-3bab615b325f5a65689abe23.json new file mode 100644 index 00000000..3d32c9bb --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-3bab615b325f5a65689abe23.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 1.5 seconds into the battle.\nYou are A2, a marine at (11.7, 18.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 17.\nYour team:\n A0 marine at (11.9, 15.8), 45/45 health, order: move 12 17\n A1 marine at (11.3, 16.1), 45/45 health, order: move 12 17\nEnemies you can see:\n E0 marine at (20.2, 17.7), 45/45 health, 8.4 away\n E2 marine at (19.7, 14.7), 45/45 health, 8.6 away\nTeam chat (most recent last):\n A1 (0.0s): Moving east together toward the center; stay within 2 of each other.\n A2 (0.0s): Advancing east together, stay within 2 of each other; attack same target when in range.\n A0 (0.5s): Continuing to (12,17); keep within 2 of each other.\n A1 (0.5s): Moving to (12,17) with A0; keep together, then focus same target.\n A2 (0.5s): Moving to (12,17) with A0; keep within 2, attack together when enemies appear.\n A0 (1.0s): Continuing to (12,17) together; no enemies yet, attack same target when seen.\n A1 (1.0s): Continuing to (12,17), staying within 2 of A0 and A2.\n A2 (1.0s): Continuing to (12,17); no enemies yet, stay within 2, attack together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 15 17\", \"say\": \"Enemies ~8 east. Advancing together to x=15; stay within 2, then focus E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-3be783a6518bc44693bb38f0.json b/examples/multi-agent-smax/results/llm-cache/ask-3be783a6518bc44693bb38f0.json new file mode 100644 index 00000000..52fea084 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-3be783a6518bc44693bb38f0.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.5 seconds into the battle.\nYou are A2, a marine at (9.9, 15.8) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0: dead\n A1 marine at (10.1, 17.3), 36/45 health, order: attack E1\nEnemies you can see:\n E2 marine at (14.4, 14.8), 45/45 health, 4.6 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A2 (3.5s): E0 at 18hp, keep focusing E0, then E2.\n A0 (4.0s): E0 dead. Focus E1 (3.6 away), then E2. I'm at 18hp.\n A1 (4.0s): E0 dead. Focus E1 (closest, 3.7 away), then E2.\n A2 (4.0s): E0 dead. Focus E1 (4.2 away), then E2.\n A1 (4.5s): Focusing E1 (27hp), then E2.\n A2 (4.5s): Focusing E1 (27hp), then E2.\n A1 (5.0s): Focusing E1 (18hp), almost dead. Then E2.\n A2 (5.0s): Attacking E1 (18hp), then E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E1 down. All focus E2, 4.6 away, 45hp.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-3c86c253ad56ca86ff6e6da6.json b/examples/multi-agent-smax/results/llm-cache/ask-3c86c253ad56ca86ff6e6da6.json new file mode 100644 index 00000000..64a8876b --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-3c86c253ad56ca86ff6e6da6.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 2.0 seconds into the battle.\nYou are A0, a marine at (13.4, 16.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1 marine at (13.2, 15.3), 36/45 health, order: attack E0\n A2 marine at (12.7, 16.6), 45/45 health, order: move 14 16\nEnemies you can see:\n E0 marine at (17.8, 15.1), 27/45 health, 4.7 away (in range)\n E1 marine at (17.7, 16.7), 45/45 health, 4.4 away (in range)\n E2 marine at (19.0, 17.1), 45/45 health, 5.6 away\nTeam chat (most recent last):\n A1 (0.5s): Continuing east to (14,16), staying close to A0 and A2.\n A2 (0.5s): Moving to (14,16) with A0 and A1, staying close; will focus the first enemy seen.\n A0 (1.0s): Enemy E0 seen east at 7.8. Keep grouped; attack E0 together when within range.\n A1 (1.0s): E0 spotted east at (19.3,15.1). Keep moving together; attack when in range 5 of all.\n A2 (1.0s): A2 continuing to (14,16), staying close; will focus first enemy seen.\n A0 (1.5s): E0 in range of A0 and A1. Attack E0 now; A2 close in and focus E0.\n A1 (1.5s): E0 in range of A1 and A0. A2 close in, everyone focus E0 now.\n A2 (1.5s): E0 at 6.7, not in range yet. Moving up together; attack E0 on same tick.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Focus E0 (27hp) now; A2 close in and fire.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-3cfa79680a78ecb992eceb6f.json b/examples/multi-agent-smax/results/llm-cache/ask-3cfa79680a78ecb992eceb6f.json new file mode 100644 index 00000000..4e8c6e0c --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-3cfa79680a78ecb992eceb6f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 1.5 seconds into the battle.\nYou are A2, a marine at (12.3, 17.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 17.\nYour team:\n A0 marine at (12.3, 15.8), 45/45 health, order: move 14 17\n A1 marine at (11.9, 17.2), 45/45 health, order: move 14 17\nEnemies you can see:\n E0 marine at (20.6, 17.1), 45/45 health, 8.3 away\n E1 marine at (19.4, 17.1), 45/45 health, 7.1 away\n E2 marine at (17.3, 16.7), 45/45 health, 5.1 away\nTeam chat (most recent last):\n A1 (0.0s): Moving east together to find enemies; stay within 2 of each other, fire together.\n A2 (0.0s): Moving east together to find enemies; stay close, attack same target when in range.\n A0 (0.5s): Moving east in formation; will attack same target once all in range.\n A1 (0.5s): Moving east in a tight group; will attack same target together.\n A2 (0.5s): Moving east in formation; A0 and A1 keep pace, no one pull ahead.\n A0 (1.0s): Advancing together toward E2; hold pace, attack same target once all in range 5.\n A1 (1.0s): Advancing east together toward E2; keep within 2, attack same target at range.\n A2 (1.0s): Closing together toward E2; hold pace, all fire on E2 once in range 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 17\", \"say\": \"Still closing together; E2 just outside range. Fire on E2 once all in range 5.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-3ddc4822e787b772a411aa0f.json b/examples/multi-agent-smax/results/llm-cache/ask-3ddc4822e787b772a411aa0f.json new file mode 100644 index 00000000..d2119c9e --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-3ddc4822e787b772a411aa0f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.0 seconds into the battle.\nYou are A1, a marine at (10.0, 15.5) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (9.3, 15.9), 45/45 health, order: attack E2\n A2: dead\nEnemies you can see:\n E0 marine at (13.5, 17.3), 45/45 health, 4.0 away (in range)\n E1 marine at (13.5, 16.6), 36/45 health, 3.7 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (3.5s): E1 out of range; E2 in range at 4.1. Everyone focus E2.\n A2 (3.5s): A2 hurt, pulling back west to you. Fire on E1 when they follow into range.\n A0 (4.0s): Switching to E2, in range at 4.7. A1 and I focus E2.\n A1 (4.0s): Firing on E2 (36hp, in range). A0 switch to E2. A2 stay back.\n A2 (4.0s): A2 hurt but farthest back, firing on E2 from range. Focus E2.\n A0 (4.5s): E2 at 18hp, finishing it now. Then focus E1 (36hp).\n A1 (4.5s): E2 at 18hp, finish it now, then E1.\n A2 (4.5s): Firing on E2 (18hp), one more volley kills it. Then E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E2 down. Focus E1 (36hp), then E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-3e206b2321ced06b0f248fea.json b/examples/multi-agent-smax/results/llm-cache/ask-3e206b2321ced06b0f248fea.json new file mode 100644 index 00000000..95069f4c --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-3e206b2321ced06b0f248fea.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.5 seconds into the battle.\nYou are A2, a marine at (7.6, 17.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.9, 16.7), 45/45 health, order: hold\n A1 marine at (7.8, 14.9), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (11.3, 15.3), 45/45 health, 4.5 away (in range)\n E1 marine at (13.8, 15.6), 45/45 health, 6.6 away\n E2 marine at (13.5, 17.7), 45/45 health, 5.9 away\nTeam chat (most recent last):\n A1 (2.0s): A1 holding near cluster; E0 spotted east at (16,15.3). Focus E0 when in range.\n A2 (2.0s): E0 seen east at 16,15. Holding clustered; focus E0 when in range.\n A0 (2.5s): A0 holding. Only E0 seen; let it come into range, focus fire together.\n A1 (2.5s): A1 holding; E0 approaching, focus fire when in range.\n A2 (2.5s): A2 holding; E0 approaching, focus it when in range.\n A0 (3.0s): A0 holding; all 3 enemies visible. Focus E0 when in range, stay tight.\n A1 (3.0s): A1 holding; E0 at 5.1, focus E0 when in range, stay tight.\n A2 (3.0s): A2 holding; E0 closest at 5.8, focus E0 together when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"A2 attacking E0 now, everyone focus E0 together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-3e8a5424f8410fe0c52167af.json b/examples/multi-agent-smax/results/llm-cache/ask-3e8a5424f8410fe0c52167af.json new file mode 100644 index 00000000..be03efa4 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-3e8a5424f8410fe0c52167af.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 0.5 seconds into the battle.\nYou are A0, a marine at (10.1, 18.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 17.\nYour team:\n A1 marine at (10.2, 17.2), 45/45 health, order: move 14 17\n A2 marine at (10.0, 16.0), 45/45 health, order: move 12 16\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Moving east together, stay within 2 of each other; no one engage alone.\n A1 (0.0s): Moving east together toward enemies; keep within 2 of each other, attack together.\n A2 (0.0s): Moving east together toward enemies, stay within 2 of each other; attack same target on call.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 17\", \"say\": \"Moving east together, keeping formation; will attack same target when all in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-3ea4218f781bc0a71855877f.json b/examples/multi-agent-smax/results/llm-cache/ask-3ea4218f781bc0a71855877f.json new file mode 100644 index 00000000..a8b5a366 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-3ea4218f781bc0a71855877f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 8.5 seconds into the battle.\nYou are A0, a marine at (3.2, 16.2) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: retreat.\nYour team:\n A1 marine at (5.1, 15.5), 18/45 health, order: attack E0\n A2: dead\nEnemies you can see:\n E0 marine at (8.8, 17.3), 27/45 health, 5.7 away\n E2 marine at (9.0, 14.1), 45/45 health, 6.1 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (6.5s): A0 9hp retreating west; A1 stay out of range, we regroup.\n A1 (6.5s): A1 18hp retreating west with A0; out of range, regroup before engaging.\n A0 (7.0s): A0 9hp still retreating west; A1 stay with me, out of range.\n A1 (7.0s): A1 18hp retreating west; enemies 7 away, out of range. Stay together.\n A0 (7.5s): A0 9hp retreating west; A1 stay with me, out of range of E0 and E2.\n A1 (7.5s): A1 18hp retreating west; staying with A0, out of range.\n A0 (8.0s): A0 9hp retreating west; A1 keep retreating, stay out of range.\n A1 (8.0s): Cornered at west edge. Both focus E0 (27hp) now, then E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"A0 9hp joining: focus E0 (27hp) together, then E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-3ff529077aee1fb53ff61b36.json b/examples/multi-agent-smax/results/llm-cache/ask-3ff529077aee1fb53ff61b36.json new file mode 100644 index 00000000..b4a48526 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-3ff529077aee1fb53ff61b36.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 9.5 seconds into the battle.\nYou are A0, a marine at (3.6, 18.5) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 2 30.\nYour team:\n A1: dead\n A2: dead\nEnemies you can see:\n E0 marine at (8.3, 17.8), 45/45 health, 4.7 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (5.5s): A0 on E1 (18hp), almost dead. Then E0.\n A0 (6.0s): Finishing E1 (18hp), then E0. A2 stay back.\n A0 (6.5s): E1 at 9hp, finishing it now, then E0. A0 at 27hp.\n A0 (7.0s): E1 down. A0 at 9hp, E0 at 45hp left. Pulling out of range.\n A0 (7.5s): A0 at 9hp, last one alive. Kiting away from E0.\n A0 (8.0s): A0 last alive, 9hp, kiting E0 out of its range.\n A0 (8.5s): A0 last alive, 9hp, still kiting E0 away from its range.\n A0 (9.0s): A0 last alive, 9hp, running north along the wall to stay out of E0 range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 2 30\", \"say\": \"A0 last alive, 9hp, still kiting E0 north along the wall.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-4090b5ab47d5fec50c9012b1.json b/examples/multi-agent-smax/results/llm-cache/ask-4090b5ab47d5fec50c9012b1.json new file mode 100644 index 00000000..6d979901 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-4090b5ab47d5fec50c9012b1.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 6.5 seconds into the battle.\nYou are A1, a marine at (8.3, 15.5) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: retreat.\nYour team:\n A0 marine at (9.5, 16.2), 9/45 health, order: retreat\n A2: dead\nEnemies you can see:\n E0 marine at (15.1, 17.3), 27/45 health, 7.0 away\n E2 marine at (15.3, 14.1), 45/45 health, 7.1 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (4.5s): A0 firing E0 (27hp), tanking. A1 stay back, then we take E2.\n A1 (4.5s): A1 18hp staying back; A0 kill E0 (27hp), then E2.\n A0 (5.0s): A0 at 9hp retreating. A1 you hold and shoot closest; we regroup and focus E0.\n A1 (5.0s): A1 joining now, both focus E0 (27hp) to split their fire.\n A0 (5.5s): A0 9hp retreating; A1 focus E0 (27hp), I return if enemies shift.\n A1 (5.5s): A1 18hp retreating with A0; regroup and focus E0 only when both in range.\n A0 (6.0s): A0 9hp retreating west; A1 stay with me, regroup before engaging E0 (27hp).\n A1 (6.0s): A1 18hp retreating west; both out of range, regroup before re-engaging E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"retreat\", \"say\": \"A1 18hp retreating west with A0; out of range, regroup before engaging.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-415a234629c972cf820d03da.json b/examples/multi-agent-smax/results/llm-cache/ask-415a234629c972cf820d03da.json new file mode 100644 index 00000000..ed9e34cb --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-415a234629c972cf820d03da.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 8.0 seconds into the battle.\nYou are A1, a marine at (8.9, 14.1) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E1 marine at (13.1, 16.8), 27/45 health, 5.0 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A2 (5.5s): Focus E2 (18hp), then E1. Keep firing.\n A0 (6.0s): E2 at 9hp, all fire now. I'm at 9hp, finish E2 then E1.\n A1 (6.0s): Firing E2 (9hp), then E1. A0 stay back, low hp.\n A2 (6.0s): E2 at 9hp, all fire E2 now, then E1.\n A1 (6.5s): E2 down. All fire E1, 45hp. A2 stay back, low hp.\n A2 (6.5s): E2 dead. Only E1 left. A1 tank and focus E1, I'm at 9hp and falling back.\n A1 (7.0s): Engaging E1 alone, 36hp. I'm at full health, firing.\n A1 (7.5s): Keep firing E1 at 36hp. I'm full health, holding the line.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A1 firing E1 at 27hp, last enemy. A0 and A2 stay back.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-41d339841d1fba7de0374474.json b/examples/multi-agent-smax/results/llm-cache/ask-41d339841d1fba7de0374474.json new file mode 100644 index 00000000..da7c11fc --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-41d339841d1fba7de0374474.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.5 seconds into the battle.\nYou are A0, a marine at (8.1, 15.8) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1 marine at (8.3, 14.1), 9/45 health, order: attack E2\n A2 marine at (8.1, 14.9), 45/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (12.9, 15.0), 45/45 health, 4.8 away (in range)\n E1 marine at (11.8, 16.2), 45/45 health, 3.7 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (3.0s): Holding at (8,14). Focus E2 first when in range, then E0.\n A2 (3.0s): Holding at (8,15). Focus E2 or E0 when in range 5.\n A0 (3.5s): Focus E2 now, then E0. Stay grouped.\n A1 (3.5s): Focus E2 now, then E0. Everyone fire.\n A2 (3.5s): Focusing E2 now, then E0. All fire E2.\n A0 (4.0s): E2 is at 18 HP, finish it, then E1.\n A1 (4.0s): Firing E2 (18hp). Then E0. I'm at 27hp.\n A2 (4.0s): Firing E2 (18 hp left), then E0. Stay grouped.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E2 is down. Focus E1 (closest), then E0. A1 fall back if hurt.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-42d6359332ec698b8dc2deeb.json b/examples/multi-agent-smax/results/llm-cache/ask-42d6359332ec698b8dc2deeb.json new file mode 100644 index 00000000..177ee131 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-42d6359332ec698b8dc2deeb.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 3.0 seconds into the battle.\nYou are A0, a marine at (13.3, 15.6) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1 marine at (12.9, 17.5), 27/45 health, order: attack E2\n A2 marine at (13.7, 16.7), 36/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (17.7, 17.8), 45/45 health, 5.0 away (in range)\n E1 marine at (16.9, 14.5), 45/45 health, 3.7 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (1.5s): E2 in my range; A0, A2 close in and focus E2 now.\n A2 (1.5s): Staying together; E2 nearly in range. All attack E2 once everyone is within 5.\n A0 (2.0s): E2 in my range 4.8; attacking E2 now, everyone focus E2.\n A1 (2.0s): All three in range of E2 now. Attack E2 together.\n A2 (2.0s): E2 and E1 in my range; attacking E2 now, everyone focus E2.\n A0 (2.5s): E2 at 9hp, finish it now; then focus E1.\n A1 (2.5s): Focusing E2 (9hp), it dies soon; then we focus E0.\n A2 (2.5s): E2 at 9hp, finishing it now. Then focus E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E2 dead. Focus E1 (closest, 3.7 away), then E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-42dc37176df8032560785114.json b/examples/multi-agent-smax/results/llm-cache/ask-42dc37176df8032560785114.json new file mode 100644 index 00000000..d7e7a6ee --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-42dc37176df8032560785114.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.0 seconds into the battle.\nYou are A2, a marine at (9.0, 16.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.2, 16.2), 45/45 health, order: hold\n A1 marine at (9.8, 15.7), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.5s): Holding position; will focus fire on closest enemy once visible.\n A2 (0.5s): Holding. Will focus fire on the closest enemy once visible.\n A0 (1.0s): Still no enemies; holding grouped, focus closest when seen.\n A1 (1.0s): Still no enemies; holding grouped, will focus closest when seen.\n A2 (1.0s): Still no enemies. Holding; will focus the closest enemy when seen.\n A0 (1.5s): Still no enemies; holding grouped, focus closest when seen.\n A1 (1.5s): Holding grouped; focus fire on closest enemy when seen.\n A2 (1.5s): Still holding grouped; will focus the closest enemy when it appears.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 16\", \"say\": \"No contact after 2s. Advancing east together to (14,16); stay close, focus closest.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-4351eb83134b3e3c94cf3381.json b/examples/multi-agent-smax/results/llm-cache/ask-4351eb83134b3e3c94cf3381.json new file mode 100644 index 00000000..ffdac7a8 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-4351eb83134b3e3c94cf3381.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 0.5 seconds into the battle.\nYou are A1, a marine at (8.9, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 15.\nYour team:\n A0 marine at (10.6, 16.0), 45/45 health, order: move 11 16\n A2 marine at (9.2, 14.8), 45/45 health, order: move 16 16\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Advancing east together; stay within 2 of each other, A1 and A2 keep pace.\n A1 (0.0s): Moving east together toward center, stay within 2 of each other.\n A2 (0.0s): Moving together to center, stay within 2 of each other; attack same target when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 15\", \"say\": \"Advancing east, staying close; will all attack same target when enemies appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-43d9fc7872e799371abc4a8c.json b/examples/multi-agent-smax/results/llm-cache/ask-43d9fc7872e799371abc4a8c.json new file mode 100644 index 00000000..8102a736 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-43d9fc7872e799371abc4a8c.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 3.0 seconds into the battle.\nYou are A0, a marine at (12.8, 15.9) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1 marine at (13.0, 15.0), 27/45 health, order: attack E2\n A2 marine at (13.0, 14.3), 36/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (17.3, 15.0), 45/45 health, 4.6 away (in range)\n E1 marine at (16.6, 14.0), 45/45 health, 4.3 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (1.5s): Moving to (14,16) with A0; enemies close, then all attack E2 together.\n A2 (1.5s): Moving to (14,16) with A0; enemies ~5 away next, then all attack E2 together.\n A0 (2.0s): E2 in range of all three. Attack E2 now, together.\n A1 (2.0s): All in range of E2 now. Attack E2 together.\n A2 (2.0s): E2 in range of all three. Attack E2 now, together.\n A0 (2.5s): Firing on E2, 18hp left. Keep attacking together.\n A1 (2.5s): Firing on E2 (18hp), keep attacking until it dies.\n A2 (2.5s): Attacking E2, it's at 18hp; finish it together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E2 dead. Everyone focus E1, closest to all of us.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-44642ce6039583ed62439074.json b/examples/multi-agent-smax/results/llm-cache/ask-44642ce6039583ed62439074.json new file mode 100644 index 00000000..15dd8198 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-44642ce6039583ed62439074.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.5 seconds into the battle.\nYou are A2, a marine at (9.4, 14.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.1, 15.9), 45/45 health, order: move 8 15\n A1 marine at (7.1, 14.7), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Regroup near (8,15) so we fight together; focus fire on closest enemy.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on the closest enemy when they appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 8 15\", \"say\": \"Moving to regroup at (8,15); will focus fire closest enemy.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-4478080515385cc0f5ad883d.json b/examples/multi-agent-smax/results/llm-cache/ask-4478080515385cc0f5ad883d.json new file mode 100644 index 00000000..779cc24b --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-4478080515385cc0f5ad883d.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 7.0 seconds into the battle.\nYou are A0, a marine at (8.1, 15.8) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1 marine at (3.6, 14.1), 9/45 health, order: hold\n A2 marine at (8.1, 14.9), 18/45 health, order: attack E1\nEnemies you can see:\n E0 marine at (12.9, 15.0), 45/45 health, 4.8 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (5.5s): A1 at 9hp staying back; focus E1 then E0.\n A2 (5.5s): Firing E1 (27hp). A0 keep focus, then E0. A1 stay back.\n A0 (6.0s): Firing E1 (9hp), nearly dead. Then E0 together.\n A1 (6.0s): A1 9hp holding back; E1 is at 9hp, finish it then E0.\n A2 (6.0s): Firing E1 (9hp), nearly dead. Then E0 together.\n A0 (6.5s): Firing E1 (9hp), finishing it. Then E0 together.\n A1 (6.5s): A1 holding back at 9hp; will shoot anything that closes in.\n A2 (6.5s): Finishing E1 (9hp) now, then all focus E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E1 down. All focus E0 now, A1 join in.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-45575027e2b885969d5d9f4c.json b/examples/multi-agent-smax/results/llm-cache/ask-45575027e2b885969d5d9f4c.json new file mode 100644 index 00000000..4b43b7f4 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-45575027e2b885969d5d9f4c.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 8.5 seconds into the battle.\nYou are A2, a marine at (9.2, 17.8) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (8.5, 16.7), 18/45 health, order: attack E1\n A1: dead\nEnemies you can see:\n E1 marine at (12.3, 15.6), 9/45 health, 3.8 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (6.5s): A0 finishing E2 now. Then all on E1.\n A2 (6.5s): A2 finishing E2 (9hp). Then both on E1.\n A0 (7.0s): E2 down. A0 and A2 all on E1, 36hp.\n A2 (7.0s): E2 down. A2 on E1, A0 keep tanking, I'm at 9hp.\n A0 (7.5s): A0 tanking, attacking E1 (27hp). A2 stay behind me and keep firing.\n A2 (7.5s): A2 9hp, falling back so A0 is closest. A0 tank, I'll rejoin shooting.\n A0 (8.0s): A0 on E1 (18hp), still tanking. A2 fire from behind me.\n A2 (8.0s): A2 back in, firing from behind A0. E1 at 18hp, focus it.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A2 firing on E1 (9hp), one more volley should finish it.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-45ab18d6c2c6947a09395b71.json b/examples/multi-agent-smax/results/llm-cache/ask-45ab18d6c2c6947a09395b71.json new file mode 100644 index 00000000..d410de2d --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-45ab18d6c2c6947a09395b71.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 1.5 seconds into the battle.\nYou are A0, a marine at (13.0, 16.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 16.\nYour team:\n A1 marine at (14.5, 15.7), 45/45 health, order: move 15 16\n A2 marine at (13.7, 16.2), 45/45 health, order: move 14 16\nEnemies you can see:\n E0 marine at (19.8, 17.3), 45/45 health, 6.9 away\n E1 marine at (19.8, 16.6), 45/45 health, 6.9 away\n E2 marine at (20.0, 14.1), 45/45 health, 7.3 away\nTeam chat (most recent last):\n A1 (0.0s): Moving east together toward enemies, stay within 2 of each other; attack same target on contact.\n A2 (0.0s): Moving east together to (14,16); stay within 2 of each other, attack together on contact.\n A0 (0.5s): Continuing east to (14,16); staying together, will attack same target on contact.\n A1 (0.5s): Continuing east in formation; will attack same target on contact.\n A2 (0.5s): A2 moving east to (14,16), staying close; attack same target on contact.\n A0 (1.0s): Continuing east to (14,16), staying together; no enemies seen yet.\n A1 (1.0s): Advancing together toward enemies; will all attack E1 once in range 5.\n A2 (1.0s): A2 continuing east to (14,16), staying together; attack same target on contact.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 15 16\", \"say\": \"Advancing together east; attack E1 once all within range 5.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-466d5b553b93bda8d382b411.json b/examples/multi-agent-smax/results/llm-cache/ask-466d5b553b93bda8d382b411.json new file mode 100644 index 00000000..a2f4f373 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-466d5b553b93bda8d382b411.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 7.0 seconds into the battle.\nYou are A2, a marine at (8.1, 14.9) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (8.1, 15.8), 9/45 health, order: attack E1\n A1 marine at (3.6, 14.1), 9/45 health, order: hold\nEnemies you can see:\n E0 marine at (12.9, 15.0), 45/45 health, 4.8 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (5.5s): A1 at 9hp staying back; focus E1 then E0.\n A2 (5.5s): Firing E1 (27hp). A0 keep focus, then E0. A1 stay back.\n A0 (6.0s): Firing E1 (9hp), nearly dead. Then E0 together.\n A1 (6.0s): A1 9hp holding back; E1 is at 9hp, finish it then E0.\n A2 (6.0s): Firing E1 (9hp), nearly dead. Then E0 together.\n A0 (6.5s): Firing E1 (9hp), finishing it. Then E0 together.\n A1 (6.5s): A1 holding back at 9hp; will shoot anything that closes in.\n A2 (6.5s): Finishing E1 (9hp) now, then all focus E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E1 down. All focus E0; I'm closest and tanking, A0 and A1 fire.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-46e41ddc51ed948e186d438c.json b/examples/multi-agent-smax/results/llm-cache/ask-46e41ddc51ed948e186d438c.json new file mode 100644 index 00000000..607dfc0e --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-46e41ddc51ed948e186d438c.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.0 seconds into the battle.\nYou are A0, a marine at (7.8, 14.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1: dead\n A2 marine at (8.2, 14.1), 36/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (12.6, 15.0), 45/45 health, 4.8 away (in range)\n E1 marine at (11.9, 14.0), 45/45 health, 4.1 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (3.5s): E2 in range 4.6, all focus fire E2 now, then E0.\n A1 (3.5s): Focus E2 now, all fire together, then E0.\n A2 (3.5s): E0 and E2 in range now. Focus E2, fire together, then E0.\n A0 (4.0s): Firing E2 (18hp), then E0. A1 stay behind us.\n A1 (4.0s): E2 at 18 HP, finish it now, then E0.\n A2 (4.0s): Firing on E2 (18hp), then E0. Keep A1 behind us.\n A0 (4.5s): E2 down. Focus E0 now, then E1. Fire together.\n A2 (4.5s): E2 down. Focus E0 (4.5 away), then E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Focus E0 together, then E1. A2 keep firing.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-4713d99bd1e75a25a0f43650.json b/examples/multi-agent-smax/results/llm-cache/ask-4713d99bd1e75a25a0f43650.json new file mode 100644 index 00000000..5f73b371 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-4713d99bd1e75a25a0f43650.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.0 seconds into the battle.\nYou are A2, a marine at (7.6, 17.8) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (8.5, 16.7), 45/45 health, order: attack E2\n A1 marine at (7.8, 14.9), 9/45 health, order: attack E1\nEnemies you can see:\n E1 marine at (12.3, 15.6), 36/45 health, 5.1 away\n E2 marine at (11.9, 17.7), 45/45 health, 4.3 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (3.5s): A1 attacking E0 now, everyone focus E0.\n A2 (3.5s): A2 attacking E0 now, everyone focus E0 together.\n A0 (4.0s): A0 firing E0 (18hp left), finish it then switch to E2.\n A1 (4.0s): E0 at 18 hp, keep focusing E0 then E1.\n A2 (4.0s): A2 firing on E0, 18 hp left, finish it then E2.\n A0 (4.5s): E0 dead. Focus E2 together, then E1. A1 stay back, you're low.\n A1 (4.5s): E0 dead. A1 on E1 at 4.5, focus E1 together; A2 close in.\n A2 (4.5s): E0 is down; all focus E2 (in range, closest), then E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"A2 on E2, in range. A0 and A2 focus E2; A1 stay back.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-4738095550fcfd05974995eb.json b/examples/multi-agent-smax/results/llm-cache/ask-4738095550fcfd05974995eb.json new file mode 100644 index 00000000..e4a9f2f4 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-4738095550fcfd05974995eb.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.5 seconds into the battle.\nYou are A1, a marine at (9.9, 15.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.2, 16.2), 45/45 health, order: hold\n A2 marine at (10.5, 16.3), 27/45 health, order: attack E1\nEnemies you can see:\n E0 marine at (15.1, 17.3), 45/45 health, 5.5 away\n E1 marine at (15.1, 16.6), 36/45 health, 5.3 away\n E2 marine at (13.7, 14.1), 45/45 health, 4.1 away (in range)\nTeam chat (most recent last):\n A1 (2.0s): Enemies at 8.5 east. Hold grouped; all focus the closest when in range.\n A2 (2.0s): No contact after 2s. Advancing east together to (14,16); stay close, focus closest.\n A0 (2.5s): A2 advancing alone is risky; hold grouped at range 5, focus E1 when in range.\n A1 (2.5s): Enemies 7 east. A2 fall back to group; hold and focus E1 when in range.\n A2 (2.5s): Cancel advance. Holding at 10.5; enemies 6 east, focus E1 when in range.\n A0 (3.0s): Holding. Enemies at 7; focus E1 when in range, stay grouped.\n A1 (3.0s): Holding. E1 is closest at 5.3; focus E1 as soon as it's in range.\n A2 (3.0s): Enemies in range. Focus E1 now, everyone fire on E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E1 out of range; E2 in range at 4.1. Everyone focus E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-477a4c497209c608bea7d306.json b/examples/multi-agent-smax/results/llm-cache/ask-477a4c497209c608bea7d306.json new file mode 100644 index 00000000..218b332e --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-477a4c497209c608bea7d306.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.0 seconds into the battle.\nYou are A2, a marine at (7.6, 17.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.9, 16.7), 45/45 health, order: hold\n A1 marine at (7.8, 14.9), 45/45 health, order: move 7.5 16.5\nEnemies you can see:\n E0 marine at (16.0, 15.3), 45/45 health, 8.8 away\nTeam chat (most recent last):\n A1 (0.5s): A1 holding; will focus fire on closest enemy once visible.\n A2 (0.5s): Holding; staying clustered near A0 until enemies appear, then focus closest.\n A0 (1.0s): A0 holding; A1 move closer to cluster, focus closest enemy when seen.\n A1 (1.0s): A1 holding; will focus closest enemy. Staying near A0 and A2.\n A2 (1.0s): A2 holding; no enemies seen yet, will focus closest when they appear.\n A0 (1.5s): A0 holding. Stay clustered; focus fire on closest enemy when seen.\n A1 (1.5s): A1 moving to cluster with A0/A2; holding together, focus closest enemy.\n A2 (1.5s): A2 holding; no enemies yet. Focus closest when they appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"E0 seen east at 16,15. Holding clustered; focus E0 when in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-47eb3bc9e1313823af5747c1.json b/examples/multi-agent-smax/results/llm-cache/ask-47eb3bc9e1313823af5747c1.json new file mode 100644 index 00000000..630c995c --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-47eb3bc9e1313823af5747c1.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 6.0 seconds into the battle.\nYou are A0, a marine at (13.7, 15.6) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1 marine at (14.2, 16.3), 9/45 health, order: attack E1\n A2: dead\nEnemies you can see:\n E1 marine at (17.9, 16.0), 27/45 health, 4.2 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (4.0s): Focus E0 (36hp), then E1. I'm 27hp, staying in.\n A1 (4.0s): Focus E0 (36hp), then E1. A0 at 27hp, stay in unless under 20.\n A0 (4.5s): E0 at 18hp, keep focusing it, then E1. I'm 27hp, staying in.\n A1 (4.5s): E0 at 18hp, keep focusing it, then E1. A0 retreat if under 20.\n A0 (5.0s): E0 dead. Focus E1 now, it's in range 4.2.\n A1 (5.0s): E0 down. Both focus E1 now, it's the last one.\n A0 (5.5s): Focusing E1. A1 at 9hp, retreat if you're targeted; I'm 27hp, staying in.\n A1 (5.5s): Attacking E1. I'm 9hp and will soak a shot. A0 keep firing, finish it.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Firing on E1 (27hp). A1 retreat if targeted; I'm 27hp, staying in.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-4858a23d10e518b1576553b3.json b/examples/multi-agent-smax/results/llm-cache/ask-4858a23d10e518b1576553b3.json new file mode 100644 index 00000000..05fdad1b --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-4858a23d10e518b1576553b3.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 1.5 seconds into the battle.\nYou are A2, a marine at (12.4, 14.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 15.\nYour team:\n A0 marine at (13.7, 16.0), 45/45 health, order: move 14 15\n A1 marine at (12.1, 14.1), 45/45 health, order: move 12 15\nEnemies you can see:\n E0 marine at (20.3, 16.4), 45/45 health, 8.1 away\n E1 marine at (21.0, 16.8), 45/45 health, 8.8 away\n E2 marine at (20.9, 15.5), 45/45 health, 8.6 away\nTeam chat (most recent last):\n A1 (0.0s): Moving east together toward center, stay within 2 of each other.\n A2 (0.0s): Moving together to center, stay within 2 of each other; attack same target when in range.\n A0 (0.5s): Moving east, staying close; A1 and A2 keep within 2 of me.\n A1 (0.5s): Advancing east, staying close; will all attack same target when enemies appear.\n A2 (0.5s): Keeping pace east, staying close; will focus same target once in range.\n A0 (1.0s): Continuing east together; A1 and A2 stay close, focus fire once enemies appear.\n A1 (1.0s): Continuing east together; will focus same target when enemies in range.\n A2 (1.0s): Continuing east to 14,15, staying close; will focus same target when enemies appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 15\", \"say\": \"Enemies 8 away; keep moving together, then all attack E0 at range 5.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-48a9944c84fec86dee3ec53f.json b/examples/multi-agent-smax/results/llm-cache/ask-48a9944c84fec86dee3ec53f.json new file mode 100644 index 00000000..4c492ec4 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-48a9944c84fec86dee3ec53f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 1.0 seconds into the battle.\nYou are A1, a marine at (11.3, 17.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 17.\nYour team:\n A0 marine at (10.1, 15.6), 45/45 health, order: move 14 16.5\n A2 marine at (10.5, 16.7), 45/45 health, order: move 14 16.5\nEnemies you can see:\n E2 marine at (19.3, 17.2), 45/45 health, 8.0 away\nTeam chat (most recent last):\n A0 (0.0s): Moving east together toward center; stay within 2 of each other, attack same target.\n A1 (0.0s): Moving east together toward center, stay within 2 of each other.\n A2 (0.0s): Moving east together toward center, stay close, all engage same enemy on contact.\n A0 (0.5s): Continuing east together; hold formation, all attack same target on contact.\n A1 (0.5s): Continuing east together; will all attack same enemy on contact.\n A2 (0.5s): Continuing east together; no enemies seen yet, will focus same target on contact.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 16.5\", \"say\": \"Moving to 14,16.5 with the group; will attack E2 together when in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-48f7827a83c20b8ce7bb91c6.json b/examples/multi-agent-smax/results/llm-cache/ask-48f7827a83c20b8ce7bb91c6.json new file mode 100644 index 00000000..1e68b982 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-48f7827a83c20b8ce7bb91c6.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.5 seconds into the battle.\nYou are A1, a marine at (7.4, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (9.0, 16.0), 45/45 health, order: hold\n A2 marine at (7.7, 14.8), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on closest enemy when they appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding; will focus fire on closest enemy once in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-49372d2c916137cc8dc048d5.json b/examples/multi-agent-smax/results/llm-cache/ask-49372d2c916137cc8dc048d5.json new file mode 100644 index 00000000..199683f1 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-49372d2c916137cc8dc048d5.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.0 seconds into the battle.\nYou are A1, a marine at (8.5, 14.8) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (7.8, 14.7), 45/45 health, order: attack E2\n A2 marine at (8.2, 14.1), 45/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (12.6, 15.0), 45/45 health, 4.1 away (in range)\n E1 marine at (13.4, 14.0), 45/45 health, 5.0 away (in range)\n E2 marine at (11.8, 16.8), 18/45 health, 3.8 away (in range)\nTeam chat (most recent last):\n A1 (2.5s): Holding. Enemies closing; all focus closest enemy once in range 5.\n A2 (2.5s): A2 holding. Enemies approaching; focus closest once in range 5.\n A0 (3.0s): Holding. Focus closest enemy E2 when in range 5, fire together.\n A1 (3.0s): Holding. E2 closest at 5.3; focus E2 when in range, then E0.\n A2 (3.0s): Holding. E2 closest at 5.8; focus whoever enters range 5 first.\n A0 (3.5s): E2 in range 4.6, all focus fire E2 now, then E0.\n A1 (3.5s): Focus E2 now, all fire together, then E0.\n A2 (3.5s): E0 and E2 in range now. Focus E2, fire together, then E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 at 18 HP, finish it now, then E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-4a188be5b8b505ad3748f559.json b/examples/multi-agent-smax/results/llm-cache/ask-4a188be5b8b505ad3748f559.json new file mode 100644 index 00000000..a67bc9f7 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-4a188be5b8b505ad3748f559.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.0 seconds into the battle.\nYou are A2, a marine at (7.6, 17.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.5, 15.8), 45/45 health, order: hold\n A1 marine at (7.2, 17.2), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together here; focus fire on the closest enemy when they appear.\n A0 (0.5s): No enemies yet. Staying grouped; focus fire on the closest one when seen.\n A1 (0.5s): A1 holding; will focus fire on the closest enemy when seen.\n A2 (0.5s): Holding; will focus fire on closest enemy once visible.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A2 holding; no enemies visible. Will focus closest when they appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-4a23fdb935cd47cecb05b271.json b/examples/multi-agent-smax/results/llm-cache/ask-4a23fdb935cd47cecb05b271.json new file mode 100644 index 00000000..1dc5acf3 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-4a23fdb935cd47cecb05b271.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 9.5 seconds into the battle.\nYou are A0, a marine at (9.3, 15.9) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1: dead\n A2: dead\nEnemies you can see:\n E0 marine at (13.5, 17.3), 9/45 health, 4.4 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (6.0s): E1 at 9hp, finishing it. Then E0 together.\n A1 (6.0s): E1 at 9hp, finishing it now. Then E0.\n A0 (6.5s): A1 and A2 are down. I'm engaging E0 alone.\n A0 (7.0s): Last one. E0 at 36hp, fighting on.\n A0 (7.5s): Last one, E0 at 36hp. Fighting on.\n A0 (8.0s): Last one, E0 at 27hp. Fighting on.\n A0 (8.5s): E0 at 27hp, still fighting alone.\n A0 (9.0s): E0 at 18hp, I'm still fighting. Last enemy.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 at 9hp, I'm 9hp too. Finishing it now.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-4bc1076ad57deb77bb15d027.json b/examples/multi-agent-smax/results/llm-cache/ask-4bc1076ad57deb77bb15d027.json new file mode 100644 index 00000000..f5428414 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-4bc1076ad57deb77bb15d027.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.0 seconds into the battle.\nYou are A1, a marine at (7.2, 17.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.5, 15.8), 45/45 health, order: hold\n A2 marine at (7.6, 17.8), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding together; focus fire on the closest enemy when they appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-4bdf32fc8dfb1bafe4342119.json b/examples/multi-agent-smax/results/llm-cache/ask-4bdf32fc8dfb1bafe4342119.json new file mode 100644 index 00000000..bfcddfbe --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-4bdf32fc8dfb1bafe4342119.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 7.5 seconds into the battle.\nYou are A1, a marine at (9.8, 14.2) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E2 marine at (10.8, 17.5), 36/45 health, 3.5 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (5.0s): E0 is dead. A0 and A1 focus E1 (27hp), then E2.\n A1 (5.0s): A1 on E1 (27hp), in range. A0 join E1, then E2.\n A0 (5.5s): A0 18hp on E1 (18hp), finishing it. Then both on E2.\n A1 (5.5s): A1 on E1 (18hp), in range. A0 keep firing, then both E2.\n A0 (6.0s): A0 9hp, finishing E1 (9hp). Then both E2.\n A1 (6.0s): A1 on E1 (9hp), finishing it. Then both on E2.\n A1 (6.5s): A1 alone vs E2 (45hp), engaging.\n A1 (7.0s): A1 last unit, fighting E2 (45hp) alone.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"A1 last unit, 36hp vs E2 36hp, fighting to the end.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-4bffc1efea9d23ffa769a10c.json b/examples/multi-agent-smax/results/llm-cache/ask-4bffc1efea9d23ffa769a10c.json new file mode 100644 index 00000000..54fad269 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-4bffc1efea9d23ffa769a10c.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.0 seconds into the battle.\nYou are A1, a marine at (9.4, 14.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.9, 16.7), 45/45 health, order: hold\n A2 marine at (7.6, 17.8), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together; focus fire on closest enemy once seen.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on closest enemy when they appear.\n A0 (0.5s): A0 holding; will focus fire on the closest enemy that appears.\n A1 (0.5s): A1 holding; will focus fire on closest enemy once visible.\n A2 (0.5s): Holding; staying clustered near A0 until enemies appear, then focus closest.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A1 holding; will focus closest enemy. Staying near A0 and A2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-4c215643e6624f1a5d7460e3.json b/examples/multi-agent-smax/results/llm-cache/ask-4c215643e6624f1a5d7460e3.json new file mode 100644 index 00000000..2ba09486 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-4c215643e6624f1a5d7460e3.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.5 seconds into the battle.\nYou are A0, a marine at (9.3, 15.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1 marine at (10.0, 15.5), 36/45 health, order: attack E2\n A2 marine at (10.9, 16.6), 18/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (13.5, 17.3), 45/45 health, 4.4 away (in range)\n E1 marine at (13.5, 16.6), 36/45 health, 4.2 away (in range)\n E2 marine at (13.7, 14.1), 18/45 health, 4.7 away (in range)\nTeam chat (most recent last):\n A1 (3.0s): Holding. E1 is closest at 5.3; focus E1 as soon as it's in range.\n A2 (3.0s): Enemies in range. Focus E1 now, everyone fire on E1.\n A0 (3.5s): Moving up to fire on E1; A2 is taking fire, everyone commit.\n A1 (3.5s): E1 out of range; E2 in range at 4.1. Everyone focus E2.\n A2 (3.5s): A2 hurt, pulling back west to you. Fire on E1 when they follow into range.\n A0 (4.0s): Switching to E2, in range at 4.7. A1 and I focus E2.\n A1 (4.0s): Firing on E2 (36hp, in range). A0 switch to E2. A2 stay back.\n A2 (4.0s): A2 hurt but farthest back, firing on E2 from range. Focus E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 at 18hp, finishing it now. Then focus E1 (36hp).\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-4c990513178c308f9d9b42e5.json b/examples/multi-agent-smax/results/llm-cache/ask-4c990513178c308f9d9b42e5.json new file mode 100644 index 00000000..736d1896 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-4c990513178c308f9d9b42e5.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.5 seconds into the battle.\nYou are A1, a marine at (8.9, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (9.0, 16.0), 45/45 health, order: hold\n A2 marine at (9.3, 14.8), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (14.0, 16.4), 45/45 health, 5.6 away\n E1 marine at (14.7, 16.8), 45/45 health, 6.4 away\n E2 marine at (14.6, 15.5), 45/45 health, 5.9 away\nTeam chat (most recent last):\n A1 (2.0s): No contact; advancing east together to find enemies. Stay grouped, focus closest.\n A2 (2.0s): Holding grouped; focus fire closest enemy when it appears.\n A0 (2.5s): Enemies 3 at east, ~7 away. Falling back to group; hold and focus E0 when in range.\n A1 (2.5s): Enemies E0, E2 east ~9 away. Holding grouped; focus E0 when in range.\n A2 (2.5s): Advancing east to join A0/A1; stay grouped, focus closest enemy.\n A0 (3.0s): Holding at (9,16). Let them come into range, then all focus the closest enemy.\n A1 (3.0s): Holding grouped. Enemies ~7 away; let them come into range, focus E0.\n A2 (3.0s): Holding at range; all focus E0 when it enters 5 range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding. Focus E0 when in range; stay grouped.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-4cda6453906279c087c654a1.json b/examples/multi-agent-smax/results/llm-cache/ask-4cda6453906279c087c654a1.json new file mode 100644 index 00000000..ff721870 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-4cda6453906279c087c654a1.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.5 seconds into the battle.\nYou are A2, a marine at (7.6, 17.8) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (6.9, 16.7), 45/45 health, order: attack E0\n A1 marine at (7.8, 14.9), 18/45 health, order: attack E0\nEnemies you can see:\n E1 marine at (12.3, 15.6), 45/45 health, 5.1 away\n E2 marine at (11.9, 17.7), 45/45 health, 4.3 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (3.0s): A1 holding; E0 at 5.1, focus E0 when in range, stay tight.\n A2 (3.0s): A2 holding; E0 closest at 5.8, focus E0 together when in range.\n A0 (3.5s): A0 attacking E0 now, everyone focus E0.\n A1 (3.5s): A1 attacking E0 now, everyone focus E0.\n A2 (3.5s): A2 attacking E0 now, everyone focus E0 together.\n A0 (4.0s): A0 firing E0 (18hp left), finish it then switch to E2.\n A1 (4.0s): E0 at 18 hp, keep focusing E0 then E1.\n A2 (4.0s): A2 firing on E0, 18 hp left, finish it then E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E0 is down; all focus E2 (in range, closest), then E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-4d77d300f79409631856da2e.json b/examples/multi-agent-smax/results/llm-cache/ask-4d77d300f79409631856da2e.json new file mode 100644 index 00000000..c25de7f6 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-4d77d300f79409631856da2e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 1.0 seconds into the battle.\nYou are A2, a marine at (10.7, 17.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 16.\nYour team:\n A0 marine at (10.1, 16.7), 45/45 health, order: move 12 16\n A1 marine at (10.9, 16.4), 45/45 health, order: move 12 16\nEnemies you can see:\n E0 marine at (19.2, 15.3), 45/45 health, 8.8 away\nTeam chat (most recent last):\n A0 (0.0s): Moving east together to (12,16); stay close, no one run ahead.\n A1 (0.0s): Moving together east to (15,16); stay within 2 of each other, attack same target.\n A2 (0.0s): Moving east together toward center, stay within 2 of each other; attack same target on contact.\n A0 (0.5s): A1 please converge on (12,16) with us; A1 is ahead, stay within 2.\n A1 (0.5s): Joining A0 and A2 at (12,16); staying grouped, then advance together.\n A2 (0.5s): A2 moving to (12,16) with team; will attack together on contact.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 16\", \"say\": \"Continuing to (12,16) together; will attack same target once all in range 5.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-4d9fa9f85f9f2809c4436721.json b/examples/multi-agent-smax/results/llm-cache/ask-4d9fa9f85f9f2809c4436721.json new file mode 100644 index 00000000..4dbe24d5 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-4d9fa9f85f9f2809c4436721.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.0 seconds into the battle.\nYou are A0, a marine at (9.9, 17.0) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1: dead\n A2: dead\nEnemies you can see:\n E0 marine at (14.6, 17.8), 45/45 health, 4.7 away (in range)\n E1 marine at (13.7, 14.5), 18/45 health, 4.5 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A2 (3.5s): Firing E2 (27hp), A0 step up and focus E2. A1 stay back.\n A0 (4.0s): E2 at 18hp, in range. Finish it now, then E1.\n A2 (4.0s): E2 at 18hp, finish it now. A0 keep firing.\n A0 (4.5s): E2 is down. Focus E1 (closest, 45hp), then E0.\n A2 (4.5s): E2 down. Focus E1 (closest, 3.8 away), then E0.\n A0 (5.0s): Focusing E1 (36hp), both in range. A2 stay behind me, you're low.\n A2 (5.0s): Focus E1 (36hp), I'm low at 18hp. A0 keep firing, then E0.\n A0 (5.5s): A0 on E1 (18hp), almost dead. Then E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Finishing E1 (18hp), then E0. A2 stay back.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-4da50f796620c41b6ef014bb.json b/examples/multi-agent-smax/results/llm-cache/ask-4da50f796620c41b6ef014bb.json new file mode 100644 index 00000000..5f0cb12e --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-4da50f796620c41b6ef014bb.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 3.0 seconds into the battle.\nYou are A0, a marine at (6.9, 15.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (6.7, 14.2), 45/45 health, order: hold\n A2 marine at (8.3, 17.3), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (13.6, 16.8), 45/45 health, 6.9 away\n E1 marine at (15.3, 16.2), 45/45 health, 8.4 away\n E2 marine at (15.4, 17.3), 45/45 health, 8.7 away\nTeam chat (most recent last):\n A1 (1.5s): A1 holding. Still no enemies; will focus same target once all in range 5.\n A2 (1.5s): A2 holding. No enemies visible; will focus fire when all within 5.\n A0 (2.0s): A0 holding; no enemies yet. Will focus same target once all within 5.\n A1 (2.0s): A1 holding; no enemies yet. Will attack together once all within 5.\n A2 (2.0s): A2 holding. E0 spotted at (16.8,16.8), 8.5 away. Wait until it's in range 5 of all.\n A0 (2.5s): A0 holding. E0 at 8.4 away; wait until within 5 of all, then focus E0.\n A1 (2.5s): A1 holding. E0 at 8.9 away; wait until in range 5 of all.\n A2 (2.5s): A2 holding. Nearest enemy E0 at 6.9; wait until within 5 of all.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A0 holding. E0 at 6.9; wait until within 5 of all, then focus E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-4da62d261bece7bffeb1bc8e.json b/examples/multi-agent-smax/results/llm-cache/ask-4da62d261bece7bffeb1bc8e.json new file mode 100644 index 00000000..9eb47163 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-4da62d261bece7bffeb1bc8e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 4.0 seconds into the battle.\nYou are A2, a marine at (8.3, 17.3) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (6.9, 15.6), 45/45 health, order: hold\n A1 marine at (6.7, 14.2), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (11.9, 16.8), 36/45 health, 3.6 away (in range)\n E1 marine at (12.2, 16.2), 45/45 health, 4.0 away (in range)\n E2 marine at (12.3, 17.4), 45/45 health, 4.0 away (in range)\nTeam chat (most recent last):\n A1 (2.5s): A1 holding. E0 at 8.9 away; wait until in range 5 of all.\n A2 (2.5s): A2 holding. Nearest enemy E0 at 6.9; wait until within 5 of all.\n A0 (3.0s): A0 holding. E0 at 6.9; wait until within 5 of all, then focus E0.\n A1 (3.0s): A1 holding. E0 at 7.4; attack E0 together once within 5 of all.\n A2 (3.0s): A2 holding. E0 at 5.3 from me, 6.8+ from A0/A1. Wait for range 5.\n A0 (3.5s): A0 holding. E0 5.3 away; attack E0 together once within 5 of all.\n A1 (3.5s): A1 holding. E0 at 6.0; attack E0 together once within 5 of all.\n A2 (3.5s): E0 in range of me, firing now. A0/A1 close in and focus E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Engaged, all 3 enemies on me. A0 A1 attack E0 now, focus fire.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-4dae29d8e833094d3433fbb2.json b/examples/multi-agent-smax/results/llm-cache/ask-4dae29d8e833094d3433fbb2.json new file mode 100644 index 00000000..e324f256 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-4dae29d8e833094d3433fbb2.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 2.5 seconds into the battle.\nYou are A2, a marine at (13.9, 17.8) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (13.8, 15.8), 36/45 health, order: attack E2\n A1 marine at (13.5, 17.2), 45/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (18.0, 17.1), 45/45 health, 4.2 away (in range)\n E1 marine at (17.3, 17.0), 45/45 health, 3.5 away (in range)\n E2 marine at (15.8, 16.7), 18/45 health, 2.2 away (in range)\nTeam chat (most recent last):\n A1 (1.0s): Advancing east together toward E2; keep within 2, attack same target at range.\n A2 (1.0s): Closing together toward E2; hold pace, all fire on E2 once in range 5.\n A0 (1.5s): E2 is 5.2 away; one more step east, then all attack E2 together.\n A1 (1.5s): Almost in range of E2; keep pace, all attack E2 together next tick.\n A2 (1.5s): Still closing together; E2 just outside range. Fire on E2 once all in range 5.\n A0 (2.0s): All in range of E2 now. Everyone fire on E2.\n A1 (2.0s): All in range of E2 (2.4 away). Attack E2 now, everyone focus fire.\n A2 (2.0s): E2 in range of me; all attack E2 now.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 at 18hp, keep firing on E2, then switch to E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-4e14619cc45578dd5b5f06e5.json b/examples/multi-agent-smax/results/llm-cache/ask-4e14619cc45578dd5b5f06e5.json new file mode 100644 index 00000000..cdedbfe4 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-4e14619cc45578dd5b5f06e5.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.5 seconds into the battle.\nYou are A1, a marine at (7.4, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (9.0, 16.0), 45/45 health, order: hold\n A2 marine at (7.7, 14.8), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on closest enemy when they appear.\n A0 (0.5s): No enemies yet. Staying grouped; focus fire on closest when they appear.\n A1 (0.5s): Holding; will focus fire on closest enemy once in range.\n A2 (0.5s): Holding position; focus fire on closest enemy once in range.\n A0 (1.0s): Holding; still no enemies. Focus fire closest when they appear.\n A1 (1.0s): Holding; no enemies in sight. Focus fire closest when they appear.\n A2 (1.0s): Still holding; no enemies visible. Focus fire on closest when they appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Still holding; will focus fire on closest enemy when visible.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-4e3626d2b6009520858e2b95.json b/examples/multi-agent-smax/results/llm-cache/ask-4e3626d2b6009520858e2b95.json new file mode 100644 index 00000000..09b96428 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-4e3626d2b6009520858e2b95.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.5 seconds into the battle.\nYou are A2, a marine at (8.2, 14.1) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (7.8, 14.7), 45/45 health, order: attack E0\n A1: dead\nEnemies you can see:\n E0 marine at (12.6, 15.0), 27/45 health, 4.5 away (in range)\n E1 marine at (11.9, 14.0), 45/45 health, 3.6 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A2 (3.5s): E0 and E2 in range now. Focus E2, fire together, then E0.\n A0 (4.0s): Firing E2 (18hp), then E0. A1 stay behind us.\n A1 (4.0s): E2 at 18 HP, finish it now, then E0.\n A2 (4.0s): Firing on E2 (18hp), then E0. Keep A1 behind us.\n A0 (4.5s): E2 down. Focus E0 now, then E1. Fire together.\n A2 (4.5s): E2 down. Focus E0 (4.5 away), then E1.\n A0 (5.0s): Focus E0 together, then E1. A2 keep firing.\n A2 (5.0s): Focus E0 together, then E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Firing E0 (27hp), then E1. I'm low, keep fire together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-4e423ccb26243689b5a2b9c3.json b/examples/multi-agent-smax/results/llm-cache/ask-4e423ccb26243689b5a2b9c3.json new file mode 100644 index 00000000..773f71f7 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-4e423ccb26243689b5a2b9c3.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad just fought a battle on map 3m and lost. Here is how it went, one line per half second:\nour units' orders and health, the enemies' health, and what was said on team chat.\n\n 0.0s A0 move 12 16 (45hp) A1 move 15 16 (45hp) A2 move 12 16 (45hp) | E0 45hp E1 45hp E2 45hp\n A0 said: Moving east together to (12,16); stay close, no one run ahead.\n A1 said: Moving together east to (15,16); stay within 2 of each other, attack same target.\n A2 said: Moving east together toward center, stay within 2 of each other; attack same target on contact.\n 0.5s A0 move 12 16 (45hp) A1 move 12 16 (45hp) A2 move 12 16 (45hp) | E0 45hp E1 45hp E2 45hp\n A0 said: A1 please converge on (12,16) with us; A1 is ahead, stay within 2.\n A1 said: Joining A0 and A2 at (12,16); staying grouped, then advance together.\n A2 said: A2 moving to (12,16) with team; will attack together on contact.\n 1.0s A0 move 12 16 (45hp) A1 move 12 16 (45hp) A2 move 12 16 (45hp) | E0 45hp E1 45hp E2 45hp\n A0 said: Continuing to (12,16); stay grouped, attack same target on contact.\n A1 said: Holding formation at (12,16); then all advance and attack E0 together.\n A2 said: Continuing to (12,16) together; will attack same target once all in range 5.\n 1.5s A0 move 14 16 (45hp) A1 move 14 16 (45hp) A2 move 13 16 (45hp) | E0 45hp E1 45hp E2 45hp\n A0 said: Advancing together toward E0; all attack E0 once everyone is within range 5.\n A1 said: Advancing together east to (14,16); then all attack E0 at once.\n A2 said: Advancing together toward E0; all attack E0 once everyone is within range 5.\n 2.0s A0 attack E0 (45hp) A1 attack E0 (45hp) A2 attack E0 (45hp) | E0 45hp E1 45hp E2 45hp\n A0 said: E0 is within range 5 of all three of us. Everyone attack E0 now.\n A1 said: E0 is in range of all three of us. Everyone attack E0 now.\n A2 said: E0 is in range of all three; attacking E0 now, focus fire.\n 2.5s A0 attack E0 (45hp) A1 attack E0 (18hp) A2 attack E0 (45hp) | E0 18hp E1 45hp E2 45hp\n A0 said: Keep focusing E0; A1 stay in fight until E0 dies, then retreat.\n A1 said: E0 at 18hp, keep focus fire; I'm at 18hp and will step back once it dies.\n A2 said: Focus E0, it's at 18hp. A1 is low; keep firing until E0 dies.\n 3.0s A0 attack E2 (45hp) A1 dead A2 attack E2 (45hp) | E0 dead E1 45hp E2 45hp\n A0 said: E0 dead. A2 stay close, all focus E2 together. A1 retreat.\n A2 said: E0 dead. A0 and I both attack E2 now, stay together.\n 3.5s A0 attack E2 (45hp) A1 dead A2 attack E2 (45hp) | E0 dead E1 45hp E2 45hp\n A0 said: Both on E2, keep firing until it dies.\n A2 said: Attacking E2 with A0, keep focus until it dies.\n 4.0s A0 attack E2 (27hp) A1 dead A2 attack E2 (45hp) | E0 dead E1 45hp E2 27hp\n A0 said: Keep focus on E2, 27hp left, then E1 together.\n A2 said: E2 at 27hp, keep focus until dead, then E1.\n 4.5s A0 attack E2 (9hp) A1 dead A2 attack E2 (45hp) | E0 dead E1 45hp E2 9hp\n A0 said: E2 at 9hp, finish it together, then both on E1.\n A2 said: E2 at 9hp, finish it now. A0 stay put, then both on E1.\n 5.0s A0 dead A1 dead A2 attack E2 (45hp) | E0 dead E1 45hp E2 9hp\n A2 said: A2 alone now. Finishing E2 at 9hp, then E1.\n 5.5s A0 dead A1 dead A2 attack E1 (45hp) | E0 dead E1 45hp E2 dead\n A2 said: E2 dead. A2 alone, attacking E1 at 3.2 range.\n 6.0s A0 dead A1 dead A2 attack E1 (36hp) | E0 dead E1 36hp E2 dead\n A2 said: A2 alone, 36hp vs E1 36hp, focusing E1.\n 6.5s A0 dead A1 dead A2 attack E1 (27hp) | E0 dead E1 36hp E2 dead\n A2 said: A2 alone, 27hp vs E1 36hp, still focusing E1.\n 7.0s A0 dead A1 dead A2 attack E1 (27hp) | E0 dead E1 27hp E2 dead\n A2 said: A2 27hp vs E1 27hp, still focusing E1.\n 7.5s A0 dead A1 dead A2 attack E1 (18hp) | E0 dead E1 18hp E2 dead\n A2 said: A2 18hp vs E1 18hp, last enemy, all-in on E1.\n 8.0s A0 dead A1 dead A2 attack E1 (9hp) | E0 dead E1 18hp E2 dead\n A2 said: A2 9hp vs E1 18hp, last stand, all-in on E1.\n 8.5s A0 dead A1 dead A2 attack E1 (9hp) | E0 dead E1 9hp E2 dead\n A2 said: A2 9hp vs E1 9hp, last shot, all-in on E1.\n 9.0s A0 dead A1 dead A2 dead | E0 dead E1 9hp E2 dead\n\nRULES.md now:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\nWrite ONE new rule for your squad's RULES.md that would have helped you win this battle. Every unit in your\nsquad will read RULES.md before every order in later battles. Make it a concrete rule about what a unit should\ndo, in one sentence, and do not repeat a rule already there.\nReply with JSON only: {\"rule\": \"\"}", + "response": "{\"rule\": \"After a kill, each surviving unit must attack the enemy that is closest to the whole squad and already within range 5 of every living unit, because a unit that picks a farther target spends its half-seconds walking instead of shooting (A2 dealt no damage to E2 for 1.5s while A0 was shot dead).\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-4ea82be0fdbc4e17b880d4cb.json b/examples/multi-agent-smax/results/llm-cache/ask-4ea82be0fdbc4e17b880d4cb.json new file mode 100644 index 00000000..1c3d0c92 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-4ea82be0fdbc4e17b880d4cb.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.5 seconds into the battle.\nYou are A0, a marine at (10.6, 16.0) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1 marine at (8.9, 14.1), 45/45 health, order: attack E2\n A2 marine at (10.8, 14.8), 18/45 health, order: attack E2\nEnemies you can see:\n E1 marine at (13.1, 16.8), 45/45 health, 2.6 away (in range)\n E2 marine at (13.1, 15.5), 18/45 health, 2.5 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (4.0s): Firing on E0 now, everyone focus E0.\n A2 (4.0s): Firing on E0 all together; A1 attack E0 too, not hold.\n A0 (4.5s): E0 at 18 hp, finish it, then switch to E2.\n A1 (4.5s): Firing E0 (18hp left), then switch to E2 together.\n A2 (4.5s): E0 at 18 hp, keep firing E0, then E2.\n A0 (5.0s): E0 dead. Focus E2 together, then E1.\n A1 (5.0s): E0 dead. Focus E2 (4.4 away, 45hp), everyone fire E2 together.\n A2 (5.0s): E0 dead. All focus E2, closest at 2.3, then E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 at 18hp, all fire E2 now, then E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-4f06b32ba6a9ff547b4c7d44.json b/examples/multi-agent-smax/results/llm-cache/ask-4f06b32ba6a9ff547b4c7d44.json new file mode 100644 index 00000000..9789169f --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-4f06b32ba6a9ff547b4c7d44.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 5.5 seconds into the battle.\nYou are A1, a marine at (14.2, 16.3) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (13.7, 15.6), 27/45 health, order: attack E1\n A2: dead\nEnemies you can see:\n E1 marine at (17.9, 16.0), 45/45 health, 3.7 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (3.5s): E2 dead. All focus E0 now, then E1. A2 retreat, you're at 9hp.\n A2 (3.5s): A2 at 9hp retreating. A0, A1 focus E0 now.\n A0 (4.0s): Focus E0 (36hp), then E1. I'm 27hp, staying in.\n A1 (4.0s): Focus E0 (36hp), then E1. A0 at 27hp, stay in unless under 20.\n A0 (4.5s): E0 at 18hp, keep focusing it, then E1. I'm 27hp, staying in.\n A1 (4.5s): E0 at 18hp, keep focusing it, then E1. A0 retreat if under 20.\n A0 (5.0s): E0 dead. Focus E1 now, it's in range 4.2.\n A1 (5.0s): E0 down. Both focus E1 now, it's the last one.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Attacking E1. I'm 9hp and will soak a shot. A0 keep firing, finish it.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-4f0ddd8a1b90b389628170be.json b/examples/multi-agent-smax/results/llm-cache/ask-4f0ddd8a1b90b389628170be.json new file mode 100644 index 00000000..a7380b6c --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-4f0ddd8a1b90b389628170be.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 4.0 seconds into the battle.\nYou are A1, a marine at (13.0, 15.5) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: retreat.\nYour team:\n A0 marine at (14.2, 16.2), 45/45 health, order: attack E0\n A2: dead\nEnemies you can see:\n E0 marine at (18.2, 17.3), 36/45 health, 5.5 away\n E2 marine at (18.4, 14.1), 45/45 health, 5.6 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A2 (2.0s): Enemies in range of me and A0. Attacking E1 now; A1 close in and fire on E1.\n A0 (2.5s): Focus E1 (27hp). A2 low at 18hp, retreat if needed.\n A1 (2.5s): Firing on E1 (27hp). A2 at 18hp, retreat if under 20.\n A2 (2.5s): A2 at 18hp retreating to pull fire off me; A0, A1 keep focusing E1.\n A0 (3.0s): E1 at 9hp, finish it now; then focus E0.\n A1 (3.0s): E1 at 9hp, finishing it now. A0 fire E1, then focus E2.\n A0 (3.5s): E1 dead. A0 focusing E0; A1 under 20hp, retreat to pull fire.\n A1 (3.5s): A1 at 18hp retreating so A0 is closest; A0 focus E2, I return when safe.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"retreat\", \"say\": \"A1 18hp retreating; A0 you're closest, focus E0 (36hp), I'll return when safe.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-4fb8097a896becebf373db2a.json b/examples/multi-agent-smax/results/llm-cache/ask-4fb8097a896becebf373db2a.json new file mode 100644 index 00000000..fb2e51c7 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-4fb8097a896becebf373db2a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 4.0 seconds into the battle.\nYou are A0, a marine at (6.9, 15.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (6.7, 14.2), 45/45 health, order: hold\n A2 marine at (8.3, 17.3), 36/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (11.9, 16.8), 36/45 health, 5.2 away\n E1 marine at (12.2, 16.2), 45/45 health, 5.3 away\n E2 marine at (12.3, 17.4), 45/45 health, 5.7 away\nTeam chat (most recent last):\n A1 (2.5s): A1 holding. E0 at 8.9 away; wait until in range 5 of all.\n A2 (2.5s): A2 holding. Nearest enemy E0 at 6.9; wait until within 5 of all.\n A0 (3.0s): A0 holding. E0 at 6.9; wait until within 5 of all, then focus E0.\n A1 (3.0s): A1 holding. E0 at 7.4; attack E0 together once within 5 of all.\n A2 (3.0s): A2 holding. E0 at 5.3 from me, 6.8+ from A0/A1. Wait for range 5.\n A0 (3.5s): A0 holding. E0 5.3 away; attack E0 together once within 5 of all.\n A1 (3.5s): A1 holding. E0 at 6.0; attack E0 together once within 5 of all.\n A2 (3.5s): E0 in range of me, firing now. A0/A1 close in and focus E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"A2 engaged, A0 attacking E0 now. A1 attack E0 too, focus fire.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-4fb9aa3a397617faafdfb4fd.json b/examples/multi-agent-smax/results/llm-cache/ask-4fb9aa3a397617faafdfb4fd.json new file mode 100644 index 00000000..e24edb14 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-4fb9aa3a397617faafdfb4fd.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.0 seconds into the battle.\nYou are A1, a marine at (8.9, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (10.6, 16.0), 18/45 health, order: attack E0\n A2 marine at (10.8, 14.8), 27/45 health, order: attack E0\nEnemies you can see:\n E1 marine at (13.1, 16.8), 45/45 health, 5.0 away (in range)\n E2 marine at (13.1, 15.5), 45/45 health, 4.4 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (3.5s): Holding. Focus E0 when in range; stay grouped.\n A2 (3.5s): E0 at range 5. Everyone attack E0 now, focus fire.\n A0 (4.0s): Focusing E0 now. A1 please attack E0 too, all fire together.\n A1 (4.0s): Attacking E0 now, focus fire.\n A2 (4.0s): All attack E0 now, in range. A1 switch from hold to attack E0.\n A0 (4.5s): E0 at 18 hp, keep focus firing E0 then E2.\n A1 (4.5s): Firing on E0, 18 hp left. Next target E2 (closest).\n A2 (4.5s): E0 at 18 hp, keep firing. Then focus E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E0 is dead. Focus fire E2, closest at 4.4.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-4fe2478b30f5b3bfe74227c5.json b/examples/multi-agent-smax/results/llm-cache/ask-4fe2478b30f5b3bfe74227c5.json new file mode 100644 index 00000000..b60a110b --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-4fe2478b30f5b3bfe74227c5.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.5 seconds into the battle.\nYou are A2, a marine at (7.6, 17.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.5, 15.8), 45/45 health, order: hold\n A1 marine at (7.2, 17.2), 45/45 health, order: hold\nEnemies you can see:\n E1 marine at (16.3, 17.1), 45/45 health, 8.7 away\n E2 marine at (14.2, 16.7), 45/45 health, 6.7 away\nTeam chat (most recent last):\n A1 (1.0s): No enemies yet. Holding; will focus fire on the closest when seen.\n A2 (1.0s): A2 holding; no enemies visible. Will focus closest when they appear.\n A0 (1.5s): Still no enemies; holding grouped. Focus closest when seen.\n A1 (1.5s): A1 holding; no enemies yet. Focus closest when seen.\n A2 (1.5s): A2 holding; no enemies visible. Focus closest when they appear.\n A0 (2.0s): E2 spotted at (15.8,16.7). Holding grouped; focus fire on whoever closes first.\n A1 (2.0s): E2 spotted east at 8.6 range. Holding grouped; focus E2 when in range.\n A2 (2.0s): E2 spotted at (15.8,16.7), 8 away. Holding grouped; focus E2 when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"E2 at 6.7, E1 behind. Holding grouped; focus closest when in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-501f3d1015cfc31ac78e9777.json b/examples/multi-agent-smax/results/llm-cache/ask-501f3d1015cfc31ac78e9777.json new file mode 100644 index 00000000..2d31e50a --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-501f3d1015cfc31ac78e9777.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 2.0 seconds into the battle.\nYou are A1, a marine at (13.3, 15.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 15.\nYour team:\n A0 marine at (12.7, 16.0), 45/45 health, order: move 15 15\n A2 marine at (12.8, 14.9), 45/45 health, order: move 15 15\nEnemies you can see:\n E0 marine at (17.6, 15.0), 45/45 health, 4.3 away (in range)\n E1 marine at (18.1, 16.2), 45/45 health, 4.9 away (in range)\n E2 marine at (17.6, 14.3), 45/45 health, 4.5 away (in range)\nTeam chat (most recent last):\n A1 (0.5s): Moving to (12,15) with team; will attack same target together.\n A2 (0.5s): A2 moving to (12,15), staying close; will attack same target when enemies appear.\n A0 (1.0s): Continuing to (12,15); will attack together once enemies appear.\n A1 (1.0s): Continuing to (12,15) together; will attack same target when enemies appear.\n A2 (1.0s): A2 continuing to (12,15); will attack together when enemies appear.\n A0 (1.5s): Advancing together toward E0; all attack E0 once everyone is in range.\n A1 (1.5s): Advancing together to (14,15); all attack E0 once in range.\n A2 (1.5s): Advancing east together to (15,15); all attack E2 once in range 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"All in range now: everyone attack E0 together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-509227431efdcd8cb26ad566.json b/examples/multi-agent-smax/results/llm-cache/ask-509227431efdcd8cb26ad566.json new file mode 100644 index 00000000..5083b752 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-509227431efdcd8cb26ad566.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 2.0 seconds into the battle.\nYou are A2, a marine at (13.9, 17.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 17.\nYour team:\n A0 marine at (13.8, 15.8), 45/45 health, order: move 14 17\n A1 marine at (13.5, 17.2), 45/45 health, order: move 14 17\nEnemies you can see:\n E0 marine at (19.0, 17.1), 45/45 health, 5.2 away\n E1 marine at (17.8, 17.1), 45/45 health, 4.0 away (in range)\n E2 marine at (15.8, 16.7), 45/45 health, 2.2 away (in range)\nTeam chat (most recent last):\n A1 (0.5s): Moving east in a tight group; will attack same target together.\n A2 (0.5s): Moving east in formation; A0 and A1 keep pace, no one pull ahead.\n A0 (1.0s): Advancing together toward E2; hold pace, attack same target once all in range 5.\n A1 (1.0s): Advancing east together toward E2; keep within 2, attack same target at range.\n A2 (1.0s): Closing together toward E2; hold pace, all fire on E2 once in range 5.\n A0 (1.5s): E2 is 5.2 away; one more step east, then all attack E2 together.\n A1 (1.5s): Almost in range of E2; keep pace, all attack E2 together next tick.\n A2 (1.5s): Still closing together; E2 just outside range. Fire on E2 once all in range 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 in range of me; all attack E2 now.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-50ba337b4738e9a91ca0e63a.json b/examples/multi-agent-smax/results/llm-cache/ask-50ba337b4738e9a91ca0e63a.json new file mode 100644 index 00000000..cf756e8d --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-50ba337b4738e9a91ca0e63a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 1.5 seconds into the battle.\nYou are A2, a marine at (8.3, 17.3) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.9, 15.6), 45/45 health, order: hold\n A1 marine at (6.7, 14.2), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.0s): A1 holding. No enemies seen; wait until all in range 5, then focus same target.\n A2 (0.0s): A2 holding. Will attack together once enemy is within 5 of all of us.\n A0 (0.5s): A0 holding. No enemies yet; will focus the same target once all in range.\n A1 (0.5s): A1 holding; no enemies visible yet. Will focus same target once all in range.\n A2 (0.5s): A2 holding. No enemies visible yet; will focus fire when all in range 5.\n A0 (1.0s): A0 holding. No enemies visible; will focus same target once all within 5.\n A1 (1.0s): A1 holding. No enemies visible; will focus same target once all in range 5.\n A2 (1.0s): A2 holding. Still no enemies; waiting until all in range 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A2 holding. No enemies visible; will focus fire when all within 5.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-50f9bf85ca58a48e7a320fe2.json b/examples/multi-agent-smax/results/llm-cache/ask-50f9bf85ca58a48e7a320fe2.json new file mode 100644 index 00000000..1606e4ae --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-50f9bf85ca58a48e7a320fe2.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.5 seconds into the battle.\nYou are A0, a marine at (8.0, 15.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (6.7, 14.2), 45/45 health, order: hold\n A2 marine at (8.7, 15.8), 36/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (13.5, 16.8), 36/45 health, 5.6 away\n E1 marine at (13.7, 16.2), 45/45 health, 5.8 away\n E2 marine at (13.9, 17.4), 45/45 health, 6.2 away\nTeam chat (most recent last):\n A1 (2.0s): A1 holding; no enemies yet, will focus closest when one appears.\n A2 (2.0s): E0 at (16.8,16.8) approaching; hold and focus it when in range.\n A0 (2.5s): A0 holding with you; enemies approaching, focus E0 when in range.\n A1 (2.5s): A1 holding at (6.7,14.2); A0 fall back to us, focus E0 together.\n A2 (2.5s): A2 holding; enemies approaching, all focus E0 when in range.\n A0 (3.0s): A0 holding; focus E0 when in range 5.\n A1 (3.0s): A1 holding; focus E0 when it enters range 5.\n A2 (3.0s): A2 attacking E0 (in range); all focus E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"A0 attacking E0 now; focus E0 together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-50fae56f37c81bfc33fdc255.json b/examples/multi-agent-smax/results/llm-cache/ask-50fae56f37c81bfc33fdc255.json new file mode 100644 index 00000000..3ce5d0c1 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-50fae56f37c81bfc33fdc255.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 0.5 seconds into the battle.\nYou are A0, a marine at (9.6, 17.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 16.\nYour team:\n A1 marine at (8.7, 14.7), 45/45 health, order: move 12 15\n A2 marine at (11.0, 14.6), 45/45 health, order: move 12 15\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Advancing east together to (12,16); stay within 2 of each other, attack together.\n A1 (0.0s): Advancing east together to (12,15); stay within 2 of each other, attack same target on contact.\n A2 (0.0s): Advancing east together, staying close. Don't outrun the group; all attack same target.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 16\", \"say\": \"Advancing to (12,16), keeping close; will attack same target on contact.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-5147ee6e579f346259054554.json b/examples/multi-agent-smax/results/llm-cache/ask-5147ee6e579f346259054554.json new file mode 100644 index 00000000..6b921508 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-5147ee6e579f346259054554.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.0 seconds into the battle.\nYou are A2, a marine at (8.2, 14.3) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 8 15.\nYour team:\n A0 marine at (8.1, 15.9), 45/45 health, order: hold\n A1 marine at (8.2, 15.0), 45/45 health, order: move 8 15\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Regroup near (8,15) so we fight together; focus fire on closest enemy.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A0 (0.5s): At (8,15), holding. Focus fire on the closest enemy that appears.\n A1 (0.5s): Closing to (8,15) to cluster; will focus closest enemy.\n A2 (0.5s): Moving to regroup at (8,15); will focus fire closest enemy.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A2 at (8,14) holding; will focus the closest enemy when it appears.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-520e20c669775472eca61b82.json b/examples/multi-agent-smax/results/llm-cache/ask-520e20c669775472eca61b82.json new file mode 100644 index 00000000..46b32ebd --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-520e20c669775472eca61b82.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.0 seconds into the battle.\nYou are A0, a marine at (8.4, 17.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (9.7, 17.5), 36/45 health, order: attack E2\n A2 marine at (9.1, 16.8), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (16.0, 17.6), 45/45 health, 7.6 away\n E1 marine at (13.7, 14.5), 45/45 health, 5.9 away\n E2 marine at (14.6, 17.2), 36/45 health, 6.2 away\nTeam chat (most recent last):\n A1 (1.5s): Holding at x=9; enemy E2 approaching, all focus the closest one.\n A2 (1.5s): E2 spotted east at 8.7 range; holding together, focus whatever enters range first.\n A0 (2.0s): Holding at x=9; shoot first enemy entering 5 range, focus closest.\n A1 (2.0s): Holding at x=9; shoot E2 when it enters range 5.\n A2 (2.0s): Holding at x=9; E2 closest, all focus E2 when in range.\n A0 (2.5s): Holding at x=9; focus E2 when it enters range 5.\n A1 (2.5s): Focus E2 now, all fire together.\n A2 (2.5s): Holding at x=9; E2 nearly in range, all focus E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding at x=9; focus E2 (36hp) first once any enemy enters range 5.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-5217b7571e4a1c11c79b9e69.json b/examples/multi-agent-smax/results/llm-cache/ask-5217b7571e4a1c11c79b9e69.json new file mode 100644 index 00000000..b0e4bcd4 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-5217b7571e4a1c11c79b9e69.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 2.0 seconds into the battle.\nYou are A1, a marine at (13.0, 15.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 16.\nYour team:\n A0 marine at (14.5, 16.3), 45/45 health, order: move 15 16\n A2 marine at (15.3, 16.3), 45/45 health, order: move 15 16\nEnemies you can see:\n E0 marine at (18.2, 17.3), 45/45 health, 5.5 away\n E1 marine at (18.2, 16.6), 45/45 health, 5.3 away\n E2 marine at (18.4, 14.1), 45/45 health, 5.6 away\nTeam chat (most recent last):\n A1 (0.5s): Continuing east in formation; will attack same target on contact.\n A2 (0.5s): A2 moving east to (14,16), staying close; attack same target on contact.\n A0 (1.0s): Continuing east to (14,16), staying together; no enemies seen yet.\n A1 (1.0s): Advancing together toward enemies; will all attack E1 once in range 5.\n A2 (1.0s): A2 continuing east to (14,16), staying together; attack same target on contact.\n A0 (1.5s): Advancing together east; attack E1 once all within range 5.\n A1 (1.5s): A1 holding near 14,16 so A0 and A2 catch up; all attack E1 together.\n A2 (1.5s): Advancing together to (15,16); all attack E1 once in range 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A1 attacking E1 now; A0 and A2 are in range, focus E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-534a71aa8afb36d77cbb634b.json b/examples/multi-agent-smax/results/llm-cache/ask-534a71aa8afb36d77cbb634b.json new file mode 100644 index 00000000..c2c848c9 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-534a71aa8afb36d77cbb634b.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.0 seconds into the battle.\nYou are A1, a marine at (8.9, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (10.6, 16.0), 18/45 health, order: attack E0\n A2 marine at (10.8, 14.8), 27/45 health, order: attack E0\nEnemies you can see:\n E1 marine at (13.1, 16.8), 45/45 health, 5.0 away (in range)\n E2 marine at (13.1, 15.5), 45/45 health, 4.4 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (3.5s): Holding at range 5. Let them approach, then everyone focus E0.\n A2 (3.5s): Focus E0 now, all fire on E0. Stay grouped.\n A0 (4.0s): E0 in range at 1.9, all fire E0. A1 attack E0 too.\n A1 (4.0s): Firing on E0 now, everyone focus E0.\n A2 (4.0s): Firing on E0 all together; A1 attack E0 too, not hold.\n A0 (4.5s): E0 at 18 hp, finish it, then switch to E2.\n A1 (4.5s): Firing E0 (18hp left), then switch to E2 together.\n A2 (4.5s): E0 at 18 hp, keep firing E0, then E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E0 dead. Focus E2 (4.4 away, 45hp), everyone fire E2 together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-538cc13ebcc7dc7dcad4c90a.json b/examples/multi-agent-smax/results/llm-cache/ask-538cc13ebcc7dc7dcad4c90a.json new file mode 100644 index 00000000..da6f0d0c --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-538cc13ebcc7dc7dcad4c90a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 8.5 seconds into the battle.\nYou are A1, a marine at (8.9, 14.1) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E1 marine at (13.1, 16.8), 18/45 health, 5.0 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (6.0s): E2 at 9hp, finish it now, then E1. I'm low, 9hp.\n A1 (6.0s): E2 at 9hp, finish it now, then E1.\n A2 (6.0s): E2 at 9hp, finish it, then all on E1.\n A1 (6.5s): E2 dead. All focus E1, it's at 45hp, 5.0 away.\n A2 (6.5s): E2 dead. I'm at 9hp, backing off. A1 focus E1, I'll rejoin.\n A1 (7.0s): Engaging E1 at 36hp, in range. A2 stay back and heal up.\n A1 (7.5s): Still on E1, 36hp. A2 stay back and heal.\n A1 (8.0s): E1 at 27hp, still firing. A2 stay back.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E1 at 18hp, still firing. Last enemy, I'm at 27hp.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-53acc72ad17c5296871a0a64.json b/examples/multi-agent-smax/results/llm-cache/ask-53acc72ad17c5296871a0a64.json new file mode 100644 index 00000000..a1ed808b --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-53acc72ad17c5296871a0a64.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 8.0 seconds into the battle.\nYou are A0, a marine at (4.8, 16.2) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: retreat.\nYour team:\n A1 marine at (3.6, 15.5), 18/45 health, order: retreat\n A2: dead\nEnemies you can see:\n E0 marine at (10.3, 17.3), 27/45 health, 5.7 away\n E2 marine at (10.5, 14.1), 45/45 health, 6.1 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (6.0s): A0 9hp retreating west; A1 stay with me, regroup before engaging E0 (27hp).\n A1 (6.0s): A1 18hp retreating west; both out of range, regroup before re-engaging E0.\n A0 (6.5s): A0 9hp retreating west; A1 stay out of range, we regroup.\n A1 (6.5s): A1 18hp retreating west with A0; out of range, regroup before engaging.\n A0 (7.0s): A0 9hp still retreating west; A1 stay with me, out of range.\n A1 (7.0s): A1 18hp retreating west; enemies 7 away, out of range. Stay together.\n A0 (7.5s): A0 9hp retreating west; A1 stay with me, out of range of E0 and E2.\n A1 (7.5s): A1 18hp retreating west; staying with A0, out of range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"retreat\", \"say\": \"A0 9hp retreating west; A1 keep retreating, stay out of range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-53c7813d0ebff3442134f857.json b/examples/multi-agent-smax/results/llm-cache/ask-53c7813d0ebff3442134f857.json new file mode 100644 index 00000000..56975a05 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-53c7813d0ebff3442134f857.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 4.5 seconds into the battle.\nYou are A2, a marine at (12.8, 14.9) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (14.3, 16.0), 27/45 health, order: attack E2\n A1: dead\nEnemies you can see:\n E1 marine at (16.5, 16.2), 45/45 health, 4.0 away (in range)\n E2 marine at (17.6, 14.3), 9/45 health, 4.8 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (2.5s): Focus E0, it's at 18hp. Keep firing until it dies.\n A2 (2.5s): A2 attacking E0 now; focus it down, then E2.\n A0 (3.0s): E0 is dead. Both attack E2 together, closest enemy; stay level with me.\n A2 (3.0s): E0 is dead. Everyone attack E2, it's in range.\n A0 (3.5s): Both on E2 together, then E1. Keep firing, no retreat.\n A2 (3.5s): Attacking E2 together; keep firing until it dies.\n A0 (4.0s): Keep firing on E2, then E1. No retreat.\n A2 (4.0s): Keep firing on E2 until dead, then E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 at 9hp, finish it now, then E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-540203116acadea4636ae4ae.json b/examples/multi-agent-smax/results/llm-cache/ask-540203116acadea4636ae4ae.json new file mode 100644 index 00000000..dc517b26 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-540203116acadea4636ae4ae.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 7.5 seconds into the battle.\nYou are A1, a marine at (3.6, 14.1) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.1, 15.8), 9/45 health, order: attack E0\n A2 marine at (8.1, 14.9), 9/45 health, order: attack E0\nYou see no enemies.\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (6.0s): A1 9hp holding back; E1 is at 9hp, finish it then E0.\n A2 (6.0s): Firing E1 (9hp), nearly dead. Then E0 together.\n A0 (6.5s): Firing E1 (9hp), finishing it. Then E0 together.\n A1 (6.5s): A1 holding back at 9hp; will shoot anything that closes in.\n A2 (6.5s): Finishing E1 (9hp) now, then all focus E0.\n A0 (7.0s): E1 down. All focus E0 now, A1 join in.\n A1 (7.0s): A1 9hp holding; will shoot anything that closes in. Finish E1, then E0.\n A2 (7.0s): E1 down. All focus E0; I'm closest and tanking, A0 and A1 fire.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"A1 joining on E0, A2 stays closest and tanks.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-547789b3e5865e002aafb1bc.json b/examples/multi-agent-smax/results/llm-cache/ask-547789b3e5865e002aafb1bc.json new file mode 100644 index 00000000..8b3be833 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-547789b3e5865e002aafb1bc.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 1.0 seconds into the battle.\nYou are A1, a marine at (11.5, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 15.\nYour team:\n A0 marine at (9.7, 15.8), 45/45 health, order: move 12 15\n A2 marine at (9.7, 14.9), 45/45 health, order: move 12 15\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Moving east together to (12,16); stay within 2 of each other, then attack same target.\n A1 (0.0s): Moving east together toward enemies; stay within 2 of each other, attack same target.\n A2 (0.0s): Advancing east together to (12,15); stay within 2 of each other.\n A0 (0.5s): Converging on (12,15) with A1/A2; will attack same target together.\n A1 (0.5s): Moving to (12,15) with team; will attack same target together.\n A2 (0.5s): A2 moving to (12,15), staying close; will attack same target when enemies appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 15\", \"say\": \"Continuing to (12,15) together; will attack same target when enemies appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-54b7f169c4edd8ad0166319c.json b/examples/multi-agent-smax/results/llm-cache/ask-54b7f169c4edd8ad0166319c.json new file mode 100644 index 00000000..eade1522 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-54b7f169c4edd8ad0166319c.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 5.5 seconds into the battle.\nYou are A0, a marine at (13.7, 15.6) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1 marine at (14.2, 16.3), 9/45 health, order: attack E1\n A2: dead\nEnemies you can see:\n E1 marine at (17.9, 16.0), 45/45 health, 4.2 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (3.5s): E2 dead. All focus E0 now, then E1. A2 retreat, you're at 9hp.\n A2 (3.5s): A2 at 9hp retreating. A0, A1 focus E0 now.\n A0 (4.0s): Focus E0 (36hp), then E1. I'm 27hp, staying in.\n A1 (4.0s): Focus E0 (36hp), then E1. A0 at 27hp, stay in unless under 20.\n A0 (4.5s): E0 at 18hp, keep focusing it, then E1. I'm 27hp, staying in.\n A1 (4.5s): E0 at 18hp, keep focusing it, then E1. A0 retreat if under 20.\n A0 (5.0s): E0 dead. Focus E1 now, it's in range 4.2.\n A1 (5.0s): E0 down. Both focus E1 now, it's the last one.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Focusing E1. A1 at 9hp, retreat if you're targeted; I'm 27hp, staying in.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-54c2bb7819cfdd97130864b1.json b/examples/multi-agent-smax/results/llm-cache/ask-54c2bb7819cfdd97130864b1.json new file mode 100644 index 00000000..cdf3eb96 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-54c2bb7819cfdd97130864b1.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 2.0 seconds into the battle.\nYou are A1, a marine at (13.2, 15.3) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (13.4, 16.9), 45/45 health, order: attack E0\n A2 marine at (12.7, 16.6), 45/45 health, order: move 14 16\nEnemies you can see:\n E0 marine at (17.8, 15.1), 27/45 health, 4.5 away (in range)\n E1 marine at (17.7, 16.7), 45/45 health, 4.7 away (in range)\n E2 marine at (19.0, 17.1), 45/45 health, 6.0 away\nTeam chat (most recent last):\n A1 (0.5s): Continuing east to (14,16), staying close to A0 and A2.\n A2 (0.5s): Moving to (14,16) with A0 and A1, staying close; will focus the first enemy seen.\n A0 (1.0s): Enemy E0 seen east at 7.8. Keep grouped; attack E0 together when within range.\n A1 (1.0s): E0 spotted east at (19.3,15.1). Keep moving together; attack when in range 5 of all.\n A2 (1.0s): A2 continuing to (14,16), staying close; will focus first enemy seen.\n A0 (1.5s): E0 in range of A0 and A1. Attack E0 now; A2 close in and focus E0.\n A1 (1.5s): E0 in range of A1 and A0. A2 close in, everyone focus E0 now.\n A2 (1.5s): E0 at 6.7, not in range yet. Moving up together; attack E0 on same tick.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Focusing E0 (27hp). A2 get in range and attack E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-54e3b08ecefd14b9230ade1b.json b/examples/multi-agent-smax/results/llm-cache/ask-54e3b08ecefd14b9230ade1b.json new file mode 100644 index 00000000..10242660 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-54e3b08ecefd14b9230ade1b.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.0 seconds into the battle.\nYou are A0, a marine at (6.9, 16.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (7.8, 14.9), 45/45 health, order: move 7.5 16.5\n A2 marine at (7.6, 17.8), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.5s): A1 holding; will focus fire on closest enemy once visible.\n A2 (0.5s): Holding; staying clustered near A0 until enemies appear, then focus closest.\n A0 (1.0s): A0 holding; A1 move closer to cluster, focus closest enemy when seen.\n A1 (1.0s): A1 holding; will focus closest enemy. Staying near A0 and A2.\n A2 (1.0s): A2 holding; no enemies seen yet, will focus closest when they appear.\n A0 (1.5s): A0 holding. Stay clustered; focus fire on closest enemy when seen.\n A1 (1.5s): A1 moving to cluster with A0/A2; holding together, focus closest enemy.\n A2 (1.5s): A2 holding; no enemies yet. Focus closest when they appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A0 holding. Focus closest enemy when seen; stay tight.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-5597d3a505712acc51fc3225.json b/examples/multi-agent-smax/results/llm-cache/ask-5597d3a505712acc51fc3225.json new file mode 100644 index 00000000..f82ffdd6 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-5597d3a505712acc51fc3225.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.0 seconds into the battle.\nYou are A2, a marine at (9.1, 16.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.4, 17.0), 45/45 health, order: hold\n A1 marine at (9.7, 17.5), 36/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (16.0, 17.6), 45/45 health, 6.9 away\n E1 marine at (13.7, 14.5), 45/45 health, 5.1 away\n E2 marine at (14.6, 17.2), 36/45 health, 5.5 away\nTeam chat (most recent last):\n A1 (1.5s): Holding at x=9; enemy E2 approaching, all focus the closest one.\n A2 (1.5s): E2 spotted east at 8.7 range; holding together, focus whatever enters range first.\n A0 (2.0s): Holding at x=9; shoot first enemy entering 5 range, focus closest.\n A1 (2.0s): Holding at x=9; shoot E2 when it enters range 5.\n A2 (2.0s): Holding at x=9; E2 closest, all focus E2 when in range.\n A0 (2.5s): Holding at x=9; focus E2 when it enters range 5.\n A1 (2.5s): Focus E2 now, all fire together.\n A2 (2.5s): Holding at x=9; E2 nearly in range, all focus E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Attacking E2 (36hp) with A1; A0 join, focus E2 first.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-55d00782882e16a9d99d60d1.json b/examples/multi-agent-smax/results/llm-cache/ask-55d00782882e16a9d99d60d1.json new file mode 100644 index 00000000..bc3507bd --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-55d00782882e16a9d99d60d1.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.5 seconds into the battle.\nYou are A0, a marine at (8.2, 16.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (9.9, 15.6), 45/45 health, order: hold\n A2 marine at (10.5, 16.3), 45/45 health, order: move 14 16\nEnemies you can see:\n E0 marine at (16.6, 17.3), 45/45 health, 8.5 away\n E1 marine at (16.7, 16.6), 45/45 health, 8.4 away\n E2 marine at (16.8, 14.1), 45/45 health, 8.8 away\nTeam chat (most recent last):\n A1 (1.0s): Still no enemies; holding grouped, will focus closest when seen.\n A2 (1.0s): Still no enemies. Holding; will focus the closest enemy when seen.\n A0 (1.5s): Still no enemies; holding grouped, focus closest when seen.\n A1 (1.5s): Holding grouped; focus fire on closest enemy when seen.\n A2 (1.5s): Still holding grouped; will focus the closest enemy when it appears.\n A0 (2.0s): Holding grouped; no enemies yet. Focus closest when seen.\n A1 (2.0s): Enemies at 8.5 east. Hold grouped; all focus the closest when in range.\n A2 (2.0s): No contact after 2s. Advancing east together to (14,16); stay close, focus closest.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A2 advancing alone is risky; hold grouped at range 5, focus E1 when in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-55ee67a6a59a87b867b3c14d.json b/examples/multi-agent-smax/results/llm-cache/ask-55ee67a6a59a87b867b3c14d.json new file mode 100644 index 00000000..e58aad05 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-55ee67a6a59a87b867b3c14d.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.0 seconds into the battle.\nYou are A2, a marine at (9.9, 15.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0: dead\n A1 marine at (10.1, 17.3), 36/45 health, order: attack E1\nEnemies you can see:\n E1 marine at (13.8, 17.3), 18/45 health, 4.2 away (in range)\n E2 marine at (14.4, 14.8), 45/45 health, 4.6 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (3.5s): Keep focusing E0 (18hp), then E1.\n A1 (3.5s): Keep focusing E0, it's at 18 health. Then E1.\n A2 (3.5s): E0 at 18hp, keep focusing E0, then E2.\n A0 (4.0s): E0 dead. Focus E1 (3.6 away), then E2. I'm at 18hp.\n A1 (4.0s): E0 dead. Focus E1 (closest, 3.7 away), then E2.\n A2 (4.0s): E0 dead. Focus E1 (4.2 away), then E2.\n A1 (4.5s): Focusing E1 (27hp), then E2.\n A2 (4.5s): Focusing E1 (27hp), then E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Attacking E1 (18hp), then E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-56d8c3bf24a31f396d1f5820.json b/examples/multi-agent-smax/results/llm-cache/ask-56d8c3bf24a31f396d1f5820.json new file mode 100644 index 00000000..6ad15d69 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-56d8c3bf24a31f396d1f5820.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 2.5 seconds into the battle.\nYou are A1, a marine at (13.5, 17.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (13.8, 15.8), 36/45 health, order: attack E2\n A2 marine at (13.9, 17.8), 36/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (18.0, 17.1), 45/45 health, 4.6 away (in range)\n E1 marine at (17.3, 17.0), 45/45 health, 3.8 away (in range)\n E2 marine at (15.8, 16.7), 18/45 health, 2.4 away (in range)\nTeam chat (most recent last):\n A1 (1.0s): Advancing east together toward E2; keep within 2, attack same target at range.\n A2 (1.0s): Closing together toward E2; hold pace, all fire on E2 once in range 5.\n A0 (1.5s): E2 is 5.2 away; one more step east, then all attack E2 together.\n A1 (1.5s): Almost in range of E2; keep pace, all attack E2 together next tick.\n A2 (1.5s): Still closing together; E2 just outside range. Fire on E2 once all in range 5.\n A0 (2.0s): All in range of E2 now. Everyone fire on E2.\n A1 (2.0s): All in range of E2 (2.4 away). Attack E2 now, everyone focus fire.\n A2 (2.0s): E2 in range of me; all attack E2 now.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Focusing E2, it's at 18hp. Keep firing, then switch to E1 together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-56ec3ec12a1ce107a269b39d.json b/examples/multi-agent-smax/results/llm-cache/ask-56ec3ec12a1ce107a269b39d.json new file mode 100644 index 00000000..6befddf5 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-56ec3ec12a1ce107a269b39d.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.0 seconds into the battle.\nYou are A0, a marine at (7.8, 14.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1 marine at (8.5, 14.8), 18/45 health, order: attack E2\n A2 marine at (8.2, 14.1), 45/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (12.6, 15.0), 45/45 health, 4.8 away (in range)\n E1 marine at (13.4, 14.0), 45/45 health, 5.7 away\n E2 marine at (11.8, 16.8), 18/45 health, 4.6 away (in range)\nTeam chat (most recent last):\n A1 (2.5s): Holding. Enemies closing; all focus closest enemy once in range 5.\n A2 (2.5s): A2 holding. Enemies approaching; focus closest once in range 5.\n A0 (3.0s): Holding. Focus closest enemy E2 when in range 5, fire together.\n A1 (3.0s): Holding. E2 closest at 5.3; focus E2 when in range, then E0.\n A2 (3.0s): Holding. E2 closest at 5.8; focus whoever enters range 5 first.\n A0 (3.5s): E2 in range 4.6, all focus fire E2 now, then E0.\n A1 (3.5s): Focus E2 now, all fire together, then E0.\n A2 (3.5s): E0 and E2 in range now. Focus E2, fire together, then E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Firing E2 (18hp), then E0. A1 stay behind us.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-572089502f2a0905921ea7e6.json b/examples/multi-agent-smax/results/llm-cache/ask-572089502f2a0905921ea7e6.json new file mode 100644 index 00000000..f0ef18f0 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-572089502f2a0905921ea7e6.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.5 seconds into the battle.\nYou are A0, a marine at (7.5, 15.8) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1 marine at (7.2, 17.2), 45/45 health, order: attack E1\n A2: dead\nEnemies you can see:\n E0 marine at (11.7, 17.0), 45/45 health, 4.4 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (4.5s): E2 down. Focus E1 (closest, 3.9 away), then E0.\n A2 (4.5s): E2 down. Focus E1 (closest, 3.5 away), then E0.\n A0 (5.0s): Firing E1 (27hp), then E0.\n A1 (5.0s): Firing E1 (27hp), then E0.\n A0 (5.5s): Firing E1 (18hp), then E0.\n A1 (5.5s): Firing E1 (18hp), then E0.\n A0 (6.0s): E1 at 9hp, finishing it. Then focus E0.\n A1 (6.0s): Firing E1 (9hp), then E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E1 down. Focusing E0, 4.4 away, all fire.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-578b73e6f679aeee14b516be.json b/examples/multi-agent-smax/results/llm-cache/ask-578b73e6f679aeee14b516be.json new file mode 100644 index 00000000..27818528 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-578b73e6f679aeee14b516be.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.5 seconds into the battle.\nYou are A2, a marine at (10.8, 14.8) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0: dead\n A1 marine at (8.9, 14.1), 45/45 health, order: attack E2\nEnemies you can see:\n E1 marine at (13.1, 16.8), 45/45 health, 3.0 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (5.0s): E0 dead. Focus E2 (4.4 away, 45hp), everyone fire E2 together.\n A2 (5.0s): E0 dead. All focus E2, closest at 2.3, then E1.\n A0 (5.5s): E2 at 18hp, all fire E2 now, then E1.\n A1 (5.5s): Firing E2 (18hp), then E1 together.\n A2 (5.5s): Keep firing E2 (18hp), then E1 together.\n A0 (6.0s): E2 at 9hp, finish it now, then E1. I'm low, 9hp.\n A1 (6.0s): E2 at 9hp, finish it now, then E1.\n A2 (6.0s): E2 at 9hp, finish it, then all on E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"retreat\", \"say\": \"E2 dead. I'm at 9hp, backing off. A1 focus E1, I'll rejoin.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-58462cbcdb98d6a33f4af53b.json b/examples/multi-agent-smax/results/llm-cache/ask-58462cbcdb98d6a33f4af53b.json new file mode 100644 index 00000000..599ac184 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-58462cbcdb98d6a33f4af53b.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.5 seconds into the battle.\nYou are A0, a marine at (7.8, 14.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1: dead\n A2 marine at (8.2, 14.1), 18/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (12.6, 15.0), 27/45 health, 4.8 away (in range)\n E1 marine at (11.9, 14.0), 45/45 health, 4.1 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A2 (3.5s): E0 and E2 in range now. Focus E2, fire together, then E0.\n A0 (4.0s): Firing E2 (18hp), then E0. A1 stay behind us.\n A1 (4.0s): E2 at 18 HP, finish it now, then E0.\n A2 (4.0s): Firing on E2 (18hp), then E0. Keep A1 behind us.\n A0 (4.5s): E2 down. Focus E0 now, then E1. Fire together.\n A2 (4.5s): E2 down. Focus E0 (4.5 away), then E1.\n A0 (5.0s): Focus E0 together, then E1. A2 keep firing.\n A2 (5.0s): Focus E0 together, then E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Keep focusing E0 (27hp), then E1. Fire together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-58b0f26c35c266ccf98aef0b.json b/examples/multi-agent-smax/results/llm-cache/ask-58b0f26c35c266ccf98aef0b.json new file mode 100644 index 00000000..9adcfe02 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-58b0f26c35c266ccf98aef0b.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 1.5 seconds into the battle.\nYou are A2, a marine at (11.2, 16.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 16.\nYour team:\n A0 marine at (13.3, 16.9), 45/45 health, order: move 14 16\n A1 marine at (13.2, 15.3), 45/45 health, order: move 14 16\nEnemies you can see:\n E0 marine at (17.8, 15.1), 45/45 health, 6.7 away\n E1 marine at (19.3, 16.7), 45/45 health, 8.1 away\nTeam chat (most recent last):\n A1 (0.0s): No enemies seen. Moving east together to (14,16); stay within 2 of each other.\n A2 (0.0s): Moving east together to find enemies; stay within 2 of each other.\n A0 (0.5s): Continuing east to (14,16), staying close; will attack together when enemies appear.\n A1 (0.5s): Continuing east to (14,16), staying close to A0 and A2.\n A2 (0.5s): Moving to (14,16) with A0 and A1, staying close; will focus the first enemy seen.\n A0 (1.0s): Enemy E0 seen east at 7.8. Keep grouped; attack E0 together when within range.\n A1 (1.0s): E0 spotted east at (19.3,15.1). Keep moving together; attack when in range 5 of all.\n A2 (1.0s): A2 continuing to (14,16), staying close; will focus first enemy seen.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 16\", \"say\": \"E0 at 6.7, not in range yet. Moving up together; attack E0 on same tick.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-58c4f7654d0aa83284439d84.json b/examples/multi-agent-smax/results/llm-cache/ask-58c4f7654d0aa83284439d84.json new file mode 100644 index 00000000..cc482b84 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-58c4f7654d0aa83284439d84.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.0 seconds into the battle.\nYou are A1, a marine at (7.2, 17.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.5, 15.8), 45/45 health, order: hold\n A2 marine at (7.6, 17.8), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (15.9, 17.1), 45/45 health, 8.7 away\n E1 marine at (14.7, 17.1), 45/45 health, 7.5 away\n E2 marine at (12.6, 16.7), 45/45 health, 5.5 away\nTeam chat (most recent last):\n A1 (1.5s): A1 holding; no enemies yet. Focus closest when seen.\n A2 (1.5s): A2 holding; no enemies visible. Focus closest when they appear.\n A0 (2.0s): E2 spotted at (15.8,16.7). Holding grouped; focus fire on whoever closes first.\n A1 (2.0s): E2 spotted east at 8.6 range. Holding grouped; focus E2 when in range.\n A2 (2.0s): E2 spotted at (15.8,16.7), 8 away. Holding grouped; focus E2 when in range.\n A0 (2.5s): E1, E2 approaching. Holding grouped; focus E2 when within 5.\n A1 (2.5s): E2 at 7 range. Holding grouped; focus E2 once in range.\n A2 (2.5s): E2 at 6.7, E1 behind. Holding grouped; focus closest when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"E2 at 5.5, nearly in range. Holding; all focus E2 when it enters 5.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-58e581fb27092511f4d8fa55.json b/examples/multi-agent-smax/results/llm-cache/ask-58e581fb27092511f4d8fa55.json new file mode 100644 index 00000000..c32ce90f --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-58e581fb27092511f4d8fa55.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 5.0 seconds into the battle.\nYou are A1, a marine at (9.9, 15.5) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: retreat.\nYour team:\n A0 marine at (14.2, 16.2), 9/45 health, order: attack E0\n A2: dead\nEnemies you can see:\n E0 marine at (18.2, 17.3), 27/45 health, 8.6 away\n E2 marine at (18.4, 14.1), 45/45 health, 8.7 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (3.0s): E1 at 9hp, finish it now; then focus E0.\n A1 (3.0s): E1 at 9hp, finishing it now. A0 fire E1, then focus E2.\n A0 (3.5s): E1 dead. A0 focusing E0; A1 under 20hp, retreat to pull fire.\n A1 (3.5s): A1 at 18hp retreating so A0 is closest; A0 focus E2, I return when safe.\n A0 (4.0s): Focusing E0 (36hp). A1 stay back; I'm tanking, then we take E2.\n A1 (4.0s): A1 18hp retreating; A0 you're closest, focus E0 (36hp), I'll return when safe.\n A0 (4.5s): A0 firing E0 (27hp), tanking. A1 stay back, then we take E2.\n A1 (4.5s): A1 18hp staying back; A0 kill E0 (27hp), then E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"A1 joining now, both focus E0 (27hp) to split their fire.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-59235b8f3ea06cadff11f1dd.json b/examples/multi-agent-smax/results/llm-cache/ask-59235b8f3ea06cadff11f1dd.json new file mode 100644 index 00000000..70412496 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-59235b8f3ea06cadff11f1dd.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.0 seconds into the battle.\nYou are A2, a marine at (9.4, 14.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.1, 17.5), 45/45 health, order: hold\n A1 marine at (7.1, 14.7), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding together; focus fire on the closest enemy when they appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-59a797e0a22e234b9be87117.json b/examples/multi-agent-smax/results/llm-cache/ask-59a797e0a22e234b9be87117.json new file mode 100644 index 00000000..87d8b9f1 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-59a797e0a22e234b9be87117.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 5.0 seconds into the battle.\nYou are A1, a marine at (13.5, 17.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E0 marine at (18.0, 17.1), 45/45 health, 4.6 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A2 (3.0s): E2 dead. All focus E1 (closest, 3.5 away) now.\n A0 (3.5s): Focus E1 together, then E0. A2 stay on target per rules.\n A1 (3.5s): Focusing E1 now; A2 at 9hp, retreat only after E1 dies.\n A2 (3.5s): Focusing E1 with you. I'm at 9hp, will keep firing until it dies.\n A0 (4.0s): Keep firing E1 (18hp), then E0 together.\n A1 (4.0s): Firing on E1 (18hp), then E0 together.\n A0 (4.5s): E1 down. Focus E0 now, both fire together.\n A1 (4.5s): E1 dead. Focus E0 (4.6 away), A0 keep firing, I'm full health.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Firing on E0, last enemy. I'm at full health.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-59eefc0ce0f1daf80429b997.json b/examples/multi-agent-smax/results/llm-cache/ask-59eefc0ce0f1daf80429b997.json new file mode 100644 index 00000000..89982303 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-59eefc0ce0f1daf80429b997.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 4.5 seconds into the battle.\nYou are A0, a marine at (13.8, 15.8) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1 marine at (13.5, 17.2), 45/45 health, order: attack E1\n A2: dead\nEnemies you can see:\n E0 marine at (18.0, 17.1), 45/45 health, 4.4 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (3.0s): E2 is dead. Everyone focus E1 now (3.6 away), then E0.\n A1 (3.0s): E2 down. Everyone focus E1 now (3.8 away), then E0.\n A2 (3.0s): E2 dead. All focus E1 (closest, 3.5 away) now.\n A0 (3.5s): Focus E1 together, then E0. A2 stay on target per rules.\n A1 (3.5s): Focusing E1 now; A2 at 9hp, retreat only after E1 dies.\n A2 (3.5s): Focusing E1 with you. I'm at 9hp, will keep firing until it dies.\n A0 (4.0s): Keep firing E1 (18hp), then E0 together.\n A1 (4.0s): Firing on E1 (18hp), then E0 together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E1 down. Focus E0 now, both fire together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-5a0546a08d3e5ec58d1d2901.json b/examples/multi-agent-smax/results/llm-cache/ask-5a0546a08d3e5ec58d1d2901.json new file mode 100644 index 00000000..5c9b1ac1 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-5a0546a08d3e5ec58d1d2901.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.5 seconds into the battle.\nYou are A0, a marine at (8.6, 16.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (8.5, 15.3), 45/45 health, order: hold\n A2 marine at (6.5, 16.6), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together here; focus fire on the closest enemy when they appear.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together as a group; focus fire on the closest enemy once seen.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"No enemies yet. Holding; focus the closest when they appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-5a12f5c9933f18aeae358e60.json b/examples/multi-agent-smax/results/llm-cache/ask-5a12f5c9933f18aeae358e60.json new file mode 100644 index 00000000..000730c2 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-5a12f5c9933f18aeae358e60.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 4.0 seconds into the battle.\nYou are A0, a marine at (14.3, 16.0) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1: dead\n A2 marine at (12.8, 14.9), 36/45 health, order: attack E2\nEnemies you can see:\n E1 marine at (16.5, 16.2), 45/45 health, 2.3 away (in range)\n E2 marine at (17.6, 14.3), 27/45 health, 3.8 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A2 (2.0s): Enemies in range now. Everyone attack E0 together.\n A0 (2.5s): Focus E0, it's at 18hp. A1 stay on target per rules.\n A1 (2.5s): Focus E0, it's at 18hp. Keep firing until it dies.\n A2 (2.5s): A2 attacking E0 now; focus it down, then E2.\n A0 (3.0s): E0 is dead. Both attack E2 together, closest enemy; stay level with me.\n A2 (3.0s): E0 is dead. Everyone attack E2, it's in range.\n A0 (3.5s): Both on E2 together, then E1. Keep firing, no retreat.\n A2 (3.5s): Attacking E2 together; keep firing until it dies.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Keep firing on E2, then E1. No retreat.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-5a45b5fd813335ccbae5b6e9.json b/examples/multi-agent-smax/results/llm-cache/ask-5a45b5fd813335ccbae5b6e9.json new file mode 100644 index 00000000..51324e1f --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-5a45b5fd813335ccbae5b6e9.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 4.0 seconds into the battle.\nYou are A2, a marine at (13.7, 16.7) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (13.3, 15.6), 18/45 health, order: attack E1\n A1 marine at (12.9, 17.5), 27/45 health, order: attack E1\nEnemies you can see:\n E0 marine at (17.7, 17.8), 45/45 health, 4.2 away (in range)\n E1 marine at (16.9, 14.5), 9/45 health, 3.9 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (2.5s): Focusing E2 (9hp), it dies soon; then we focus E0.\n A2 (2.5s): E2 at 9hp, finishing it now. Then focus E1.\n A0 (3.0s): E2 dead. Focus E1 (closest, 3.7 away), then E0.\n A1 (3.0s): E2 dead. Everyone focus E1 now, then E0.\n A2 (3.0s): E2 dead. Everyone focus E1 now, closest at 3.9.\n A0 (3.5s): Focus E1 (27hp). Keep attacking until dead, then E0.\n A1 (3.5s): Focusing E1 (27hp). A0 at 18hp, keep firing until E1 dies.\n A2 (3.5s): Focusing E1 (27hp), then E0. A0 at 18hp, keep firing.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E1 at 9hp, keep firing until dead, then E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-5a8d4a5e1c647d802107416f.json b/examples/multi-agent-smax/results/llm-cache/ask-5a8d4a5e1c647d802107416f.json new file mode 100644 index 00000000..4d9ec7b8 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-5a8d4a5e1c647d802107416f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.5 seconds into the battle.\nYou are A0, a marine at (9.9, 17.0) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1: dead\n A2: dead\nEnemies you can see:\n E0 marine at (14.6, 17.8), 45/45 health, 4.7 away (in range)\n E1 marine at (13.7, 14.5), 9/45 health, 4.5 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (4.0s): E2 at 18hp, in range. Finish it now, then E1.\n A2 (4.0s): E2 at 18hp, finish it now. A0 keep firing.\n A0 (4.5s): E2 is down. Focus E1 (closest, 45hp), then E0.\n A2 (4.5s): E2 down. Focus E1 (closest, 3.8 away), then E0.\n A0 (5.0s): Focusing E1 (36hp), both in range. A2 stay behind me, you're low.\n A2 (5.0s): Focus E1 (36hp), I'm low at 18hp. A0 keep firing, then E0.\n A0 (5.5s): A0 on E1 (18hp), almost dead. Then E0.\n A0 (6.0s): Finishing E1 (18hp), then E0. A2 stay back.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E1 at 9hp, finishing it now, then E0. A0 at 27hp.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-5add05521cf1b57e9add2607.json b/examples/multi-agent-smax/results/llm-cache/ask-5add05521cf1b57e9add2607.json new file mode 100644 index 00000000..6f979449 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-5add05521cf1b57e9add2607.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.5 seconds into the battle.\nYou are A1, a marine at (8.9, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0: dead\n A2 marine at (10.8, 14.8), 9/45 health, order: attack E2\nEnemies you can see:\n E1 marine at (13.1, 16.8), 45/45 health, 5.0 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (5.0s): E0 is dead. Focus fire E2, closest at 4.4.\n A2 (5.0s): E0 down. Focus E2 (closest), then E1.\n A0 (5.5s): E2 at 18hp, all fire E2 now, then E1. I'm at 9hp.\n A1 (5.5s): Focus E2 (18 hp), then E1. Keep firing.\n A2 (5.5s): Focus E2 (18hp), then E1. Keep firing.\n A0 (6.0s): E2 at 9hp, all fire now. I'm at 9hp, finish E2 then E1.\n A1 (6.0s): Firing E2 (9hp), then E1. A0 stay back, low hp.\n A2 (6.0s): E2 at 9hp, all fire E2 now, then E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E2 down. All fire E1, 45hp. A2 stay back, low hp.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-5af756e5ba1334f391d782d5.json b/examples/multi-agent-smax/results/llm-cache/ask-5af756e5ba1334f391d782d5.json new file mode 100644 index 00000000..31d7b1eb --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-5af756e5ba1334f391d782d5.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 6.0 seconds into the battle.\nYou are A1, a marine at (14.2, 16.3) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (13.7, 15.6), 27/45 health, order: attack E1\n A2: dead\nEnemies you can see:\n E1 marine at (17.9, 16.0), 27/45 health, 3.7 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (4.0s): Focus E0 (36hp), then E1. I'm 27hp, staying in.\n A1 (4.0s): Focus E0 (36hp), then E1. A0 at 27hp, stay in unless under 20.\n A0 (4.5s): E0 at 18hp, keep focusing it, then E1. I'm 27hp, staying in.\n A1 (4.5s): E0 at 18hp, keep focusing it, then E1. A0 retreat if under 20.\n A0 (5.0s): E0 dead. Focus E1 now, it's in range 4.2.\n A1 (5.0s): E0 down. Both focus E1 now, it's the last one.\n A0 (5.5s): Focusing E1. A1 at 9hp, retreat if you're targeted; I'm 27hp, staying in.\n A1 (5.5s): Attacking E1. I'm 9hp and will soak a shot. A0 keep firing, finish it.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"retreat\", \"say\": \"A1 at 9hp retreating so I'm not the target. A0 finish E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-5b17efc53d4c126e4353f8d6.json b/examples/multi-agent-smax/results/llm-cache/ask-5b17efc53d4c126e4353f8d6.json new file mode 100644 index 00000000..94b11605 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-5b17efc53d4c126e4353f8d6.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.0 seconds into the battle.\nYou are A0, a marine at (9.9, 17.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1: dead\n A2 marine at (10.7, 16.8), 36/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (14.6, 17.8), 45/45 health, 4.7 away (in range)\n E1 marine at (13.7, 14.5), 45/45 health, 4.5 away (in range)\n E2 marine at (14.4, 17.0), 18/45 health, 4.6 away (in range)\nTeam chat (most recent last):\n A1 (2.5s): Focus E2 now, all fire together.\n A2 (2.5s): Holding at x=9; E2 nearly in range, all focus E2.\n A0 (3.0s): Holding at x=9; focus E2 (36hp) first once any enemy enters range 5.\n A1 (3.0s): Firing on E2 (36hp, in range). A0, A2 step up and focus E2.\n A2 (3.0s): Attacking E2 (36hp) with A1; A0 join, focus E2 first.\n A0 (3.5s): Attacking E2 (27hp), closing in to focus fire with A2.\n A1 (3.5s): E2 at 27hp, keep focusing it. A0 attack E2 too.\n A2 (3.5s): Firing E2 (27hp), A0 step up and focus E2. A1 stay back.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 at 18hp, in range. Finish it now, then E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-5b7b8e777f1b678d419d93a6.json b/examples/multi-agent-smax/results/llm-cache/ask-5b7b8e777f1b678d419d93a6.json new file mode 100644 index 00000000..16dc9363 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-5b7b8e777f1b678d419d93a6.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 1.0 seconds into the battle.\nYou are A2, a marine at (11.6, 16.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 17.\nYour team:\n A0 marine at (11.7, 18.0), 45/45 health, order: move 12 17\n A1 marine at (11.8, 17.2), 45/45 health, order: move 12 17\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Moving east together, stay within 2 of each other; no one engage alone.\n A1 (0.0s): Moving east together toward enemies; keep within 2 of each other, attack together.\n A2 (0.0s): Moving east together toward enemies, stay within 2 of each other; attack same target on call.\n A0 (0.5s): Moving east together, keeping formation; will attack same target when all in range.\n A1 (0.5s): Moving east in formation at x=12; no one engages alone.\n A2 (0.5s): Moving east, staying close; A0 at 12,17 is my anchor point.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 16 17\", \"say\": \"Moving east together to x=16; will attack same target once all in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-5bdd16bec79edbfa646464de.json b/examples/multi-agent-smax/results/llm-cache/ask-5bdd16bec79edbfa646464de.json new file mode 100644 index 00000000..3595abf6 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-5bdd16bec79edbfa646464de.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.5 seconds into the battle.\nYou are A2, a marine at (8.7, 15.8) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (8.0, 15.5), 45/45 health, order: hold\n A1 marine at (6.7, 14.2), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (13.5, 16.8), 36/45 health, 4.9 away (in range)\n E1 marine at (13.7, 16.2), 45/45 health, 5.0 away\n E2 marine at (13.9, 17.4), 45/45 health, 5.4 away\nTeam chat (most recent last):\n A1 (2.0s): A1 holding; no enemies yet, will focus closest when one appears.\n A2 (2.0s): E0 at (16.8,16.8) approaching; hold and focus it when in range.\n A0 (2.5s): A0 holding with you; enemies approaching, focus E0 when in range.\n A1 (2.5s): A1 holding at (6.7,14.2); A0 fall back to us, focus E0 together.\n A2 (2.5s): A2 holding; enemies approaching, all focus E0 when in range.\n A0 (3.0s): A0 holding; focus E0 when in range 5.\n A1 (3.0s): A1 holding; focus E0 when it enters range 5.\n A2 (3.0s): A2 attacking E0 (in range); all focus E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"A2 attacking E0 (36hp, in range); all focus E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-5bf2fc4bdb0f31d047303e97.json b/examples/multi-agent-smax/results/llm-cache/ask-5bf2fc4bdb0f31d047303e97.json new file mode 100644 index 00000000..0025a225 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-5bf2fc4bdb0f31d047303e97.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.5 seconds into the battle.\nYou are A0, a marine at (7.2, 15.7) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1 marine at (6.5, 16.0), 45/45 health, order: hold\n A2 marine at (7.1, 16.5), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (10.7, 17.7), 45/45 health, 4.0 away (in range)\n E1 marine at (11.6, 16.0), 45/45 health, 4.3 away (in range)\n E2 marine at (11.8, 14.7), 36/45 health, 4.7 away (in range)\nTeam chat (most recent last):\n A1 (3.0s): A1 holding; E2 seen east at 8.6. Let them come into range, focus closest.\n A2 (3.0s): A2 holding; enemies at 8 range, let them come in, focus closest.\n A0 (3.5s): Holding; E2 closest at 6.2. Focus E2 when in range.\n A1 (3.5s): A1 holding; fire on closest enemy once in range, E2 first.\n A2 (3.5s): A2 holding; enemies closing, fire on closest E2 when in range.\n A0 (4.0s): E2 in range at 4.7; all focus fire E2 now.\n A1 (4.0s): Holding; E2 closest at 5.5, focus E2 once in range.\n A2 (4.0s): Holding. E2 at 5.1, about to enter range. Focus E2 together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Firing E2 now, it's at 36 health. Everyone focus E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-5c2269f2e27314e5a547ed8a.json b/examples/multi-agent-smax/results/llm-cache/ask-5c2269f2e27314e5a547ed8a.json new file mode 100644 index 00000000..21e38add --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-5c2269f2e27314e5a547ed8a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.0 seconds into the battle.\nYou are A2, a marine at (7.7, 14.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (9.0, 16.0), 45/45 health, order: hold\n A1 marine at (7.4, 14.1), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on closest enemy when they appear.\n A0 (0.5s): No enemies yet. Staying grouped; focus fire on closest when they appear.\n A1 (0.5s): Holding; will focus fire on closest enemy once in range.\n A2 (0.5s): Holding position; focus fire on closest enemy once in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Still holding; no enemies visible. Focus fire on closest when they appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-5d1f66131f1ebb3f0d1d62e9.json b/examples/multi-agent-smax/results/llm-cache/ask-5d1f66131f1ebb3f0d1d62e9.json new file mode 100644 index 00000000..b7ee29c0 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-5d1f66131f1ebb3f0d1d62e9.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.0 seconds into the battle.\nYou are A1, a marine at (9.9, 15.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (9.4, 15.9), 45/45 health, order: attack E1\n A2 marine at (9.3, 16.6), 18/45 health, order: retreat\nEnemies you can see:\n E0 marine at (15.1, 17.3), 45/45 health, 5.4 away\n E1 marine at (15.1, 16.6), 36/45 health, 5.3 away\n E2 marine at (13.7, 14.1), 36/45 health, 4.0 away (in range)\nTeam chat (most recent last):\n A1 (2.5s): Enemies 7 east. A2 fall back to group; hold and focus E1 when in range.\n A2 (2.5s): Cancel advance. Holding at 10.5; enemies 6 east, focus E1 when in range.\n A0 (3.0s): Holding. Enemies at 7; focus E1 when in range, stay grouped.\n A1 (3.0s): Holding. E1 is closest at 5.3; focus E1 as soon as it's in range.\n A2 (3.0s): Enemies in range. Focus E1 now, everyone fire on E1.\n A0 (3.5s): Moving up to fire on E1; A2 is taking fire, everyone commit.\n A1 (3.5s): E1 out of range; E2 in range at 4.1. Everyone focus E2.\n A2 (3.5s): A2 hurt, pulling back west to you. Fire on E1 when they follow into range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Firing on E2 (36hp, in range). A0 switch to E2. A2 stay back.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-5d2c8e2627e69892b1f860ba.json b/examples/multi-agent-smax/results/llm-cache/ask-5d2c8e2627e69892b1f860ba.json new file mode 100644 index 00000000..9c32dde0 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-5d2c8e2627e69892b1f860ba.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 0.0 seconds into the battle.\nYou are A2, a marine at (8.4, 16.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.5, 18.0), 45/45 health, order: hold\n A1 marine at (8.6, 17.2), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 16\", \"say\": \"Moving east together toward enemies, stay within 2 of each other; attack same target on call.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-5d5822997d79a2efacda2d84.json b/examples/multi-agent-smax/results/llm-cache/ask-5d5822997d79a2efacda2d84.json new file mode 100644 index 00000000..d8355ee7 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-5d5822997d79a2efacda2d84.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 1.5 seconds into the battle.\nYou are A1, a marine at (12.9, 17.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 16.5.\nYour team:\n A0 marine at (11.7, 15.6), 45/45 health, order: move 14 16.5\n A2 marine at (12.1, 16.7), 45/45 health, order: move 14 16.8\nEnemies you can see:\n E0 marine at (20.7, 17.6), 45/45 health, 7.8 away\n E1 marine at (18.4, 14.5), 45/45 health, 6.3 away\n E2 marine at (17.8, 17.2), 45/45 health, 4.9 away (in range)\nTeam chat (most recent last):\n A1 (0.0s): Moving east together toward center, stay within 2 of each other.\n A2 (0.0s): Moving east together toward center, stay close, all engage same enemy on contact.\n A0 (0.5s): Continuing east together; hold formation, all attack same target on contact.\n A1 (0.5s): Continuing east together; will all attack same enemy on contact.\n A2 (0.5s): Continuing east together; no enemies seen yet, will focus same target on contact.\n A0 (1.0s): Continuing east together; no enemies yet, will focus same target on contact.\n A1 (1.0s): Moving to 14,16.5 with the group; will attack E2 together when in range.\n A2 (1.0s): Enemy E2 seen at 19.3,17.2. Keep formation, advance together, then all attack E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 in my range; A0, A2 close in and focus E2 now.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-5db8c6dc66363709f0e3617e.json b/examples/multi-agent-smax/results/llm-cache/ask-5db8c6dc66363709f0e3617e.json new file mode 100644 index 00000000..a8eb9021 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-5db8c6dc66363709f0e3617e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.5 seconds into the battle.\nYou are A1, a marine at (3.6, 14.1) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.1, 15.8), 9/45 health, order: attack E1\n A2 marine at (8.1, 14.9), 27/45 health, order: attack E1\nEnemies you can see:\n E1 marine at (11.8, 16.2), 9/45 health, 8.5 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (5.0s): A1 at 9hp staying back. Focus E1 then E0, keep grouped.\n A2 (5.0s): Firing E1 (closest). A0 focus E1 too, then E0. A1 stay back.\n A0 (5.5s): Firing E1 (27hp). A1 stay back. Then E0.\n A1 (5.5s): A1 at 9hp staying back; focus E1 then E0.\n A2 (5.5s): Firing E1 (27hp). A0 keep focus, then E0. A1 stay back.\n A0 (6.0s): Firing E1 (9hp), nearly dead. Then E0 together.\n A1 (6.0s): A1 9hp holding back; E1 is at 9hp, finish it then E0.\n A2 (6.0s): Firing E1 (9hp), nearly dead. Then E0 together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A1 holding back at 9hp; will shoot anything that closes in.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-5dc13d524d03d658ff561ced.json b/examples/multi-agent-smax/results/llm-cache/ask-5dc13d524d03d658ff561ced.json new file mode 100644 index 00000000..7d9dff4a --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-5dc13d524d03d658ff561ced.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.5 seconds into the battle.\nYou are A1, a marine at (7.2, 17.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (7.5, 15.8), 27/45 health, order: attack E1\n A2: dead\nEnemies you can see:\n E0 marine at (11.7, 17.0), 45/45 health, 4.6 away (in range)\n E1 marine at (11.0, 17.2), 18/45 health, 3.9 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (4.0s): Firing E2 (18hp left); then E1.\n A1 (4.0s): Keep firing E2 (18hp), then E1.\n A2 (4.0s): Keep firing E2, it's at 18 HP. Then focus E1.\n A0 (4.5s): E2 down. Focus E1 (closest), then E0.\n A1 (4.5s): E2 down. Focus E1 (closest, 3.9 away), then E0.\n A2 (4.5s): E2 down. Focus E1 (closest, 3.5 away), then E0.\n A0 (5.0s): Firing E1 (27hp), then E0.\n A1 (5.0s): Firing E1 (27hp), then E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Firing E1 (18hp), then E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-5df661619fe94f03bae6b837.json b/examples/multi-agent-smax/results/llm-cache/ask-5df661619fe94f03bae6b837.json new file mode 100644 index 00000000..c7fac73f --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-5df661619fe94f03bae6b837.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 4.5 seconds into the battle.\nYou are A0, a marine at (14.2, 16.2) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1 marine at (11.4, 15.5), 18/45 health, order: retreat\n A2: dead\nEnemies you can see:\n E0 marine at (18.2, 17.3), 27/45 health, 4.1 away (in range)\n E2 marine at (18.4, 14.1), 45/45 health, 4.7 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (2.5s): Firing on E1 (27hp). A2 at 18hp, retreat if under 20.\n A2 (2.5s): A2 at 18hp retreating to pull fire off me; A0, A1 keep focusing E1.\n A0 (3.0s): E1 at 9hp, finish it now; then focus E0.\n A1 (3.0s): E1 at 9hp, finishing it now. A0 fire E1, then focus E2.\n A0 (3.5s): E1 dead. A0 focusing E0; A1 under 20hp, retreat to pull fire.\n A1 (3.5s): A1 at 18hp retreating so A0 is closest; A0 focus E2, I return when safe.\n A0 (4.0s): Focusing E0 (36hp). A1 stay back; I'm tanking, then we take E2.\n A1 (4.0s): A1 18hp retreating; A0 you're closest, focus E0 (36hp), I'll return when safe.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"A0 firing E0 (27hp), tanking. A1 stay back, then we take E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-5e99c08dce9d529fac7c06e4.json b/examples/multi-agent-smax/results/llm-cache/ask-5e99c08dce9d529fac7c06e4.json new file mode 100644 index 00000000..41e59157 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-5e99c08dce9d529fac7c06e4.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.5 seconds into the battle.\nYou are A0, a marine at (9.3, 15.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1: dead\n A2: dead\nEnemies you can see:\n E0 marine at (13.5, 17.3), 45/45 health, 4.4 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (4.5s): E2 at 18hp, finish it now, then E1.\n A2 (4.5s): Firing on E2 (18hp), one more volley kills it. Then E1.\n A0 (5.0s): E2 down. Focus E1 (36hp), then E0.\n A1 (5.0s): E2 down. Focus E1 (36hp), then E0.\n A0 (5.5s): Focusing E1 (18hp), both of us fire. Then E0.\n A1 (5.5s): Focusing E1 (18hp), both fire. Then E0.\n A0 (6.0s): E1 at 9hp, finishing it. Then E0 together.\n A1 (6.0s): E1 at 9hp, finishing it now. Then E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"A1 and A2 are down. I'm engaging E0 alone.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-5ea3336e6ed733efe63f4208.json b/examples/multi-agent-smax/results/llm-cache/ask-5ea3336e6ed733efe63f4208.json new file mode 100644 index 00000000..e5d0e13a --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-5ea3336e6ed733efe63f4208.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 2.0 seconds into the battle.\nYou are A0, a marine at (13.8, 15.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 17.\nYour team:\n A1 marine at (13.5, 17.2), 45/45 health, order: move 14 17\n A2 marine at (13.9, 17.8), 45/45 health, order: move 14 17\nEnemies you can see:\n E0 marine at (19.0, 17.1), 45/45 health, 5.3 away\n E1 marine at (17.8, 17.1), 45/45 health, 4.2 away (in range)\n E2 marine at (15.8, 16.7), 45/45 health, 2.1 away (in range)\nTeam chat (most recent last):\n A1 (0.5s): Moving east in a tight group; will attack same target together.\n A2 (0.5s): Moving east in formation; A0 and A1 keep pace, no one pull ahead.\n A0 (1.0s): Advancing together toward E2; hold pace, attack same target once all in range 5.\n A1 (1.0s): Advancing east together toward E2; keep within 2, attack same target at range.\n A2 (1.0s): Closing together toward E2; hold pace, all fire on E2 once in range 5.\n A0 (1.5s): E2 is 5.2 away; one more step east, then all attack E2 together.\n A1 (1.5s): Almost in range of E2; keep pace, all attack E2 together next tick.\n A2 (1.5s): Still closing together; E2 just outside range. Fire on E2 once all in range 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"All in range of E2 now. Everyone fire on E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-5ed3275c040238f5b13ac5c9.json b/examples/multi-agent-smax/results/llm-cache/ask-5ed3275c040238f5b13ac5c9.json new file mode 100644 index 00000000..6cb60f85 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-5ed3275c040238f5b13ac5c9.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 5.0 seconds into the battle.\nYou are A0, a marine at (13.6, 17.1) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1 marine at (13.2, 15.3), 27/45 health, order: attack E2\n A2 marine at (14.1, 16.4), 9/45 health, order: attack E2\nEnemies you can see:\n E2 marine at (17.5, 17.3), 9/45 health, 4.0 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (3.5s): Attacking E1 (18hp), all keep firing; then E2.\n A2 (3.5s): Attacking E1 (18hp) now, then E2.\n A0 (4.0s): E1 dead. All focus E2 now, no retreating.\n A1 (4.0s): E1 down. All focus E2 now, same target, no retreating.\n A2 (4.0s): E1 dead. All attack E2 now, same target, keep firing.\n A0 (4.5s): Keep firing E2, last enemy, no retreating.\n A1 (4.5s): Keep firing E2, last enemy, no retreating.\n A2 (4.5s): Keep firing on E2, last enemy, no retreating.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Firing E2, last enemy at 9hp. Keep attacking.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-5ed439ed45003654ab249d1e.json b/examples/multi-agent-smax/results/llm-cache/ask-5ed439ed45003654ab249d1e.json new file mode 100644 index 00000000..2bf71a9a --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-5ed439ed45003654ab249d1e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.0 seconds into the battle.\nYou are A2, a marine at (8.2, 14.1) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (7.8, 14.7), 45/45 health, order: attack E0\n A1: dead\nEnemies you can see:\n E0 marine at (12.6, 15.0), 9/45 health, 4.5 away (in range)\n E1 marine at (11.9, 14.0), 45/45 health, 3.6 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (4.0s): E2 at 18 HP, finish it now, then E0.\n A2 (4.0s): Firing on E2 (18hp), then E0. Keep A1 behind us.\n A0 (4.5s): E2 down. Focus E0 now, then E1. Fire together.\n A2 (4.5s): E2 down. Focus E0 (4.5 away), then E1.\n A0 (5.0s): Focus E0 together, then E1. A2 keep firing.\n A2 (5.0s): Focus E0 together, then E1.\n A0 (5.5s): Keep focusing E0 (27hp), then E1. Fire together.\n A2 (5.5s): Firing E0 (27hp), then E1. I'm low, keep fire together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 at 9hp, finishing it now. Then all focus E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-5f05f4dcd4b5a8bb063532e5.json b/examples/multi-agent-smax/results/llm-cache/ask-5f05f4dcd4b5a8bb063532e5.json new file mode 100644 index 00000000..eecefd61 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-5f05f4dcd4b5a8bb063532e5.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 2.0 seconds into the battle.\nYou are A2, a marine at (12.3, 16.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 13 16.\nYour team:\n A0 marine at (13.3, 16.4), 45/45 health, order: move 14 16\n A1 marine at (14.1, 16.4), 45/45 health, order: move 14 16\nEnemies you can see:\n E0 marine at (16.0, 15.3), 45/45 health, 3.9 away (in range)\n E1 marine at (18.6, 15.6), 45/45 health, 6.3 away\n E2 marine at (18.2, 17.7), 45/45 health, 6.0 away\nTeam chat (most recent last):\n A1 (0.5s): Joining A0 and A2 at (12,16); staying grouped, then advance together.\n A2 (0.5s): A2 moving to (12,16) with team; will attack together on contact.\n A0 (1.0s): Continuing to (12,16); stay grouped, attack same target on contact.\n A1 (1.0s): Holding formation at (12,16); then all advance and attack E0 together.\n A2 (1.0s): Continuing to (12,16) together; will attack same target once all in range 5.\n A0 (1.5s): Advancing together toward E0; all attack E0 once everyone is within range 5.\n A1 (1.5s): Advancing together east to (14,16); then all attack E0 at once.\n A2 (1.5s): Advancing together toward E0; all attack E0 once everyone is within range 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 is in range of all three; attacking E0 now, focus fire.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-5fcd740ab03840fdbddb5a01.json b/examples/multi-agent-smax/results/llm-cache/ask-5fcd740ab03840fdbddb5a01.json new file mode 100644 index 00000000..b64b6819 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-5fcd740ab03840fdbddb5a01.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.5 seconds into the battle.\nYou are A1, a marine at (9.7, 17.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 17.\nYour team:\n A0 marine at (7.0, 15.6), 45/45 health, order: hold\n A2 marine at (7.4, 16.7), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together at the cluster; focus fire on the closest enemy when they appear.\n A1 (0.0s): Advancing east together; stay close and focus fire on the nearest enemy.\n A2 (0.0s): Holding together; focus fire on the closest enemy when they appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 8 16.5\", \"say\": \"Falling back to cluster; hold together and focus the closest enemy.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-5fe4e48c936600972909f64d.json b/examples/multi-agent-smax/results/llm-cache/ask-5fe4e48c936600972909f64d.json new file mode 100644 index 00000000..124ad338 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-5fe4e48c936600972909f64d.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 3.5 seconds into the battle.\nYou are A0, a marine at (13.8, 15.8) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1 marine at (13.5, 17.2), 45/45 health, order: attack E1\n A2 marine at (13.9, 17.8), 9/45 health, order: attack E1\nEnemies you can see:\n E0 marine at (18.0, 17.1), 45/45 health, 4.4 away (in range)\n E1 marine at (17.3, 17.0), 45/45 health, 3.6 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (2.0s): All in range of E2 (2.4 away). Attack E2 now, everyone focus fire.\n A2 (2.0s): E2 in range of me; all attack E2 now.\n A0 (2.5s): Firing on E2, it's at 18hp. Then focus E1 next.\n A1 (2.5s): Focusing E2, it's at 18hp. Keep firing, then switch to E1 together.\n A2 (2.5s): E2 at 18hp, keep firing on E2, then switch to E1.\n A0 (3.0s): E2 is dead. Everyone focus E1 now (3.6 away), then E0.\n A1 (3.0s): E2 down. Everyone focus E1 now (3.8 away), then E0.\n A2 (3.0s): E2 dead. All focus E1 (closest, 3.5 away) now.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Focus E1 together, then E0. A2 stay on target per rules.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-607f928dae4c95c40bdecddd.json b/examples/multi-agent-smax/results/llm-cache/ask-607f928dae4c95c40bdecddd.json new file mode 100644 index 00000000..bf5aaca6 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-607f928dae4c95c40bdecddd.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 5.0 seconds into the battle.\nYou are A1, a marine at (14.2, 16.3) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (13.7, 15.6), 27/45 health, order: attack E0\n A2: dead\nEnemies you can see:\n E1 marine at (17.9, 16.0), 45/45 health, 3.7 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A2 (3.0s): E2 at 9hp, finish it now, then focus E0.\n A0 (3.5s): E2 dead. Everyone focus E0 now. A2 at 9hp, retreat.\n A1 (3.5s): E2 dead. All focus E0 now, then E1. A2 retreat, you're at 9hp.\n A2 (3.5s): A2 at 9hp retreating. A0, A1 focus E0 now.\n A0 (4.0s): Focus E0 (36hp), then E1. I'm 27hp, staying in.\n A1 (4.0s): Focus E0 (36hp), then E1. A0 at 27hp, stay in unless under 20.\n A0 (4.5s): E0 at 18hp, keep focusing it, then E1. I'm 27hp, staying in.\n A1 (4.5s): E0 at 18hp, keep focusing it, then E1. A0 retreat if under 20.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E0 down. Both focus E1 now, it's the last one.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-60bb8c4445e3b1a45904b90b.json b/examples/multi-agent-smax/results/llm-cache/ask-60bb8c4445e3b1a45904b90b.json new file mode 100644 index 00000000..1f9fd09e --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-60bb8c4445e3b1a45904b90b.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 7.5 seconds into the battle.\nYou are A0, a marine at (9.3, 15.9) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1: dead\n A2: dead\nEnemies you can see:\n E0 marine at (13.5, 17.3), 36/45 health, 4.4 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (5.0s): E2 down. Focus E1 (36hp), then E0.\n A1 (5.0s): E2 down. Focus E1 (36hp), then E0.\n A0 (5.5s): Focusing E1 (18hp), both of us fire. Then E0.\n A1 (5.5s): Focusing E1 (18hp), both fire. Then E0.\n A0 (6.0s): E1 at 9hp, finishing it. Then E0 together.\n A1 (6.0s): E1 at 9hp, finishing it now. Then E0.\n A0 (6.5s): A1 and A2 are down. I'm engaging E0 alone.\n A0 (7.0s): Last one. E0 at 36hp, fighting on.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Last one, E0 at 36hp. Fighting on.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-60ca535fe5af62aa34b390a1.json b/examples/multi-agent-smax/results/llm-cache/ask-60ca535fe5af62aa34b390a1.json new file mode 100644 index 00000000..0bf9e9f0 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-60ca535fe5af62aa34b390a1.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 6.0 seconds into the battle.\nYou are A1, a marine at (9.9, 15.5) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: retreat.\nYour team:\n A0 marine at (11.1, 16.2), 9/45 health, order: retreat\n A2: dead\nEnemies you can see:\n E0 marine at (16.6, 17.3), 27/45 health, 7.0 away\n E2 marine at (16.8, 14.1), 45/45 health, 7.1 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (4.0s): Focusing E0 (36hp). A1 stay back; I'm tanking, then we take E2.\n A1 (4.0s): A1 18hp retreating; A0 you're closest, focus E0 (36hp), I'll return when safe.\n A0 (4.5s): A0 firing E0 (27hp), tanking. A1 stay back, then we take E2.\n A1 (4.5s): A1 18hp staying back; A0 kill E0 (27hp), then E2.\n A0 (5.0s): A0 at 9hp retreating. A1 you hold and shoot closest; we regroup and focus E0.\n A1 (5.0s): A1 joining now, both focus E0 (27hp) to split their fire.\n A0 (5.5s): A0 9hp retreating; A1 focus E0 (27hp), I return if enemies shift.\n A1 (5.5s): A1 18hp retreating with A0; regroup and focus E0 only when both in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"retreat\", \"say\": \"A1 18hp retreating west; both out of range, regroup before re-engaging E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-61748b3318ae2aedd273f813.json b/examples/multi-agent-smax/results/llm-cache/ask-61748b3318ae2aedd273f813.json new file mode 100644 index 00000000..12401d64 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-61748b3318ae2aedd273f813.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.0 seconds into the battle.\nYou are A0, a marine at (7.2, 15.7) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1 marine at (6.5, 16.0), 45/45 health, order: attack E0\n A2 marine at (7.1, 16.5), 36/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (10.7, 17.7), 27/45 health, 4.0 away (in range)\n E1 marine at (11.6, 16.0), 45/45 health, 4.3 away (in range)\n E2 marine at (11.8, 14.7), 27/45 health, 4.7 away (in range)\nTeam chat (most recent last):\n A1 (3.5s): A1 holding; fire on closest enemy once in range, E2 first.\n A2 (3.5s): A2 holding; enemies closing, fire on closest E2 when in range.\n A0 (4.0s): E2 in range at 4.7; all focus fire E2 now.\n A1 (4.0s): Holding; E2 closest at 5.5, focus E2 once in range.\n A2 (4.0s): Holding. E2 at 5.1, about to enter range. Focus E2 together.\n A0 (4.5s): Firing E2 now, it's at 36 health. Everyone focus E2.\n A1 (4.5s): E0 in range at 4.6, I'm firing on E0. Focus E0 if in range.\n A2 (4.5s): E0 in range at 3.8; I focus E0, A0 on E2. Kill fast.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Switching to E0 with you both. Focus E0 down, then E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-61967bc98529401dc4a12eb9.json b/examples/multi-agent-smax/results/llm-cache/ask-61967bc98529401dc4a12eb9.json new file mode 100644 index 00000000..e2e27239 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-61967bc98529401dc4a12eb9.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.5 seconds into the battle.\nYou are A0, a marine at (7.8, 14.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 8 15.\nYour team:\n A1 marine at (8.5, 14.8), 45/45 health, order: hold\n A2 marine at (8.2, 14.1), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A0 (0.5s): At (8,15), holding. Focus fire on the closest enemy that appears.\n A1 (0.5s): Closing to (8,15) to cluster; will focus closest enemy.\n A2 (0.5s): Moving to regroup at (8,15); will focus fire closest enemy.\n A0 (1.0s): Moving to cluster at (8,15); will focus fire closest enemy.\n A1 (1.0s): A1 at (8,15) holding. Focus fire on closest enemy.\n A2 (1.0s): A2 at (8,14) holding; will focus the closest enemy when it appears.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A0 holding at (8,15); focus fire on the closest enemy when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-61f3786a383a77c000041a34.json b/examples/multi-agent-smax/results/llm-cache/ask-61f3786a383a77c000041a34.json new file mode 100644 index 00000000..445c86e3 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-61f3786a383a77c000041a34.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 1.5 seconds into the battle.\nYou are A2, a marine at (11.2, 14.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 15.\nYour team:\n A0 marine at (11.1, 16.0), 45/45 health, order: move 12 15\n A1 marine at (11.7, 15.5), 45/45 health, order: move 12 15\nEnemies you can see:\n E0 marine at (19.2, 15.0), 45/45 health, 7.9 away\n E1 marine at (19.7, 16.2), 45/45 health, 8.6 away\n E2 marine at (19.2, 14.3), 45/45 health, 8.0 away\nTeam chat (most recent last):\n A1 (0.0s): Moving east together toward enemies; stay within 2 of each other, attack same target.\n A2 (0.0s): Advancing east together to (12,15); stay within 2 of each other.\n A0 (0.5s): Converging on (12,15) with A1/A2; will attack same target together.\n A1 (0.5s): Moving to (12,15) with team; will attack same target together.\n A2 (0.5s): A2 moving to (12,15), staying close; will attack same target when enemies appear.\n A0 (1.0s): Continuing to (12,15); will attack together once enemies appear.\n A1 (1.0s): Continuing to (12,15) together; will attack same target when enemies appear.\n A2 (1.0s): A2 continuing to (12,15); will attack together when enemies appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 15 15\", \"say\": \"Advancing east together to (15,15); all attack E2 once in range 5.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-61f5e19728e4b64179149796.json b/examples/multi-agent-smax/results/llm-cache/ask-61f5e19728e4b64179149796.json new file mode 100644 index 00000000..1d7d2f1f --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-61f5e19728e4b64179149796.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 0.0 seconds into the battle.\nYou are A0, a marine at (7.5, 15.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (7.2, 17.2), 45/45 health, order: hold\n A2 marine at (7.6, 17.8), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 16.8\", \"say\": \"Moving east together to find enemies; stay within 2 of each other, attack together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-623d12b83983c9e4570ffc9a.json b/examples/multi-agent-smax/results/llm-cache/ask-623d12b83983c9e4570ffc9a.json new file mode 100644 index 00000000..7a91b425 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-623d12b83983c9e4570ffc9a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 7.5 seconds into the battle.\nYou are A0, a marine at (3.7, 15.6) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: retreat.\nYour team:\n A1 marine at (8.3, 14.2), 27/45 health, order: attack E1\n A2: dead\nEnemies you can see:\n E1 marine at (12.2, 16.1), 18/45 health, 8.5 away\n E2 marine at (10.7, 17.4), 45/45 health, 7.3 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (5.5s): E0 dead. Both focus E1 now, then E2.\n A1 (5.5s): E0 down. Focus E1 (4.4 away, in range) now, both of us.\n A0 (6.0s): A0 at 18hp retreating to pull fire off. A1 focus E1, I'll rejoin if safe.\n A1 (6.0s): A1 attacking E1 (45hp). A0 at 18hp, retreat if under 20 to shed aggro.\n A0 (6.5s): A0 at 9hp, staying out of range. A1 focus E1, 36hp left.\n A1 (6.5s): A1 attacking E1 (36hp), in range. A0 stay back, keep out of range.\n A0 (7.0s): A0 9hp, staying out of range. A1 focus E1 (27hp), then E2.\n A1 (7.0s): A1 on E1 (27hp), 3 shots left. A0 stay out of range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"retreat\", \"say\": \"A0 9hp staying out of range. A1 finish E1 (18hp), then E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-627da881506200a9f4cef47f.json b/examples/multi-agent-smax/results/llm-cache/ask-627da881506200a9f4cef47f.json new file mode 100644 index 00000000..ab5eeefd --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-627da881506200a9f4cef47f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 8.5 seconds into the battle.\nYou are A0, a marine at (8.5, 16.7) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1: dead\n A2 marine at (9.2, 17.8), 9/45 health, order: attack E1\nEnemies you can see:\n E1 marine at (12.3, 15.6), 9/45 health, 3.9 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (6.5s): A0 finishing E2 now. Then all on E1.\n A2 (6.5s): A2 finishing E2 (9hp). Then both on E1.\n A0 (7.0s): E2 down. A0 and A2 all on E1, 36hp.\n A2 (7.0s): E2 down. A2 on E1, A0 keep tanking, I'm at 9hp.\n A0 (7.5s): A0 tanking, attacking E1 (27hp). A2 stay behind me and keep firing.\n A2 (7.5s): A2 9hp, falling back so A0 is closest. A0 tank, I'll rejoin shooting.\n A0 (8.0s): A0 on E1 (18hp), still tanking. A2 fire from behind me.\n A2 (8.0s): A2 back in, firing from behind A0. E1 at 18hp, focus it.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A0 on E1 (9hp), keep firing, finish it.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-63558305bc813ceeed6604f9.json b/examples/multi-agent-smax/results/llm-cache/ask-63558305bc813ceeed6604f9.json new file mode 100644 index 00000000..dae9632a --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-63558305bc813ceeed6604f9.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 7.0 seconds into the battle.\nYou are A0, a marine at (7.9, 16.2) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: retreat.\nYour team:\n A1 marine at (6.7, 15.5), 18/45 health, order: retreat\n A2: dead\nEnemies you can see:\n E0 marine at (13.5, 17.3), 27/45 health, 5.7 away\n E2 marine at (13.7, 14.1), 45/45 health, 6.1 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (5.0s): A0 at 9hp retreating. A1 you hold and shoot closest; we regroup and focus E0.\n A1 (5.0s): A1 joining now, both focus E0 (27hp) to split their fire.\n A0 (5.5s): A0 9hp retreating; A1 focus E0 (27hp), I return if enemies shift.\n A1 (5.5s): A1 18hp retreating with A0; regroup and focus E0 only when both in range.\n A0 (6.0s): A0 9hp retreating west; A1 stay with me, regroup before engaging E0 (27hp).\n A1 (6.0s): A1 18hp retreating west; both out of range, regroup before re-engaging E0.\n A0 (6.5s): A0 9hp retreating west; A1 stay out of range, we regroup.\n A1 (6.5s): A1 18hp retreating west with A0; out of range, regroup before engaging.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"retreat\", \"say\": \"A0 9hp still retreating west; A1 stay with me, out of range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-637a4cd6a1e5b8bee19db96f.json b/examples/multi-agent-smax/results/llm-cache/ask-637a4cd6a1e5b8bee19db96f.json new file mode 100644 index 00000000..1ca0ae92 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-637a4cd6a1e5b8bee19db96f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 4.0 seconds into the battle.\nYou are A0, a marine at (13.6, 17.1) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1 marine at (13.2, 15.3), 27/45 health, order: attack E1\n A2 marine at (14.1, 16.4), 27/45 health, order: attack E1\nEnemies you can see:\n E2 marine at (17.5, 17.3), 45/45 health, 4.0 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (2.5s): E0 at 9hp, finishing it now; then everyone focus E1.\n A2 (2.5s): E0 at 9hp in range, firing on E0 now.\n A0 (3.0s): E0 dead. Everyone focus E1 now, same target, no retreating.\n A1 (3.0s): E0 dead. Everyone focus E1 now, same tick; then E2.\n A2 (3.0s): E0 dead. Everyone focus E1 now, then E2.\n A0 (3.5s): Focusing E1 (18hp), same target; then E2.\n A1 (3.5s): Attacking E1 (18hp), all keep firing; then E2.\n A2 (3.5s): Attacking E1 (18hp) now, then E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E1 dead. All focus E2 now, no retreating.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-63ff2d76737d402910980c4a.json b/examples/multi-agent-smax/results/llm-cache/ask-63ff2d76737d402910980c4a.json new file mode 100644 index 00000000..5ae09283 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-63ff2d76737d402910980c4a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 3.0 seconds into the battle.\nYou are A2, a marine at (12.8, 14.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (12.7, 16.0), 45/45 health, order: attack E0\n A1: dead\nEnemies you can see:\n E1 marine at (18.1, 16.2), 45/45 health, 5.5 away\n E2 marine at (17.6, 14.3), 45/45 health, 4.8 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (1.5s): Advancing together to (14,15); all attack E0 once in range.\n A2 (1.5s): Advancing east together to (15,15); all attack E2 once in range 5.\n A0 (2.0s): All in range of E0 now. Everyone attack E0 together.\n A1 (2.0s): All in range now: everyone attack E0 together.\n A2 (2.0s): Enemies in range now. Everyone attack E0 together.\n A0 (2.5s): Focus E0, it's at 18hp. A1 stay on target per rules.\n A1 (2.5s): Focus E0, it's at 18hp. Keep firing until it dies.\n A2 (2.5s): A2 attacking E0 now; focus it down, then E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E0 is dead. Everyone attack E2, it's in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-6459dfeb94a62fee50974dd0.json b/examples/multi-agent-smax/results/llm-cache/ask-6459dfeb94a62fee50974dd0.json new file mode 100644 index 00000000..f8d03549 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-6459dfeb94a62fee50974dd0.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.5 seconds into the battle.\nYou are A2, a marine at (10.9, 16.6) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (9.3, 15.9), 45/45 health, order: attack E2\n A1 marine at (10.0, 15.5), 36/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (13.5, 17.3), 45/45 health, 2.7 away (in range)\n E1 marine at (13.5, 16.6), 36/45 health, 2.6 away (in range)\n E2 marine at (13.7, 14.1), 18/45 health, 3.8 away (in range)\nTeam chat (most recent last):\n A1 (3.0s): Holding. E1 is closest at 5.3; focus E1 as soon as it's in range.\n A2 (3.0s): Enemies in range. Focus E1 now, everyone fire on E1.\n A0 (3.5s): Moving up to fire on E1; A2 is taking fire, everyone commit.\n A1 (3.5s): E1 out of range; E2 in range at 4.1. Everyone focus E2.\n A2 (3.5s): A2 hurt, pulling back west to you. Fire on E1 when they follow into range.\n A0 (4.0s): Switching to E2, in range at 4.7. A1 and I focus E2.\n A1 (4.0s): Firing on E2 (36hp, in range). A0 switch to E2. A2 stay back.\n A2 (4.0s): A2 hurt but farthest back, firing on E2 from range. Focus E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Firing on E2 (18hp), one more volley kills it. Then E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-6464062f20898836306c6e7b.json b/examples/multi-agent-smax/results/llm-cache/ask-6464062f20898836306c6e7b.json new file mode 100644 index 00000000..c0d0d604 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-6464062f20898836306c6e7b.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 5.0 seconds into the battle.\nYou are A2, a marine at (14.1, 16.4) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (13.6, 17.1), 18/45 health, order: attack E2\n A1 marine at (13.2, 15.3), 27/45 health, order: attack E2\nEnemies you can see:\n E2 marine at (17.5, 17.3), 9/45 health, 3.5 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (3.5s): Attacking E1 (18hp), all keep firing; then E2.\n A2 (3.5s): Attacking E1 (18hp) now, then E2.\n A0 (4.0s): E1 dead. All focus E2 now, no retreating.\n A1 (4.0s): E1 down. All focus E2 now, same target, no retreating.\n A2 (4.0s): E1 dead. All attack E2 now, same target, keep firing.\n A0 (4.5s): Keep firing E2, last enemy, no retreating.\n A1 (4.5s): Keep firing E2, last enemy, no retreating.\n A2 (4.5s): Keep firing on E2, last enemy, no retreating.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Keep firing E2, last enemy, almost dead.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-64b91cdaab9c786f064ef0f8.json b/examples/multi-agent-smax/results/llm-cache/ask-64b91cdaab9c786f064ef0f8.json new file mode 100644 index 00000000..16109281 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-64b91cdaab9c786f064ef0f8.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.5 seconds into the battle.\nYou are A2, a marine at (8.2, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.8, 14.7), 45/45 health, order: move 8 15\n A1 marine at (8.5, 14.8), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A0 (0.5s): At (8,15), holding. Focus fire on the closest enemy that appears.\n A1 (0.5s): Closing to (8,15) to cluster; will focus closest enemy.\n A2 (0.5s): Moving to regroup at (8,15); will focus fire closest enemy.\n A0 (1.0s): Moving to cluster at (8,15); will focus fire closest enemy.\n A1 (1.0s): A1 at (8,15) holding. Focus fire on closest enemy.\n A2 (1.0s): A2 at (8,14) holding; will focus the closest enemy when it appears.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A2 holding at (8,14). Clustered; focus fire on closest enemy.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-64c02fd18266c653ac32d406.json b/examples/multi-agent-smax/results/llm-cache/ask-64c02fd18266c653ac32d406.json new file mode 100644 index 00000000..10fd5994 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-64c02fd18266c653ac32d406.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 3.5 seconds into the battle.\nYou are A2, a marine at (13.9, 16.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (14.8, 16.4), 45/45 health, order: attack E2\n A1: dead\nEnemies you can see:\n E1 marine at (17.0, 15.6), 45/45 health, 3.2 away (in range)\n E2 marine at (16.6, 17.7), 45/45 health, 3.0 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (2.0s): E0 is within range 5 of all three of us. Everyone attack E0 now.\n A1 (2.0s): E0 is in range of all three of us. Everyone attack E0 now.\n A2 (2.0s): E0 is in range of all three; attacking E0 now, focus fire.\n A0 (2.5s): Keep focusing E0; A1 stay in fight until E0 dies, then retreat.\n A1 (2.5s): E0 at 18hp, keep focus fire; I'm at 18hp and will step back once it dies.\n A2 (2.5s): Focus E0, it's at 18hp. A1 is low; keep firing until E0 dies.\n A0 (3.0s): E0 dead. A2 stay close, all focus E2 together. A1 retreat.\n A2 (3.0s): E0 dead. A0 and I both attack E2 now, stay together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Attacking E2 with A0, keep focus until it dies.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-64cc6833502a209a39d5d5a1.json b/examples/multi-agent-smax/results/llm-cache/ask-64cc6833502a209a39d5d5a1.json new file mode 100644 index 00000000..81aca969 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-64cc6833502a209a39d5d5a1.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 3.0 seconds into the battle.\nYou are A1, a marine at (13.0, 15.0) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (12.8, 15.9), 27/45 health, order: attack E2\n A2 marine at (13.0, 14.3), 36/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (17.3, 15.0), 45/45 health, 4.4 away (in range)\n E1 marine at (16.6, 14.0), 45/45 health, 3.8 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (1.5s): Moving to (14,16) with A0; enemies close, then all attack E2 together.\n A2 (1.5s): Moving to (14,16) with A0; enemies ~5 away next, then all attack E2 together.\n A0 (2.0s): E2 in range of all three. Attack E2 now, together.\n A1 (2.0s): All in range of E2 now. Attack E2 together.\n A2 (2.0s): E2 in range of all three. Attack E2 now, together.\n A0 (2.5s): Firing on E2, 18hp left. Keep attacking together.\n A1 (2.5s): Firing on E2 (18hp), keep attacking until it dies.\n A2 (2.5s): Attacking E2, it's at 18hp; finish it together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E2 dead. Focus E1 (closest, 3.8 away), all attack E1 together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-65602d3759f34788e6b9502a.json b/examples/multi-agent-smax/results/llm-cache/ask-65602d3759f34788e6b9502a.json new file mode 100644 index 00000000..e0eab805 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-65602d3759f34788e6b9502a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 4.5 seconds into the battle.\nYou are A0, a marine at (8.4, 15.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1 marine at (8.3, 14.2), 45/45 health, order: attack E0\n A2 marine at (8.3, 17.3), 9/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (11.9, 16.8), 27/45 health, 3.6 away (in range)\n E1 marine at (12.2, 16.1), 45/45 health, 3.8 away (in range)\n E2 marine at (12.3, 17.4), 45/45 health, 4.3 away (in range)\nTeam chat (most recent last):\n A1 (3.0s): A1 holding. E0 at 7.4; attack E0 together once within 5 of all.\n A2 (3.0s): A2 holding. E0 at 5.3 from me, 6.8+ from A0/A1. Wait for range 5.\n A0 (3.5s): A0 holding. E0 5.3 away; attack E0 together once within 5 of all.\n A1 (3.5s): A1 holding. E0 at 6.0; attack E0 together once within 5 of all.\n A2 (3.5s): E0 in range of me, firing now. A0/A1 close in and focus E0.\n A0 (4.0s): A2 engaged, A0 attacking E0 now. A1 attack E0 too, focus fire.\n A1 (4.0s): A2 is engaged; A1 attacking E0 now. A0 join and focus E0.\n A2 (4.0s): Engaged, all 3 enemies on me. A0 A1 attack E0 now, focus fire.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Focus E0 (27hp). A2 at 9hp, retreat to draw fire away if possible.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-6608244cf4fb21a8e1a62d86.json b/examples/multi-agent-smax/results/llm-cache/ask-6608244cf4fb21a8e1a62d86.json new file mode 100644 index 00000000..811311ee --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-6608244cf4fb21a8e1a62d86.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 0.5 seconds into the battle.\nYou are A2, a marine at (11.0, 14.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 15.\nYour team:\n A0 marine at (9.6, 17.5), 45/45 health, order: move 12 16\n A1 marine at (8.7, 14.7), 45/45 health, order: move 12 15\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Advancing east together to (12,16); stay within 2 of each other, attack together.\n A1 (0.0s): Advancing east together to (12,15); stay within 2 of each other, attack same target on contact.\n A2 (0.0s): Advancing east together, staying close. Don't outrun the group; all attack same target.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 15\", \"say\": \"A2 advancing to (12,15), staying close; will attack same target on contact.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-662cb11545662d8ce9970788.json b/examples/multi-agent-smax/results/llm-cache/ask-662cb11545662d8ce9970788.json new file mode 100644 index 00000000..e84715b5 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-662cb11545662d8ce9970788.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 0.5 seconds into the battle.\nYou are A2, a marine at (8.9, 16.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 16.5.\nYour team:\n A0 marine at (8.5, 15.6), 45/45 health, order: move 14 16.5\n A1 marine at (9.7, 17.5), 45/45 health, order: move 14 17\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Moving east together toward center; stay within 2 of each other, attack same target.\n A1 (0.0s): Moving east together toward center, stay within 2 of each other.\n A2 (0.0s): Moving east together toward center, stay close, all engage same enemy on contact.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 16.5\", \"say\": \"Continuing east together; no enemies seen yet, will focus same target on contact.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-6643a369eea42ea9151b086e.json b/examples/multi-agent-smax/results/llm-cache/ask-6643a369eea42ea9151b086e.json new file mode 100644 index 00000000..8668f9b6 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-6643a369eea42ea9151b086e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 3.5 seconds into the battle.\nYou are A1, a marine at (6.7, 14.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.9, 15.6), 45/45 health, order: hold\n A2 marine at (8.3, 17.3), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (12.0, 16.8), 45/45 health, 6.0 away\n E1 marine at (13.7, 16.2), 45/45 health, 7.3 away\n E2 marine at (13.8, 17.3), 45/45 health, 7.7 away\nTeam chat (most recent last):\n A1 (2.0s): A1 holding; no enemies yet. Will attack together once all within 5.\n A2 (2.0s): A2 holding. E0 spotted at (16.8,16.8), 8.5 away. Wait until it's in range 5 of all.\n A0 (2.5s): A0 holding. E0 at 8.4 away; wait until within 5 of all, then focus E0.\n A1 (2.5s): A1 holding. E0 at 8.9 away; wait until in range 5 of all.\n A2 (2.5s): A2 holding. Nearest enemy E0 at 6.9; wait until within 5 of all.\n A0 (3.0s): A0 holding. E0 at 6.9; wait until within 5 of all, then focus E0.\n A1 (3.0s): A1 holding. E0 at 7.4; attack E0 together once within 5 of all.\n A2 (3.0s): A2 holding. E0 at 5.3 from me, 6.8+ from A0/A1. Wait for range 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A1 holding. E0 at 6.0; attack E0 together once within 5 of all.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-6646a8a9cf7837298563a2d6.json b/examples/multi-agent-smax/results/llm-cache/ask-6646a8a9cf7837298563a2d6.json new file mode 100644 index 00000000..10956fcb --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-6646a8a9cf7837298563a2d6.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 1.0 seconds into the battle.\nYou are A2, a marine at (12.1, 16.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 16.\nYour team:\n A0 marine at (11.4, 16.2), 45/45 health, order: move 14 16\n A1 marine at (13.0, 15.7), 45/45 health, order: move 14 16\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Advancing east together to find enemies; keep within 2 of each other, then all attack same target.\n A1 (0.0s): Moving east together toward enemies, stay within 2 of each other; attack same target on contact.\n A2 (0.0s): Moving east together to (14,16); stay within 2 of each other, attack together on contact.\n A0 (0.5s): Continuing east to (14,16); staying together, will attack same target on contact.\n A1 (0.5s): Continuing east in formation; will attack same target on contact.\n A2 (0.5s): A2 moving east to (14,16), staying close; attack same target on contact.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 16\", \"say\": \"A2 continuing east to (14,16), staying together; attack same target on contact.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-665a472cc7cf729865f95b83.json b/examples/multi-agent-smax/results/llm-cache/ask-665a472cc7cf729865f95b83.json new file mode 100644 index 00000000..6813d974 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-665a472cc7cf729865f95b83.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 2.5 seconds into the battle.\nYou are A0, a marine at (12.7, 16.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1 marine at (13.3, 15.5), 18/45 health, order: attack E0\n A2 marine at (12.8, 14.9), 45/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (17.6, 15.0), 18/45 health, 5.0 away (in range)\n E1 marine at (18.1, 16.2), 45/45 health, 5.4 away\n E2 marine at (17.6, 14.3), 45/45 health, 5.2 away\nTeam chat (most recent last):\n A1 (1.0s): Continuing to (12,15) together; will attack same target when enemies appear.\n A2 (1.0s): A2 continuing to (12,15); will attack together when enemies appear.\n A0 (1.5s): Advancing together toward E0; all attack E0 once everyone is in range.\n A1 (1.5s): Advancing together to (14,15); all attack E0 once in range.\n A2 (1.5s): Advancing east together to (15,15); all attack E2 once in range 5.\n A0 (2.0s): All in range of E0 now. Everyone attack E0 together.\n A1 (2.0s): All in range now: everyone attack E0 together.\n A2 (2.0s): Enemies in range now. Everyone attack E0 together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Focus E0, it's at 18hp. A1 stay on target per rules.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-665be50af9ee1560c8a7cd0a.json b/examples/multi-agent-smax/results/llm-cache/ask-665be50af9ee1560c8a7cd0a.json new file mode 100644 index 00000000..a9c2b341 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-665be50af9ee1560c8a7cd0a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 8.5 seconds into the battle.\nYou are A1, a marine at (9.8, 14.2) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E2 marine at (10.8, 17.5), 18/45 health, 3.5 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (5.5s): A0 18hp on E1 (18hp), finishing it. Then both on E2.\n A1 (5.5s): A1 on E1 (18hp), in range. A0 keep firing, then both E2.\n A0 (6.0s): A0 9hp, finishing E1 (9hp). Then both E2.\n A1 (6.0s): A1 on E1 (9hp), finishing it. Then both on E2.\n A1 (6.5s): A1 alone vs E2 (45hp), engaging.\n A1 (7.0s): A1 last unit, fighting E2 (45hp) alone.\n A1 (7.5s): A1 last unit, 36hp vs E2 36hp, fighting to the end.\n A1 (8.0s): A1 last unit, 27hp vs E2 27hp, fighting to the end.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"A1 27hp vs E2 18hp, fighting on, one enemy left.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-6664121a232d04ec487662be.json b/examples/multi-agent-smax/results/llm-cache/ask-6664121a232d04ec487662be.json new file mode 100644 index 00000000..08209abe --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-6664121a232d04ec487662be.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 0.0 seconds into the battle.\nYou are A2, a marine at (7.7, 14.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (9.0, 16.0), 45/45 health, order: hold\n A1 marine at (7.4, 14.1), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 16 16\", \"say\": \"Moving together to center, stay within 2 of each other; attack same target when in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-66b52d3873eda2678ebba78e.json b/examples/multi-agent-smax/results/llm-cache/ask-66b52d3873eda2678ebba78e.json new file mode 100644 index 00000000..988809cf --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-66b52d3873eda2678ebba78e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.0 seconds into the battle.\nYou are A2, a marine at (9.0, 16.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.2, 16.2), 45/45 health, order: hold\n A1 marine at (9.8, 15.7), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together as a group; focus fire on the closest enemy when they appear.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together as a group; focus fire on the closest enemy when they appear.\n A0 (0.5s): No enemies yet; staying grouped, will focus the closest enemy when seen.\n A1 (0.5s): Holding position; will focus fire on closest enemy once visible.\n A2 (0.5s): Holding. Will focus fire on the closest enemy once visible.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Still no enemies. Holding; will focus the closest enemy when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-671665c3fa638f21c1744283.json b/examples/multi-agent-smax/results/llm-cache/ask-671665c3fa638f21c1744283.json new file mode 100644 index 00000000..1b91010e --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-671665c3fa638f21c1744283.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.0 seconds into the battle.\nYou are A1, a marine at (8.9, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (10.6, 16.0), 45/45 health, order: attack E0\n A2 marine at (10.8, 14.8), 45/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (12.4, 16.4), 45/45 health, 4.2 away (in range)\n E1 marine at (13.1, 16.8), 45/45 health, 5.0 away (in range)\n E2 marine at (13.1, 15.5), 45/45 health, 4.4 away (in range)\nTeam chat (most recent last):\n A1 (2.5s): Enemies E0, E2 east ~9 away. Holding grouped; focus E0 when in range.\n A2 (2.5s): Advancing east to join A0/A1; stay grouped, focus closest enemy.\n A0 (3.0s): Holding at range; focus E0 when it enters 5. Stay grouped.\n A1 (3.0s): Holding at range 5; focus E0 when in range. Stay grouped, don't advance alone.\n A2 (3.0s): Holding at range; focus fire E0 (closest) when in range.\n A0 (3.5s): E0 at range 5, firing. Everyone focus E0 now.\n A1 (3.5s): Holding at range 5. Let them approach, then everyone focus E0.\n A2 (3.5s): Focus E0 now, all fire on E0. Stay grouped.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Firing on E0 now, everyone focus E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-676785c2f6cb0b189fad86d6.json b/examples/multi-agent-smax/results/llm-cache/ask-676785c2f6cb0b189fad86d6.json new file mode 100644 index 00000000..50cf419b --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-676785c2f6cb0b189fad86d6.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 8.0 seconds into the battle.\nYou are A0, a marine at (2.1, 15.6) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: retreat.\nYour team:\n A1 marine at (8.3, 14.2), 9/45 health, order: attack E1\n A2: dead\nEnemies you can see:\n E2 marine at (10.7, 17.4), 45/45 health, 8.8 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (6.0s): A0 at 18hp retreating to pull fire off. A1 focus E1, I'll rejoin if safe.\n A1 (6.0s): A1 attacking E1 (45hp). A0 at 18hp, retreat if under 20 to shed aggro.\n A0 (6.5s): A0 at 9hp, staying out of range. A1 focus E1, 36hp left.\n A1 (6.5s): A1 attacking E1 (36hp), in range. A0 stay back, keep out of range.\n A0 (7.0s): A0 9hp, staying out of range. A1 focus E1 (27hp), then E2.\n A1 (7.0s): A1 on E1 (27hp), 3 shots left. A0 stay out of range.\n A0 (7.5s): A0 9hp staying out of range. A1 finish E1 (18hp), then E2.\n A1 (7.5s): A1 on E1 (18hp), finishing it, then E2. A0 stay back.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A0 9hp joining on E1 to finish it fast, then focus E2 together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-6772ad13b08c00f528f2f367.json b/examples/multi-agent-smax/results/llm-cache/ask-6772ad13b08c00f528f2f367.json new file mode 100644 index 00000000..d4e68da5 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-6772ad13b08c00f528f2f367.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.5 seconds into the battle.\nYou are A2, a marine at (9.9, 15.8) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0: dead\n A1 marine at (10.1, 17.3), 36/45 health, order: attack E2\nEnemies you can see:\n E2 marine at (14.4, 14.8), 27/45 health, 4.6 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (4.5s): Focusing E1 (27hp), then E2.\n A2 (4.5s): Focusing E1 (27hp), then E2.\n A1 (5.0s): Focusing E1 (18hp), almost dead. Then E2.\n A2 (5.0s): Attacking E1 (18hp), then E2.\n A1 (5.5s): E1 down. All focus E2 (45hp), 5.0 away.\n A2 (5.5s): E1 down. All focus E2, 4.6 away, 45hp.\n A1 (6.0s): Focusing E2 (36hp), keep firing.\n A2 (6.0s): Focusing E2 (36hp), keep firing.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 at 27hp, keep focusing, almost down.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-67a0165f0d8750f7ca3aa4a2.json b/examples/multi-agent-smax/results/llm-cache/ask-67a0165f0d8750f7ca3aa4a2.json new file mode 100644 index 00000000..4a8f9322 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-67a0165f0d8750f7ca3aa4a2.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 2.0 seconds into the battle.\nYou are A0, a marine at (12.7, 16.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 15 15.\nYour team:\n A1 marine at (13.3, 15.5), 45/45 health, order: move 14 15\n A2 marine at (12.8, 14.9), 45/45 health, order: move 15 15\nEnemies you can see:\n E0 marine at (17.6, 15.0), 45/45 health, 5.0 away (in range)\n E1 marine at (18.1, 16.2), 45/45 health, 5.4 away\n E2 marine at (17.6, 14.3), 45/45 health, 5.2 away\nTeam chat (most recent last):\n A1 (0.5s): Moving to (12,15) with team; will attack same target together.\n A2 (0.5s): A2 moving to (12,15), staying close; will attack same target when enemies appear.\n A0 (1.0s): Continuing to (12,15); will attack together once enemies appear.\n A1 (1.0s): Continuing to (12,15) together; will attack same target when enemies appear.\n A2 (1.0s): A2 continuing to (12,15); will attack together when enemies appear.\n A0 (1.5s): Advancing together toward E0; all attack E0 once everyone is in range.\n A1 (1.5s): Advancing together to (14,15); all attack E0 once in range.\n A2 (1.5s): Advancing east together to (15,15); all attack E2 once in range 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"All in range of E0 now. Everyone attack E0 together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-67b12349b16e2dc63bcfaa2a.json b/examples/multi-agent-smax/results/llm-cache/ask-67b12349b16e2dc63bcfaa2a.json new file mode 100644 index 00000000..52667fdf --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-67b12349b16e2dc63bcfaa2a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.0 seconds into the battle.\nYou are A0, a marine at (8.1, 15.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 8.5 15.\nYour team:\n A1 marine at (8.3, 14.1), 45/45 health, order: hold\n A2 marine at (8.1, 14.9), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (14.4, 15.0), 45/45 health, 6.3 away\n E1 marine at (15.0, 16.2), 45/45 health, 6.8 away\n E2 marine at (14.5, 14.3), 45/45 health, 6.5 away\nTeam chat (most recent last):\n A1 (1.5s): Advancing east slowly to find enemies; stay grouped, focus closest.\n A2 (1.5s): In position at (8,15); holding, focus fire closest enemy when seen.\n A0 (2.0s): Moving east to group with A1; focus closest enemy when seen.\n A1 (2.0s): Falling back to group; hold and focus fire when enemies enter range.\n A2 (2.0s): A2 holding at (8,15); A1 is advancing east, stay close, focus closest.\n A0 (2.5s): Enemies 3 at east x16. Pull back to group at (8.5,15), then focus E0 together.\n A1 (2.5s): Enemies east at 16,15. Hold grouped; focus fire on the closest, starting with E2 or E0.\n A2 (2.5s): Enemies ~8 east. Hold at range 5, focus closest when they approach.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding at (8,15). Everyone hold; focus fire closest enemy when in range 5.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-67db5edc50f0c538cd36adfa.json b/examples/multi-agent-smax/results/llm-cache/ask-67db5edc50f0c538cd36adfa.json new file mode 100644 index 00000000..54b12a07 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-67db5edc50f0c538cd36adfa.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 0.0 seconds into the battle.\nYou are A1, a marine at (9.4, 14.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.9, 16.7), 45/45 health, order: hold\n A2 marine at (7.6, 17.8), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 15 16\", \"say\": \"Moving together east to (15,16); stay within 2 of each other, attack same target.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-683db049015f3bc181797251.json b/examples/multi-agent-smax/results/llm-cache/ask-683db049015f3bc181797251.json new file mode 100644 index 00000000..7bf4fc45 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-683db049015f3bc181797251.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 1.5 seconds into the battle.\nYou are A1, a marine at (12.5, 16.4) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 16.\nYour team:\n A0 marine at (11.7, 16.4), 45/45 health, order: move 12 16\n A2 marine at (10.7, 16.5), 45/45 health, order: move 12 16\nEnemies you can see:\n E0 marine at (17.6, 15.3), 45/45 health, 5.2 away\n E1 marine at (20.1, 15.6), 45/45 health, 7.7 away\n E2 marine at (19.8, 17.7), 45/45 health, 7.3 away\nTeam chat (most recent last):\n A1 (0.0s): Moving together east to (15,16); stay within 2 of each other, attack same target.\n A2 (0.0s): Moving east together toward center, stay within 2 of each other; attack same target on contact.\n A0 (0.5s): A1 please converge on (12,16) with us; A1 is ahead, stay within 2.\n A1 (0.5s): Joining A0 and A2 at (12,16); staying grouped, then advance together.\n A2 (0.5s): A2 moving to (12,16) with team; will attack together on contact.\n A0 (1.0s): Continuing to (12,16); stay grouped, attack same target on contact.\n A1 (1.0s): Holding formation at (12,16); then all advance and attack E0 together.\n A2 (1.0s): Continuing to (12,16) together; will attack same target once all in range 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 16\", \"say\": \"Advancing together east to (14,16); then all attack E0 at once.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-684c1fe35a9c988de5a2d550.json b/examples/multi-agent-smax/results/llm-cache/ask-684c1fe35a9c988de5a2d550.json new file mode 100644 index 00000000..7ff5ddc0 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-684c1fe35a9c988de5a2d550.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 3.5 seconds into the battle.\nYou are A1, a marine at (14.6, 15.5) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (14.2, 16.2), 45/45 health, order: attack E1\n A2: dead\nEnemies you can see:\n E0 marine at (18.2, 17.3), 45/45 health, 4.1 away (in range)\n E2 marine at (18.4, 14.1), 45/45 health, 4.1 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (2.0s): Enemies in range now. All attack E1, A1 close in.\n A1 (2.0s): A1 attacking E1 now; A0 and A2 are in range, focus E1.\n A2 (2.0s): Enemies in range of me and A0. Attacking E1 now; A1 close in and fire on E1.\n A0 (2.5s): Focus E1 (27hp). A2 low at 18hp, retreat if needed.\n A1 (2.5s): Firing on E1 (27hp). A2 at 18hp, retreat if under 20.\n A2 (2.5s): A2 at 18hp retreating to pull fire off me; A0, A1 keep focusing E1.\n A0 (3.0s): E1 at 9hp, finish it now; then focus E0.\n A1 (3.0s): E1 at 9hp, finishing it now. A0 fire E1, then focus E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"retreat\", \"say\": \"A1 at 18hp retreating so A0 is closest; A0 focus E2, I return when safe.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-68a7bb5d24ba6411d430cb00.json b/examples/multi-agent-smax/results/llm-cache/ask-68a7bb5d24ba6411d430cb00.json new file mode 100644 index 00000000..3ac3456f --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-68a7bb5d24ba6411d430cb00.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 0.5 seconds into the battle.\nYou are A0, a marine at (9.7, 17.4) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 16.\nYour team:\n A1 marine at (9.9, 14.1), 45/45 health, order: move 12 15\n A2 marine at (8.1, 14.9), 45/45 health, order: move 12 15\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Moving east together to (12,16); stay within 2 of each other, then attack same target.\n A1 (0.0s): Moving east together toward enemies; stay within 2 of each other, attack same target.\n A2 (0.0s): Advancing east together to (12,15); stay within 2 of each other.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 15\", \"say\": \"Converging on (12,15) with A1/A2; will attack same target together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-68e969d1c7afd437788de21f.json b/examples/multi-agent-smax/results/llm-cache/ask-68e969d1c7afd437788de21f.json new file mode 100644 index 00000000..e3ea8318 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-68e969d1c7afd437788de21f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 9.5 seconds into the battle.\nYou are A0, a marine at (0.6, 15.6) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: retreat.\nYour team:\n A1: dead\n A2: dead\nEnemies you can see:\n E1 marine at (9.0, 16.1), 9/45 health, 8.5 away\n E2 marine at (7.6, 17.4), 45/45 health, 7.3 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (7.0s): A0 9hp, staying out of range. A1 focus E1 (27hp), then E2.\n A1 (7.0s): A1 on E1 (27hp), 3 shots left. A0 stay out of range.\n A0 (7.5s): A0 9hp staying out of range. A1 finish E1 (18hp), then E2.\n A1 (7.5s): A1 on E1 (18hp), finishing it, then E2. A0 stay back.\n A0 (8.0s): A0 9hp joining on E1 to finish it fast, then focus E2 together.\n A1 (8.0s): A1 9hp, finishing E1 (18hp). A0 stay back, then we focus E2.\n A0 (8.5s): A0 9hp alone, retreating out of range; E1 has 9hp left.\n A0 (9.0s): A0 9hp, last unit. Retreating out of range; enemies E1 9hp, E2 45hp.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A0 9hp last unit, cornered at the wall; going for E1 (9hp) to kill it.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-692f0a4b10dd47cd63dbc264.json b/examples/multi-agent-smax/results/llm-cache/ask-692f0a4b10dd47cd63dbc264.json new file mode 100644 index 00000000..c76c693e --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-692f0a4b10dd47cd63dbc264.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.0 seconds into the battle.\nYou are A1, a marine at (6.7, 14.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.0, 15.5), 45/45 health, order: hold\n A2 marine at (8.7, 15.8), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (13.6, 16.8), 45/45 health, 7.4 away\n E1 marine at (15.3, 16.2), 45/45 health, 8.8 away\nTeam chat (most recent last):\n A1 (1.5s): A1 holding; will focus fire on the first enemy in range.\n A2 (1.5s): A2 holding at (8.3,15.7); will focus closest enemy with team.\n A0 (2.0s): Advancing slowly east to scout; stay close, focus closest enemy when seen.\n A1 (2.0s): A1 holding; no enemies yet, will focus closest when one appears.\n A2 (2.0s): E0 at (16.8,16.8) approaching; hold and focus it when in range.\n A0 (2.5s): A0 holding with you; enemies approaching, focus E0 when in range.\n A1 (2.5s): A1 holding at (6.7,14.2); A0 fall back to us, focus E0 together.\n A2 (2.5s): A2 holding; enemies approaching, all focus E0 when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A1 holding; focus E0 when it enters range 5.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-6948be0eb23e8ecf418ec7c9.json b/examples/multi-agent-smax/results/llm-cache/ask-6948be0eb23e8ecf418ec7c9.json new file mode 100644 index 00000000..a5ca1c8d --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-6948be0eb23e8ecf418ec7c9.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 4.0 seconds into the battle.\nYou are A1, a marine at (6.7, 14.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.9, 15.6), 45/45 health, order: hold\n A2 marine at (8.3, 17.3), 36/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (11.9, 16.8), 36/45 health, 5.8 away\n E1 marine at (12.2, 16.2), 45/45 health, 5.8 away\n E2 marine at (12.3, 17.4), 45/45 health, 6.5 away\nTeam chat (most recent last):\n A1 (2.5s): A1 holding. E0 at 8.9 away; wait until in range 5 of all.\n A2 (2.5s): A2 holding. Nearest enemy E0 at 6.9; wait until within 5 of all.\n A0 (3.0s): A0 holding. E0 at 6.9; wait until within 5 of all, then focus E0.\n A1 (3.0s): A1 holding. E0 at 7.4; attack E0 together once within 5 of all.\n A2 (3.0s): A2 holding. E0 at 5.3 from me, 6.8+ from A0/A1. Wait for range 5.\n A0 (3.5s): A0 holding. E0 5.3 away; attack E0 together once within 5 of all.\n A1 (3.5s): A1 holding. E0 at 6.0; attack E0 together once within 5 of all.\n A2 (3.5s): E0 in range of me, firing now. A0/A1 close in and focus E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"A2 is engaged; A1 attacking E0 now. A0 join and focus E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-694d3bf29bcdf5c99bacdd44.json b/examples/multi-agent-smax/results/llm-cache/ask-694d3bf29bcdf5c99bacdd44.json new file mode 100644 index 00000000..d57f4ff1 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-694d3bf29bcdf5c99bacdd44.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.5 seconds into the battle.\nYou are A2, a marine at (7.6, 17.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.9, 16.7), 45/45 health, order: hold\n A1 marine at (9.4, 14.9), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together; focus fire on closest enemy once seen.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on closest enemy when they appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding; staying clustered near A0 until enemies appear, then focus closest.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-698a0c626dd1fe33587f24a5.json b/examples/multi-agent-smax/results/llm-cache/ask-698a0c626dd1fe33587f24a5.json new file mode 100644 index 00000000..41129119 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-698a0c626dd1fe33587f24a5.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.0 seconds into the battle.\nYou are A1, a marine at (8.5, 15.3) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.6, 16.9), 45/45 health, order: hold\n A2 marine at (6.5, 16.6), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding together; focus fire on the closest enemy when they appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-69a08f92e099e0497729b14f.json b/examples/multi-agent-smax/results/llm-cache/ask-69a08f92e099e0497729b14f.json new file mode 100644 index 00000000..5235ee89 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-69a08f92e099e0497729b14f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 1.5 seconds into the battle.\nYou are A0, a marine at (11.7, 15.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 16.5.\nYour team:\n A1 marine at (12.9, 17.5), 45/45 health, order: move 14 16.5\n A2 marine at (12.1, 16.7), 45/45 health, order: move 14 16.8\nEnemies you can see:\n E1 marine at (18.4, 14.5), 45/45 health, 6.8 away\n E2 marine at (17.8, 17.2), 45/45 health, 6.3 away\nTeam chat (most recent last):\n A1 (0.0s): Moving east together toward center, stay within 2 of each other.\n A2 (0.0s): Moving east together toward center, stay close, all engage same enemy on contact.\n A0 (0.5s): Continuing east together; hold formation, all attack same target on contact.\n A1 (0.5s): Continuing east together; will all attack same enemy on contact.\n A2 (0.5s): Continuing east together; no enemies seen yet, will focus same target on contact.\n A0 (1.0s): Continuing east together; no enemies yet, will focus same target on contact.\n A1 (1.0s): Moving to 14,16.5 with the group; will attack E2 together when in range.\n A2 (1.0s): Enemy E2 seen at 19.3,17.2. Keep formation, advance together, then all attack E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 16.5\", \"say\": \"Enemies 6-7 away; keep advancing together, then all attack E2 at range 5.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-69ce84adc8968a6db40c6cd9.json b/examples/multi-agent-smax/results/llm-cache/ask-69ce84adc8968a6db40c6cd9.json new file mode 100644 index 00000000..82f3f83a --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-69ce84adc8968a6db40c6cd9.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.0 seconds into the battle.\nYou are A0, a marine at (8.2, 16.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (9.8, 15.7), 45/45 health, order: hold\n A2 marine at (9.0, 16.2), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.5s): Holding position; will focus fire on closest enemy once visible.\n A2 (0.5s): Holding. Will focus fire on the closest enemy once visible.\n A0 (1.0s): Still no enemies; holding grouped, focus closest when seen.\n A1 (1.0s): Still no enemies; holding grouped, will focus closest when seen.\n A2 (1.0s): Still no enemies. Holding; will focus the closest enemy when seen.\n A0 (1.5s): Still no enemies; holding grouped, focus closest when seen.\n A1 (1.5s): Holding grouped; focus fire on closest enemy when seen.\n A2 (1.5s): Still holding grouped; will focus the closest enemy when it appears.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding grouped; no enemies yet. Focus closest when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-69d11d9843dc21fc9da2bead.json b/examples/multi-agent-smax/results/llm-cache/ask-69d11d9843dc21fc9da2bead.json new file mode 100644 index 00000000..6f8ca7ab --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-69d11d9843dc21fc9da2bead.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 0.5 seconds into the battle.\nYou are A2, a marine at (9.2, 17.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 16.\nYour team:\n A0 marine at (8.5, 16.7), 45/45 health, order: move 12 16\n A1 marine at (10.9, 14.9), 45/45 health, order: move 15 16\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Moving east together to (12,16); stay close, no one run ahead.\n A1 (0.0s): Moving together east to (15,16); stay within 2 of each other, attack same target.\n A2 (0.0s): Moving east together toward center, stay within 2 of each other; attack same target on contact.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 16\", \"say\": \"A2 moving to (12,16) with team; will attack together on contact.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-69d9a7b05c3b4bb84aa019ca.json b/examples/multi-agent-smax/results/llm-cache/ask-69d9a7b05c3b4bb84aa019ca.json new file mode 100644 index 00000000..cc434bf3 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-69d9a7b05c3b4bb84aa019ca.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.5 seconds into the battle.\nYou are A2, a marine at (8.2, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.8, 14.7), 45/45 health, order: hold\n A1 marine at (8.5, 14.8), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (12.6, 15.0), 45/45 health, 4.5 away (in range)\n E1 marine at (13.4, 14.0), 45/45 health, 5.2 away\n E2 marine at (11.8, 16.8), 45/45 health, 4.5 away (in range)\nTeam chat (most recent last):\n A1 (2.0s): Holding cluster; let them walk into range, then focus closest enemy.\n A2 (2.0s): E2 spotted east at 8.7 range. Holding cluster; let them come, focus first in range.\n A0 (2.5s): Enemies approaching; hold cluster, all focus whichever enemy enters range first.\n A1 (2.5s): Holding. Enemies closing; all focus closest enemy once in range 5.\n A2 (2.5s): A2 holding. Enemies approaching; focus closest once in range 5.\n A0 (3.0s): Holding. Focus closest enemy E2 when in range 5, fire together.\n A1 (3.0s): Holding. E2 closest at 5.3; focus E2 when in range, then E0.\n A2 (3.0s): Holding. E2 closest at 5.8; focus whoever enters range 5 first.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E0 and E2 in range now. Focus E2, fire together, then E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-6a1b8f2fdc116bc5fcddf8dd.json b/examples/multi-agent-smax/results/llm-cache/ask-6a1b8f2fdc116bc5fcddf8dd.json new file mode 100644 index 00000000..8b622ddf --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-6a1b8f2fdc116bc5fcddf8dd.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.0 seconds into the battle.\nYou are A0, a marine at (6.9, 16.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (9.4, 14.9), 45/45 health, order: hold\n A2 marine at (7.6, 17.8), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding together; focus fire on closest enemy once seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-6a5f144a4d4b6232f47858ac.json b/examples/multi-agent-smax/results/llm-cache/ask-6a5f144a4d4b6232f47858ac.json new file mode 100644 index 00000000..cae51150 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-6a5f144a4d4b6232f47858ac.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 2.5 seconds into the battle.\nYou are A2, a marine at (14.1, 16.4) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (13.6, 17.1), 36/45 health, order: attack E0\n A1 marine at (13.2, 15.3), 27/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (17.8, 15.1), 9/45 health, 3.9 away (in range)\n E1 marine at (17.6, 16.5), 45/45 health, 3.5 away (in range)\n E2 marine at (17.5, 17.3), 45/45 health, 3.5 away (in range)\nTeam chat (most recent last):\n A1 (1.0s): E0 spotted east at (19.3,15.1). Keep moving together; attack when in range 5 of all.\n A2 (1.0s): A2 continuing to (14,16), staying close; will focus first enemy seen.\n A0 (1.5s): E0 in range of A0 and A1. Attack E0 now; A2 close in and focus E0.\n A1 (1.5s): E0 in range of A1 and A0. A2 close in, everyone focus E0 now.\n A2 (1.5s): E0 at 6.7, not in range yet. Moving up together; attack E0 on same tick.\n A0 (2.0s): Focus E0 (27hp) now; A2 close in and fire.\n A1 (2.0s): Focusing E0 (27hp). A2 get in range and attack E0.\n A2 (2.0s): Attacking E0 now, closing in with you both.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 at 9hp in range, firing on E0 now.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-6b10b279b31a43fd973b0f84.json b/examples/multi-agent-smax/results/llm-cache/ask-6b10b279b31a43fd973b0f84.json new file mode 100644 index 00000000..44d19b3e --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-6b10b279b31a43fd973b0f84.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 7.0 seconds into the battle.\nYou are A1, a marine at (13.5, 17.2) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E0 marine at (18.0, 17.1), 18/45 health, 4.6 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (4.0s): Keep firing E1 (18hp), then E0 together.\n A1 (4.0s): Firing on E1 (18hp), then E0 together.\n A0 (4.5s): E1 down. Focus E0 now, both fire together.\n A1 (4.5s): E1 dead. Focus E0 (4.6 away), A0 keep firing, I'm full health.\n A1 (5.0s): Firing on E0, last enemy. I'm at full health.\n A1 (5.5s): Last enemy E0 at 36hp; I'm the only one left, firing.\n A1 (6.0s): Last enemy E0 at 36hp, in range, firing.\n A1 (6.5s): Last enemy E0 at 27hp, in range, firing. I'm at 27hp.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 at 18hp, I'm at 18hp, last enemy, keep firing.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-6c3008642f97e7b5c3c0183d.json b/examples/multi-agent-smax/results/llm-cache/ask-6c3008642f97e7b5c3c0183d.json new file mode 100644 index 00000000..ab83b310 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-6c3008642f97e7b5c3c0183d.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.5 seconds into the battle.\nYou are A0, a marine at (8.2, 16.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (9.8, 15.7), 45/45 health, order: hold\n A2 marine at (9.0, 16.2), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together as a group; focus fire on the closest enemy when they appear.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together as a group; focus fire on the closest enemy when they appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"No enemies yet; staying grouped, will focus the closest enemy when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-6da42ccc65f7cc68313cd6e3.json b/examples/multi-agent-smax/results/llm-cache/ask-6da42ccc65f7cc68313cd6e3.json new file mode 100644 index 00000000..11627794 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-6da42ccc65f7cc68313cd6e3.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 10.0 seconds into the battle.\nYou are A0, a marine at (2.1, 15.6) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1: dead\n A2: dead\nEnemies you can see:\n E1 marine at (7.5, 16.1), 9/45 health, 5.3 away\n E2 marine at (6.0, 17.4), 45/45 health, 4.3 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (7.0s): A1 on E1 (27hp), 3 shots left. A0 stay out of range.\n A0 (7.5s): A0 9hp staying out of range. A1 finish E1 (18hp), then E2.\n A1 (7.5s): A1 on E1 (18hp), finishing it, then E2. A0 stay back.\n A0 (8.0s): A0 9hp joining on E1 to finish it fast, then focus E2 together.\n A1 (8.0s): A1 9hp, finishing E1 (18hp). A0 stay back, then we focus E2.\n A0 (8.5s): A0 9hp alone, retreating out of range; E1 has 9hp left.\n A0 (9.0s): A0 9hp, last unit. Retreating out of range; enemies E1 9hp, E2 45hp.\n A0 (9.5s): A0 9hp last unit, cornered at the wall; going for E1 (9hp) to kill it.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A0 9hp, last unit, killing E1 (9hp) now.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-6e564744cfd80ee58f9425f7.json b/examples/multi-agent-smax/results/llm-cache/ask-6e564744cfd80ee58f9425f7.json new file mode 100644 index 00000000..2c89033d --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-6e564744cfd80ee58f9425f7.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 8.0 seconds into the battle.\nYou are A0, a marine at (9.3, 15.9) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1: dead\n A2: dead\nEnemies you can see:\n E0 marine at (13.5, 17.3), 27/45 health, 4.4 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (5.0s): E2 down. Focus E1 (36hp), then E0.\n A0 (5.5s): Focusing E1 (18hp), both of us fire. Then E0.\n A1 (5.5s): Focusing E1 (18hp), both fire. Then E0.\n A0 (6.0s): E1 at 9hp, finishing it. Then E0 together.\n A1 (6.0s): E1 at 9hp, finishing it now. Then E0.\n A0 (6.5s): A1 and A2 are down. I'm engaging E0 alone.\n A0 (7.0s): Last one. E0 at 36hp, fighting on.\n A0 (7.5s): Last one, E0 at 36hp. Fighting on.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Last one, E0 at 27hp. Fighting on.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-6e64da16fb044982ca87390b.json b/examples/multi-agent-smax/results/llm-cache/ask-6e64da16fb044982ca87390b.json new file mode 100644 index 00000000..da3e6bbd --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-6e64da16fb044982ca87390b.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 8.5 seconds into the battle.\nYou are A2, a marine at (13.9, 16.5) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0: dead\n A1: dead\nEnemies you can see:\n E1 marine at (17.0, 15.6), 9/45 health, 3.2 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A2 (4.5s): E2 at 9hp, finish it now. A0 stay put, then both on E1.\n A2 (5.0s): A2 alone now. Finishing E2 at 9hp, then E1.\n A2 (5.5s): E2 dead. A2 alone, attacking E1 at 3.2 range.\n A2 (6.0s): A2 alone, 36hp vs E1 36hp, focusing E1.\n A2 (6.5s): A2 alone, 27hp vs E1 36hp, still focusing E1.\n A2 (7.0s): A2 27hp vs E1 27hp, still focusing E1.\n A2 (7.5s): A2 18hp vs E1 18hp, last enemy, all-in on E1.\n A2 (8.0s): A2 9hp vs E1 18hp, last stand, all-in on E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A2 9hp vs E1 9hp, last shot, all-in on E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-6e92f577163e56016f3aede8.json b/examples/multi-agent-smax/results/llm-cache/ask-6e92f577163e56016f3aede8.json new file mode 100644 index 00000000..524574d3 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-6e92f577163e56016f3aede8.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 7.0 seconds into the battle.\nYou are A1, a marine at (9.8, 14.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E2 marine at (10.8, 17.5), 45/45 health, 3.5 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A2 (4.5s): A2 9hp, still firing on E0 (18hp). A0 finish E0, then E1.\n A0 (5.0s): A0 firing E1 (27hp), A1 same. Focus E1 then E2.\n A1 (5.0s): A1 hitting E1 (27hp, in range). A0 switch to E1, then E2.\n A0 (5.5s): A0 18hp firing E1 (18hp). Finish E1, then all E2.\n A1 (5.5s): A1 on E1 (18hp). A0 keep firing E1, then E2.\n A0 (6.0s): A0 9hp, finishing E1 (9hp). Then focus E2 together.\n A1 (6.0s): A1 on E1 (9hp), finishing it. Then all E2.\n A1 (6.5s): A1 alone vs E2 (45hp), engaging.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"A1 alone vs E2 (45hp), still firing.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-6ea2b003e15551be634b0411.json b/examples/multi-agent-smax/results/llm-cache/ask-6ea2b003e15551be634b0411.json new file mode 100644 index 00000000..80414a4d --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-6ea2b003e15551be634b0411.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 3.5 seconds into the battle.\nYou are A0, a marine at (13.3, 15.6) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1 marine at (12.9, 17.5), 27/45 health, order: attack E1\n A2 marine at (13.7, 16.7), 27/45 health, order: attack E1\nEnemies you can see:\n E0 marine at (17.7, 17.8), 45/45 health, 5.0 away (in range)\n E1 marine at (16.9, 14.5), 27/45 health, 3.7 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (2.0s): All three in range of E2 now. Attack E2 together.\n A2 (2.0s): E2 and E1 in my range; attacking E2 now, everyone focus E2.\n A0 (2.5s): E2 at 9hp, finish it now; then focus E1.\n A1 (2.5s): Focusing E2 (9hp), it dies soon; then we focus E0.\n A2 (2.5s): E2 at 9hp, finishing it now. Then focus E1.\n A0 (3.0s): E2 dead. Focus E1 (closest, 3.7 away), then E0.\n A1 (3.0s): E2 dead. Everyone focus E1 now, then E0.\n A2 (3.0s): E2 dead. Everyone focus E1 now, closest at 3.9.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Focus E1 (27hp). Keep attacking until dead, then E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-6ed30212e57753c836087fa1.json b/examples/multi-agent-smax/results/llm-cache/ask-6ed30212e57753c836087fa1.json new file mode 100644 index 00000000..80e45659 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-6ed30212e57753c836087fa1.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.5 seconds into the battle.\nYou are A0, a marine at (7.0, 15.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (9.7, 17.5), 45/45 health, order: move 12 17\n A2 marine at (7.4, 16.7), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together at the cluster; focus fire on the closest enemy when they appear.\n A1 (0.0s): Advancing east together; stay close and focus fire on the nearest enemy.\n A2 (0.0s): Holding together; focus fire on the closest enemy when they appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 9 16.5\", \"say\": \"A1 fell back toward cluster; I'm moving to x=9 so we stay grouped.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-6f20b875b13fe4c399dcc202.json b/examples/multi-agent-smax/results/llm-cache/ask-6f20b875b13fe4c399dcc202.json new file mode 100644 index 00000000..8a730efa --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-6f20b875b13fe4c399dcc202.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 1.5 seconds into the battle.\nYou are A1, a marine at (12.1, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 15.\nYour team:\n A0 marine at (13.7, 16.0), 45/45 health, order: move 14 15\n A2 marine at (12.4, 14.8), 45/45 health, order: move 14 15\nEnemies you can see:\n E0 marine at (20.3, 16.4), 45/45 health, 8.6 away\n E2 marine at (20.9, 15.5), 45/45 health, 9.0 away\nTeam chat (most recent last):\n A1 (0.0s): Moving east together toward center, stay within 2 of each other.\n A2 (0.0s): Moving together to center, stay within 2 of each other; attack same target when in range.\n A0 (0.5s): Moving east, staying close; A1 and A2 keep within 2 of me.\n A1 (0.5s): Advancing east, staying close; will all attack same target when enemies appear.\n A2 (0.5s): Keeping pace east, staying close; will focus same target once in range.\n A0 (1.0s): Continuing east together; A1 and A2 stay close, focus fire once enemies appear.\n A1 (1.0s): Continuing east together; will focus same target when enemies in range.\n A2 (1.0s): Continuing east to 14,15, staying close; will focus same target when enemies appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 15\", \"say\": \"Moving to 14,15 with A0 and A2; will focus same target at range 5.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-6f42757ce65cdaae84768aaf.json b/examples/multi-agent-smax/results/llm-cache/ask-6f42757ce65cdaae84768aaf.json new file mode 100644 index 00000000..4f77da43 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-6f42757ce65cdaae84768aaf.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 4.5 seconds into the battle.\nYou are A2, a marine at (13.7, 16.7) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (13.3, 15.6), 18/45 health, order: attack E1\n A1 marine at (12.9, 17.5), 27/45 health, order: attack E1\nEnemies you can see:\n E0 marine at (17.7, 17.8), 45/45 health, 4.2 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (3.0s): E2 dead. Everyone focus E1 now, then E0.\n A2 (3.0s): E2 dead. Everyone focus E1 now, closest at 3.9.\n A0 (3.5s): Focus E1 (27hp). Keep attacking until dead, then E0.\n A1 (3.5s): Focusing E1 (27hp). A0 at 18hp, keep firing until E1 dies.\n A2 (3.5s): Focusing E1 (27hp), then E0. A0 at 18hp, keep firing.\n A0 (4.0s): E1 at 9hp, finishing it now, then E0.\n A1 (4.0s): E1 at 9hp, all keep firing until dead, then E0.\n A2 (4.0s): E1 at 9hp, keep firing until dead, then E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E1 dead. All focus E0, 4.2 away in range. Keep firing.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-6f84adfd5987910ab51ff264.json b/examples/multi-agent-smax/results/llm-cache/ask-6f84adfd5987910ab51ff264.json new file mode 100644 index 00000000..12476612 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-6f84adfd5987910ab51ff264.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 1.5 seconds into the battle.\nYou are A1, a marine at (13.2, 15.3) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 16.\nYour team:\n A0 marine at (13.3, 16.9), 45/45 health, order: move 14 16\n A2 marine at (11.2, 16.6), 45/45 health, order: move 14 16\nEnemies you can see:\n E0 marine at (17.8, 15.1), 45/45 health, 4.5 away (in range)\n E1 marine at (19.3, 16.7), 45/45 health, 6.3 away\n E2 marine at (20.6, 17.1), 45/45 health, 7.5 away\nTeam chat (most recent last):\n A1 (0.0s): No enemies seen. Moving east together to (14,16); stay within 2 of each other.\n A2 (0.0s): Moving east together to find enemies; stay within 2 of each other.\n A0 (0.5s): Continuing east to (14,16), staying close; will attack together when enemies appear.\n A1 (0.5s): Continuing east to (14,16), staying close to A0 and A2.\n A2 (0.5s): Moving to (14,16) with A0 and A1, staying close; will focus the first enemy seen.\n A0 (1.0s): Enemy E0 seen east at 7.8. Keep grouped; attack E0 together when within range.\n A1 (1.0s): E0 spotted east at (19.3,15.1). Keep moving together; attack when in range 5 of all.\n A2 (1.0s): A2 continuing to (14,16), staying close; will focus first enemy seen.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 in range of A1 and A0. A2 close in, everyone focus E0 now.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-6fd3efeda8627c9565a56cae.json b/examples/multi-agent-smax/results/llm-cache/ask-6fd3efeda8627c9565a56cae.json new file mode 100644 index 00000000..970d2eb5 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-6fd3efeda8627c9565a56cae.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 4.0 seconds into the battle.\nYou are A1, a marine at (13.5, 17.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (13.8, 15.8), 27/45 health, order: attack E1\n A2: dead\nEnemies you can see:\n E0 marine at (18.0, 17.1), 45/45 health, 4.6 away (in range)\n E1 marine at (17.3, 17.0), 18/45 health, 3.8 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (2.5s): Focusing E2, it's at 18hp. Keep firing, then switch to E1 together.\n A2 (2.5s): E2 at 18hp, keep firing on E2, then switch to E1.\n A0 (3.0s): E2 is dead. Everyone focus E1 now (3.6 away), then E0.\n A1 (3.0s): E2 down. Everyone focus E1 now (3.8 away), then E0.\n A2 (3.0s): E2 dead. All focus E1 (closest, 3.5 away) now.\n A0 (3.5s): Focus E1 together, then E0. A2 stay on target per rules.\n A1 (3.5s): Focusing E1 now; A2 at 9hp, retreat only after E1 dies.\n A2 (3.5s): Focusing E1 with you. I'm at 9hp, will keep firing until it dies.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Firing on E1 (18hp), then E0 together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-7040654239ca3c9096cad2b8.json b/examples/multi-agent-smax/results/llm-cache/ask-7040654239ca3c9096cad2b8.json new file mode 100644 index 00000000..66bdbd7b --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-7040654239ca3c9096cad2b8.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 1.5 seconds into the battle.\nYou are A0, a marine at (6.9, 15.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (6.7, 14.2), 45/45 health, order: hold\n A2 marine at (8.3, 17.3), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.0s): A1 holding. No enemies seen; wait until all in range 5, then focus same target.\n A2 (0.0s): A2 holding. Will attack together once enemy is within 5 of all of us.\n A0 (0.5s): A0 holding. No enemies yet; will focus the same target once all in range.\n A1 (0.5s): A1 holding; no enemies visible yet. Will focus same target once all in range.\n A2 (0.5s): A2 holding. No enemies visible yet; will focus fire when all in range 5.\n A0 (1.0s): A0 holding. No enemies visible; will focus same target once all within 5.\n A1 (1.0s): A1 holding. No enemies visible; will focus same target once all in range 5.\n A2 (1.0s): A2 holding. Still no enemies; waiting until all in range 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A0 holding. Still no enemies; waiting for all within 5 to focus fire.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-7055d51ebbe03efdd699dd00.json b/examples/multi-agent-smax/results/llm-cache/ask-7055d51ebbe03efdd699dd00.json new file mode 100644 index 00000000..45da0789 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-7055d51ebbe03efdd699dd00.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.0 seconds into the battle.\nYou are A1, a marine at (7.2, 17.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.5, 15.8), 45/45 health, order: hold\n A2 marine at (7.6, 17.8), 45/45 health, order: hold\nEnemies you can see:\n E2 marine at (15.8, 16.7), 45/45 health, 8.6 away\nTeam chat (most recent last):\n A1 (0.5s): A1 holding; will focus fire on the closest enemy when seen.\n A2 (0.5s): Holding; will focus fire on closest enemy once visible.\n A0 (1.0s): No enemies visible; holding grouped. Focus fire on the closest when they appear.\n A1 (1.0s): No enemies yet. Holding; will focus fire on the closest when seen.\n A2 (1.0s): A2 holding; no enemies visible. Will focus closest when they appear.\n A0 (1.5s): Still no enemies; holding grouped. Focus closest when seen.\n A1 (1.5s): A1 holding; no enemies yet. Focus closest when seen.\n A2 (1.5s): A2 holding; no enemies visible. Focus closest when they appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"E2 spotted east at 8.6 range. Holding grouped; focus E2 when in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-7068a3e8308cbbf83b3f0617.json b/examples/multi-agent-smax/results/llm-cache/ask-7068a3e8308cbbf83b3f0617.json new file mode 100644 index 00000000..4fe6c9b6 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-7068a3e8308cbbf83b3f0617.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 7.5 seconds into the battle.\nYou are A1, a marine at (8.3, 14.2) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (3.7, 15.6), 9/45 health, order: retreat\n A2: dead\nEnemies you can see:\n E1 marine at (12.2, 16.1), 18/45 health, 4.4 away (in range)\n E2 marine at (10.7, 17.4), 45/45 health, 4.1 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (5.5s): E0 dead. Both focus E1 now, then E2.\n A1 (5.5s): E0 down. Focus E1 (4.4 away, in range) now, both of us.\n A0 (6.0s): A0 at 18hp retreating to pull fire off. A1 focus E1, I'll rejoin if safe.\n A1 (6.0s): A1 attacking E1 (45hp). A0 at 18hp, retreat if under 20 to shed aggro.\n A0 (6.5s): A0 at 9hp, staying out of range. A1 focus E1, 36hp left.\n A1 (6.5s): A1 attacking E1 (36hp), in range. A0 stay back, keep out of range.\n A0 (7.0s): A0 9hp, staying out of range. A1 focus E1 (27hp), then E2.\n A1 (7.0s): A1 on E1 (27hp), 3 shots left. A0 stay out of range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A1 on E1 (18hp), finishing it, then E2. A0 stay back.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-70dc3fc306ae4b4ba2ddd77d.json b/examples/multi-agent-smax/results/llm-cache/ask-70dc3fc306ae4b4ba2ddd77d.json new file mode 100644 index 00000000..aeafdfea --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-70dc3fc306ae4b4ba2ddd77d.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.5 seconds into the battle.\nYou are A0, a marine at (9.9, 17.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1: dead\n A2 marine at (10.7, 16.8), 27/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (14.6, 17.8), 45/45 health, 4.7 away (in range)\n E1 marine at (13.7, 14.5), 45/45 health, 4.5 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (3.0s): Holding at x=9; focus E2 (36hp) first once any enemy enters range 5.\n A1 (3.0s): Firing on E2 (36hp, in range). A0, A2 step up and focus E2.\n A2 (3.0s): Attacking E2 (36hp) with A1; A0 join, focus E2 first.\n A0 (3.5s): Attacking E2 (27hp), closing in to focus fire with A2.\n A1 (3.5s): E2 at 27hp, keep focusing it. A0 attack E2 too.\n A2 (3.5s): Firing E2 (27hp), A0 step up and focus E2. A1 stay back.\n A0 (4.0s): E2 at 18hp, in range. Finish it now, then E1.\n A2 (4.0s): E2 at 18hp, finish it now. A0 keep firing.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E2 is down. Focus E1 (closest, 45hp), then E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-718b5b3dcde972bce8c09e31.json b/examples/multi-agent-smax/results/llm-cache/ask-718b5b3dcde972bce8c09e31.json new file mode 100644 index 00000000..6cb066bb --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-718b5b3dcde972bce8c09e31.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 5.0 seconds into the battle.\nYou are A0, a marine at (13.7, 15.6) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1 marine at (14.2, 16.3), 18/45 health, order: attack E0\n A2: dead\nEnemies you can see:\n E1 marine at (17.9, 16.0), 45/45 health, 4.2 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A2 (3.0s): E2 at 9hp, finish it now, then focus E0.\n A0 (3.5s): E2 dead. Everyone focus E0 now. A2 at 9hp, retreat.\n A1 (3.5s): E2 dead. All focus E0 now, then E1. A2 retreat, you're at 9hp.\n A2 (3.5s): A2 at 9hp retreating. A0, A1 focus E0 now.\n A0 (4.0s): Focus E0 (36hp), then E1. I'm 27hp, staying in.\n A1 (4.0s): Focus E0 (36hp), then E1. A0 at 27hp, stay in unless under 20.\n A0 (4.5s): E0 at 18hp, keep focusing it, then E1. I'm 27hp, staying in.\n A1 (4.5s): E0 at 18hp, keep focusing it, then E1. A0 retreat if under 20.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E0 dead. Focus E1 now, it's in range 4.2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-71c0461674bc05c8f50ce817.json b/examples/multi-agent-smax/results/llm-cache/ask-71c0461674bc05c8f50ce817.json new file mode 100644 index 00000000..dd804256 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-71c0461674bc05c8f50ce817.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 7.5 seconds into the battle.\nYou are A2, a marine at (8.1, 14.9) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (8.1, 15.8), 9/45 health, order: attack E0\n A1 marine at (3.6, 14.1), 9/45 health, order: hold\nEnemies you can see:\n E0 marine at (12.9, 15.0), 27/45 health, 4.8 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (6.0s): A1 9hp holding back; E1 is at 9hp, finish it then E0.\n A2 (6.0s): Firing E1 (9hp), nearly dead. Then E0 together.\n A0 (6.5s): Firing E1 (9hp), finishing it. Then E0 together.\n A1 (6.5s): A1 holding back at 9hp; will shoot anything that closes in.\n A2 (6.5s): Finishing E1 (9hp) now, then all focus E0.\n A0 (7.0s): E1 down. All focus E0 now, A1 join in.\n A1 (7.0s): A1 9hp holding; will shoot anything that closes in. Finish E1, then E0.\n A2 (7.0s): E1 down. All focus E0; I'm closest and tanking, A0 and A1 fire.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 at 27hp, 4.8 away. A0, A1 fire now; focus E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-71fa03e270a4070d0e8e2c91.json b/examples/multi-agent-smax/results/llm-cache/ask-71fa03e270a4070d0e8e2c91.json new file mode 100644 index 00000000..7a3a0a7d --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-71fa03e270a4070d0e8e2c91.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 3.0 seconds into the battle.\nYou are A0, a marine at (12.7, 16.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1: dead\n A2 marine at (12.8, 14.9), 45/45 health, order: attack E0\nEnemies you can see:\n E1 marine at (18.1, 16.2), 45/45 health, 5.4 away\n E2 marine at (17.6, 14.3), 45/45 health, 5.2 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (1.5s): Advancing together to (14,15); all attack E0 once in range.\n A2 (1.5s): Advancing east together to (15,15); all attack E2 once in range 5.\n A0 (2.0s): All in range of E0 now. Everyone attack E0 together.\n A1 (2.0s): All in range now: everyone attack E0 together.\n A2 (2.0s): Enemies in range now. Everyone attack E0 together.\n A0 (2.5s): Focus E0, it's at 18hp. A1 stay on target per rules.\n A1 (2.5s): Focus E0, it's at 18hp. Keep firing until it dies.\n A2 (2.5s): A2 attacking E0 now; focus it down, then E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E0 is dead. Both attack E2 together, closest enemy; stay level with me.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-720f30e3dafaf731f14837f0.json b/examples/multi-agent-smax/results/llm-cache/ask-720f30e3dafaf731f14837f0.json new file mode 100644 index 00000000..0e75be76 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-720f30e3dafaf731f14837f0.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 4.5 seconds into the battle.\nYou are A0, a marine at (14.8, 16.4) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1: dead\n A2 marine at (13.9, 16.5), 45/45 health, order: attack E2\nEnemies you can see:\n E1 marine at (17.0, 15.6), 45/45 health, 2.3 away (in range)\n E2 marine at (16.6, 17.7), 9/45 health, 2.2 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (2.5s): E0 at 18hp, keep focus fire; I'm at 18hp and will step back once it dies.\n A2 (2.5s): Focus E0, it's at 18hp. A1 is low; keep firing until E0 dies.\n A0 (3.0s): E0 dead. A2 stay close, all focus E2 together. A1 retreat.\n A2 (3.0s): E0 dead. A0 and I both attack E2 now, stay together.\n A0 (3.5s): Both on E2, keep firing until it dies.\n A2 (3.5s): Attacking E2 with A0, keep focus until it dies.\n A0 (4.0s): Keep focus on E2, 27hp left, then E1 together.\n A2 (4.0s): E2 at 27hp, keep focus until dead, then E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 at 9hp, finish it together, then both on E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-721a0689eaba7f07e302e3c3.json b/examples/multi-agent-smax/results/llm-cache/ask-721a0689eaba7f07e302e3c3.json new file mode 100644 index 00000000..0ec9759c --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-721a0689eaba7f07e302e3c3.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.0 seconds into the battle.\nYou are A0, a marine at (8.6, 16.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (8.5, 15.3), 45/45 health, order: hold\n A2 marine at (6.5, 16.6), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together here; focus fire on the closest enemy when they appear.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together as a group; focus fire on the closest enemy once seen.\n A0 (0.5s): No enemies yet. Holding; focus the closest when they appear.\n A1 (0.5s): A1 holding; will focus fire on the closest enemy that appears.\n A2 (0.5s): No enemies yet; staying grouped, will focus the closest one when seen.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Still no enemies; holding grouped, focus closest when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-72e62e991f51fe6734ce22a4.json b/examples/multi-agent-smax/results/llm-cache/ask-72e62e991f51fe6734ce22a4.json new file mode 100644 index 00000000..669733ad --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-72e62e991f51fe6734ce22a4.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.5 seconds into the battle.\nYou are A0, a marine at (8.6, 16.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1 marine at (8.5, 15.3), 36/45 health, order: attack E0\n A2 marine at (6.5, 16.6), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (13.0, 15.1), 27/45 health, 4.8 away (in range)\n E1 marine at (13.0, 16.7), 45/45 health, 4.4 away (in range)\n E2 marine at (14.3, 17.1), 45/45 health, 5.7 away\nTeam chat (most recent last):\n A1 (2.0s): E0 east at 7.7 away. Holding grouped; focus E0 when in range.\n A2 (2.0s): A2 holding; will focus the closest enemy when it appears.\n A0 (2.5s): Holding grouped; let them walk into range, then all focus E0.\n A1 (2.5s): Holding grouped; let them walk into range, then focus E0.\n A2 (2.5s): A2 holding grouped; focus E0 when it enters range.\n A0 (3.0s): E0 in range, all attack E0 now.\n A1 (3.0s): E0 in range at 4.5, all focus fire E0 now.\n A2 (3.0s): A2 holding; focus E0 when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"A0 focusing E0 (27hp). A2 attack E0 too, don't hold.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-72edf0485acf84530995a7a6.json b/examples/multi-agent-smax/results/llm-cache/ask-72edf0485acf84530995a7a6.json new file mode 100644 index 00000000..4f9eb228 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-72edf0485acf84530995a7a6.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.0 seconds into the battle.\nYou are A0, a marine at (10.6, 16.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1 marine at (8.9, 14.1), 45/45 health, order: hold\n A2 marine at (10.8, 14.8), 45/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (12.4, 16.4), 45/45 health, 1.9 away (in range)\n E1 marine at (13.1, 16.8), 45/45 health, 2.6 away (in range)\n E2 marine at (13.1, 15.5), 45/45 health, 2.5 away (in range)\nTeam chat (most recent last):\n A1 (2.5s): Enemies E0, E2 east ~9 away. Holding grouped; focus E0 when in range.\n A2 (2.5s): Advancing east to join A0/A1; stay grouped, focus closest enemy.\n A0 (3.0s): Holding at (9,16). Let them come into range, then all focus the closest enemy.\n A1 (3.0s): Holding grouped. Enemies ~7 away; let them come into range, focus E0.\n A2 (3.0s): Holding at range; all focus E0 when it enters 5 range.\n A0 (3.5s): E0 at 5 range. All focus E0 now.\n A1 (3.5s): Holding. Focus E0 when in range; stay grouped.\n A2 (3.5s): E0 at range 5. Everyone attack E0 now, focus fire.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Focusing E0 now. A1 please attack E0 too, all fire together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-7338283f8d3e5c40c7cdef97.json b/examples/multi-agent-smax/results/llm-cache/ask-7338283f8d3e5c40c7cdef97.json new file mode 100644 index 00000000..dc59a0e8 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-7338283f8d3e5c40c7cdef97.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.0 seconds into the battle.\nYou are A0, a marine at (7.5, 15.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (7.2, 17.2), 45/45 health, order: hold\n A2 marine at (7.6, 17.8), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together here; focus fire on the closest enemy when they appear.\n A0 (0.5s): No enemies yet. Staying grouped; focus fire on the closest one when seen.\n A1 (0.5s): A1 holding; will focus fire on the closest enemy when seen.\n A2 (0.5s): Holding; will focus fire on closest enemy once visible.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"No enemies visible; holding grouped. Focus fire on the closest when they appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-738b398b8fc793785c662df5.json b/examples/multi-agent-smax/results/llm-cache/ask-738b398b8fc793785c662df5.json new file mode 100644 index 00000000..8d1e43b9 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-738b398b8fc793785c662df5.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.0 seconds into the battle.\nYou are A1, a marine at (8.9, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (10.6, 16.0), 9/45 health, order: attack E2\n A2 marine at (10.8, 14.8), 18/45 health, order: attack E2\nEnemies you can see:\n E1 marine at (13.1, 16.8), 45/45 health, 5.0 away (in range)\n E2 marine at (13.1, 15.5), 9/45 health, 4.4 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (4.5s): Firing on E0, 18 hp left. Next target E2 (closest).\n A2 (4.5s): E0 at 18 hp, keep firing. Then focus E2.\n A0 (5.0s): E0 dead. Focus E2 (closest), then E1. Stay grouped.\n A1 (5.0s): E0 is dead. Focus fire E2, closest at 4.4.\n A2 (5.0s): E0 down. Focus E2 (closest), then E1.\n A0 (5.5s): E2 at 18hp, all fire E2 now, then E1. I'm at 9hp.\n A1 (5.5s): Focus E2 (18 hp), then E1. Keep firing.\n A2 (5.5s): Focus E2 (18hp), then E1. Keep firing.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Firing E2 (9hp), then E1. A0 stay back, low hp.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-73ef58d2058b0f60817b14ce.json b/examples/multi-agent-smax/results/llm-cache/ask-73ef58d2058b0f60817b14ce.json new file mode 100644 index 00000000..574184c6 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-73ef58d2058b0f60817b14ce.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 6.0 seconds into the battle.\nYou are A1, a marine at (15.1, 13.7) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E1 marine at (18.0, 17.0), 27/45 health, 4.3 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A2 (3.5s): E0 down. Everyone focus E2 (3.0 away), then E1.\n A0 (4.0s): E2 at 18hp, keep focusing E2 then E1.\n A1 (4.0s): E2 at 18hp, keep focusing E2 then E1. Nobody retreat.\n A0 (4.5s): E2 at 9hp, finish it now, then E1. I'm low but still firing.\n A1 (4.5s): E2 at 9hp, finishing it. Then E1. A0 stay in, no retreat.\n A0 (5.0s): E2 dead. Focus E1 now, 4.2 away, both fire together.\n A1 (5.0s): E2 dead. All focus E1 now, 4.3 away. A0 keep firing.\n A1 (5.5s): A1 alone now, attacking E1 (27hp). Keep firing.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A1 alone, E1 at 27hp, still firing.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-7450bbe0625808dc67335f9e.json b/examples/multi-agent-smax/results/llm-cache/ask-7450bbe0625808dc67335f9e.json new file mode 100644 index 00000000..c8bd412d --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-7450bbe0625808dc67335f9e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 4.5 seconds into the battle.\nYou are A2, a marine at (14.6, 17.4) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (15.0, 18.1), 27/45 health, order: attack E1\n A1: dead\nEnemies you can see:\n E1 marine at (18.5, 17.3), 9/45 health, 3.9 away (in range)\n E2 marine at (17.5, 14.8), 45/45 health, 3.9 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (2.5s): A1 at 18hp, retreating to stop being the closest target. A0, A2 focus E0.\n A2 (2.5s): Attacking E0 now; A1 under 20hp, retreat if needed.\n A0 (3.0s): E0 dead. A2 attack E1 now, it's in my range. A1 stay back.\n A2 (3.0s): E0 dead. A0, A2 focus E1 together now; A1 stay back.\n A0 (3.5s): Focusing E1 together, A2 keep firing. A1 stay back.\n A2 (3.5s): Attacking E1 with A0. A1 stay back.\n A0 (4.0s): Keep focusing E1 (27hp), both firing together.\n A2 (4.0s): Focusing E1 (27hp), both in range. Keep firing, then E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E1 at 9hp, finishing it now. Then both on E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-745a977686a3ab1cb7149044.json b/examples/multi-agent-smax/results/llm-cache/ask-745a977686a3ab1cb7149044.json new file mode 100644 index 00000000..95be2b91 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-745a977686a3ab1cb7149044.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 3.5 seconds into the battle.\nYou are A2, a marine at (13.9, 17.8) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (13.8, 15.8), 27/45 health, order: attack E1\n A1 marine at (13.5, 17.2), 45/45 health, order: attack E1\nEnemies you can see:\n E0 marine at (18.0, 17.1), 45/45 health, 4.2 away (in range)\n E1 marine at (17.3, 17.0), 45/45 health, 3.5 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (2.0s): All in range of E2 (2.4 away). Attack E2 now, everyone focus fire.\n A2 (2.0s): E2 in range of me; all attack E2 now.\n A0 (2.5s): Firing on E2, it's at 18hp. Then focus E1 next.\n A1 (2.5s): Focusing E2, it's at 18hp. Keep firing, then switch to E1 together.\n A2 (2.5s): E2 at 18hp, keep firing on E2, then switch to E1.\n A0 (3.0s): E2 is dead. Everyone focus E1 now (3.6 away), then E0.\n A1 (3.0s): E2 down. Everyone focus E1 now (3.8 away), then E0.\n A2 (3.0s): E2 dead. All focus E1 (closest, 3.5 away) now.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Focusing E1 with you. I'm at 9hp, will keep firing until it dies.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-745c02d313cb2ab6f52e9de6.json b/examples/multi-agent-smax/results/llm-cache/ask-745c02d313cb2ab6f52e9de6.json new file mode 100644 index 00000000..70469755 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-745c02d313cb2ab6f52e9de6.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 8.0 seconds into the battle.\nYou are A1, a marine at (8.9, 14.1) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E1 marine at (13.1, 16.8), 27/45 health, 5.0 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A2 (5.5s): Keep firing E2 (18hp), then E1 together.\n A0 (6.0s): E2 at 9hp, finish it now, then E1. I'm low, 9hp.\n A1 (6.0s): E2 at 9hp, finish it now, then E1.\n A2 (6.0s): E2 at 9hp, finish it, then all on E1.\n A1 (6.5s): E2 dead. All focus E1, it's at 45hp, 5.0 away.\n A2 (6.5s): E2 dead. I'm at 9hp, backing off. A1 focus E1, I'll rejoin.\n A1 (7.0s): Engaging E1 at 36hp, in range. A2 stay back and heal up.\n A1 (7.5s): Still on E1, 36hp. A2 stay back and heal.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E1 at 27hp, still firing. A2 stay back.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-74fd1462ed5e93d6b5d5e854.json b/examples/multi-agent-smax/results/llm-cache/ask-74fd1462ed5e93d6b5d5e854.json new file mode 100644 index 00000000..b7fa015c --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-74fd1462ed5e93d6b5d5e854.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.5 seconds into the battle.\nYou are A2, a marine at (7.6, 17.8) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (7.5, 15.8), 45/45 health, order: attack E2\n A1 marine at (7.2, 17.2), 45/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (11.7, 17.0), 45/45 health, 4.2 away (in range)\n E1 marine at (11.0, 17.2), 45/45 health, 3.5 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (3.0s): E2 at 5.5, nearly in range. Holding; all focus E2 when it enters 5.\n A2 (3.0s): E2 at 5.1, nearly in range. Holding, all fire on E2 first.\n A0 (3.5s): E2 in range, all fire E2 now.\n A1 (3.5s): E2 in range at 3.9. Everyone fire on E2.\n A2 (3.5s): E2 in range at 3.6, all fire E2 now.\n A0 (4.0s): Firing E2 (18hp left); then E1.\n A1 (4.0s): Keep firing E2 (18hp), then E1.\n A2 (4.0s): Keep firing E2, it's at 18 HP. Then focus E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E2 down. Focus E1 (closest, 3.5 away), then E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-7535371ab934d2a4e089f7cc.json b/examples/multi-agent-smax/results/llm-cache/ask-7535371ab934d2a4e089f7cc.json new file mode 100644 index 00000000..05cfe630 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-7535371ab934d2a4e089f7cc.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 0.5 seconds into the battle.\nYou are A0, a marine at (9.1, 15.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 16.8.\nYour team:\n A1 marine at (8.7, 17.2), 45/45 health, order: move 11 17\n A2 marine at (9.2, 17.8), 45/45 health, order: move 14 17\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Moving east together to find enemies; stay within 2 of each other, attack together.\n A1 (0.0s): Moving east together to find enemies; stay within 2 of each other, fire together.\n A2 (0.0s): Moving east together to find enemies; stay close, attack same target when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 17\", \"say\": \"Moving east in formation; will attack same target once all in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-7582da67e6f22ae6afe6ec16.json b/examples/multi-agent-smax/results/llm-cache/ask-7582da67e6f22ae6afe6ec16.json new file mode 100644 index 00000000..6da2feb8 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-7582da67e6f22ae6afe6ec16.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.5 seconds into the battle.\nYou are A1, a marine at (6.5, 16.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.2, 15.7), 36/45 health, order: attack E2\n A2 marine at (7.1, 16.5), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (10.7, 17.7), 45/45 health, 4.6 away (in range)\n E1 marine at (11.6, 16.0), 45/45 health, 5.1 away\n E2 marine at (11.8, 14.7), 36/45 health, 5.5 away\nTeam chat (most recent last):\n A1 (3.0s): A1 holding; E2 seen east at 8.6. Let them come into range, focus closest.\n A2 (3.0s): A2 holding; enemies at 8 range, let them come in, focus closest.\n A0 (3.5s): Holding; E2 closest at 6.2. Focus E2 when in range.\n A1 (3.5s): A1 holding; fire on closest enemy once in range, E2 first.\n A2 (3.5s): A2 holding; enemies closing, fire on closest E2 when in range.\n A0 (4.0s): E2 in range at 4.7; all focus fire E2 now.\n A1 (4.0s): Holding; E2 closest at 5.5, focus E2 once in range.\n A2 (4.0s): Holding. E2 at 5.1, about to enter range. Focus E2 together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 in range at 4.6, I'm firing on E0. Focus E0 if in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-7595356dc49509583015a602.json b/examples/multi-agent-smax/results/llm-cache/ask-7595356dc49509583015a602.json new file mode 100644 index 00000000..7dd21a23 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-7595356dc49509583015a602.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.0 seconds into the battle.\nYou are A2, a marine at (10.7, 16.8) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (9.9, 17.0), 45/45 health, order: attack E1\n A1: dead\nEnemies you can see:\n E0 marine at (14.6, 17.8), 45/45 health, 4.0 away (in range)\n E1 marine at (13.7, 14.5), 36/45 health, 3.8 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A2 (3.0s): Attacking E2 (36hp) with A1; A0 join, focus E2 first.\n A0 (3.5s): Attacking E2 (27hp), closing in to focus fire with A2.\n A1 (3.5s): E2 at 27hp, keep focusing it. A0 attack E2 too.\n A2 (3.5s): Firing E2 (27hp), A0 step up and focus E2. A1 stay back.\n A0 (4.0s): E2 at 18hp, in range. Finish it now, then E1.\n A2 (4.0s): E2 at 18hp, finish it now. A0 keep firing.\n A0 (4.5s): E2 is down. Focus E1 (closest, 45hp), then E0.\n A2 (4.5s): E2 down. Focus E1 (closest, 3.8 away), then E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Focus E1 (36hp), I'm low at 18hp. A0 keep firing, then E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-75c8703853d80112036ad7f9.json b/examples/multi-agent-smax/results/llm-cache/ask-75c8703853d80112036ad7f9.json new file mode 100644 index 00000000..5aec62dd --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-75c8703853d80112036ad7f9.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.0 seconds into the battle.\nYou are A2, a marine at (10.8, 14.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (10.6, 16.0), 45/45 health, order: attack E0\n A1 marine at (8.9, 14.1), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (12.4, 16.4), 45/45 health, 2.3 away (in range)\n E1 marine at (13.1, 16.8), 45/45 health, 3.0 away (in range)\n E2 marine at (13.1, 15.5), 45/45 health, 2.3 away (in range)\nTeam chat (most recent last):\n A1 (2.5s): Enemies E0, E2 east ~9 away. Holding grouped; focus E0 when in range.\n A2 (2.5s): Advancing east to join A0/A1; stay grouped, focus closest enemy.\n A0 (3.0s): Holding at (9,16). Let them come into range, then all focus the closest enemy.\n A1 (3.0s): Holding grouped. Enemies ~7 away; let them come into range, focus E0.\n A2 (3.0s): Holding at range; all focus E0 when it enters 5 range.\n A0 (3.5s): E0 at 5 range. All focus E0 now.\n A1 (3.5s): Holding. Focus E0 when in range; stay grouped.\n A2 (3.5s): E0 at range 5. Everyone attack E0 now, focus fire.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"All attack E0 now, in range. A1 switch from hold to attack E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-76998f3c577fdb50b5c473ae.json b/examples/multi-agent-smax/results/llm-cache/ask-76998f3c577fdb50b5c473ae.json new file mode 100644 index 00000000..3317a57a --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-76998f3c577fdb50b5c473ae.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 4.5 seconds into the battle.\nYou are A2, a marine at (14.1, 16.4) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (13.6, 17.1), 18/45 health, order: attack E2\n A1 marine at (13.2, 15.3), 27/45 health, order: attack E2\nEnemies you can see:\n E2 marine at (17.5, 17.3), 27/45 health, 3.5 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (3.0s): E0 dead. Everyone focus E1 now, same tick; then E2.\n A2 (3.0s): E0 dead. Everyone focus E1 now, then E2.\n A0 (3.5s): Focusing E1 (18hp), same target; then E2.\n A1 (3.5s): Attacking E1 (18hp), all keep firing; then E2.\n A2 (3.5s): Attacking E1 (18hp) now, then E2.\n A0 (4.0s): E1 dead. All focus E2 now, no retreating.\n A1 (4.0s): E1 down. All focus E2 now, same target, no retreating.\n A2 (4.0s): E1 dead. All attack E2 now, same target, keep firing.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Keep firing on E2, last enemy, no retreating.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-76f5da1753d0a7b987692f43.json b/examples/multi-agent-smax/results/llm-cache/ask-76f5da1753d0a7b987692f43.json new file mode 100644 index 00000000..722a8136 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-76f5da1753d0a7b987692f43.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 4.0 seconds into the battle.\nYou are A0, a marine at (12.8, 15.9) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1 marine at (13.0, 15.0), 18/45 health, order: attack E1\n A2 marine at (13.0, 14.3), 27/45 health, order: attack E1\nEnemies you can see:\n E0 marine at (17.3, 15.0), 45/45 health, 4.6 away (in range)\n E1 marine at (16.6, 14.0), 18/45 health, 4.3 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (2.5s): Firing on E2 (18hp), keep attacking until it dies.\n A2 (2.5s): Attacking E2, it's at 18hp; finish it together.\n A0 (3.0s): E2 dead. Everyone focus E1, closest to all of us.\n A1 (3.0s): E2 dead. Focus E1 (closest, 3.8 away), all attack E1 together.\n A2 (3.0s): E2 is dead. Focus E1 (closest, 3.6 away), all together.\n A0 (3.5s): Attacking E1 (36hp), keep focusing until it dies.\n A1 (3.5s): Attacking E1 (36hp), keep focus until it dies.\n A2 (3.5s): Keep firing on E1, 36hp left. All together until it dies.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E1 at 18hp, keep focusing it until it dies, then E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-7741477518758f7e7fa2b5ec.json b/examples/multi-agent-smax/results/llm-cache/ask-7741477518758f7e7fa2b5ec.json new file mode 100644 index 00000000..8161341d --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-7741477518758f7e7fa2b5ec.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 7.0 seconds into the battle.\nYou are A1, a marine at (9.8, 14.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E2 marine at (10.8, 17.5), 45/45 health, 3.5 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A2 (4.5s): A2 9hp. E0 at 18hp, A0 and I finish it now, then E1.\n A0 (5.0s): E0 is dead. A0 and A1 focus E1 (27hp), then E2.\n A1 (5.0s): A1 on E1 (27hp), in range. A0 join E1, then E2.\n A0 (5.5s): A0 18hp on E1 (18hp), finishing it. Then both on E2.\n A1 (5.5s): A1 on E1 (18hp), in range. A0 keep firing, then both E2.\n A0 (6.0s): A0 9hp, finishing E1 (9hp). Then both E2.\n A1 (6.0s): A1 on E1 (9hp), finishing it. Then both on E2.\n A1 (6.5s): A1 alone vs E2 (45hp), engaging.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"A1 last unit, fighting E2 (45hp) alone.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-7787bcad13505c69a74a3394.json b/examples/multi-agent-smax/results/llm-cache/ask-7787bcad13505c69a74a3394.json new file mode 100644 index 00000000..ab43dad0 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-7787bcad13505c69a74a3394.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.5 seconds into the battle.\nYou are A1, a marine at (7.8, 14.9) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (6.9, 16.7), 45/45 health, order: attack E0\n A2 marine at (7.6, 17.8), 36/45 health, order: attack E0\nEnemies you can see:\n E1 marine at (12.3, 15.6), 45/45 health, 4.5 away (in range)\n E2 marine at (11.9, 17.7), 45/45 health, 5.0 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (3.0s): A1 holding; E0 at 5.1, focus E0 when in range, stay tight.\n A2 (3.0s): A2 holding; E0 closest at 5.8, focus E0 together when in range.\n A0 (3.5s): A0 attacking E0 now, everyone focus E0.\n A1 (3.5s): A1 attacking E0 now, everyone focus E0.\n A2 (3.5s): A2 attacking E0 now, everyone focus E0 together.\n A0 (4.0s): A0 firing E0 (18hp left), finish it then switch to E2.\n A1 (4.0s): E0 at 18 hp, keep focusing E0 then E1.\n A2 (4.0s): A2 firing on E0, 18 hp left, finish it then E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E0 dead. A1 on E1 at 4.5, focus E1 together; A2 close in.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-77c97096198b6cb88edb52f3.json b/examples/multi-agent-smax/results/llm-cache/ask-77c97096198b6cb88edb52f3.json new file mode 100644 index 00000000..c5103b9b --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-77c97096198b6cb88edb52f3.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.5 seconds into the battle.\nYou are A2, a marine at (10.7, 16.8) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (9.9, 17.0), 45/45 health, order: attack E2\n A1: dead\nEnemies you can see:\n E0 marine at (14.6, 17.8), 45/45 health, 4.0 away (in range)\n E1 marine at (13.7, 14.5), 45/45 health, 3.8 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (3.0s): Holding at x=9; focus E2 (36hp) first once any enemy enters range 5.\n A1 (3.0s): Firing on E2 (36hp, in range). A0, A2 step up and focus E2.\n A2 (3.0s): Attacking E2 (36hp) with A1; A0 join, focus E2 first.\n A0 (3.5s): Attacking E2 (27hp), closing in to focus fire with A2.\n A1 (3.5s): E2 at 27hp, keep focusing it. A0 attack E2 too.\n A2 (3.5s): Firing E2 (27hp), A0 step up and focus E2. A1 stay back.\n A0 (4.0s): E2 at 18hp, in range. Finish it now, then E1.\n A2 (4.0s): E2 at 18hp, finish it now. A0 keep firing.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E2 down. Focus E1 (closest, 3.8 away), then E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-77ca415ff14836df263a680e.json b/examples/multi-agent-smax/results/llm-cache/ask-77ca415ff14836df263a680e.json new file mode 100644 index 00000000..d494dcf0 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-77ca415ff14836df263a680e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.0 seconds into the battle.\nYou are A2, a marine at (8.0, 16.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (8.7, 16.9), 36/45 health, order: attack E0\n A1 marine at (8.5, 15.3), 27/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (13.0, 15.1), 9/45 health, 5.3 away\n E1 marine at (12.9, 16.5), 45/45 health, 4.9 away (in range)\n E2 marine at (12.8, 17.3), 45/45 health, 4.9 away (in range)\nTeam chat (most recent last):\n A1 (2.5s): Holding grouped; let them walk into range, then focus E0.\n A2 (2.5s): A2 holding grouped; focus E0 when it enters range.\n A0 (3.0s): E0 in range, all attack E0 now.\n A1 (3.0s): E0 in range at 4.5, all focus fire E0 now.\n A2 (3.0s): A2 holding; focus E0 when in range.\n A0 (3.5s): A0 focusing E0 (27hp). A2 attack E0 too, don't hold.\n A1 (3.5s): A1 focusing E0 (27hp), in range. A2 please attack E0 too.\n A2 (3.5s): A2 attacking E0, closing in to focus fire.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"A2 closing on E0 (9hp), then focus E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-77fc1b092d613ac385184490.json b/examples/multi-agent-smax/results/llm-cache/ask-77fc1b092d613ac385184490.json new file mode 100644 index 00000000..51f2edce --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-77fc1b092d613ac385184490.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 5.5 seconds into the battle.\nYou are A1, a marine at (15.1, 13.7) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E1 marine at (18.0, 17.0), 27/45 health, 4.3 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (3.5s): E0 down. Everyone focus E2 (closest), then E1.\n A2 (3.5s): E0 down. Everyone focus E2 (3.0 away), then E1.\n A0 (4.0s): E2 at 18hp, keep focusing E2 then E1.\n A1 (4.0s): E2 at 18hp, keep focusing E2 then E1. Nobody retreat.\n A0 (4.5s): E2 at 9hp, finish it now, then E1. I'm low but still firing.\n A1 (4.5s): E2 at 9hp, finishing it. Then E1. A0 stay in, no retreat.\n A0 (5.0s): E2 dead. Focus E1 now, 4.2 away, both fire together.\n A1 (5.0s): E2 dead. All focus E1 now, 4.3 away. A0 keep firing.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A1 alone now, attacking E1 (27hp). Keep firing.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-785f4c6b79b779ee1df9394c.json b/examples/multi-agent-smax/results/llm-cache/ask-785f4c6b79b779ee1df9394c.json new file mode 100644 index 00000000..58adc53f --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-785f4c6b79b779ee1df9394c.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 4.5 seconds into the battle.\nYou are A0, a marine at (14.3, 16.0) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1: dead\n A2 marine at (12.8, 14.9), 27/45 health, order: attack E2\nEnemies you can see:\n E1 marine at (16.5, 16.2), 45/45 health, 2.3 away (in range)\n E2 marine at (17.6, 14.3), 9/45 health, 3.8 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (2.5s): Focus E0, it's at 18hp. Keep firing until it dies.\n A2 (2.5s): A2 attacking E0 now; focus it down, then E2.\n A0 (3.0s): E0 is dead. Both attack E2 together, closest enemy; stay level with me.\n A2 (3.0s): E0 is dead. Everyone attack E2, it's in range.\n A0 (3.5s): Both on E2 together, then E1. Keep firing, no retreat.\n A2 (3.5s): Attacking E2 together; keep firing until it dies.\n A0 (4.0s): Keep firing on E2, then E1. No retreat.\n A2 (4.0s): Keep firing on E2 until dead, then E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 at 9hp, keep firing together, then E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-788a8c2725ab1e5a416d7b57.json b/examples/multi-agent-smax/results/llm-cache/ask-788a8c2725ab1e5a416d7b57.json new file mode 100644 index 00000000..33793ca3 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-788a8c2725ab1e5a416d7b57.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 0.0 seconds into the battle.\nYou are A1, a marine at (8.1, 17.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.0, 15.6), 45/45 health, order: hold\n A2 marine at (7.4, 16.7), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 17\", \"say\": \"Moving east together toward center, stay within 2 of each other.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-78dcb2c82acab9250bfa08fe.json b/examples/multi-agent-smax/results/llm-cache/ask-78dcb2c82acab9250bfa08fe.json new file mode 100644 index 00000000..dace0933 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-78dcb2c82acab9250bfa08fe.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.5 seconds into the battle.\nYou are A2, a marine at (6.5, 16.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.6, 16.9), 45/45 health, order: hold\n A1 marine at (8.5, 15.3), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together as a group; focus fire on the closest enemy once seen.\n A0 (0.5s): No enemies yet. Holding; focus the closest when they appear.\n A1 (0.5s): A1 holding; will focus fire on the closest enemy that appears.\n A2 (0.5s): No enemies yet; staying grouped, will focus the closest one when seen.\n A0 (1.0s): Still no enemies; holding grouped, focus closest when seen.\n A1 (1.0s): A1 holding; no enemies yet, will focus the closest when seen.\n A2 (1.0s): A2 holding; will focus the closest enemy when it appears.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A2 holding; will focus fire on the closest enemy when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-790f82709437e5a4095ef4ba.json b/examples/multi-agent-smax/results/llm-cache/ask-790f82709437e5a4095ef4ba.json new file mode 100644 index 00000000..52cc7744 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-790f82709437e5a4095ef4ba.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 0.5 seconds into the battle.\nYou are A2, a marine at (8.1, 16.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 16.\nYour team:\n A0 marine at (10.2, 16.9), 45/45 health, order: move 14 16\n A1 marine at (10.1, 15.3), 45/45 health, order: move 14 16\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Moving east together toward center, stay within 2 of each other; attack same target when seen.\n A1 (0.0s): No enemies seen. Moving east together to (14,16); stay within 2 of each other.\n A2 (0.0s): Moving east together to find enemies; stay within 2 of each other.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 16\", \"say\": \"Moving to (14,16) with A0 and A1, staying close; will focus the first enemy seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-7964da6d7dbcfd546e6edeb0.json b/examples/multi-agent-smax/results/llm-cache/ask-7964da6d7dbcfd546e6edeb0.json new file mode 100644 index 00000000..6dc0e328 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-7964da6d7dbcfd546e6edeb0.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 8.5 seconds into the battle.\nYou are A0, a marine at (8.1, 15.8) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1 marine at (6.8, 14.1), 9/45 health, order: attack E0\n A2: dead\nEnemies you can see:\n E0 marine at (12.9, 15.0), 9/45 health, 4.8 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (7.0s): E1 down. All focus E0 now, A1 join in.\n A1 (7.0s): A1 9hp holding; will shoot anything that closes in. Finish E1, then E0.\n A2 (7.0s): E1 down. All focus E0; I'm closest and tanking, A0 and A1 fire.\n A0 (7.5s): A0 firing E0 (27hp). A1 close in and shoot, all focus fire.\n A1 (7.5s): A1 joining on E0, A2 stays closest and tanks.\n A2 (7.5s): E0 at 27hp, 4.8 away. A0, A1 fire now; focus E0.\n A0 (8.0s): A0 firing E0 (18hp), 4.8 away. A1 fire too, finish it.\n A1 (8.0s): A1 closing on E0 (18hp). A0, focus fire to finish it.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"A0 firing E0 (9hp), in range. A1 fire too, finish it.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-7a4b75ab04a05fa8125d4cc2.json b/examples/multi-agent-smax/results/llm-cache/ask-7a4b75ab04a05fa8125d4cc2.json new file mode 100644 index 00000000..8c7c070c --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-7a4b75ab04a05fa8125d4cc2.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 6.0 seconds into the battle.\nYou are A1, a marine at (8.3, 14.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (8.4, 15.6), 18/45 health, order: attack E1\n A2: dead\nEnemies you can see:\n E1 marine at (12.2, 16.1), 45/45 health, 4.4 away (in range)\n E2 marine at (12.3, 17.4), 45/45 health, 5.2 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A2 (4.0s): Engaged, all 3 enemies on me. A0 A1 attack E0 now, focus fire.\n A0 (4.5s): Focus E0 (27hp). A2 at 9hp, retreat to draw fire away if possible.\n A1 (4.5s): A1 focusing E0 (27hp). A2 retreat, you're at 9hp.\n A2 (4.5s): A2 at 9hp retreating. A0 A1 keep focus on E0, it has 27hp.\n A0 (5.0s): E0 at 9hp, finishing it now. A1 focus E0.\n A1 (5.0s): A1 firing on E0 (9hp), finish it then focus E1.\n A0 (5.5s): E0 dead. Both focus E1 now, then E2.\n A1 (5.5s): E0 down. Focus E1 (4.4 away, in range) now, both of us.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A1 attacking E1 (45hp). A0 at 18hp, retreat if under 20 to shed aggro.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-7a8d21fe082378e6b2908fb0.json b/examples/multi-agent-smax/results/llm-cache/ask-7a8d21fe082378e6b2908fb0.json new file mode 100644 index 00000000..05d81772 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-7a8d21fe082378e6b2908fb0.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 3.0 seconds into the battle.\nYou are A1, a marine at (15.1, 13.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (14.6, 14.4), 27/45 health, order: attack E0\n A2 marine at (14.8, 15.1), 27/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (18.6, 16.2), 9/45 health, 4.3 away (in range)\n E1 marine at (18.0, 17.0), 45/45 health, 4.3 away (in range)\n E2 marine at (17.8, 15.5), 45/45 health, 3.2 away (in range)\nTeam chat (most recent last):\n A1 (1.5s): Moving to 14,15 with A0 and A2; will focus same target at range 5.\n A2 (1.5s): Enemies 8 away; keep moving together, then all attack E0 at range 5.\n A0 (2.0s): Attacking E0 now. A1, A2, step in and focus E0 immediately.\n A1 (2.0s): Closing on E0 together; once all within 5, everyone attacks E0 same tick.\n A2 (2.0s): Attacking E0 now; A0 is already in range, A1 close up and focus E0.\n A0 (2.5s): Focusing E0; A1 attack E0 now, all in range.\n A1 (2.5s): In range of all; attacking E0 now.\n A2 (2.5s): Focusing E0 (36hp). A1 attack E0 now, all in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Attacking E0 (9hp), finish it then focus E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-7aa5c02fbfb7177d96d07e06.json b/examples/multi-agent-smax/results/llm-cache/ask-7aa5c02fbfb7177d96d07e06.json new file mode 100644 index 00000000..77b98152 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-7aa5c02fbfb7177d96d07e06.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.0 seconds into the battle.\nYou are A2, a marine at (6.5, 16.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.6, 16.9), 45/45 health, order: hold\n A1 marine at (8.5, 15.3), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (13.0, 15.1), 45/45 health, 6.7 away\n E1 marine at (14.6, 16.7), 45/45 health, 8.1 away\nTeam chat (most recent last):\n A1 (1.5s): A1 holding; no enemies yet, focus closest when seen.\n A2 (1.5s): A2 holding; will focus fire on the closest enemy when seen.\n A0 (2.0s): E0 spotted at distance 7.8. Holding grouped; focus E0 when in range.\n A1 (2.0s): E0 east at 7.7 away. Holding grouped; focus E0 when in range.\n A2 (2.0s): A2 holding; will focus the closest enemy when it appears.\n A0 (2.5s): Holding grouped; let them walk into range, then all focus E0.\n A1 (2.5s): Holding grouped; let them walk into range, then focus E0.\n A2 (2.5s): A2 holding grouped; focus E0 when it enters range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A2 holding; focus E0 when in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-7abc348a9966daae7ce7265f.json b/examples/multi-agent-smax/results/llm-cache/ask-7abc348a9966daae7ce7265f.json new file mode 100644 index 00000000..60e7df7b --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-7abc348a9966daae7ce7265f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.5 seconds into the battle.\nYou are A2, a marine at (7.6, 17.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.5, 15.8), 45/45 health, order: hold\n A1 marine at (7.2, 17.2), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (14.3, 17.1), 45/45 health, 6.7 away\n E1 marine at (13.1, 17.1), 45/45 health, 5.6 away\n E2 marine at (11.0, 16.7), 45/45 health, 3.6 away (in range)\nTeam chat (most recent last):\n A1 (2.0s): E2 spotted east at 8.6 range. Holding grouped; focus E2 when in range.\n A2 (2.0s): E2 spotted at (15.8,16.7), 8 away. Holding grouped; focus E2 when in range.\n A0 (2.5s): E1, E2 approaching. Holding grouped; focus E2 when within 5.\n A1 (2.5s): E2 at 7 range. Holding grouped; focus E2 once in range.\n A2 (2.5s): E2 at 6.7, E1 behind. Holding grouped; focus closest when in range.\n A0 (3.0s): A0 holding; E2 at 5.2, focus E2 the moment it enters range.\n A1 (3.0s): E2 at 5.5, nearly in range. Holding; all focus E2 when it enters 5.\n A2 (3.0s): E2 at 5.1, nearly in range. Holding, all fire on E2 first.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 in range at 3.6, all fire E2 now.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-7adc22b710cb3466174e1127.json b/examples/multi-agent-smax/results/llm-cache/ask-7adc22b710cb3466174e1127.json new file mode 100644 index 00000000..baa1e012 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-7adc22b710cb3466174e1127.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 4.5 seconds into the battle.\nYou are A2, a marine at (8.3, 17.3) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (8.4, 15.6), 45/45 health, order: attack E0\n A1 marine at (8.3, 14.2), 45/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (11.9, 16.8), 27/45 health, 3.6 away (in range)\n E1 marine at (12.2, 16.1), 45/45 health, 4.0 away (in range)\n E2 marine at (12.3, 17.4), 45/45 health, 4.0 away (in range)\nTeam chat (most recent last):\n A1 (3.0s): A1 holding. E0 at 7.4; attack E0 together once within 5 of all.\n A2 (3.0s): A2 holding. E0 at 5.3 from me, 6.8+ from A0/A1. Wait for range 5.\n A0 (3.5s): A0 holding. E0 5.3 away; attack E0 together once within 5 of all.\n A1 (3.5s): A1 holding. E0 at 6.0; attack E0 together once within 5 of all.\n A2 (3.5s): E0 in range of me, firing now. A0/A1 close in and focus E0.\n A0 (4.0s): A2 engaged, A0 attacking E0 now. A1 attack E0 too, focus fire.\n A1 (4.0s): A2 is engaged; A1 attacking E0 now. A0 join and focus E0.\n A2 (4.0s): Engaged, all 3 enemies on me. A0 A1 attack E0 now, focus fire.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"retreat\", \"say\": \"A2 at 9hp retreating. A0 A1 keep focus on E0, it has 27hp.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-7afe6750dbc8e3489bbf3af9.json b/examples/multi-agent-smax/results/llm-cache/ask-7afe6750dbc8e3489bbf3af9.json new file mode 100644 index 00000000..4a148946 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-7afe6750dbc8e3489bbf3af9.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.5 seconds into the battle.\nYou are A0, a marine at (10.6, 16.0) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1 marine at (8.9, 14.1), 45/45 health, order: attack E2\n A2 marine at (10.8, 14.8), 18/45 health, order: attack E2\nEnemies you can see:\n E1 marine at (13.1, 16.8), 45/45 health, 2.6 away (in range)\n E2 marine at (13.1, 15.5), 18/45 health, 2.5 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (4.0s): Attacking E0 now, focus fire.\n A2 (4.0s): All attack E0 now, in range. A1 switch from hold to attack E0.\n A0 (4.5s): E0 at 18 hp, keep focus firing E0 then E2.\n A1 (4.5s): Firing on E0, 18 hp left. Next target E2 (closest).\n A2 (4.5s): E0 at 18 hp, keep firing. Then focus E2.\n A0 (5.0s): E0 dead. Focus E2 (closest), then E1. Stay grouped.\n A1 (5.0s): E0 is dead. Focus fire E2, closest at 4.4.\n A2 (5.0s): E0 down. Focus E2 (closest), then E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 at 18hp, all fire E2 now, then E1. I'm at 9hp.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-7b3803d28ab5d03b9f2a3c4e.json b/examples/multi-agent-smax/results/llm-cache/ask-7b3803d28ab5d03b9f2a3c4e.json new file mode 100644 index 00000000..f7f764d9 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-7b3803d28ab5d03b9f2a3c4e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.5 seconds into the battle.\nYou are A1, a marine at (9.8, 15.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.2, 16.2), 45/45 health, order: hold\n A2 marine at (9.0, 16.2), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together as a group; focus fire on the closest enemy when they appear.\n A0 (0.5s): No enemies yet; staying grouped, will focus the closest enemy when seen.\n A1 (0.5s): Holding position; will focus fire on closest enemy once visible.\n A2 (0.5s): Holding. Will focus fire on the closest enemy once visible.\n A0 (1.0s): Still no enemies; holding grouped, focus closest when seen.\n A1 (1.0s): Still no enemies; holding grouped, will focus closest when seen.\n A2 (1.0s): Still no enemies. Holding; will focus the closest enemy when seen.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding grouped; focus fire on closest enemy when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-7b395a4a4a922f23f313fb3d.json b/examples/multi-agent-smax/results/llm-cache/ask-7b395a4a4a922f23f313fb3d.json new file mode 100644 index 00000000..9d256719 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-7b395a4a4a922f23f313fb3d.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 6.0 seconds into the battle.\nYou are A1, a marine at (13.5, 17.2) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E0 marine at (18.0, 17.1), 36/45 health, 4.6 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (3.5s): Focusing E1 now; A2 at 9hp, retreat only after E1 dies.\n A2 (3.5s): Focusing E1 with you. I'm at 9hp, will keep firing until it dies.\n A0 (4.0s): Keep firing E1 (18hp), then E0 together.\n A1 (4.0s): Firing on E1 (18hp), then E0 together.\n A0 (4.5s): E1 down. Focus E0 now, both fire together.\n A1 (4.5s): E1 dead. Focus E0 (4.6 away), A0 keep firing, I'm full health.\n A1 (5.0s): Firing on E0, last enemy. I'm at full health.\n A1 (5.5s): Last enemy E0 at 36hp; I'm the only one left, firing.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Last enemy E0 at 36hp, in range, firing.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-7b583cd35e9254e8182870f5.json b/examples/multi-agent-smax/results/llm-cache/ask-7b583cd35e9254e8182870f5.json new file mode 100644 index 00000000..798e1e82 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-7b583cd35e9254e8182870f5.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 0.5 seconds into the battle.\nYou are A1, a marine at (10.2, 17.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 17.\nYour team:\n A0 marine at (10.1, 18.0), 45/45 health, order: move 12 17\n A2 marine at (10.0, 16.0), 45/45 health, order: move 12 16\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Moving east together, stay within 2 of each other; no one engage alone.\n A1 (0.0s): Moving east together toward enemies; keep within 2 of each other, attack together.\n A2 (0.0s): Moving east together toward enemies, stay within 2 of each other; attack same target on call.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 17\", \"say\": \"Moving east in formation at x=12; no one engages alone.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-7bb3624da32b57be0d0f4f76.json b/examples/multi-agent-smax/results/llm-cache/ask-7bb3624da32b57be0d0f4f76.json new file mode 100644 index 00000000..1d4474bd --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-7bb3624da32b57be0d0f4f76.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 4.0 seconds into the battle.\nYou are A0, a marine at (13.8, 15.8) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1 marine at (13.5, 17.2), 45/45 health, order: attack E1\n A2: dead\nEnemies you can see:\n E0 marine at (18.0, 17.1), 45/45 health, 4.4 away (in range)\n E1 marine at (17.3, 17.0), 18/45 health, 3.6 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (2.5s): Focusing E2, it's at 18hp. Keep firing, then switch to E1 together.\n A2 (2.5s): E2 at 18hp, keep firing on E2, then switch to E1.\n A0 (3.0s): E2 is dead. Everyone focus E1 now (3.6 away), then E0.\n A1 (3.0s): E2 down. Everyone focus E1 now (3.8 away), then E0.\n A2 (3.0s): E2 dead. All focus E1 (closest, 3.5 away) now.\n A0 (3.5s): Focus E1 together, then E0. A2 stay on target per rules.\n A1 (3.5s): Focusing E1 now; A2 at 9hp, retreat only after E1 dies.\n A2 (3.5s): Focusing E1 with you. I'm at 9hp, will keep firing until it dies.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Keep firing E1 (18hp), then E0 together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-7bdcf0444ac31441ad03d1ca.json b/examples/multi-agent-smax/results/llm-cache/ask-7bdcf0444ac31441ad03d1ca.json new file mode 100644 index 00000000..4aa114f2 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-7bdcf0444ac31441ad03d1ca.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 4.0 seconds into the battle.\nYou are A1, a marine at (13.2, 15.3) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (13.6, 17.1), 18/45 health, order: attack E1\n A2 marine at (14.1, 16.4), 27/45 health, order: attack E1\nEnemies you can see:\n E2 marine at (17.5, 17.3), 45/45 health, 4.8 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (2.5s): E0 at 9hp, finishing it now; then everyone focus E1.\n A2 (2.5s): E0 at 9hp in range, firing on E0 now.\n A0 (3.0s): E0 dead. Everyone focus E1 now, same target, no retreating.\n A1 (3.0s): E0 dead. Everyone focus E1 now, same tick; then E2.\n A2 (3.0s): E0 dead. Everyone focus E1 now, then E2.\n A0 (3.5s): Focusing E1 (18hp), same target; then E2.\n A1 (3.5s): Attacking E1 (18hp), all keep firing; then E2.\n A2 (3.5s): Attacking E1 (18hp) now, then E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E1 down. All focus E2 now, same target, no retreating.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-7c18d125ebe58db42b53a924.json b/examples/multi-agent-smax/results/llm-cache/ask-7c18d125ebe58db42b53a924.json new file mode 100644 index 00000000..e0fa2172 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-7c18d125ebe58db42b53a924.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 9.0 seconds into the battle.\nYou are A0, a marine at (3.6, 17.0) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: retreat.\nYour team:\n A1: dead\n A2: dead\nEnemies you can see:\n E0 marine at (9.8, 17.8), 45/45 health, 6.3 away\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A2 (5.0s): Focus E1 (36hp), I'm low at 18hp. A0 keep firing, then E0.\n A0 (5.5s): A0 on E1 (18hp), almost dead. Then E0.\n A0 (6.0s): Finishing E1 (18hp), then E0. A2 stay back.\n A0 (6.5s): E1 at 9hp, finishing it now, then E0. A0 at 27hp.\n A0 (7.0s): E1 down. A0 at 9hp, E0 at 45hp left. Pulling out of range.\n A0 (7.5s): A0 at 9hp, last one alive. Kiting away from E0.\n A0 (8.0s): A0 last alive, 9hp, kiting E0 out of its range.\n A0 (8.5s): A0 last alive, 9hp, still kiting E0 away from its range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 2 30\", \"say\": \"A0 last alive, 9hp, running north along the wall to stay out of E0 range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-7cd5dd892a62eb960d7130fe.json b/examples/multi-agent-smax/results/llm-cache/ask-7cd5dd892a62eb960d7130fe.json new file mode 100644 index 00000000..04763825 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-7cd5dd892a62eb960d7130fe.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.5 seconds into the battle.\nYou are A1, a marine at (8.5, 15.3) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.6, 16.9), 45/45 health, order: hold\n A2 marine at (6.5, 16.6), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (14.6, 15.1), 45/45 health, 6.1 away\n E1 marine at (16.2, 16.7), 45/45 health, 7.8 away\nTeam chat (most recent last):\n A1 (1.0s): A1 holding; no enemies yet, will focus the closest when seen.\n A2 (1.0s): A2 holding; will focus the closest enemy when it appears.\n A0 (1.5s): A0 holding; still no enemies. Focus the closest when they appear.\n A1 (1.5s): A1 holding; no enemies yet, focus closest when seen.\n A2 (1.5s): A2 holding; will focus fire on the closest enemy when seen.\n A0 (2.0s): E0 spotted at distance 7.8. Holding grouped; focus E0 when in range.\n A1 (2.0s): E0 east at 7.7 away. Holding grouped; focus E0 when in range.\n A2 (2.0s): A2 holding; will focus the closest enemy when it appears.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding grouped; let them walk into range, then focus E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-7cdbf2c6f6747776f3c60b02.json b/examples/multi-agent-smax/results/llm-cache/ask-7cdbf2c6f6747776f3c60b02.json new file mode 100644 index 00000000..edcbe7b1 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-7cdbf2c6f6747776f3c60b02.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 0.0 seconds into the battle.\nYou are A0, a marine at (8.6, 16.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (8.5, 15.3), 45/45 health, order: hold\n A2 marine at (6.5, 16.6), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 16\", \"say\": \"Moving east together toward center, stay within 2 of each other; attack same target when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-7cf5ffc87559403bf993554d.json b/examples/multi-agent-smax/results/llm-cache/ask-7cf5ffc87559403bf993554d.json new file mode 100644 index 00000000..0a677f52 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-7cf5ffc87559403bf993554d.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.5 seconds into the battle.\nYou are A0, a marine at (8.5, 16.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1 marine at (7.8, 14.9), 9/45 health, order: attack E2\n A2 marine at (7.6, 17.8), 27/45 health, order: attack E2\nEnemies you can see:\n E1 marine at (12.3, 15.6), 36/45 health, 3.9 away (in range)\n E2 marine at (11.9, 17.7), 27/45 health, 3.5 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (4.0s): E0 at 18 hp, keep focusing E0 then E1.\n A2 (4.0s): A2 firing on E0, 18 hp left, finish it then E2.\n A0 (4.5s): E0 dead. Focus E2 together, then E1. A1 stay back, you're low.\n A1 (4.5s): E0 dead. A1 on E1 at 4.5, focus E1 together; A2 close in.\n A2 (4.5s): E0 is down; all focus E2 (in range, closest), then E1.\n A0 (5.0s): A0 on E2 (full hp). A1 stay back, low. A2 keep firing E2.\n A1 (5.0s): A1 low, shooting E2 from back. A0 you're tanking, focus E2.\n A2 (5.0s): A2 on E2, in range. A0 and A2 focus E2; A1 stay back.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"A0 on E2 (27hp). Keep firing E2, then E1. A1 stay back.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-7d425ce907b2f72acc2bb33c.json b/examples/multi-agent-smax/results/llm-cache/ask-7d425ce907b2f72acc2bb33c.json new file mode 100644 index 00000000..651e1726 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-7d425ce907b2f72acc2bb33c.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 1.0 seconds into the battle.\nYou are A1, a marine at (11.8, 17.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 17.\nYour team:\n A0 marine at (11.7, 18.0), 45/45 health, order: move 12 17\n A2 marine at (11.6, 16.0), 45/45 health, order: move 12 17\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Moving east together, stay within 2 of each other; no one engage alone.\n A1 (0.0s): Moving east together toward enemies; keep within 2 of each other, attack together.\n A2 (0.0s): Moving east together toward enemies, stay within 2 of each other; attack same target on call.\n A0 (0.5s): Moving east together, keeping formation; will attack same target when all in range.\n A1 (0.5s): Moving east in formation at x=12; no one engages alone.\n A2 (0.5s): Moving east, staying close; A0 at 12,17 is my anchor point.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 17\", \"say\": \"Advancing east to 14,17 together; no one engages until all in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-7d497034b50d44f0828382d0.json b/examples/multi-agent-smax/results/llm-cache/ask-7d497034b50d44f0828382d0.json new file mode 100644 index 00000000..3e8ca7ff --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-7d497034b50d44f0828382d0.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 1.0 seconds into the battle.\nYou are A2, a marine at (8.3, 17.3) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.9, 15.6), 45/45 health, order: hold\n A1 marine at (6.7, 14.2), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding per rules until enemy within 5 of all; then focus same target.\n A1 (0.0s): A1 holding. No enemies seen; wait until all in range 5, then focus same target.\n A2 (0.0s): A2 holding. Will attack together once enemy is within 5 of all of us.\n A0 (0.5s): A0 holding. No enemies yet; will focus the same target once all in range.\n A1 (0.5s): A1 holding; no enemies visible yet. Will focus same target once all in range.\n A2 (0.5s): A2 holding. No enemies visible yet; will focus fire when all in range 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A2 holding. Still no enemies; waiting until all in range 5.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-7d507629bb2be0fe1dfee7e3.json b/examples/multi-agent-smax/results/llm-cache/ask-7d507629bb2be0fe1dfee7e3.json new file mode 100644 index 00000000..6897dc1e --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-7d507629bb2be0fe1dfee7e3.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.5 seconds into the battle.\nYou are A1, a marine at (8.5, 14.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.8, 14.7), 45/45 health, order: move 8 15\n A2 marine at (8.2, 14.1), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A0 (0.5s): At (8,15), holding. Focus fire on the closest enemy that appears.\n A1 (0.5s): Closing to (8,15) to cluster; will focus closest enemy.\n A2 (0.5s): Moving to regroup at (8,15); will focus fire closest enemy.\n A0 (1.0s): Moving to cluster at (8,15); will focus fire closest enemy.\n A1 (1.0s): A1 at (8,15) holding. Focus fire on closest enemy.\n A2 (1.0s): A2 at (8,14) holding; will focus the closest enemy when it appears.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A1 holding at cluster; focus fire on closest enemy when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-7d940dd28b5150d61eb1fb08.json b/examples/multi-agent-smax/results/llm-cache/ask-7d940dd28b5150d61eb1fb08.json new file mode 100644 index 00000000..62cc92bc --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-7d940dd28b5150d61eb1fb08.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.5 seconds into the battle.\nYou are A0, a marine at (10.6, 16.0) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1 marine at (8.9, 14.1), 45/45 health, order: attack E0\n A2 marine at (10.8, 14.8), 36/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (12.4, 16.4), 18/45 health, 1.9 away (in range)\n E1 marine at (13.1, 16.8), 45/45 health, 2.6 away (in range)\n E2 marine at (13.1, 15.5), 45/45 health, 2.5 away (in range)\nTeam chat (most recent last):\n A1 (3.0s): Holding grouped. Enemies ~7 away; let them come into range, focus E0.\n A2 (3.0s): Holding at range; all focus E0 when it enters 5 range.\n A0 (3.5s): E0 at 5 range. All focus E0 now.\n A1 (3.5s): Holding. Focus E0 when in range; stay grouped.\n A2 (3.5s): E0 at range 5. Everyone attack E0 now, focus fire.\n A0 (4.0s): Focusing E0 now. A1 please attack E0 too, all fire together.\n A1 (4.0s): Attacking E0 now, focus fire.\n A2 (4.0s): All attack E0 now, in range. A1 switch from hold to attack E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 at 18 hp, keep focus firing E0 then E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-7edb6c77289fffbb0867237e.json b/examples/multi-agent-smax/results/llm-cache/ask-7edb6c77289fffbb0867237e.json new file mode 100644 index 00000000..24962460 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-7edb6c77289fffbb0867237e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 8.0 seconds into the battle.\nYou are A1, a marine at (13.5, 17.2) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E0 marine at (18.0, 17.1), 9/45 health, 4.6 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (4.5s): E1 down. Focus E0 now, both fire together.\n A1 (4.5s): E1 dead. Focus E0 (4.6 away), A0 keep firing, I'm full health.\n A1 (5.0s): Firing on E0, last enemy. I'm at full health.\n A1 (5.5s): Last enemy E0 at 36hp; I'm the only one left, firing.\n A1 (6.0s): Last enemy E0 at 36hp, in range, firing.\n A1 (6.5s): Last enemy E0 at 27hp, in range, firing. I'm at 27hp.\n A1 (7.0s): E0 at 18hp, I'm at 18hp, last enemy, keep firing.\n A1 (7.5s): E0 at 9hp, one more hit kills it. Firing.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 at 9hp, one hit from dead. Firing, last enemy.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-7fb2d3897d81cca9b7ed972e.json b/examples/multi-agent-smax/results/llm-cache/ask-7fb2d3897d81cca9b7ed972e.json new file mode 100644 index 00000000..711cabeb --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-7fb2d3897d81cca9b7ed972e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 7.0 seconds into the battle.\nYou are A1, a marine at (6.7, 15.5) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: retreat.\nYour team:\n A0 marine at (7.9, 16.2), 9/45 health, order: retreat\n A2: dead\nEnemies you can see:\n E0 marine at (13.5, 17.3), 27/45 health, 7.0 away\n E2 marine at (13.7, 14.1), 45/45 health, 7.1 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (5.0s): A0 at 9hp retreating. A1 you hold and shoot closest; we regroup and focus E0.\n A1 (5.0s): A1 joining now, both focus E0 (27hp) to split their fire.\n A0 (5.5s): A0 9hp retreating; A1 focus E0 (27hp), I return if enemies shift.\n A1 (5.5s): A1 18hp retreating with A0; regroup and focus E0 only when both in range.\n A0 (6.0s): A0 9hp retreating west; A1 stay with me, regroup before engaging E0 (27hp).\n A1 (6.0s): A1 18hp retreating west; both out of range, regroup before re-engaging E0.\n A0 (6.5s): A0 9hp retreating west; A1 stay out of range, we regroup.\n A1 (6.5s): A1 18hp retreating west with A0; out of range, regroup before engaging.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"retreat\", \"say\": \"A1 18hp retreating west; enemies 7 away, out of range. Stay together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-7fd13f1c44a35b7336c3c88c.json b/examples/multi-agent-smax/results/llm-cache/ask-7fd13f1c44a35b7336c3c88c.json new file mode 100644 index 00000000..9e311c49 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-7fd13f1c44a35b7336c3c88c.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 6.5 seconds into the battle.\nYou are A2, a marine at (13.9, 16.5) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0: dead\n A1: dead\nEnemies you can see:\n E1 marine at (17.0, 15.6), 36/45 health, 3.2 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A2 (3.5s): Attacking E2 with A0, keep focus until it dies.\n A0 (4.0s): Keep focus on E2, 27hp left, then E1 together.\n A2 (4.0s): E2 at 27hp, keep focus until dead, then E1.\n A0 (4.5s): E2 at 9hp, finish it together, then both on E1.\n A2 (4.5s): E2 at 9hp, finish it now. A0 stay put, then both on E1.\n A2 (5.0s): A2 alone now. Finishing E2 at 9hp, then E1.\n A2 (5.5s): E2 dead. A2 alone, attacking E1 at 3.2 range.\n A2 (6.0s): A2 alone, 36hp vs E1 36hp, focusing E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A2 alone, 27hp vs E1 36hp, still focusing E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-800e7d4c902a92467d25177a.json b/examples/multi-agent-smax/results/llm-cache/ask-800e7d4c902a92467d25177a.json new file mode 100644 index 00000000..c0e45e42 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-800e7d4c902a92467d25177a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 3.5 seconds into the battle.\nYou are A0, a marine at (12.8, 15.9) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1 marine at (13.0, 15.0), 27/45 health, order: attack E1\n A2 marine at (13.0, 14.3), 27/45 health, order: attack E1\nEnemies you can see:\n E0 marine at (17.3, 15.0), 45/45 health, 4.6 away (in range)\n E1 marine at (16.6, 14.0), 36/45 health, 4.3 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (2.0s): All in range of E2 now. Attack E2 together.\n A2 (2.0s): E2 in range of all three. Attack E2 now, together.\n A0 (2.5s): Firing on E2, 18hp left. Keep attacking together.\n A1 (2.5s): Firing on E2 (18hp), keep attacking until it dies.\n A2 (2.5s): Attacking E2, it's at 18hp; finish it together.\n A0 (3.0s): E2 dead. Everyone focus E1, closest to all of us.\n A1 (3.0s): E2 dead. Focus E1 (closest, 3.8 away), all attack E1 together.\n A2 (3.0s): E2 is dead. Focus E1 (closest, 3.6 away), all together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Attacking E1 (36hp), keep focusing until it dies.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-8068fc0adfa26cf246c6c3a0.json b/examples/multi-agent-smax/results/llm-cache/ask-8068fc0adfa26cf246c6c3a0.json new file mode 100644 index 00000000..3f7a8dbd --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-8068fc0adfa26cf246c6c3a0.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 8.0 seconds into the battle.\nYou are A1, a marine at (5.2, 14.1) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (8.1, 15.8), 9/45 health, order: attack E0\n A2: dead\nEnemies you can see:\n E0 marine at (12.9, 15.0), 18/45 health, 7.7 away\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (6.5s): A1 holding back at 9hp; will shoot anything that closes in.\n A2 (6.5s): Finishing E1 (9hp) now, then all focus E0.\n A0 (7.0s): E1 down. All focus E0 now, A1 join in.\n A1 (7.0s): A1 9hp holding; will shoot anything that closes in. Finish E1, then E0.\n A2 (7.0s): E1 down. All focus E0; I'm closest and tanking, A0 and A1 fire.\n A0 (7.5s): A0 firing E0 (27hp). A1 close in and shoot, all focus fire.\n A1 (7.5s): A1 joining on E0, A2 stays closest and tanks.\n A2 (7.5s): E0 at 27hp, 4.8 away. A0, A1 fire now; focus E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"A1 closing on E0 (18hp). A0, focus fire to finish it.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-8069b303b0ecf1349a13b770.json b/examples/multi-agent-smax/results/llm-cache/ask-8069b303b0ecf1349a13b770.json new file mode 100644 index 00000000..8f7a7a10 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-8069b303b0ecf1349a13b770.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 3.5 seconds into the battle.\nYou are A1, a marine at (13.5, 17.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (13.8, 15.8), 27/45 health, order: attack E1\n A2 marine at (13.9, 17.8), 9/45 health, order: attack E1\nEnemies you can see:\n E0 marine at (18.0, 17.1), 45/45 health, 4.6 away (in range)\n E1 marine at (17.3, 17.0), 45/45 health, 3.8 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (2.0s): All in range of E2 (2.4 away). Attack E2 now, everyone focus fire.\n A2 (2.0s): E2 in range of me; all attack E2 now.\n A0 (2.5s): Firing on E2, it's at 18hp. Then focus E1 next.\n A1 (2.5s): Focusing E2, it's at 18hp. Keep firing, then switch to E1 together.\n A2 (2.5s): E2 at 18hp, keep firing on E2, then switch to E1.\n A0 (3.0s): E2 is dead. Everyone focus E1 now (3.6 away), then E0.\n A1 (3.0s): E2 down. Everyone focus E1 now (3.8 away), then E0.\n A2 (3.0s): E2 dead. All focus E1 (closest, 3.5 away) now.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Focusing E1 now; A2 at 9hp, retreat only after E1 dies.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-81410340f011b7f55ffee127.json b/examples/multi-agent-smax/results/llm-cache/ask-81410340f011b7f55ffee127.json new file mode 100644 index 00000000..5e6c1bd0 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-81410340f011b7f55ffee127.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.5 seconds into the battle.\nYou are A0, a marine at (9.3, 15.3) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1 marine at (8.3, 14.2), 45/45 health, order: attack E1\n A2: dead\nEnemies you can see:\n E1 marine at (12.2, 16.1), 18/45 health, 3.0 away (in range)\n E2 marine at (12.3, 17.5), 45/45 health, 3.8 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (4.0s): A0 attacking E0 (27hp); everyone keep focusing E0.\n A1 (4.0s): E0 out of my range; hitting E1 (in range). A0, A2 finish E0, then all E1.\n A2 (4.0s): A2 firing on E0 (27hp); finish it, then E1.\n A0 (4.5s): A0 firing E0 (18hp), nearly dead. Then all E1.\n A1 (4.5s): A1 hitting E1 (36hp). After E0 dies, everyone on E1.\n A2 (4.5s): A2 9hp. E0 at 18hp, A0 and I finish it now, then E1.\n A0 (5.0s): E0 is dead. A0 and A1 focus E1 (27hp), then E2.\n A1 (5.0s): A1 on E1 (27hp), in range. A0 join E1, then E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A0 18hp on E1 (18hp), finishing it. Then both on E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-81a2bf897a043e4b77bee79f.json b/examples/multi-agent-smax/results/llm-cache/ask-81a2bf897a043e4b77bee79f.json new file mode 100644 index 00000000..37a03728 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-81a2bf897a043e4b77bee79f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 5.0 seconds into the battle.\nYou are A0, a marine at (8.4, 15.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1 marine at (8.3, 14.2), 45/45 health, order: attack E0\n A2: dead\nEnemies you can see:\n E0 marine at (11.9, 16.8), 9/45 health, 3.6 away (in range)\n E1 marine at (12.2, 16.1), 45/45 health, 3.8 away (in range)\n E2 marine at (12.3, 17.4), 45/45 health, 4.3 away (in range)\nTeam chat (most recent last):\n A1 (3.5s): A1 holding. E0 at 6.0; attack E0 together once within 5 of all.\n A2 (3.5s): E0 in range of me, firing now. A0/A1 close in and focus E0.\n A0 (4.0s): A2 engaged, A0 attacking E0 now. A1 attack E0 too, focus fire.\n A1 (4.0s): A2 is engaged; A1 attacking E0 now. A0 join and focus E0.\n A2 (4.0s): Engaged, all 3 enemies on me. A0 A1 attack E0 now, focus fire.\n A0 (4.5s): Focus E0 (27hp). A2 at 9hp, retreat to draw fire away if possible.\n A1 (4.5s): A1 focusing E0 (27hp). A2 retreat, you're at 9hp.\n A2 (4.5s): A2 at 9hp retreating. A0 A1 keep focus on E0, it has 27hp.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 at 9hp, finishing it now. A1 focus E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-81b9876c2126650a39014bf7.json b/examples/multi-agent-smax/results/llm-cache/ask-81b9876c2126650a39014bf7.json new file mode 100644 index 00000000..81565769 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-81b9876c2126650a39014bf7.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 7.5 seconds into the battle.\nYou are A1, a marine at (7.2, 17.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (7.5, 15.8), 9/45 health, order: attack E0\n A2: dead\nEnemies you can see:\n E0 marine at (11.7, 17.0), 9/45 health, 4.6 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (5.5s): Firing E1 (18hp), then E0.\n A1 (5.5s): Firing E1 (18hp), then E0.\n A0 (6.0s): E1 at 9hp, finishing it. Then focus E0.\n A1 (6.0s): Firing E1 (9hp), then E0.\n A0 (6.5s): E1 down. Focusing E0, 4.4 away, all fire.\n A1 (6.5s): E1 down. All focus E0, 4.6 away, 45hp.\n A0 (7.0s): E0 at 27hp, keep firing. I'm at 9hp.\n A1 (7.0s): Focusing E0 at 27hp, keep firing. A0 stay behind me.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 at 9hp, finishing it. A0 stay back.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-82737c91264c3cb99dce1fdd.json b/examples/multi-agent-smax/results/llm-cache/ask-82737c91264c3cb99dce1fdd.json new file mode 100644 index 00000000..3bf1906c --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-82737c91264c3cb99dce1fdd.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 7.0 seconds into the battle.\nYou are A0, a marine at (7.5, 15.8) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1 marine at (7.2, 17.2), 45/45 health, order: attack E0\n A2: dead\nEnemies you can see:\n E0 marine at (11.7, 17.0), 27/45 health, 4.4 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (5.0s): Firing E1 (27hp), then E0.\n A1 (5.0s): Firing E1 (27hp), then E0.\n A0 (5.5s): Firing E1 (18hp), then E0.\n A1 (5.5s): Firing E1 (18hp), then E0.\n A0 (6.0s): E1 at 9hp, finishing it. Then focus E0.\n A1 (6.0s): Firing E1 (9hp), then E0.\n A0 (6.5s): E1 down. Focusing E0, 4.4 away, all fire.\n A1 (6.5s): E1 down. All focus E0, 4.6 away, 45hp.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 at 27hp, keep firing. I'm at 9hp.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-8314328eb3cf3c02cd63ec5b.json b/examples/multi-agent-smax/results/llm-cache/ask-8314328eb3cf3c02cd63ec5b.json new file mode 100644 index 00000000..bb84a05a --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-8314328eb3cf3c02cd63ec5b.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.0 seconds into the battle.\nYou are A0, a marine at (7.5, 15.8) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1 marine at (7.2, 17.2), 45/45 health, order: attack E1\n A2: dead\nEnemies you can see:\n E0 marine at (11.7, 17.0), 45/45 health, 4.4 away (in range)\n E1 marine at (11.0, 17.2), 9/45 health, 3.8 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A2 (4.0s): Keep firing E2, it's at 18 HP. Then focus E1.\n A0 (4.5s): E2 down. Focus E1 (closest), then E0.\n A1 (4.5s): E2 down. Focus E1 (closest, 3.9 away), then E0.\n A2 (4.5s): E2 down. Focus E1 (closest, 3.5 away), then E0.\n A0 (5.0s): Firing E1 (27hp), then E0.\n A1 (5.0s): Firing E1 (27hp), then E0.\n A0 (5.5s): Firing E1 (18hp), then E0.\n A1 (5.5s): Firing E1 (18hp), then E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E1 at 9hp, finishing it. Then focus E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-83998631d357b7836072b7f6.json b/examples/multi-agent-smax/results/llm-cache/ask-83998631d357b7836072b7f6.json new file mode 100644 index 00000000..942a675f --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-83998631d357b7836072b7f6.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 2.5 seconds into the battle.\nYou are A2, a marine at (8.3, 17.3) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.9, 15.6), 45/45 health, order: hold\n A1 marine at (6.7, 14.2), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (15.2, 16.8), 45/45 health, 6.9 away\n E1 marine at (16.9, 16.2), 45/45 health, 8.6 away\n E2 marine at (16.9, 17.3), 45/45 health, 8.6 away\nTeam chat (most recent last):\n A1 (1.0s): A1 holding. No enemies visible; will focus same target once all in range 5.\n A2 (1.0s): A2 holding. Still no enemies; waiting until all in range 5.\n A0 (1.5s): A0 holding. Still no enemies; waiting for all within 5 to focus fire.\n A1 (1.5s): A1 holding. Still no enemies; will focus same target once all in range 5.\n A2 (1.5s): A2 holding. No enemies visible; will focus fire when all within 5.\n A0 (2.0s): A0 holding; no enemies yet. Will focus same target once all within 5.\n A1 (2.0s): A1 holding; no enemies yet. Will attack together once all within 5.\n A2 (2.0s): A2 holding. E0 spotted at (16.8,16.8), 8.5 away. Wait until it's in range 5 of all.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A2 holding. Nearest enemy E0 at 6.9; wait until within 5 of all.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-8496e106ad00582f2fa3996e.json b/examples/multi-agent-smax/results/llm-cache/ask-8496e106ad00582f2fa3996e.json new file mode 100644 index 00000000..e9cc903c --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-8496e106ad00582f2fa3996e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 1.0 seconds into the battle.\nYou are A2, a marine at (10.1, 18.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 17.\nYour team:\n A0 marine at (10.4, 15.8), 45/45 health, order: move 12 17\n A1 marine at (9.7, 16.1), 45/45 health, order: move 12 17\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Moving east together to (12,17); stay within 2 of each other, then all attack same target.\n A1 (0.0s): Moving east together toward the center; stay within 2 of each other.\n A2 (0.0s): Advancing east together, stay within 2 of each other; attack same target when in range.\n A0 (0.5s): Continuing to (12,17); keep within 2 of each other.\n A1 (0.5s): Moving to (12,17) with A0; keep together, then focus same target.\n A2 (0.5s): Moving to (12,17) with A0; keep within 2, attack together when enemies appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 17\", \"say\": \"Continuing to (12,17); no enemies yet, stay within 2, attack together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-84ed0fc3235cc7a741c0e967.json b/examples/multi-agent-smax/results/llm-cache/ask-84ed0fc3235cc7a741c0e967.json new file mode 100644 index 00000000..228703a4 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-84ed0fc3235cc7a741c0e967.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.0 seconds into the battle.\nYou are A2, a marine at (7.6, 17.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.5, 15.8), 45/45 health, order: hold\n A1 marine at (7.2, 17.2), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding together here; focus fire on the closest enemy when they appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-851e40253d07a5d0291ce7a7.json b/examples/multi-agent-smax/results/llm-cache/ask-851e40253d07a5d0291ce7a7.json new file mode 100644 index 00000000..a6c756c1 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-851e40253d07a5d0291ce7a7.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.5 seconds into the battle.\nYou are A2, a marine at (10.8, 14.8) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (10.6, 16.0), 9/45 health, order: attack E2\n A1 marine at (8.9, 14.1), 45/45 health, order: attack E2\nEnemies you can see:\n E1 marine at (13.1, 16.8), 45/45 health, 3.0 away (in range)\n E2 marine at (13.1, 15.5), 18/45 health, 2.3 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (4.0s): Attacking E0 now, focus fire.\n A2 (4.0s): All attack E0 now, in range. A1 switch from hold to attack E0.\n A0 (4.5s): E0 at 18 hp, keep focus firing E0 then E2.\n A1 (4.5s): Firing on E0, 18 hp left. Next target E2 (closest).\n A2 (4.5s): E0 at 18 hp, keep firing. Then focus E2.\n A0 (5.0s): E0 dead. Focus E2 (closest), then E1. Stay grouped.\n A1 (5.0s): E0 is dead. Focus fire E2, closest at 4.4.\n A2 (5.0s): E0 down. Focus E2 (closest), then E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Focus E2 (18hp), then E1. Keep firing.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-85baf956c5d390573ae61112.json b/examples/multi-agent-smax/results/llm-cache/ask-85baf956c5d390573ae61112.json new file mode 100644 index 00000000..5d29bd54 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-85baf956c5d390573ae61112.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 2.5 seconds into the battle.\nYou are A2, a marine at (12.3, 16.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (13.3, 16.4), 45/45 health, order: attack E0\n A1 marine at (14.1, 16.4), 18/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (16.0, 15.3), 18/45 health, 3.9 away (in range)\n E1 marine at (18.6, 15.6), 45/45 health, 6.3 away\n E2 marine at (18.2, 17.7), 45/45 health, 6.0 away\nTeam chat (most recent last):\n A1 (1.0s): Holding formation at (12,16); then all advance and attack E0 together.\n A2 (1.0s): Continuing to (12,16) together; will attack same target once all in range 5.\n A0 (1.5s): Advancing together toward E0; all attack E0 once everyone is within range 5.\n A1 (1.5s): Advancing together east to (14,16); then all attack E0 at once.\n A2 (1.5s): Advancing together toward E0; all attack E0 once everyone is within range 5.\n A0 (2.0s): E0 is within range 5 of all three of us. Everyone attack E0 now.\n A1 (2.0s): E0 is in range of all three of us. Everyone attack E0 now.\n A2 (2.0s): E0 is in range of all three; attacking E0 now, focus fire.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Focus E0, it's at 18hp. A1 is low; keep firing until E0 dies.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-85c6b09ff640e647ccc51e10.json b/examples/multi-agent-smax/results/llm-cache/ask-85c6b09ff640e647ccc51e10.json new file mode 100644 index 00000000..1a12ca1d --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-85c6b09ff640e647ccc51e10.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.5 seconds into the battle.\nYou are A1, a marine at (8.5, 15.3) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0: dead\n A2 marine at (9.4, 16.4), 27/45 health, order: attack E2\nEnemies you can see:\n E2 marine at (12.8, 17.3), 27/45 health, 4.8 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A2 (4.5s): E0 dead. A2 focusing E1, everyone focus E1 then E2.\n A0 (5.0s): A0 switching to E1 (27hp), focus fire. A2 is tanking.\n A1 (5.0s): A1 on E1 (27hp), focus fire. A0 hurt, fall back if needed.\n A2 (5.0s): A2 on E1 (27hp), in range. A0 retreat if low, A1 focus E1.\n A1 (5.5s): E1 down. All focus E2, 4.8 away, in range.\n A2 (5.5s): A2 on E2 (45hp, in range). A1 focus E2, last enemy.\n A1 (6.0s): A1 on E2 (36hp), in range. Keep focus fire, last enemy.\n A2 (6.0s): A2 on E2 (36hp), in range. A1 keep firing, last enemy.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"A1 on E2 (27hp), in range. Keep firing, last enemy.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-861b62af9830666f51ce5e5a.json b/examples/multi-agent-smax/results/llm-cache/ask-861b62af9830666f51ce5e5a.json new file mode 100644 index 00000000..a0881f4d --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-861b62af9830666f51ce5e5a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.0 seconds into the battle.\nYou are A1, a marine at (8.3, 14.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (9.3, 15.3), 27/45 health, order: attack E0\n A2: dead\nEnemies you can see:\n E1 marine at (12.2, 16.1), 27/45 health, 4.3 away (in range)\n E2 marine at (12.3, 17.5), 45/45 health, 5.3 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (3.5s): A1 advancing, focusing E0 with A2. A0 join fire on E0.\n A2 (3.5s): A2 attacking E0 (36hp, in range); all focus E0.\n A0 (4.0s): A0 attacking E0 (27hp); everyone keep focusing E0.\n A1 (4.0s): E0 out of my range; hitting E1 (in range). A0, A2 finish E0, then all E1.\n A2 (4.0s): A2 firing on E0 (27hp); finish it, then E1.\n A0 (4.5s): A0 firing E0 (18hp), finish it then E1.\n A1 (4.5s): A1 shooting E1 (36hp). E0 at 18hp, finish it, then all E1.\n A2 (4.5s): A2 9hp, still firing on E0 (18hp). A0 finish E0, then E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A1 hitting E1 (27hp, in range). A0 switch to E1, then E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-86943ab6b11a69621a481b4a.json b/examples/multi-agent-smax/results/llm-cache/ask-86943ab6b11a69621a481b4a.json new file mode 100644 index 00000000..57cc0a47 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-86943ab6b11a69621a481b4a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 1.5 seconds into the battle.\nYou are A2, a marine at (13.7, 16.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 16.\nYour team:\n A0 marine at (13.0, 16.2), 45/45 health, order: move 14 16\n A1 marine at (14.5, 15.7), 45/45 health, order: move 15 16\nEnemies you can see:\n E0 marine at (19.8, 17.3), 45/45 health, 6.2 away\n E1 marine at (19.8, 16.6), 45/45 health, 6.1 away\n E2 marine at (20.0, 14.1), 45/45 health, 6.6 away\nTeam chat (most recent last):\n A1 (0.0s): Moving east together toward enemies, stay within 2 of each other; attack same target on contact.\n A2 (0.0s): Moving east together to (14,16); stay within 2 of each other, attack together on contact.\n A0 (0.5s): Continuing east to (14,16); staying together, will attack same target on contact.\n A1 (0.5s): Continuing east in formation; will attack same target on contact.\n A2 (0.5s): A2 moving east to (14,16), staying close; attack same target on contact.\n A0 (1.0s): Continuing east to (14,16), staying together; no enemies seen yet.\n A1 (1.0s): Advancing together toward enemies; will all attack E1 once in range 5.\n A2 (1.0s): A2 continuing east to (14,16), staying together; attack same target on contact.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 15 16\", \"say\": \"Advancing together to (15,16); all attack E1 once in range 5.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-8710f5ad79c9d823d8dfe115.json b/examples/multi-agent-smax/results/llm-cache/ask-8710f5ad79c9d823d8dfe115.json new file mode 100644 index 00000000..adf26b01 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-8710f5ad79c9d823d8dfe115.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 1.0 seconds into the battle.\nYou are A2, a marine at (12.5, 14.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 15.\nYour team:\n A0 marine at (11.2, 17.5), 45/45 health, order: move 12 16\n A1 marine at (10.3, 14.7), 45/45 health, order: move 12 15\nEnemies you can see:\n E0 marine at (20.5, 15.0), 45/45 health, 8.0 away\n E1 marine at (21.3, 14.0), 45/45 health, 8.8 away\n E2 marine at (19.7, 16.8), 45/45 health, 7.5 away\nTeam chat (most recent last):\n A0 (0.0s): Advancing east together to (12,16); stay within 2 of each other, attack together.\n A1 (0.0s): Advancing east together to (12,15); stay within 2 of each other, attack same target on contact.\n A2 (0.0s): Advancing east together, staying close. Don't outrun the group; all attack same target.\n A0 (0.5s): Advancing to (12,16), keeping close; will attack same target on contact.\n A1 (0.5s): A1 advancing to (12,15), staying close; will attack same target on contact.\n A2 (0.5s): A2 advancing to (12,15), staying close; will attack same target on contact.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 15\", \"say\": \"Holding formation at (12,15); will advance together, then all attack E2 at once.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-87762e57c60f5d77902fc4e4.json b/examples/multi-agent-smax/results/llm-cache/ask-87762e57c60f5d77902fc4e4.json new file mode 100644 index 00000000..acfc46bb --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-87762e57c60f5d77902fc4e4.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.5 seconds into the battle.\nYou are A1, a marine at (8.3, 14.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (9.3, 15.3), 18/45 health, order: attack E1\n A2: dead\nEnemies you can see:\n E1 marine at (12.2, 16.1), 18/45 health, 4.3 away (in range)\n E2 marine at (12.3, 17.5), 45/45 health, 5.3 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (4.0s): A0 attacking E0 (27hp); everyone keep focusing E0.\n A1 (4.0s): E0 out of my range; hitting E1 (in range). A0, A2 finish E0, then all E1.\n A2 (4.0s): A2 firing on E0 (27hp); finish it, then E1.\n A0 (4.5s): A0 firing E0 (18hp), finish it then E1.\n A1 (4.5s): A1 shooting E1 (36hp). E0 at 18hp, finish it, then all E1.\n A2 (4.5s): A2 9hp, still firing on E0 (18hp). A0 finish E0, then E1.\n A0 (5.0s): A0 firing E1 (27hp), A1 same. Focus E1 then E2.\n A1 (5.0s): A1 hitting E1 (27hp, in range). A0 switch to E1, then E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A1 on E1 (18hp). A0 keep firing E1, then E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-87bda3e04ae77146537c81f3.json b/examples/multi-agent-smax/results/llm-cache/ask-87bda3e04ae77146537c81f3.json new file mode 100644 index 00000000..9c4f287f --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-87bda3e04ae77146537c81f3.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 2.5 seconds into the battle.\nYou are A0, a marine at (13.3, 16.4) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1 marine at (14.1, 16.4), 18/45 health, order: attack E0\n A2 marine at (12.3, 16.5), 45/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (16.0, 15.3), 18/45 health, 3.0 away (in range)\n E1 marine at (18.6, 15.6), 45/45 health, 5.4 away\n E2 marine at (18.2, 17.7), 45/45 health, 5.1 away\nTeam chat (most recent last):\n A1 (1.0s): Holding formation at (12,16); then all advance and attack E0 together.\n A2 (1.0s): Continuing to (12,16) together; will attack same target once all in range 5.\n A0 (1.5s): Advancing together toward E0; all attack E0 once everyone is within range 5.\n A1 (1.5s): Advancing together east to (14,16); then all attack E0 at once.\n A2 (1.5s): Advancing together toward E0; all attack E0 once everyone is within range 5.\n A0 (2.0s): E0 is within range 5 of all three of us. Everyone attack E0 now.\n A1 (2.0s): E0 is in range of all three of us. Everyone attack E0 now.\n A2 (2.0s): E0 is in range of all three; attacking E0 now, focus fire.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Keep focusing E0; A1 stay in fight until E0 dies, then retreat.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-87cd5a39b39065537471b336.json b/examples/multi-agent-smax/results/llm-cache/ask-87cd5a39b39065537471b336.json new file mode 100644 index 00000000..60038483 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-87cd5a39b39065537471b336.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.5 seconds into the battle.\nYou are A2, a marine at (7.4, 16.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.0, 15.6), 45/45 health, order: hold\n A1 marine at (9.7, 17.5), 45/45 health, order: move 12 17\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together at the cluster; focus fire on the closest enemy when they appear.\n A1 (0.0s): Advancing east together; stay close and focus fire on the nearest enemy.\n A2 (0.0s): Holding together; focus fire on the closest enemy when they appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 10 17\", \"say\": \"A1 is ahead alone; moving up to group with A1, then focus nearest enemy.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-87dc05c8b716496f687b36a1.json b/examples/multi-agent-smax/results/llm-cache/ask-87dc05c8b716496f687b36a1.json new file mode 100644 index 00000000..a5d0d096 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-87dc05c8b716496f687b36a1.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 4.0 seconds into the battle.\nYou are A1, a marine at (12.9, 17.5) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (13.3, 15.6), 18/45 health, order: attack E1\n A2 marine at (13.7, 16.7), 18/45 health, order: attack E1\nEnemies you can see:\n E0 marine at (17.7, 17.8), 45/45 health, 4.9 away (in range)\n E1 marine at (16.9, 14.5), 9/45 health, 5.0 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (2.5s): Focusing E2 (9hp), it dies soon; then we focus E0.\n A2 (2.5s): E2 at 9hp, finishing it now. Then focus E1.\n A0 (3.0s): E2 dead. Focus E1 (closest, 3.7 away), then E0.\n A1 (3.0s): E2 dead. Everyone focus E1 now, then E0.\n A2 (3.0s): E2 dead. Everyone focus E1 now, closest at 3.9.\n A0 (3.5s): Focus E1 (27hp). Keep attacking until dead, then E0.\n A1 (3.5s): Focusing E1 (27hp). A0 at 18hp, keep firing until E1 dies.\n A2 (3.5s): Focusing E1 (27hp), then E0. A0 at 18hp, keep firing.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E1 at 9hp, all keep firing until dead, then E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-87f3837de96bd2c0601f67f9.json b/examples/multi-agent-smax/results/llm-cache/ask-87f3837de96bd2c0601f67f9.json new file mode 100644 index 00000000..43ba2eef --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-87f3837de96bd2c0601f67f9.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 2.0 seconds into the battle.\nYou are A1, a marine at (6.7, 14.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.9, 15.6), 45/45 health, order: hold\n A2 marine at (8.3, 17.3), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.5s): A1 holding; no enemies visible yet. Will focus same target once all in range.\n A2 (0.5s): A2 holding. No enemies visible yet; will focus fire when all in range 5.\n A0 (1.0s): A0 holding. No enemies visible; will focus same target once all within 5.\n A1 (1.0s): A1 holding. No enemies visible; will focus same target once all in range 5.\n A2 (1.0s): A2 holding. Still no enemies; waiting until all in range 5.\n A0 (1.5s): A0 holding. Still no enemies; waiting for all within 5 to focus fire.\n A1 (1.5s): A1 holding. Still no enemies; will focus same target once all in range 5.\n A2 (1.5s): A2 holding. No enemies visible; will focus fire when all within 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A1 holding; no enemies yet. Will attack together once all within 5.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-8807e594d94190d35200b4c6.json b/examples/multi-agent-smax/results/llm-cache/ask-8807e594d94190d35200b4c6.json new file mode 100644 index 00000000..f868a12a --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-8807e594d94190d35200b4c6.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.0 seconds into the battle.\nYou are A2, a marine at (6.5, 16.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.6, 16.9), 45/45 health, order: hold\n A1 marine at (8.5, 15.3), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together here; focus fire on the closest enemy when they appear.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together as a group; focus fire on the closest enemy once seen.\n A0 (0.5s): No enemies yet. Holding; focus the closest when they appear.\n A1 (0.5s): A1 holding; will focus fire on the closest enemy that appears.\n A2 (0.5s): No enemies yet; staying grouped, will focus the closest one when seen.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A2 holding; will focus the closest enemy when it appears.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-8812a02af088bd436530b2fa.json b/examples/multi-agent-smax/results/llm-cache/ask-8812a02af088bd436530b2fa.json new file mode 100644 index 00000000..3f6b5ce6 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-8812a02af088bd436530b2fa.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.0 seconds into the battle.\nYou are A0, a marine at (9.3, 15.3) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1 marine at (8.3, 14.2), 45/45 health, order: attack E1\n A2: dead\nEnemies you can see:\n E1 marine at (12.2, 16.1), 27/45 health, 3.0 away (in range)\n E2 marine at (12.3, 17.5), 45/45 health, 3.8 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (3.5s): A1 advancing, focusing E0 with A2. A0 join fire on E0.\n A2 (3.5s): A2 attacking E0 (36hp, in range); all focus E0.\n A0 (4.0s): A0 attacking E0 (27hp); everyone keep focusing E0.\n A1 (4.0s): E0 out of my range; hitting E1 (in range). A0, A2 finish E0, then all E1.\n A2 (4.0s): A2 firing on E0 (27hp); finish it, then E1.\n A0 (4.5s): A0 firing E0 (18hp), finish it then E1.\n A1 (4.5s): A1 shooting E1 (36hp). E0 at 18hp, finish it, then all E1.\n A2 (4.5s): A2 9hp, still firing on E0 (18hp). A0 finish E0, then E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A0 firing E1 (27hp), A1 same. Focus E1 then E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-8828e14c60c73220a00fbc91.json b/examples/multi-agent-smax/results/llm-cache/ask-8828e14c60c73220a00fbc91.json new file mode 100644 index 00000000..d570d8c9 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-8828e14c60c73220a00fbc91.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 7.0 seconds into the battle.\nYou are A1, a marine at (15.1, 13.7) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E1 marine at (18.0, 17.0), 9/45 health, 4.3 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (4.0s): E2 at 18hp, keep focusing E2 then E1. Nobody retreat.\n A0 (4.5s): E2 at 9hp, finish it now, then E1. I'm low but still firing.\n A1 (4.5s): E2 at 9hp, finishing it. Then E1. A0 stay in, no retreat.\n A0 (5.0s): E2 dead. Focus E1 now, 4.2 away, both fire together.\n A1 (5.0s): E2 dead. All focus E1 now, 4.3 away. A0 keep firing.\n A1 (5.5s): A1 alone now, attacking E1 (27hp). Keep firing.\n A1 (6.0s): A1 alone, E1 at 27hp, still firing.\n A1 (6.5s): A1 alone, E1 at 18hp, keep firing until it dies.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A1 alone, E1 at 9hp, finishing it.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-88a35581ee87c79dff0f288b.json b/examples/multi-agent-smax/results/llm-cache/ask-88a35581ee87c79dff0f288b.json new file mode 100644 index 00000000..990b1310 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-88a35581ee87c79dff0f288b.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 1.5 seconds into the battle.\nYou are A0, a marine at (12.8, 17.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 16.\nYour team:\n A1 marine at (11.4, 15.0), 45/45 health, order: move 12 15\n A2 marine at (11.4, 14.3), 45/45 health, order: move 12 15\nEnemies you can see:\n E0 marine at (18.9, 15.0), 45/45 health, 6.6 away\n E1 marine at (19.7, 14.0), 45/45 health, 7.8 away\n E2 marine at (18.1, 16.8), 45/45 health, 5.4 away\nTeam chat (most recent last):\n A1 (0.0s): Advancing east together to (12,15); stay within 2 of each other, attack same target on contact.\n A2 (0.0s): Advancing east together, staying close. Don't outrun the group; all attack same target.\n A0 (0.5s): Advancing to (12,16), keeping close; will attack same target on contact.\n A1 (0.5s): A1 advancing to (12,15), staying close; will attack same target on contact.\n A2 (0.5s): A2 advancing to (12,15), staying close; will attack same target on contact.\n A0 (1.0s): Moving together east to (14,16); stay grouped, attack same target on contact.\n A1 (1.0s): A1 continuing to (12,15), staying close; attack same target on contact.\n A2 (1.0s): Holding formation at (12,15); will advance together, then all attack E2 at once.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 16\", \"say\": \"A0 closing on group at (12,16); then all advance together on E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-88a6199eb02124150c48f233.json b/examples/multi-agent-smax/results/llm-cache/ask-88a6199eb02124150c48f233.json new file mode 100644 index 00000000..8c7faa55 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-88a6199eb02124150c48f233.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 1.0 seconds into the battle.\nYou are A2, a marine at (9.7, 14.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 15.\nYour team:\n A0 marine at (9.7, 15.8), 45/45 health, order: move 12 15\n A1 marine at (11.5, 14.1), 45/45 health, order: move 12 15\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Moving east together to (12,16); stay within 2 of each other, then attack same target.\n A1 (0.0s): Moving east together toward enemies; stay within 2 of each other, attack same target.\n A2 (0.0s): Advancing east together to (12,15); stay within 2 of each other.\n A0 (0.5s): Converging on (12,15) with A1/A2; will attack same target together.\n A1 (0.5s): Moving to (12,15) with team; will attack same target together.\n A2 (0.5s): A2 moving to (12,15), staying close; will attack same target when enemies appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 15\", \"say\": \"A2 continuing to (12,15); will attack together when enemies appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-88ccd3134baceb5f532ce330.json b/examples/multi-agent-smax/results/llm-cache/ask-88ccd3134baceb5f532ce330.json new file mode 100644 index 00000000..2a9143f0 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-88ccd3134baceb5f532ce330.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 4.0 seconds into the battle.\nYou are A2, a marine at (13.9, 16.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (14.8, 16.4), 27/45 health, order: attack E2\n A1: dead\nEnemies you can see:\n E1 marine at (17.0, 15.6), 45/45 health, 3.2 away (in range)\n E2 marine at (16.6, 17.7), 27/45 health, 3.0 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A2 (2.0s): E0 is in range of all three; attacking E0 now, focus fire.\n A0 (2.5s): Keep focusing E0; A1 stay in fight until E0 dies, then retreat.\n A1 (2.5s): E0 at 18hp, keep focus fire; I'm at 18hp and will step back once it dies.\n A2 (2.5s): Focus E0, it's at 18hp. A1 is low; keep firing until E0 dies.\n A0 (3.0s): E0 dead. A2 stay close, all focus E2 together. A1 retreat.\n A2 (3.0s): E0 dead. A0 and I both attack E2 now, stay together.\n A0 (3.5s): Both on E2, keep firing until it dies.\n A2 (3.5s): Attacking E2 with A0, keep focus until it dies.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 at 27hp, keep focus until dead, then E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-88d245d57cf06791df56187c.json b/examples/multi-agent-smax/results/llm-cache/ask-88d245d57cf06791df56187c.json new file mode 100644 index 00000000..750ed212 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-88d245d57cf06791df56187c.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 7.5 seconds into the battle.\nYou are A2, a marine at (9.2, 17.8) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (8.5, 16.7), 27/45 health, order: attack E1\n A1: dead\nEnemies you can see:\n E1 marine at (12.3, 15.6), 27/45 health, 3.8 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (5.5s): A1 firing E2 from back; A0 is closest, keep tanking. Focus E2.\n A2 (5.5s): A2 on E2 (27hp), keep focusing. A1 stay back.\n A0 (6.0s): A0 on E2 (9hp), finishing it. Then all E1.\n A2 (6.0s): A2 on E2 (9hp), nearly dead. Then E1 together.\n A0 (6.5s): A0 finishing E2 now. Then all on E1.\n A2 (6.5s): A2 finishing E2 (9hp). Then both on E1.\n A0 (7.0s): E2 down. A0 and A2 all on E1, 36hp.\n A2 (7.0s): E2 down. A2 on E1, A0 keep tanking, I'm at 9hp.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"retreat\", \"say\": \"A2 9hp, falling back so A0 is closest. A0 tank, I'll rejoin shooting.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-899084089c8696031ebbf948.json b/examples/multi-agent-smax/results/llm-cache/ask-899084089c8696031ebbf948.json new file mode 100644 index 00000000..a763a1b2 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-899084089c8696031ebbf948.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 9.0 seconds into the battle.\nYou are A1, a marine at (8.9, 14.1) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E1 marine at (13.1, 16.8), 18/45 health, 5.0 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (6.0s): E2 at 9hp, finish it now, then E1.\n A2 (6.0s): E2 at 9hp, finish it, then all on E1.\n A1 (6.5s): E2 dead. All focus E1, it's at 45hp, 5.0 away.\n A2 (6.5s): E2 dead. I'm at 9hp, backing off. A1 focus E1, I'll rejoin.\n A1 (7.0s): Engaging E1 at 36hp, in range. A2 stay back and heal up.\n A1 (7.5s): Still on E1, 36hp. A2 stay back and heal.\n A1 (8.0s): E1 at 27hp, still firing. A2 stay back.\n A1 (8.5s): E1 at 18hp, still firing. Last enemy, I'm at 27hp.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E1 at 18hp, still firing. I'm at 27hp, keep going.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-8995d601b6af0c1d6c4d9b8d.json b/examples/multi-agent-smax/results/llm-cache/ask-8995d601b6af0c1d6c4d9b8d.json new file mode 100644 index 00000000..72e3c82a --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-8995d601b6af0c1d6c4d9b8d.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 1.5 seconds into the battle.\nYou are A0, a marine at (11.1, 16.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 15.\nYour team:\n A1 marine at (11.7, 15.5), 45/45 health, order: move 12 15\n A2 marine at (11.2, 14.9), 45/45 health, order: move 12 15\nEnemies you can see:\n E0 marine at (19.2, 15.0), 45/45 health, 8.1 away\n E1 marine at (19.7, 16.2), 45/45 health, 8.6 away\n E2 marine at (19.2, 14.3), 45/45 health, 8.3 away\nTeam chat (most recent last):\n A1 (0.0s): Moving east together toward enemies; stay within 2 of each other, attack same target.\n A2 (0.0s): Advancing east together to (12,15); stay within 2 of each other.\n A0 (0.5s): Converging on (12,15) with A1/A2; will attack same target together.\n A1 (0.5s): Moving to (12,15) with team; will attack same target together.\n A2 (0.5s): A2 moving to (12,15), staying close; will attack same target when enemies appear.\n A0 (1.0s): Continuing to (12,15); will attack together once enemies appear.\n A1 (1.0s): Continuing to (12,15) together; will attack same target when enemies appear.\n A2 (1.0s): A2 continuing to (12,15); will attack together when enemies appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 15 15\", \"say\": \"Advancing together toward E0; all attack E0 once everyone is in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-89d530aaa0fcc304437d1e23.json b/examples/multi-agent-smax/results/llm-cache/ask-89d530aaa0fcc304437d1e23.json new file mode 100644 index 00000000..d45b9a0f --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-89d530aaa0fcc304437d1e23.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 1.0 seconds into the battle.\nYou are A1, a marine at (10.5, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 15.\nYour team:\n A0 marine at (12.2, 16.0), 45/45 health, order: move 12 15\n A2 marine at (10.8, 14.8), 45/45 health, order: move 14 15\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Advancing east together; stay within 2 of each other, A1 and A2 keep pace.\n A1 (0.0s): Moving east together toward center, stay within 2 of each other.\n A2 (0.0s): Moving together to center, stay within 2 of each other; attack same target when in range.\n A0 (0.5s): Moving east, staying close; A1 and A2 keep within 2 of me.\n A1 (0.5s): Advancing east, staying close; will all attack same target when enemies appear.\n A2 (0.5s): Keeping pace east, staying close; will focus same target once in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 15\", \"say\": \"Continuing east together; will focus same target when enemies in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-8a9c34bf53f2ca96413bded7.json b/examples/multi-agent-smax/results/llm-cache/ask-8a9c34bf53f2ca96413bded7.json new file mode 100644 index 00000000..9824d185 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-8a9c34bf53f2ca96413bded7.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 1.0 seconds into the battle.\nYou are A1, a marine at (10.3, 17.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 17.\nYour team:\n A0 marine at (10.7, 15.8), 45/45 health, order: move 14 17\n A2 marine at (10.7, 17.8), 45/45 health, order: move 12 17\nEnemies you can see:\n E2 marine at (18.9, 16.7), 45/45 health, 8.6 away\nTeam chat (most recent last):\n A0 (0.0s): Moving east together to find enemies; stay within 2 of each other, attack together.\n A1 (0.0s): Moving east together to find enemies; stay within 2 of each other, fire together.\n A2 (0.0s): Moving east together to find enemies; stay close, attack same target when in range.\n A0 (0.5s): Moving east in formation; will attack same target once all in range.\n A1 (0.5s): Moving east in a tight group; will attack same target together.\n A2 (0.5s): Moving east in formation; A0 and A1 keep pace, no one pull ahead.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 17\", \"say\": \"Advancing east together toward E2; keep within 2, attack same target at range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-8b233a2d1971150e73e880c1.json b/examples/multi-agent-smax/results/llm-cache/ask-8b233a2d1971150e73e880c1.json new file mode 100644 index 00000000..011522cd --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-8b233a2d1971150e73e880c1.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 0.5 seconds into the battle.\nYou are A2, a marine at (10.0, 16.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 16.\nYour team:\n A0 marine at (10.1, 18.0), 45/45 health, order: move 12 17\n A1 marine at (10.2, 17.2), 45/45 health, order: move 14 17\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Moving east together, stay within 2 of each other; no one engage alone.\n A1 (0.0s): Moving east together toward enemies; keep within 2 of each other, attack together.\n A2 (0.0s): Moving east together toward enemies, stay within 2 of each other; attack same target on call.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 17\", \"say\": \"Moving east, staying close; A0 at 12,17 is my anchor point.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-8b4bacc6c799b1df4d0c58ab.json b/examples/multi-agent-smax/results/llm-cache/ask-8b4bacc6c799b1df4d0c58ab.json new file mode 100644 index 00000000..2a4b2854 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-8b4bacc6c799b1df4d0c58ab.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 7.5 seconds into the battle.\nYou are A2, a marine at (13.9, 16.5) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0: dead\n A1: dead\nEnemies you can see:\n E1 marine at (17.0, 15.6), 18/45 health, 3.2 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A2 (4.0s): E2 at 27hp, keep focus until dead, then E1.\n A0 (4.5s): E2 at 9hp, finish it together, then both on E1.\n A2 (4.5s): E2 at 9hp, finish it now. A0 stay put, then both on E1.\n A2 (5.0s): A2 alone now. Finishing E2 at 9hp, then E1.\n A2 (5.5s): E2 dead. A2 alone, attacking E1 at 3.2 range.\n A2 (6.0s): A2 alone, 36hp vs E1 36hp, focusing E1.\n A2 (6.5s): A2 alone, 27hp vs E1 36hp, still focusing E1.\n A2 (7.0s): A2 27hp vs E1 27hp, still focusing E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A2 18hp vs E1 18hp, last enemy, all-in on E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-8b58a203eb777f3c3cea6e81.json b/examples/multi-agent-smax/results/llm-cache/ask-8b58a203eb777f3c3cea6e81.json new file mode 100644 index 00000000..b12fbeb5 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-8b58a203eb777f3c3cea6e81.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 8.5 seconds into the battle.\nYou are A1, a marine at (8.0, 16.0) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E1 marine at (11.6, 16.0), 27/45 health, 3.5 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A2 (5.5s): E0 dead. Focus E2 (27hp) together, then E1.\n A1 (6.0s): Focusing E2 (27hp), then E1. A2 stay behind me.\n A2 (6.0s): Focusing E2 (27hp), then E1. A1 keep firing.\n A1 (6.5s): Finishing E2 (9hp) now, then E1. A2 stay behind me.\n A2 (6.5s): E2 at 9hp, finishing it. A1 then focus E1.\n A1 (7.0s): E2 dead, A0 and A2 down. I'm alone on E1, 45hp each.\n A1 (7.5s): Last fight: A1 vs E1, 36hp vs 45hp. Fighting on.\n A1 (8.0s): Last fight, A1 vs E1. Keep firing.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A1 vs E1, both 27hp. Fighting on.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-8b7966ba510abb5096ab1ad2.json b/examples/multi-agent-smax/results/llm-cache/ask-8b7966ba510abb5096ab1ad2.json new file mode 100644 index 00000000..ad4e4dd4 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-8b7966ba510abb5096ab1ad2.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.0 seconds into the battle.\nYou are A1, a marine at (10.1, 17.3) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0: dead\n A2 marine at (9.9, 15.8), 45/45 health, order: attack E1\nEnemies you can see:\n E1 marine at (13.8, 17.3), 18/45 health, 3.7 away (in range)\n E2 marine at (14.4, 14.8), 45/45 health, 5.0 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (3.5s): Keep focusing E0 (18hp), then E1.\n A1 (3.5s): Keep focusing E0, it's at 18 health. Then E1.\n A2 (3.5s): E0 at 18hp, keep focusing E0, then E2.\n A0 (4.0s): E0 dead. Focus E1 (3.6 away), then E2. I'm at 18hp.\n A1 (4.0s): E0 dead. Focus E1 (closest, 3.7 away), then E2.\n A2 (4.0s): E0 dead. Focus E1 (4.2 away), then E2.\n A1 (4.5s): Focusing E1 (27hp), then E2.\n A2 (4.5s): Focusing E1 (27hp), then E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Focusing E1 (18hp), almost dead. Then E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-8c09bfcdebffc7c58a165c28.json b/examples/multi-agent-smax/results/llm-cache/ask-8c09bfcdebffc7c58a165c28.json new file mode 100644 index 00000000..9b8bef70 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-8c09bfcdebffc7c58a165c28.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.0 seconds into the battle.\nYou are A1, a marine at (8.5, 15.3) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (8.8, 17.1), 9/45 health, order: attack E2\n A2 marine at (9.4, 16.4), 45/45 health, order: attack E1\nEnemies you can see:\n E1 marine at (12.9, 16.5), 27/45 health, 4.5 away (in range)\n E2 marine at (12.8, 17.3), 45/45 health, 4.8 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (3.5s): A1 focusing E0 (27hp), in range. A2 please attack E0 too.\n A2 (3.5s): A2 attacking E0, closing in to focus fire.\n A0 (4.0s): E0 at 9hp, finish it, then focus E2.\n A1 (4.0s): A1 attacking E0 (9hp), finish it then switch to E1.\n A2 (4.0s): A2 closing on E0 (9hp), then focus E1.\n A0 (4.5s): E0 dead. A0 on E2, all focus E2 please.\n A1 (4.5s): E0 dead. Focus E1 (4.5 away), then E2.\n A2 (4.5s): E0 dead. A2 focusing E1, everyone focus E1 then E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A1 on E1 (27hp), focus fire. A0 hurt, fall back if needed.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-8c55384c41579835ff76695f.json b/examples/multi-agent-smax/results/llm-cache/ask-8c55384c41579835ff76695f.json new file mode 100644 index 00000000..ad619a53 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-8c55384c41579835ff76695f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 7.0 seconds into the battle.\nYou are A1, a marine at (8.9, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E1 marine at (13.1, 16.8), 36/45 health, 5.0 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (5.5s): E2 at 18hp, all fire E2 now, then E1. I'm at 9hp.\n A1 (5.5s): Focus E2 (18 hp), then E1. Keep firing.\n A2 (5.5s): Focus E2 (18hp), then E1. Keep firing.\n A0 (6.0s): E2 at 9hp, all fire now. I'm at 9hp, finish E2 then E1.\n A1 (6.0s): Firing E2 (9hp), then E1. A0 stay back, low hp.\n A2 (6.0s): E2 at 9hp, all fire E2 now, then E1.\n A1 (6.5s): E2 down. All fire E1, 45hp. A2 stay back, low hp.\n A2 (6.5s): E2 dead. Only E1 left. A1 tank and focus E1, I'm at 9hp and falling back.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Engaging E1 alone, 36hp. I'm at full health, firing.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-8c7a40b1e17e626f4fb31e0a.json b/examples/multi-agent-smax/results/llm-cache/ask-8c7a40b1e17e626f4fb31e0a.json new file mode 100644 index 00000000..4e586da1 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-8c7a40b1e17e626f4fb31e0a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.5 seconds into the battle.\nYou are A2, a marine at (9.4, 16.4) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0: dead\n A1 marine at (8.5, 15.3), 27/45 health, order: attack E2\nEnemies you can see:\n E2 marine at (12.8, 17.3), 27/45 health, 3.5 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A2 (4.5s): E0 dead. A2 focusing E1, everyone focus E1 then E2.\n A0 (5.0s): A0 switching to E1 (27hp), focus fire. A2 is tanking.\n A1 (5.0s): A1 on E1 (27hp), focus fire. A0 hurt, fall back if needed.\n A2 (5.0s): A2 on E1 (27hp), in range. A0 retreat if low, A1 focus E1.\n A1 (5.5s): E1 down. All focus E2, 4.8 away, in range.\n A2 (5.5s): A2 on E2 (45hp, in range). A1 focus E2, last enemy.\n A1 (6.0s): A1 on E2 (36hp), in range. Keep focus fire, last enemy.\n A2 (6.0s): A2 on E2 (36hp), in range. A1 keep firing, last enemy.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 at 27hp, in range. Both keep firing, last enemy.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-8cb07b913c4666e301fa126e.json b/examples/multi-agent-smax/results/llm-cache/ask-8cb07b913c4666e301fa126e.json new file mode 100644 index 00000000..3c899807 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-8cb07b913c4666e301fa126e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 7.5 seconds into the battle.\nYou are A1, a marine at (13.5, 17.2) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E0 marine at (18.0, 17.1), 9/45 health, 4.6 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (4.0s): Firing on E1 (18hp), then E0 together.\n A0 (4.5s): E1 down. Focus E0 now, both fire together.\n A1 (4.5s): E1 dead. Focus E0 (4.6 away), A0 keep firing, I'm full health.\n A1 (5.0s): Firing on E0, last enemy. I'm at full health.\n A1 (5.5s): Last enemy E0 at 36hp; I'm the only one left, firing.\n A1 (6.0s): Last enemy E0 at 36hp, in range, firing.\n A1 (6.5s): Last enemy E0 at 27hp, in range, firing. I'm at 27hp.\n A1 (7.0s): E0 at 18hp, I'm at 18hp, last enemy, keep firing.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 at 9hp, one more hit kills it. Firing.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-8cd933e55312e205336ffc27.json b/examples/multi-agent-smax/results/llm-cache/ask-8cd933e55312e205336ffc27.json new file mode 100644 index 00000000..00855883 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-8cd933e55312e205336ffc27.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.0 seconds into the battle.\nYou are A1, a marine at (8.5, 15.3) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.6, 16.9), 45/45 health, order: hold\n A2 marine at (6.5, 16.6), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (13.0, 15.1), 45/45 health, 4.5 away (in range)\n E1 marine at (14.6, 16.7), 45/45 health, 6.3 away\n E2 marine at (15.8, 17.1), 45/45 health, 7.5 away\nTeam chat (most recent last):\n A1 (1.5s): A1 holding; no enemies yet, focus closest when seen.\n A2 (1.5s): A2 holding; will focus fire on the closest enemy when seen.\n A0 (2.0s): E0 spotted at distance 7.8. Holding grouped; focus E0 when in range.\n A1 (2.0s): E0 east at 7.7 away. Holding grouped; focus E0 when in range.\n A2 (2.0s): A2 holding; will focus the closest enemy when it appears.\n A0 (2.5s): Holding grouped; let them walk into range, then all focus E0.\n A1 (2.5s): Holding grouped; let them walk into range, then focus E0.\n A2 (2.5s): A2 holding grouped; focus E0 when it enters range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 in range at 4.5, all focus fire E0 now.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-8d8105aae58004820bbff3d7.json b/examples/multi-agent-smax/results/llm-cache/ask-8d8105aae58004820bbff3d7.json new file mode 100644 index 00000000..4231cd41 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-8d8105aae58004820bbff3d7.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.5 seconds into the battle.\nYou are A1, a marine at (9.4, 14.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.9, 16.7), 45/45 health, order: hold\n A2 marine at (7.6, 17.8), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (17.6, 15.3), 45/45 health, 8.3 away\nTeam chat (most recent last):\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on closest enemy when they appear.\n A0 (0.5s): A0 holding; will focus fire on the closest enemy that appears.\n A1 (0.5s): A1 holding; will focus fire on closest enemy once visible.\n A2 (0.5s): Holding; staying clustered near A0 until enemies appear, then focus closest.\n A0 (1.0s): A0 holding; A1 move closer to cluster, focus closest enemy when seen.\n A1 (1.0s): A1 holding; will focus closest enemy. Staying near A0 and A2.\n A2 (1.0s): A2 holding; no enemies seen yet, will focus closest when they appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 7.5 16.5\", \"say\": \"A1 moving to cluster with A0/A2; holding together, focus closest enemy.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-8d8e63f194a77e968e7fedab.json b/examples/multi-agent-smax/results/llm-cache/ask-8d8e63f194a77e968e7fedab.json new file mode 100644 index 00000000..169dc3d8 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-8d8e63f194a77e968e7fedab.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.5 seconds into the battle.\nYou are A1, a marine at (8.0, 16.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0: dead\n A2 marine at (8.6, 16.5), 9/45 health, order: attack E2\nEnemies you can see:\n E1 marine at (11.6, 16.0), 45/45 health, 3.5 away (in range)\n E2 marine at (11.8, 14.7), 9/45 health, 4.0 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (5.0s): Switching to E0 with you both. Focus E0 down, then E2.\n A1 (5.0s): Focusing E0 (27hp) with A2; A0 on E2 is fine, then E1.\n A2 (5.0s): A2 firing E0 (27hp). A1 and I kill E0, A0 stays on E2.\n A0 (5.5s): E0 is dead. Focus E2 (27hp), then E1. I'm at 9hp.\n A1 (5.5s): E0 down. Focus E2 (27hp), then E1. A0, stay back, you're low.\n A2 (5.5s): E0 dead. Focus E2 (27hp) together, then E1.\n A1 (6.0s): Focusing E2 (27hp), then E1. A2 stay behind me.\n A2 (6.0s): Focusing E2 (27hp), then E1. A1 keep firing.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Finishing E2 (9hp) now, then E1. A2 stay behind me.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-8e3a29d5b950a613eaea7eab.json b/examples/multi-agent-smax/results/llm-cache/ask-8e3a29d5b950a613eaea7eab.json new file mode 100644 index 00000000..4c923183 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-8e3a29d5b950a613eaea7eab.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 7.0 seconds into the battle.\nYou are A2, a marine at (9.9, 15.8) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0: dead\n A1 marine at (10.1, 17.3), 36/45 health, order: attack E2\nEnemies you can see:\n E2 marine at (14.4, 14.8), 9/45 health, 4.6 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (5.0s): Focusing E1 (18hp), almost dead. Then E2.\n A2 (5.0s): Attacking E1 (18hp), then E2.\n A1 (5.5s): E1 down. All focus E2 (45hp), 5.0 away.\n A2 (5.5s): E1 down. All focus E2, 4.6 away, 45hp.\n A1 (6.0s): Focusing E2 (36hp), keep firing.\n A2 (6.0s): Focusing E2 (36hp), keep firing.\n A1 (6.5s): E2 27hp, in range. Keep firing, finish it.\n A2 (6.5s): E2 at 27hp, keep focusing, almost down.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 at 9hp, in range. Finish it.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-8e6fabf26f08956023d7c977.json b/examples/multi-agent-smax/results/llm-cache/ask-8e6fabf26f08956023d7c977.json new file mode 100644 index 00000000..603cc00a --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-8e6fabf26f08956023d7c977.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 8.0 seconds into the battle.\nYou are A1, a marine at (9.8, 14.2) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E2 marine at (10.8, 17.5), 27/45 health, 3.5 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (5.0s): A1 hitting E1 (27hp, in range). A0 switch to E1, then E2.\n A0 (5.5s): A0 18hp firing E1 (18hp). Finish E1, then all E2.\n A1 (5.5s): A1 on E1 (18hp). A0 keep firing E1, then E2.\n A0 (6.0s): A0 9hp, finishing E1 (9hp). Then focus E2 together.\n A1 (6.0s): A1 on E1 (9hp), finishing it. Then all E2.\n A1 (6.5s): A1 alone vs E2 (45hp), engaging.\n A1 (7.0s): A1 alone vs E2 (45hp), still firing.\n A1 (7.5s): A1 36hp vs E2 36hp, still firing.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"A1 27hp vs E2 27hp, still firing.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-8e75cbf4c0cc92203fa358fc.json b/examples/multi-agent-smax/results/llm-cache/ask-8e75cbf4c0cc92203fa358fc.json new file mode 100644 index 00000000..c7bfdc10 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-8e75cbf4c0cc92203fa358fc.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 2.5 seconds into the battle.\nYou are A2, a marine at (15.3, 16.3) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (14.5, 16.3), 45/45 health, order: attack E1\n A1 marine at (14.6, 15.5), 45/45 health, order: attack E1\nEnemies you can see:\n E0 marine at (18.2, 17.3), 45/45 health, 3.1 away (in range)\n E1 marine at (18.2, 16.6), 27/45 health, 3.0 away (in range)\n E2 marine at (18.4, 14.1), 45/45 health, 3.8 away (in range)\nTeam chat (most recent last):\n A1 (1.0s): Advancing together toward enemies; will all attack E1 once in range 5.\n A2 (1.0s): A2 continuing east to (14,16), staying together; attack same target on contact.\n A0 (1.5s): Advancing together east; attack E1 once all within range 5.\n A1 (1.5s): A1 holding near 14,16 so A0 and A2 catch up; all attack E1 together.\n A2 (1.5s): Advancing together to (15,16); all attack E1 once in range 5.\n A0 (2.0s): Enemies in range now. All attack E1, A1 close in.\n A1 (2.0s): A1 attacking E1 now; A0 and A2 are in range, focus E1.\n A2 (2.0s): Enemies in range of me and A0. Attacking E1 now; A1 close in and fire on E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"retreat\", \"say\": \"A2 at 18hp retreating to pull fire off me; A0, A1 keep focusing E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-8ec7d5167db70b4c1cb00f3e.json b/examples/multi-agent-smax/results/llm-cache/ask-8ec7d5167db70b4c1cb00f3e.json new file mode 100644 index 00000000..0108d031 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-8ec7d5167db70b4c1cb00f3e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.0 seconds into the battle.\nYou are A0, a marine at (8.5, 16.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1: dead\n A2 marine at (7.6, 17.8), 18/45 health, order: attack E2\nEnemies you can see:\n E1 marine at (12.3, 15.6), 36/45 health, 3.9 away (in range)\n E2 marine at (11.9, 17.7), 9/45 health, 3.5 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (4.5s): E0 dead. A1 on E1 at 4.5, focus E1 together; A2 close in.\n A2 (4.5s): E0 is down; all focus E2 (in range, closest), then E1.\n A0 (5.0s): A0 on E2 (full hp). A1 stay back, low. A2 keep firing E2.\n A1 (5.0s): A1 low, shooting E2 from back. A0 you're tanking, focus E2.\n A2 (5.0s): A2 on E2, in range. A0 and A2 focus E2; A1 stay back.\n A0 (5.5s): A0 on E2 (27hp). Keep firing E2, then E1. A1 stay back.\n A1 (5.5s): A1 firing E2 from back; A0 is closest, keep tanking. Focus E2.\n A2 (5.5s): A2 on E2 (27hp), keep focusing. A1 stay back.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"A0 on E2 (9hp), finishing it. Then all E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-8ee43d9a798c9c57ee3de26c.json b/examples/multi-agent-smax/results/llm-cache/ask-8ee43d9a798c9c57ee3de26c.json new file mode 100644 index 00000000..3a3f0804 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-8ee43d9a798c9c57ee3de26c.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.5 seconds into the battle.\nYou are A2, a marine at (10.8, 14.8) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (10.6, 16.0), 27/45 health, order: attack E0\n A1 marine at (8.9, 14.1), 45/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (12.4, 16.4), 18/45 health, 2.3 away (in range)\n E1 marine at (13.1, 16.8), 45/45 health, 3.0 away (in range)\n E2 marine at (13.1, 15.5), 45/45 health, 2.3 away (in range)\nTeam chat (most recent last):\n A1 (3.0s): Holding at range 5; focus E0 when in range. Stay grouped, don't advance alone.\n A2 (3.0s): Holding at range; focus fire E0 (closest) when in range.\n A0 (3.5s): E0 at range 5, firing. Everyone focus E0 now.\n A1 (3.5s): Holding at range 5. Let them approach, then everyone focus E0.\n A2 (3.5s): Focus E0 now, all fire on E0. Stay grouped.\n A0 (4.0s): E0 in range at 1.9, all fire E0. A1 attack E0 too.\n A1 (4.0s): Firing on E0 now, everyone focus E0.\n A2 (4.0s): Firing on E0 all together; A1 attack E0 too, not hold.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 at 18 hp, keep firing E0, then E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-8ef5ff56738e5a88dfca76c6.json b/examples/multi-agent-smax/results/llm-cache/ask-8ef5ff56738e5a88dfca76c6.json new file mode 100644 index 00000000..c559f860 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-8ef5ff56738e5a88dfca76c6.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 1.5 seconds into the battle.\nYou are A2, a marine at (10.7, 16.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 16.\nYour team:\n A0 marine at (11.7, 16.4), 45/45 health, order: move 12 16\n A1 marine at (12.5, 16.4), 45/45 health, order: move 12 16\nEnemies you can see:\n E0 marine at (17.6, 15.3), 45/45 health, 7.0 away\nTeam chat (most recent last):\n A1 (0.0s): Moving together east to (15,16); stay within 2 of each other, attack same target.\n A2 (0.0s): Moving east together toward center, stay within 2 of each other; attack same target on contact.\n A0 (0.5s): A1 please converge on (12,16) with us; A1 is ahead, stay within 2.\n A1 (0.5s): Joining A0 and A2 at (12,16); staying grouped, then advance together.\n A2 (0.5s): A2 moving to (12,16) with team; will attack together on contact.\n A0 (1.0s): Continuing to (12,16); stay grouped, attack same target on contact.\n A1 (1.0s): Holding formation at (12,16); then all advance and attack E0 together.\n A2 (1.0s): Continuing to (12,16) together; will attack same target once all in range 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 13 16\", \"say\": \"Advancing together toward E0; all attack E0 once everyone is within range 5.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-8f8bb7e399bb57441529b1e4.json b/examples/multi-agent-smax/results/llm-cache/ask-8f8bb7e399bb57441529b1e4.json new file mode 100644 index 00000000..e1864a7e --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-8f8bb7e399bb57441529b1e4.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 7.5 seconds into the battle.\nYou are A1, a marine at (15.1, 13.7) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E1 marine at (18.0, 17.0), 9/45 health, 4.3 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (4.5s): E2 at 9hp, finish it now, then E1. I'm low but still firing.\n A1 (4.5s): E2 at 9hp, finishing it. Then E1. A0 stay in, no retreat.\n A0 (5.0s): E2 dead. Focus E1 now, 4.2 away, both fire together.\n A1 (5.0s): E2 dead. All focus E1 now, 4.3 away. A0 keep firing.\n A1 (5.5s): A1 alone now, attacking E1 (27hp). Keep firing.\n A1 (6.0s): A1 alone, E1 at 27hp, still firing.\n A1 (6.5s): A1 alone, E1 at 18hp, keep firing until it dies.\n A1 (7.0s): A1 alone, E1 at 9hp, finishing it.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A1 alone, E1 at 9hp, finishing it now.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-8f93c32a7794d2d3f6ff4b26.json b/examples/multi-agent-smax/results/llm-cache/ask-8f93c32a7794d2d3f6ff4b26.json new file mode 100644 index 00000000..1fda7c7c --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-8f93c32a7794d2d3f6ff4b26.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.0 seconds into the battle.\nYou are A1, a marine at (6.5, 16.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.2, 15.7), 45/45 health, order: hold\n A2 marine at (7.1, 16.5), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (12.3, 17.7), 45/45 health, 6.1 away\n E1 marine at (13.1, 16.0), 45/45 health, 6.7 away\n E2 marine at (11.8, 14.7), 45/45 health, 5.5 away\nTeam chat (most recent last):\n A1 (2.5s): A1 holding in formation; all focus fire on closest enemy when seen.\n A2 (2.5s): A2 holding; will focus closest enemy when seen.\n A0 (3.0s): Enemies approaching at ~8 range; hold together, fire on closest when in range.\n A1 (3.0s): A1 holding; E2 seen east at 8.6. Let them come into range, focus closest.\n A2 (3.0s): A2 holding; enemies at 8 range, let them come in, focus closest.\n A0 (3.5s): Holding; E2 closest at 6.2. Focus E2 when in range.\n A1 (3.5s): A1 holding; fire on closest enemy once in range, E2 first.\n A2 (3.5s): A2 holding; enemies closing, fire on closest E2 when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding; E2 closest at 5.5, focus E2 once in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-8fb0b69b2ab7835bdf57a6fc.json b/examples/multi-agent-smax/results/llm-cache/ask-8fb0b69b2ab7835bdf57a6fc.json new file mode 100644 index 00000000..635a56d2 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-8fb0b69b2ab7835bdf57a6fc.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 2.0 seconds into the battle.\nYou are A1, a marine at (13.6, 14.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 15.\nYour team:\n A0 marine at (14.2, 14.5), 45/45 health, order: move 14 15\n A2 marine at (13.5, 14.8), 45/45 health, order: move 14 15\nEnemies you can see:\n E0 marine at (18.7, 16.4), 45/45 health, 5.7 away\n E1 marine at (19.4, 16.8), 45/45 health, 6.4 away\n E2 marine at (19.4, 15.5), 45/45 health, 5.9 away\nTeam chat (most recent last):\n A1 (0.5s): Advancing east, staying close; will all attack same target when enemies appear.\n A2 (0.5s): Keeping pace east, staying close; will focus same target once in range.\n A0 (1.0s): Continuing east together; A1 and A2 stay close, focus fire once enemies appear.\n A1 (1.0s): Continuing east together; will focus same target when enemies in range.\n A2 (1.0s): Continuing east to 14,15, staying close; will focus same target when enemies appear.\n A0 (1.5s): Enemies ~6.6 east. Closing up on me; attack E0 together once all in range.\n A1 (1.5s): Moving to 14,15 with A0 and A2; will focus same target at range 5.\n A2 (1.5s): Enemies 8 away; keep moving together, then all attack E0 at range 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 15 15\", \"say\": \"Closing on E0 together; once all within 5, everyone attacks E0 same tick.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-905ef517ffcae672539eb3c5.json b/examples/multi-agent-smax/results/llm-cache/ask-905ef517ffcae672539eb3c5.json new file mode 100644 index 00000000..27a2b3fd --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-905ef517ffcae672539eb3c5.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 3.5 seconds into the battle.\nYou are A1, a marine at (12.9, 17.5) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (13.3, 15.6), 18/45 health, order: attack E1\n A2 marine at (13.7, 16.7), 27/45 health, order: attack E1\nEnemies you can see:\n E0 marine at (17.7, 17.8), 45/45 health, 4.9 away (in range)\n E1 marine at (16.9, 14.5), 27/45 health, 5.0 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (2.0s): All three in range of E2 now. Attack E2 together.\n A2 (2.0s): E2 and E1 in my range; attacking E2 now, everyone focus E2.\n A0 (2.5s): E2 at 9hp, finish it now; then focus E1.\n A1 (2.5s): Focusing E2 (9hp), it dies soon; then we focus E0.\n A2 (2.5s): E2 at 9hp, finishing it now. Then focus E1.\n A0 (3.0s): E2 dead. Focus E1 (closest, 3.7 away), then E0.\n A1 (3.0s): E2 dead. Everyone focus E1 now, then E0.\n A2 (3.0s): E2 dead. Everyone focus E1 now, closest at 3.9.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Focusing E1 (27hp). A0 at 18hp, keep firing until E1 dies.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-90aa66edef4093d9ba061f2e.json b/examples/multi-agent-smax/results/llm-cache/ask-90aa66edef4093d9ba061f2e.json new file mode 100644 index 00000000..d9bf1c91 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-90aa66edef4093d9ba061f2e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 8.0 seconds into the battle.\nYou are A1, a marine at (3.6, 15.5) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: retreat.\nYour team:\n A0 marine at (4.8, 16.2), 9/45 health, order: retreat\n A2: dead\nEnemies you can see:\n E0 marine at (10.3, 17.3), 27/45 health, 7.0 away\n E2 marine at (10.5, 14.1), 45/45 health, 7.1 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (6.0s): A0 9hp retreating west; A1 stay with me, regroup before engaging E0 (27hp).\n A1 (6.0s): A1 18hp retreating west; both out of range, regroup before re-engaging E0.\n A0 (6.5s): A0 9hp retreating west; A1 stay out of range, we regroup.\n A1 (6.5s): A1 18hp retreating west with A0; out of range, regroup before engaging.\n A0 (7.0s): A0 9hp still retreating west; A1 stay with me, out of range.\n A1 (7.0s): A1 18hp retreating west; enemies 7 away, out of range. Stay together.\n A0 (7.5s): A0 9hp retreating west; A1 stay with me, out of range of E0 and E2.\n A1 (7.5s): A1 18hp retreating west; staying with A0, out of range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Cornered at west edge. Both focus E0 (27hp) now, then E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-91256a686ce09c7111eaa044.json b/examples/multi-agent-smax/results/llm-cache/ask-91256a686ce09c7111eaa044.json new file mode 100644 index 00000000..224a5c6a --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-91256a686ce09c7111eaa044.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 0.0 seconds into the battle.\nYou are A1, a marine at (8.5, 15.3) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.6, 16.9), 45/45 health, order: hold\n A2 marine at (6.5, 16.6), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 16\", \"say\": \"No enemies seen. Moving east together to (14,16); stay within 2 of each other.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-912ce579bcdae68f5c0d246f.json b/examples/multi-agent-smax/results/llm-cache/ask-912ce579bcdae68f5c0d246f.json new file mode 100644 index 00000000..063d5bcc --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-912ce579bcdae68f5c0d246f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.0 seconds into the battle.\nYou are A0, a marine at (10.6, 16.0) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1 marine at (8.9, 14.1), 45/45 health, order: attack E0\n A2 marine at (10.8, 14.8), 27/45 health, order: attack E0\nEnemies you can see:\n E1 marine at (13.1, 16.8), 45/45 health, 2.6 away (in range)\n E2 marine at (13.1, 15.5), 45/45 health, 2.5 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (3.5s): Holding at range 5. Let them approach, then everyone focus E0.\n A2 (3.5s): Focus E0 now, all fire on E0. Stay grouped.\n A0 (4.0s): E0 in range at 1.9, all fire E0. A1 attack E0 too.\n A1 (4.0s): Firing on E0 now, everyone focus E0.\n A2 (4.0s): Firing on E0 all together; A1 attack E0 too, not hold.\n A0 (4.5s): E0 at 18 hp, finish it, then switch to E2.\n A1 (4.5s): Firing E0 (18hp left), then switch to E2 together.\n A2 (4.5s): E0 at 18 hp, keep firing E0, then E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E0 dead. Focus E2 together, then E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-91376c93a0ae0f32993cab65.json b/examples/multi-agent-smax/results/llm-cache/ask-91376c93a0ae0f32993cab65.json new file mode 100644 index 00000000..51cce0d8 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-91376c93a0ae0f32993cab65.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 8.5 seconds into the battle.\nYou are A1, a marine at (9.8, 14.2) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E2 marine at (10.8, 17.5), 18/45 health, 3.5 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (5.5s): A0 18hp firing E1 (18hp). Finish E1, then all E2.\n A1 (5.5s): A1 on E1 (18hp). A0 keep firing E1, then E2.\n A0 (6.0s): A0 9hp, finishing E1 (9hp). Then focus E2 together.\n A1 (6.0s): A1 on E1 (9hp), finishing it. Then all E2.\n A1 (6.5s): A1 alone vs E2 (45hp), engaging.\n A1 (7.0s): A1 alone vs E2 (45hp), still firing.\n A1 (7.5s): A1 36hp vs E2 36hp, still firing.\n A1 (8.0s): A1 27hp vs E2 27hp, still firing.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"A1 27hp vs E2 18hp, still firing. Last enemy.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-913f0ef1c98f7b42c5be985a.json b/examples/multi-agent-smax/results/llm-cache/ask-913f0ef1c98f7b42c5be985a.json new file mode 100644 index 00000000..5210106b --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-913f0ef1c98f7b42c5be985a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.5 seconds into the battle.\nYou are A2, a marine at (7.7, 14.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (9.0, 16.0), 45/45 health, order: hold\n A1 marine at (7.4, 14.1), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on closest enemy when they appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding position; focus fire on closest enemy once in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-91eff851de517c47b337547d.json b/examples/multi-agent-smax/results/llm-cache/ask-91eff851de517c47b337547d.json new file mode 100644 index 00000000..6cbd1e9a --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-91eff851de517c47b337547d.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.5 seconds into the battle.\nYou are A1, a marine at (7.2, 17.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (7.5, 15.8), 45/45 health, order: attack E2\n A2 marine at (7.6, 17.8), 18/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (11.7, 17.0), 45/45 health, 4.6 away (in range)\n E1 marine at (11.0, 17.2), 45/45 health, 3.9 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (3.0s): E2 at 5.5, nearly in range. Holding; all focus E2 when it enters 5.\n A2 (3.0s): E2 at 5.1, nearly in range. Holding, all fire on E2 first.\n A0 (3.5s): E2 in range, all fire E2 now.\n A1 (3.5s): E2 in range at 3.9. Everyone fire on E2.\n A2 (3.5s): E2 in range at 3.6, all fire E2 now.\n A0 (4.0s): Firing E2 (18hp left); then E1.\n A1 (4.0s): Keep firing E2 (18hp), then E1.\n A2 (4.0s): Keep firing E2, it's at 18 HP. Then focus E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E2 down. Focus E1 (closest, 3.9 away), then E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-92541dedbb2c746f2aeb128a.json b/examples/multi-agent-smax/results/llm-cache/ask-92541dedbb2c746f2aeb128a.json new file mode 100644 index 00000000..2d905169 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-92541dedbb2c746f2aeb128a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.0 seconds into the battle.\nYou are A1, a marine at (7.4, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (9.0, 16.0), 45/45 health, order: hold\n A2 marine at (7.7, 14.8), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding together; focus fire on the closest enemy when they appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-925f851f70afe7e002b28cb9.json b/examples/multi-agent-smax/results/llm-cache/ask-925f851f70afe7e002b28cb9.json new file mode 100644 index 00000000..522dbffb --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-925f851f70afe7e002b28cb9.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.5 seconds into the battle.\nYou are A2, a marine at (10.7, 16.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (8.4, 17.0), 45/45 health, order: hold\n A1 marine at (9.7, 17.5), 18/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (14.6, 17.8), 45/45 health, 4.0 away (in range)\n E1 marine at (13.7, 14.5), 45/45 health, 3.8 away (in range)\n E2 marine at (14.4, 17.0), 27/45 health, 3.8 away (in range)\nTeam chat (most recent last):\n A1 (2.0s): Holding at x=9; shoot E2 when it enters range 5.\n A2 (2.0s): Holding at x=9; E2 closest, all focus E2 when in range.\n A0 (2.5s): Holding at x=9; focus E2 when it enters range 5.\n A1 (2.5s): Focus E2 now, all fire together.\n A2 (2.5s): Holding at x=9; E2 nearly in range, all focus E2.\n A0 (3.0s): Holding at x=9; focus E2 (36hp) first once any enemy enters range 5.\n A1 (3.0s): Firing on E2 (36hp, in range). A0, A2 step up and focus E2.\n A2 (3.0s): Attacking E2 (36hp) with A1; A0 join, focus E2 first.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Firing E2 (27hp), A0 step up and focus E2. A1 stay back.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-92723088e32c1fd61a8ab3b2.json b/examples/multi-agent-smax/results/llm-cache/ask-92723088e32c1fd61a8ab3b2.json new file mode 100644 index 00000000..688db819 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-92723088e32c1fd61a8ab3b2.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 5.0 seconds into the battle.\nYou are A1, a marine at (8.3, 14.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (8.4, 15.6), 45/45 health, order: attack E0\n A2: dead\nEnemies you can see:\n E0 marine at (11.9, 16.8), 9/45 health, 4.5 away (in range)\n E1 marine at (12.2, 16.1), 45/45 health, 4.4 away (in range)\n E2 marine at (12.3, 17.4), 45/45 health, 5.2 away\nTeam chat (most recent last):\n A1 (3.5s): A1 holding. E0 at 6.0; attack E0 together once within 5 of all.\n A2 (3.5s): E0 in range of me, firing now. A0/A1 close in and focus E0.\n A0 (4.0s): A2 engaged, A0 attacking E0 now. A1 attack E0 too, focus fire.\n A1 (4.0s): A2 is engaged; A1 attacking E0 now. A0 join and focus E0.\n A2 (4.0s): Engaged, all 3 enemies on me. A0 A1 attack E0 now, focus fire.\n A0 (4.5s): Focus E0 (27hp). A2 at 9hp, retreat to draw fire away if possible.\n A1 (4.5s): A1 focusing E0 (27hp). A2 retreat, you're at 9hp.\n A2 (4.5s): A2 at 9hp retreating. A0 A1 keep focus on E0, it has 27hp.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"A1 firing on E0 (9hp), finish it then focus E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-92808ee3a83a1286efa2acc7.json b/examples/multi-agent-smax/results/llm-cache/ask-92808ee3a83a1286efa2acc7.json new file mode 100644 index 00000000..8abdde96 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-92808ee3a83a1286efa2acc7.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 4.0 seconds into the battle.\nYou are A2, a marine at (12.8, 14.9) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (14.3, 16.0), 36/45 health, order: attack E2\n A1: dead\nEnemies you can see:\n E1 marine at (16.5, 16.2), 45/45 health, 4.0 away (in range)\n E2 marine at (17.6, 14.3), 27/45 health, 4.8 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A2 (2.0s): Enemies in range now. Everyone attack E0 together.\n A0 (2.5s): Focus E0, it's at 18hp. A1 stay on target per rules.\n A1 (2.5s): Focus E0, it's at 18hp. Keep firing until it dies.\n A2 (2.5s): A2 attacking E0 now; focus it down, then E2.\n A0 (3.0s): E0 is dead. Both attack E2 together, closest enemy; stay level with me.\n A2 (3.0s): E0 is dead. Everyone attack E2, it's in range.\n A0 (3.5s): Both on E2 together, then E1. Keep firing, no retreat.\n A2 (3.5s): Attacking E2 together; keep firing until it dies.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Keep firing on E2 until dead, then E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-92a0b437ab3c3260a834afda.json b/examples/multi-agent-smax/results/llm-cache/ask-92a0b437ab3c3260a834afda.json new file mode 100644 index 00000000..42e9c1a6 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-92a0b437ab3c3260a834afda.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 2.0 seconds into the battle.\nYou are A0, a marine at (12.8, 15.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 16.\nYour team:\n A1 marine at (13.0, 15.0), 45/45 health, order: move 14 16\n A2 marine at (13.0, 14.3), 45/45 health, order: move 14 16\nEnemies you can see:\n E0 marine at (17.3, 15.0), 45/45 health, 4.6 away (in range)\n E1 marine at (18.2, 14.0), 45/45 health, 5.7 away\n E2 marine at (16.6, 16.8), 45/45 health, 3.9 away (in range)\nTeam chat (most recent last):\n A1 (0.5s): A1 advancing to (12,15), staying close; will attack same target on contact.\n A2 (0.5s): A2 advancing to (12,15), staying close; will attack same target on contact.\n A0 (1.0s): Moving together east to (14,16); stay grouped, attack same target on contact.\n A1 (1.0s): A1 continuing to (12,15), staying close; attack same target on contact.\n A2 (1.0s): Holding formation at (12,15); will advance together, then all attack E2 at once.\n A0 (1.5s): A0 closing on group at (12,16); then all advance together on E2.\n A1 (1.5s): Moving to (14,16) with A0; enemies close, then all attack E2 together.\n A2 (1.5s): Moving to (14,16) with A0; enemies ~5 away next, then all attack E2 together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 in range of all three. Attack E2 now, together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-934f4d8a99c7ea91f733b783.json b/examples/multi-agent-smax/results/llm-cache/ask-934f4d8a99c7ea91f733b783.json new file mode 100644 index 00000000..b93712f0 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-934f4d8a99c7ea91f733b783.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.0 seconds into the battle.\nYou are A2, a marine at (10.8, 14.8) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (10.6, 16.0), 18/45 health, order: attack E0\n A1 marine at (8.9, 14.1), 45/45 health, order: attack E0\nEnemies you can see:\n E1 marine at (13.1, 16.8), 45/45 health, 3.0 away (in range)\n E2 marine at (13.1, 15.5), 45/45 health, 2.3 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (3.5s): Holding at range 5. Let them approach, then everyone focus E0.\n A2 (3.5s): Focus E0 now, all fire on E0. Stay grouped.\n A0 (4.0s): E0 in range at 1.9, all fire E0. A1 attack E0 too.\n A1 (4.0s): Firing on E0 now, everyone focus E0.\n A2 (4.0s): Firing on E0 all together; A1 attack E0 too, not hold.\n A0 (4.5s): E0 at 18 hp, finish it, then switch to E2.\n A1 (4.5s): Firing E0 (18hp left), then switch to E2 together.\n A2 (4.5s): E0 at 18 hp, keep firing E0, then E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E0 dead. All focus E2, closest at 2.3, then E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-93a1853ec2ffc733cbe8a0ed.json b/examples/multi-agent-smax/results/llm-cache/ask-93a1853ec2ffc733cbe8a0ed.json new file mode 100644 index 00000000..de02fd9d --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-93a1853ec2ffc733cbe8a0ed.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.0 seconds into the battle.\nYou are A2, a marine at (9.3, 14.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 11 15.\nYour team:\n A0 marine at (9.0, 16.0), 45/45 health, order: move 9.3 15\n A1 marine at (8.9, 14.1), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (15.6, 16.4), 45/45 health, 6.5 away\n E1 marine at (16.2, 16.8), 45/45 health, 7.3 away\n E2 marine at (16.2, 15.5), 45/45 health, 7.0 away\nTeam chat (most recent last):\n A1 (1.5s): Still holding; will focus fire on closest enemy when visible.\n A2 (1.5s): Holding grouped; focus fire on closest enemy when it appears.\n A0 (2.0s): No contact; advancing east to center together. Stay close, focus closest enemy.\n A1 (2.0s): No contact; advancing east together to find enemies. Stay grouped, focus closest.\n A2 (2.0s): Holding grouped; focus fire closest enemy when it appears.\n A0 (2.5s): Enemies 3 at east, ~7 away. Falling back to group; hold and focus E0 when in range.\n A1 (2.5s): Enemies E0, E2 east ~9 away. Holding grouped; focus E0 when in range.\n A2 (2.5s): Advancing east to join A0/A1; stay grouped, focus closest enemy.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding at range; all focus E0 when it enters 5 range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-93defdb077780b2555e4468c.json b/examples/multi-agent-smax/results/llm-cache/ask-93defdb077780b2555e4468c.json new file mode 100644 index 00000000..874b587f --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-93defdb077780b2555e4468c.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 6.5 seconds into the battle.\nYou are A1, a marine at (8.3, 14.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (6.9, 15.6), 9/45 health, order: retreat\n A2: dead\nEnemies you can see:\n E1 marine at (12.2, 16.1), 36/45 health, 4.4 away (in range)\n E2 marine at (12.3, 17.4), 45/45 health, 5.2 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (4.5s): A1 focusing E0 (27hp). A2 retreat, you're at 9hp.\n A2 (4.5s): A2 at 9hp retreating. A0 A1 keep focus on E0, it has 27hp.\n A0 (5.0s): E0 at 9hp, finishing it now. A1 focus E0.\n A1 (5.0s): A1 firing on E0 (9hp), finish it then focus E1.\n A0 (5.5s): E0 dead. Both focus E1 now, then E2.\n A1 (5.5s): E0 down. Focus E1 (4.4 away, in range) now, both of us.\n A0 (6.0s): A0 at 18hp retreating to pull fire off. A1 focus E1, I'll rejoin if safe.\n A1 (6.0s): A1 attacking E1 (45hp). A0 at 18hp, retreat if under 20 to shed aggro.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A1 attacking E1 (36hp), in range. A0 stay back, keep out of range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-93f5677b1911bf17f2a09e7d.json b/examples/multi-agent-smax/results/llm-cache/ask-93f5677b1911bf17f2a09e7d.json new file mode 100644 index 00000000..bf1e828f --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-93f5677b1911bf17f2a09e7d.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.0 seconds into the battle.\nYou are A2, a marine at (9.0, 16.0) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (9.3, 15.3), 45/45 health, order: attack E0\n A1 marine at (8.3, 14.2), 45/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (13.4, 16.8), 27/45 health, 4.5 away (in range)\n E1 marine at (12.2, 16.1), 45/45 health, 3.2 away (in range)\n E2 marine at (12.3, 17.5), 45/45 health, 3.6 away (in range)\nTeam chat (most recent last):\n A1 (2.5s): A1 holding at (6.7,14.2); A0 fall back to us, focus E0 together.\n A2 (2.5s): A2 holding; enemies approaching, all focus E0 when in range.\n A0 (3.0s): A0 holding; focus E0 when in range 5.\n A1 (3.0s): A1 holding; focus E0 when it enters range 5.\n A2 (3.0s): A2 attacking E0 (in range); all focus E0.\n A0 (3.5s): A0 attacking E0 now; focus E0 together.\n A1 (3.5s): A1 advancing, focusing E0 with A2. A0 join fire on E0.\n A2 (3.5s): A2 attacking E0 (36hp, in range); all focus E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"A2 firing on E0 (27hp); finish it, then E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-93fbc9b67ba3669fdaf8518f.json b/examples/multi-agent-smax/results/llm-cache/ask-93fbc9b67ba3669fdaf8518f.json new file mode 100644 index 00000000..210c7b1e --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-93fbc9b67ba3669fdaf8518f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.5 seconds into the battle.\nYou are A1, a marine at (8.9, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0: dead\n A2 marine at (10.8, 14.8), 9/45 health, order: attack E2\nEnemies you can see:\n E1 marine at (13.1, 16.8), 45/45 health, 5.0 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (5.0s): E0 dead. Focus E2 (4.4 away, 45hp), everyone fire E2 together.\n A2 (5.0s): E0 dead. All focus E2, closest at 2.3, then E1.\n A0 (5.5s): E2 at 18hp, all fire E2 now, then E1.\n A1 (5.5s): Firing E2 (18hp), then E1 together.\n A2 (5.5s): Keep firing E2 (18hp), then E1 together.\n A0 (6.0s): E2 at 9hp, finish it now, then E1. I'm low, 9hp.\n A1 (6.0s): E2 at 9hp, finish it now, then E1.\n A2 (6.0s): E2 at 9hp, finish it, then all on E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E2 dead. All focus E1, it's at 45hp, 5.0 away.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-941203aabbee7d19514a1dbe.json b/examples/multi-agent-smax/results/llm-cache/ask-941203aabbee7d19514a1dbe.json new file mode 100644 index 00000000..fec7b25b --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-941203aabbee7d19514a1dbe.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.5 seconds into the battle.\nYou are A0, a marine at (8.4, 17.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (9.7, 17.5), 18/45 health, order: attack E2\n A2 marine at (10.7, 16.8), 45/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (14.6, 17.8), 45/45 health, 6.2 away\n E1 marine at (13.7, 14.5), 45/45 health, 5.9 away\n E2 marine at (14.4, 17.0), 27/45 health, 6.1 away\nTeam chat (most recent last):\n A1 (2.0s): Holding at x=9; shoot E2 when it enters range 5.\n A2 (2.0s): Holding at x=9; E2 closest, all focus E2 when in range.\n A0 (2.5s): Holding at x=9; focus E2 when it enters range 5.\n A1 (2.5s): Focus E2 now, all fire together.\n A2 (2.5s): Holding at x=9; E2 nearly in range, all focus E2.\n A0 (3.0s): Holding at x=9; focus E2 (36hp) first once any enemy enters range 5.\n A1 (3.0s): Firing on E2 (36hp, in range). A0, A2 step up and focus E2.\n A2 (3.0s): Attacking E2 (36hp) with A1; A0 join, focus E2 first.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Attacking E2 (27hp), closing in to focus fire with A2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-945b4080151536fc5d0f1e07.json b/examples/multi-agent-smax/results/llm-cache/ask-945b4080151536fc5d0f1e07.json new file mode 100644 index 00000000..2e83b58c --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-945b4080151536fc5d0f1e07.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 3.5 seconds into the battle.\nYou are A1, a marine at (13.0, 15.0) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (12.8, 15.9), 27/45 health, order: attack E1\n A2 marine at (13.0, 14.3), 27/45 health, order: attack E1\nEnemies you can see:\n E0 marine at (17.3, 15.0), 45/45 health, 4.4 away (in range)\n E1 marine at (16.6, 14.0), 36/45 health, 3.8 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (2.0s): All in range of E2 now. Attack E2 together.\n A2 (2.0s): E2 in range of all three. Attack E2 now, together.\n A0 (2.5s): Firing on E2, 18hp left. Keep attacking together.\n A1 (2.5s): Firing on E2 (18hp), keep attacking until it dies.\n A2 (2.5s): Attacking E2, it's at 18hp; finish it together.\n A0 (3.0s): E2 dead. Everyone focus E1, closest to all of us.\n A1 (3.0s): E2 dead. Focus E1 (closest, 3.8 away), all attack E1 together.\n A2 (3.0s): E2 is dead. Focus E1 (closest, 3.6 away), all together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Attacking E1 (36hp), keep focus until it dies.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-950901ad03adc2b8f39c428d.json b/examples/multi-agent-smax/results/llm-cache/ask-950901ad03adc2b8f39c428d.json new file mode 100644 index 00000000..8555fa7c --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-950901ad03adc2b8f39c428d.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 4.5 seconds into the battle.\nYou are A1, a marine at (14.2, 16.3) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (13.7, 15.6), 27/45 health, order: attack E0\n A2: dead\nEnemies you can see:\n E0 marine at (17.0, 17.7), 18/45 health, 3.1 away (in range)\n E1 marine at (17.9, 16.0), 45/45 health, 3.7 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (3.0s): E2 at 9hp, finish it now, then focus E1.\n A1 (3.0s): E2 at 9hp, finish it now, then focus E0.\n A2 (3.0s): E2 at 9hp, finish it now, then focus E0.\n A0 (3.5s): E2 dead. Everyone focus E0 now. A2 at 9hp, retreat.\n A1 (3.5s): E2 dead. All focus E0 now, then E1. A2 retreat, you're at 9hp.\n A2 (3.5s): A2 at 9hp retreating. A0, A1 focus E0 now.\n A0 (4.0s): Focus E0 (36hp), then E1. I'm 27hp, staying in.\n A1 (4.0s): Focus E0 (36hp), then E1. A0 at 27hp, stay in unless under 20.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 at 18hp, keep focusing it, then E1. A0 retreat if under 20.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-9582fb1af10b67f8325e06f7.json b/examples/multi-agent-smax/results/llm-cache/ask-9582fb1af10b67f8325e06f7.json new file mode 100644 index 00000000..f2381b25 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-9582fb1af10b67f8325e06f7.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.5 seconds into the battle.\nYou are A0, a marine at (8.6, 16.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (8.5, 15.3), 45/45 health, order: hold\n A2 marine at (6.5, 16.6), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together as a group; focus fire on the closest enemy once seen.\n A0 (0.5s): No enemies yet. Holding; focus the closest when they appear.\n A1 (0.5s): A1 holding; will focus fire on the closest enemy that appears.\n A2 (0.5s): No enemies yet; staying grouped, will focus the closest one when seen.\n A0 (1.0s): Still no enemies; holding grouped, focus closest when seen.\n A1 (1.0s): A1 holding; no enemies yet, will focus the closest when seen.\n A2 (1.0s): A2 holding; will focus the closest enemy when it appears.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A0 holding; still no enemies. Focus the closest when they appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-967503d5044de409f7ebe058.json b/examples/multi-agent-smax/results/llm-cache/ask-967503d5044de409f7ebe058.json new file mode 100644 index 00000000..90ee3b75 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-967503d5044de409f7ebe058.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.0 seconds into the battle.\nYou are A0, a marine at (10.6, 16.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1 marine at (8.9, 14.1), 45/45 health, order: hold\n A2 marine at (10.8, 14.8), 45/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (12.4, 16.4), 45/45 health, 1.9 away (in range)\n E1 marine at (13.1, 16.8), 45/45 health, 2.6 away (in range)\n E2 marine at (13.1, 15.5), 45/45 health, 2.5 away (in range)\nTeam chat (most recent last):\n A1 (2.5s): Enemies E0, E2 east ~9 away. Holding grouped; focus E0 when in range.\n A2 (2.5s): Advancing east to join A0/A1; stay grouped, focus closest enemy.\n A0 (3.0s): Holding at range; focus E0 when it enters 5. Stay grouped.\n A1 (3.0s): Holding at range 5; focus E0 when in range. Stay grouped, don't advance alone.\n A2 (3.0s): Holding at range; focus fire E0 (closest) when in range.\n A0 (3.5s): E0 at range 5, firing. Everyone focus E0 now.\n A1 (3.5s): Holding at range 5. Let them approach, then everyone focus E0.\n A2 (3.5s): Focus E0 now, all fire on E0. Stay grouped.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 in range at 1.9, all fire E0. A1 attack E0 too.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-96a26b93386e56d442f1f47f.json b/examples/multi-agent-smax/results/llm-cache/ask-96a26b93386e56d442f1f47f.json new file mode 100644 index 00000000..f18b1113 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-96a26b93386e56d442f1f47f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 2.0 seconds into the battle.\nYou are A0, a marine at (14.2, 14.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 15.\nYour team:\n A1 marine at (13.6, 14.0), 45/45 health, order: move 14 15\n A2 marine at (13.5, 14.8), 45/45 health, order: move 14 15\nEnemies you can see:\n E0 marine at (18.7, 16.4), 45/45 health, 4.9 away (in range)\n E1 marine at (19.4, 16.8), 45/45 health, 5.7 away\n E2 marine at (19.4, 15.5), 45/45 health, 5.2 away\nTeam chat (most recent last):\n A1 (0.5s): Advancing east, staying close; will all attack same target when enemies appear.\n A2 (0.5s): Keeping pace east, staying close; will focus same target once in range.\n A0 (1.0s): Continuing east together; A1 and A2 stay close, focus fire once enemies appear.\n A1 (1.0s): Continuing east together; will focus same target when enemies in range.\n A2 (1.0s): Continuing east to 14,15, staying close; will focus same target when enemies appear.\n A0 (1.5s): Enemies ~6.6 east. Closing up on me; attack E0 together once all in range.\n A1 (1.5s): Moving to 14,15 with A0 and A2; will focus same target at range 5.\n A2 (1.5s): Enemies 8 away; keep moving together, then all attack E0 at range 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Attacking E0 now. A1, A2, step in and focus E0 immediately.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-9714e5017324452c6c99c480.json b/examples/multi-agent-smax/results/llm-cache/ask-9714e5017324452c6c99c480.json new file mode 100644 index 00000000..96f4bb8e --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-9714e5017324452c6c99c480.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.5 seconds into the battle.\nYou are A2, a marine at (8.1, 14.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (8.1, 15.8), 36/45 health, order: attack E2\n A1 marine at (8.3, 14.1), 9/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (12.9, 15.0), 45/45 health, 4.8 away (in range)\n E1 marine at (11.8, 16.2), 45/45 health, 3.9 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (3.0s): Holding at (8,14). Focus E2 first when in range, then E0.\n A2 (3.0s): Holding at (8,15). Focus E2 or E0 when in range 5.\n A0 (3.5s): Focus E2 now, then E0. Stay grouped.\n A1 (3.5s): Focus E2 now, then E0. Everyone fire.\n A2 (3.5s): Focusing E2 now, then E0. All fire E2.\n A0 (4.0s): E2 is at 18 HP, finish it, then E1.\n A1 (4.0s): Firing E2 (18hp). Then E0. I'm at 27hp.\n A2 (4.0s): Firing E2 (18 hp left), then E0. Stay grouped.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E2 is dead. Focus E1 (closest, 3.9 away), then E0. A1 is at 9hp, so stay behind.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-97765be58d1b18f617f8ba45.json b/examples/multi-agent-smax/results/llm-cache/ask-97765be58d1b18f617f8ba45.json new file mode 100644 index 00000000..44d1e4aa --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-97765be58d1b18f617f8ba45.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.5 seconds into the battle.\nYou are A2, a marine at (9.1, 16.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.4, 17.0), 45/45 health, order: hold\n A1 marine at (9.7, 17.5), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (17.6, 17.6), 45/45 health, 8.5 away\n E1 marine at (15.3, 14.5), 45/45 health, 6.6 away\n E2 marine at (14.6, 17.2), 45/45 health, 5.5 away\nTeam chat (most recent last):\n A1 (1.0s): Grouping at x=9; focus fire on nearest enemy when seen.\n A2 (1.0s): Holding at cluster near (9,16.7); focus fire on the closest enemy.\n A0 (1.5s): Holding at x=9 with cluster; focus fire on closest enemy when seen.\n A1 (1.5s): Holding at x=9; enemy E2 approaching, all focus the closest one.\n A2 (1.5s): E2 spotted east at 8.7 range; holding together, focus whatever enters range first.\n A0 (2.0s): Holding at x=9; shoot first enemy entering 5 range, focus closest.\n A1 (2.0s): Holding at x=9; shoot E2 when it enters range 5.\n A2 (2.0s): Holding at x=9; E2 closest, all focus E2 when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding at x=9; E2 nearly in range, all focus E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-978088459e6990d16acfc76b.json b/examples/multi-agent-smax/results/llm-cache/ask-978088459e6990d16acfc76b.json new file mode 100644 index 00000000..8158b834 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-978088459e6990d16acfc76b.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 3.0 seconds into the battle.\nYou are A2, a marine at (14.9, 18.0) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (13.7, 15.6), 27/45 health, order: attack E2\n A1 marine at (14.2, 16.3), 45/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (17.0, 17.7), 45/45 health, 2.1 away (in range)\n E1 marine at (17.9, 16.0), 45/45 health, 3.6 away (in range)\n E2 marine at (18.1, 14.7), 9/45 health, 4.6 away (in range)\nTeam chat (most recent last):\n A1 (1.5s): Enemy E2 at (19.7,14.7). Advancing together to 15,16; attack E2 when all in range.\n A2 (1.5s): Enemies ~8 east. Advancing together to x=15; stay within 2, then focus E0.\n A0 (2.0s): E2 in my range, firing now. A1, A2 close in and focus E2.\n A1 (2.0s): Moving with you to 15,16; next tick all attack E2 together.\n A2 (2.0s): Closing to 15,17 together; once all in range 5, everyone attack E0 same tick.\n A0 (2.5s): All in range now. Everyone attack E2 this tick.\n A1 (2.5s): All in range now. Everyone focus E2, it's at 36hp.\n A2 (2.5s): All in range now. Focus E2 (36hp), everyone attack E2 this tick.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 at 9hp, finish it now, then focus E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-97d45a6794e75e19564604f0.json b/examples/multi-agent-smax/results/llm-cache/ask-97d45a6794e75e19564604f0.json new file mode 100644 index 00000000..c1ed8d58 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-97d45a6794e75e19564604f0.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 3.0 seconds into the battle.\nYou are A2, a marine at (13.9, 17.8) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (13.8, 15.8), 27/45 health, order: attack E2\n A1 marine at (13.5, 17.2), 45/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (18.0, 17.1), 45/45 health, 4.2 away (in range)\n E1 marine at (17.3, 17.0), 45/45 health, 3.5 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (1.5s): Almost in range of E2; keep pace, all attack E2 together next tick.\n A2 (1.5s): Still closing together; E2 just outside range. Fire on E2 once all in range 5.\n A0 (2.0s): All in range of E2 now. Everyone fire on E2.\n A1 (2.0s): All in range of E2 (2.4 away). Attack E2 now, everyone focus fire.\n A2 (2.0s): E2 in range of me; all attack E2 now.\n A0 (2.5s): Firing on E2, it's at 18hp. Then focus E1 next.\n A1 (2.5s): Focusing E2, it's at 18hp. Keep firing, then switch to E1 together.\n A2 (2.5s): E2 at 18hp, keep firing on E2, then switch to E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E2 dead. All focus E1 (closest, 3.5 away) now.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-982b9e0a9948857ba303b855.json b/examples/multi-agent-smax/results/llm-cache/ask-982b9e0a9948857ba303b855.json new file mode 100644 index 00000000..6bf4036f --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-982b9e0a9948857ba303b855.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 7.5 seconds into the battle.\nYou are A0, a marine at (8.3, 17.0) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: retreat.\nYour team:\n A1: dead\n A2: dead\nEnemies you can see:\n E0 marine at (14.6, 17.8), 45/45 health, 6.3 away\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (4.5s): E2 is down. Focus E1 (closest, 45hp), then E0.\n A2 (4.5s): E2 down. Focus E1 (closest, 3.8 away), then E0.\n A0 (5.0s): Focusing E1 (36hp), both in range. A2 stay behind me, you're low.\n A2 (5.0s): Focus E1 (36hp), I'm low at 18hp. A0 keep firing, then E0.\n A0 (5.5s): A0 on E1 (18hp), almost dead. Then E0.\n A0 (6.0s): Finishing E1 (18hp), then E0. A2 stay back.\n A0 (6.5s): E1 at 9hp, finishing it now, then E0. A0 at 27hp.\n A0 (7.0s): E1 down. A0 at 9hp, E0 at 45hp left. Pulling out of range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"retreat\", \"say\": \"A0 at 9hp, last one alive. Kiting away from E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-98502ad16a6b6f7399c59d9b.json b/examples/multi-agent-smax/results/llm-cache/ask-98502ad16a6b6f7399c59d9b.json new file mode 100644 index 00000000..e029a635 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-98502ad16a6b6f7399c59d9b.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 0.0 seconds into the battle.\nYou are A1, a marine at (6.5, 16.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.2, 15.8), 45/45 health, order: hold\n A2 marine at (7.0, 18.0), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 16\", \"say\": \"Moving east together toward the center; stay within 2 of each other.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-98861c7989de174fdd6b6f3b.json b/examples/multi-agent-smax/results/llm-cache/ask-98861c7989de174fdd6b6f3b.json new file mode 100644 index 00000000..ab6ac9f6 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-98861c7989de174fdd6b6f3b.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.5 seconds into the battle.\nYou are A2, a marine at (9.3, 14.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (9.0, 16.0), 45/45 health, order: hold\n A1 marine at (8.9, 14.1), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (14.0, 16.4), 45/45 health, 5.0 away\n E1 marine at (14.7, 16.8), 45/45 health, 5.8 away\n E2 marine at (14.6, 15.5), 45/45 health, 5.4 away\nTeam chat (most recent last):\n A1 (2.0s): No contact; advancing east together to find enemies. Stay grouped, focus closest.\n A2 (2.0s): Holding grouped; focus fire closest enemy when it appears.\n A0 (2.5s): Enemies 3 at east, ~7 away. Falling back to group; hold and focus E0 when in range.\n A1 (2.5s): Enemies E0, E2 east ~9 away. Holding grouped; focus E0 when in range.\n A2 (2.5s): Advancing east to join A0/A1; stay grouped, focus closest enemy.\n A0 (3.0s): Holding at range; focus E0 when it enters 5. Stay grouped.\n A1 (3.0s): Holding at range 5; focus E0 when in range. Stay grouped, don't advance alone.\n A2 (3.0s): Holding at range; focus fire E0 (closest) when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Focus E0 now, all fire on E0. Stay grouped.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-99798a5df3026d5e27ffb6a1.json b/examples/multi-agent-smax/results/llm-cache/ask-99798a5df3026d5e27ffb6a1.json new file mode 100644 index 00000000..d86b7fbc --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-99798a5df3026d5e27ffb6a1.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 3.0 seconds into the battle.\nYou are A0, a marine at (13.3, 16.4) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1: dead\n A2 marine at (12.3, 16.5), 45/45 health, order: attack E0\nEnemies you can see:\n E1 marine at (18.6, 15.6), 45/45 health, 5.4 away\n E2 marine at (18.2, 17.7), 45/45 health, 5.1 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (1.5s): Advancing together east to (14,16); then all attack E0 at once.\n A2 (1.5s): Advancing together toward E0; all attack E0 once everyone is within range 5.\n A0 (2.0s): E0 is within range 5 of all three of us. Everyone attack E0 now.\n A1 (2.0s): E0 is in range of all three of us. Everyone attack E0 now.\n A2 (2.0s): E0 is in range of all three; attacking E0 now, focus fire.\n A0 (2.5s): Keep focusing E0; A1 stay in fight until E0 dies, then retreat.\n A1 (2.5s): E0 at 18hp, keep focus fire; I'm at 18hp and will step back once it dies.\n A2 (2.5s): Focus E0, it's at 18hp. A1 is low; keep firing until E0 dies.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E0 dead. A2 stay close, all focus E2 together. A1 retreat.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-999d3c8a833fe5112221f210.json b/examples/multi-agent-smax/results/llm-cache/ask-999d3c8a833fe5112221f210.json new file mode 100644 index 00000000..c09d8555 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-999d3c8a833fe5112221f210.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 7.0 seconds into the battle.\nYou are A0, a marine at (9.9, 17.0) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1: dead\n A2: dead\nEnemies you can see:\n E0 marine at (14.6, 17.8), 45/45 health, 4.7 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A2 (4.0s): E2 at 18hp, finish it now. A0 keep firing.\n A0 (4.5s): E2 is down. Focus E1 (closest, 45hp), then E0.\n A2 (4.5s): E2 down. Focus E1 (closest, 3.8 away), then E0.\n A0 (5.0s): Focusing E1 (36hp), both in range. A2 stay behind me, you're low.\n A2 (5.0s): Focus E1 (36hp), I'm low at 18hp. A0 keep firing, then E0.\n A0 (5.5s): A0 on E1 (18hp), almost dead. Then E0.\n A0 (6.0s): Finishing E1 (18hp), then E0. A2 stay back.\n A0 (6.5s): E1 at 9hp, finishing it now, then E0. A0 at 27hp.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"retreat\", \"say\": \"E1 down. A0 at 9hp, E0 at 45hp left. Pulling out of range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-99b49f22294e2dfb14586956.json b/examples/multi-agent-smax/results/llm-cache/ask-99b49f22294e2dfb14586956.json new file mode 100644 index 00000000..1e60ec32 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-99b49f22294e2dfb14586956.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.5 seconds into the battle.\nYou are A2, a marine at (9.1, 16.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.4, 17.0), 45/45 health, order: move 9 16.5\n A1 marine at (9.7, 17.5), 45/45 health, order: move 9 16.8\nEnemies you can see:\n E2 marine at (17.8, 17.2), 45/45 health, 8.7 away\nTeam chat (most recent last):\n A1 (0.0s): Advancing east together; stay close and focus fire on the nearest enemy.\n A2 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A0 (0.5s): A1 fell back toward cluster; I'm moving to x=9 so we stay grouped.\n A1 (0.5s): Falling back to cluster; hold together and focus the closest enemy.\n A2 (0.5s): A1 is ahead alone; moving up to group with A1, then focus nearest enemy.\n A0 (1.0s): Grouped at x=9; hold here and focus the closest enemy when seen.\n A1 (1.0s): Grouping at x=9; focus fire on nearest enemy when seen.\n A2 (1.0s): Holding at cluster near (9,16.7); focus fire on the closest enemy.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"E2 spotted east at 8.7 range; holding together, focus whatever enters range first.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-99bbb9db8aa767117dd3433c.json b/examples/multi-agent-smax/results/llm-cache/ask-99bbb9db8aa767117dd3433c.json new file mode 100644 index 00000000..1a369911 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-99bbb9db8aa767117dd3433c.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.5 seconds into the battle.\nYou are A0, a marine at (8.4, 17.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 9 16.5.\nYour team:\n A1 marine at (9.7, 17.5), 45/45 health, order: move 9 16.8\n A2 marine at (9.1, 16.8), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.0s): Advancing east together; stay close and focus fire on the nearest enemy.\n A2 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A0 (0.5s): A1 fell back toward cluster; I'm moving to x=9 so we stay grouped.\n A1 (0.5s): Falling back to cluster; hold together and focus the closest enemy.\n A2 (0.5s): A1 is ahead alone; moving up to group with A1, then focus nearest enemy.\n A0 (1.0s): Grouped at x=9; hold here and focus the closest enemy when seen.\n A1 (1.0s): Grouping at x=9; focus fire on nearest enemy when seen.\n A2 (1.0s): Holding at cluster near (9,16.7); focus fire on the closest enemy.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding at x=9 with cluster; focus fire on closest enemy when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-99fd1782b946a13e7c117e0a.json b/examples/multi-agent-smax/results/llm-cache/ask-99fd1782b946a13e7c117e0a.json new file mode 100644 index 00000000..5ab603da --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-99fd1782b946a13e7c117e0a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 7.5 seconds into the battle.\nYou are A0, a marine at (13.7, 15.6) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1: dead\n A2: dead\nEnemies you can see:\n E1 marine at (17.9, 16.0), 9/45 health, 4.2 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (5.0s): E0 dead. Focus E1 now, it's in range 4.2.\n A1 (5.0s): E0 down. Both focus E1 now, it's the last one.\n A0 (5.5s): Focusing E1. A1 at 9hp, retreat if you're targeted; I'm 27hp, staying in.\n A1 (5.5s): Attacking E1. I'm 9hp and will soak a shot. A0 keep firing, finish it.\n A0 (6.0s): Firing on E1 (27hp). A1 retreat if targeted; I'm 27hp, staying in.\n A1 (6.0s): A1 at 9hp retreating so I'm not the target. A0 finish E1.\n A0 (6.5s): Firing on E1, last enemy. A0 27hp, staying in.\n A0 (7.0s): Firing on E1, 18hp left. A0 27hp, finishing it.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Firing on E1, 9hp left. Finishing it.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-9afa134acc85d06c782ea7b4.json b/examples/multi-agent-smax/results/llm-cache/ask-9afa134acc85d06c782ea7b4.json new file mode 100644 index 00000000..027629d1 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-9afa134acc85d06c782ea7b4.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 5.5 seconds into the battle.\nYou are A0, a marine at (12.7, 16.2) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: retreat.\nYour team:\n A1 marine at (11.4, 15.5), 18/45 health, order: attack E0\n A2: dead\nEnemies you can see:\n E0 marine at (18.2, 17.3), 27/45 health, 5.7 away\n E2 marine at (18.4, 14.1), 45/45 health, 6.1 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (3.5s): E1 dead. A0 focusing E0; A1 under 20hp, retreat to pull fire.\n A1 (3.5s): A1 at 18hp retreating so A0 is closest; A0 focus E2, I return when safe.\n A0 (4.0s): Focusing E0 (36hp). A1 stay back; I'm tanking, then we take E2.\n A1 (4.0s): A1 18hp retreating; A0 you're closest, focus E0 (36hp), I'll return when safe.\n A0 (4.5s): A0 firing E0 (27hp), tanking. A1 stay back, then we take E2.\n A1 (4.5s): A1 18hp staying back; A0 kill E0 (27hp), then E2.\n A0 (5.0s): A0 at 9hp retreating. A1 you hold and shoot closest; we regroup and focus E0.\n A1 (5.0s): A1 joining now, both focus E0 (27hp) to split their fire.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"retreat\", \"say\": \"A0 9hp retreating; A1 focus E0 (27hp), I return if enemies shift.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-9b5e0161cf22116000e943a2.json b/examples/multi-agent-smax/results/llm-cache/ask-9b5e0161cf22116000e943a2.json new file mode 100644 index 00000000..fa98ee22 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-9b5e0161cf22116000e943a2.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.0 seconds into the battle.\nYou are A1, a marine at (8.3, 14.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (9.3, 15.3), 9/45 health, order: attack E1\n A2: dead\nEnemies you can see:\n E1 marine at (12.2, 16.1), 9/45 health, 4.3 away (in range)\n E2 marine at (12.3, 17.5), 45/45 health, 5.3 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A2 (4.0s): A2 firing on E0 (27hp); finish it, then E1.\n A0 (4.5s): A0 firing E0 (18hp), nearly dead. Then all E1.\n A1 (4.5s): A1 hitting E1 (36hp). After E0 dies, everyone on E1.\n A2 (4.5s): A2 9hp. E0 at 18hp, A0 and I finish it now, then E1.\n A0 (5.0s): E0 is dead. A0 and A1 focus E1 (27hp), then E2.\n A1 (5.0s): A1 on E1 (27hp), in range. A0 join E1, then E2.\n A0 (5.5s): A0 18hp on E1 (18hp), finishing it. Then both on E2.\n A1 (5.5s): A1 on E1 (18hp), in range. A0 keep firing, then both E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A1 on E1 (9hp), finishing it. Then both on E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-9bccfe7c1b53c7a312fd26a4.json b/examples/multi-agent-smax/results/llm-cache/ask-9bccfe7c1b53c7a312fd26a4.json new file mode 100644 index 00000000..edb47429 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-9bccfe7c1b53c7a312fd26a4.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.0 seconds into the battle.\nYou are A1, a marine at (9.9, 15.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.2, 16.2), 45/45 health, order: hold\n A2 marine at (10.5, 16.3), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (15.1, 17.3), 45/45 health, 5.5 away\n E1 marine at (15.1, 16.6), 45/45 health, 5.3 away\n E2 marine at (15.3, 14.1), 45/45 health, 5.6 away\nTeam chat (most recent last):\n A1 (1.5s): Holding grouped; focus fire on closest enemy when seen.\n A2 (1.5s): Still holding grouped; will focus the closest enemy when it appears.\n A0 (2.0s): Holding grouped; no enemies yet. Focus closest when seen.\n A1 (2.0s): Enemies at 8.5 east. Hold grouped; all focus the closest when in range.\n A2 (2.0s): No contact after 2s. Advancing east together to (14,16); stay close, focus closest.\n A0 (2.5s): A2 advancing alone is risky; hold grouped at range 5, focus E1 when in range.\n A1 (2.5s): Enemies 7 east. A2 fall back to group; hold and focus E1 when in range.\n A2 (2.5s): Cancel advance. Holding at 10.5; enemies 6 east, focus E1 when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding. E1 is closest at 5.3; focus E1 as soon as it's in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-9c4cec0271f63012f3670c7e.json b/examples/multi-agent-smax/results/llm-cache/ask-9c4cec0271f63012f3670c7e.json new file mode 100644 index 00000000..fda4dcd4 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-9c4cec0271f63012f3670c7e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.0 seconds into the battle.\nYou are A1, a marine at (8.5, 14.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.8, 14.7), 45/45 health, order: hold\n A2 marine at (8.2, 14.1), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (17.3, 15.0), 45/45 health, 8.8 away\n E2 marine at (16.6, 16.8), 45/45 health, 8.3 away\nTeam chat (most recent last):\n A1 (0.5s): Closing to (8,15) to cluster; will focus closest enemy.\n A2 (0.5s): Moving to regroup at (8,15); will focus fire closest enemy.\n A0 (1.0s): Moving to cluster at (8,15); will focus fire closest enemy.\n A1 (1.0s): A1 at (8,15) holding. Focus fire on closest enemy.\n A2 (1.0s): A2 at (8,14) holding; will focus the closest enemy when it appears.\n A0 (1.5s): A0 holding at (8,15); focus fire on the closest enemy when seen.\n A1 (1.5s): A1 holding at cluster; focus fire on closest enemy when seen.\n A2 (1.5s): A2 holding at (8,14). Clustered; focus fire on closest enemy.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding cluster; let them walk into range, then focus closest enemy.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-9c600114746c2ea6006dd729.json b/examples/multi-agent-smax/results/llm-cache/ask-9c600114746c2ea6006dd729.json new file mode 100644 index 00000000..8f8c75d8 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-9c600114746c2ea6006dd729.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.0 seconds into the battle.\nYou are A1, a marine at (9.7, 17.5) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (8.4, 17.0), 45/45 health, order: hold\n A2 marine at (9.1, 16.8), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (16.0, 17.6), 45/45 health, 6.3 away\n E1 marine at (13.7, 14.5), 45/45 health, 5.0 away (in range)\n E2 marine at (14.6, 17.2), 36/45 health, 4.9 away (in range)\nTeam chat (most recent last):\n A1 (1.5s): Holding at x=9; enemy E2 approaching, all focus the closest one.\n A2 (1.5s): E2 spotted east at 8.7 range; holding together, focus whatever enters range first.\n A0 (2.0s): Holding at x=9; shoot first enemy entering 5 range, focus closest.\n A1 (2.0s): Holding at x=9; shoot E2 when it enters range 5.\n A2 (2.0s): Holding at x=9; E2 closest, all focus E2 when in range.\n A0 (2.5s): Holding at x=9; focus E2 when it enters range 5.\n A1 (2.5s): Focus E2 now, all fire together.\n A2 (2.5s): Holding at x=9; E2 nearly in range, all focus E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Firing on E2 (36hp, in range). A0, A2 step up and focus E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-9ccedf4e3a4bb0c591fd725d.json b/examples/multi-agent-smax/results/llm-cache/ask-9ccedf4e3a4bb0c591fd725d.json new file mode 100644 index 00000000..b1f83ae9 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-9ccedf4e3a4bb0c591fd725d.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 3.5 seconds into the battle.\nYou are A0, a marine at (14.3, 16.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1: dead\n A2 marine at (12.8, 14.9), 36/45 health, order: attack E2\nEnemies you can see:\n E1 marine at (16.5, 16.2), 45/45 health, 2.3 away (in range)\n E2 marine at (17.6, 14.3), 45/45 health, 3.8 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (2.0s): All in range of E0 now. Everyone attack E0 together.\n A1 (2.0s): All in range now: everyone attack E0 together.\n A2 (2.0s): Enemies in range now. Everyone attack E0 together.\n A0 (2.5s): Focus E0, it's at 18hp. A1 stay on target per rules.\n A1 (2.5s): Focus E0, it's at 18hp. Keep firing until it dies.\n A2 (2.5s): A2 attacking E0 now; focus it down, then E2.\n A0 (3.0s): E0 is dead. Both attack E2 together, closest enemy; stay level with me.\n A2 (3.0s): E0 is dead. Everyone attack E2, it's in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Both on E2 together, then E1. Keep firing, no retreat.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-9d30d3cabc03caffc912269e.json b/examples/multi-agent-smax/results/llm-cache/ask-9d30d3cabc03caffc912269e.json new file mode 100644 index 00000000..ce929d13 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-9d30d3cabc03caffc912269e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.0 seconds into the battle.\nYou are A1, a marine at (3.6, 14.1) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: retreat.\nYour team:\n A0 marine at (8.1, 15.8), 18/45 health, order: attack E1\n A2 marine at (8.1, 14.9), 27/45 health, order: attack E1\nEnemies you can see:\n E1 marine at (11.8, 16.2), 9/45 health, 8.5 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (4.5s): A1 at 9hp, falling back. Focus E1 (closest to A0), then E0.\n A2 (4.5s): E2 is dead. Focus E1 (closest, 3.9 away), then E0. A1 is at 9hp, so stay behind.\n A0 (5.0s): Focus E1 (3.7 away). A1 stay back. Then E0.\n A1 (5.0s): A1 at 9hp staying back. Focus E1 then E0, keep grouped.\n A2 (5.0s): Firing E1 (closest). A0 focus E1 too, then E0. A1 stay back.\n A0 (5.5s): Firing E1 (27hp). A1 stay back. Then E0.\n A1 (5.5s): A1 at 9hp staying back; focus E1 then E0.\n A2 (5.5s): Firing E1 (27hp). A0 keep focus, then E0. A1 stay back.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A1 9hp holding back; E1 is at 9hp, finish it then E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-9d51f61bebbd121d91e84a09.json b/examples/multi-agent-smax/results/llm-cache/ask-9d51f61bebbd121d91e84a09.json new file mode 100644 index 00000000..c2ed979e --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-9d51f61bebbd121d91e84a09.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 5.0 seconds into the battle.\nYou are A2, a marine at (13.7, 16.7) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (13.3, 15.6), 18/45 health, order: attack E0\n A1 marine at (12.9, 17.5), 27/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (17.7, 17.8), 18/45 health, 4.2 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (3.5s): Focusing E1 (27hp). A0 at 18hp, keep firing until E1 dies.\n A2 (3.5s): Focusing E1 (27hp), then E0. A0 at 18hp, keep firing.\n A0 (4.0s): E1 at 9hp, finishing it now, then E0.\n A1 (4.0s): E1 at 9hp, all keep firing until dead, then E0.\n A2 (4.0s): E1 at 9hp, keep firing until dead, then E0.\n A0 (4.5s): E1 dead. All focus E0, it's in range 5.0 now.\n A1 (4.5s): E1 dead. All attack E0 now, it's in range 4.9.\n A2 (4.5s): E1 dead. All focus E0, 4.2 away in range. Keep firing.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Attacking E0 (18hp), last enemy. Keep firing until it dies.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-9d8df1f74f55b3ad10d8436e.json b/examples/multi-agent-smax/results/llm-cache/ask-9d8df1f74f55b3ad10d8436e.json new file mode 100644 index 00000000..d7f95524 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-9d8df1f74f55b3ad10d8436e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.0 seconds into the battle.\nYou are A2, a marine at (9.0, 16.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.2, 16.2), 45/45 health, order: hold\n A1 marine at (9.8, 15.7), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding together as a group; focus fire on the closest enemy when they appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-9dafb93353559ce044c8d1f4.json b/examples/multi-agent-smax/results/llm-cache/ask-9dafb93353559ce044c8d1f4.json new file mode 100644 index 00000000..31ff534a --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-9dafb93353559ce044c8d1f4.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 4.0 seconds into the battle.\nYou are A0, a marine at (13.3, 15.6) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1 marine at (12.9, 17.5), 27/45 health, order: attack E1\n A2 marine at (13.7, 16.7), 18/45 health, order: attack E1\nEnemies you can see:\n E0 marine at (17.7, 17.8), 45/45 health, 5.0 away (in range)\n E1 marine at (16.9, 14.5), 9/45 health, 3.7 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (2.5s): Focusing E2 (9hp), it dies soon; then we focus E0.\n A2 (2.5s): E2 at 9hp, finishing it now. Then focus E1.\n A0 (3.0s): E2 dead. Focus E1 (closest, 3.7 away), then E0.\n A1 (3.0s): E2 dead. Everyone focus E1 now, then E0.\n A2 (3.0s): E2 dead. Everyone focus E1 now, closest at 3.9.\n A0 (3.5s): Focus E1 (27hp). Keep attacking until dead, then E0.\n A1 (3.5s): Focusing E1 (27hp). A0 at 18hp, keep firing until E1 dies.\n A2 (3.5s): Focusing E1 (27hp), then E0. A0 at 18hp, keep firing.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E1 at 9hp, finishing it now, then E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-9e6e14b3e5eb738d087cf404.json b/examples/multi-agent-smax/results/llm-cache/ask-9e6e14b3e5eb738d087cf404.json new file mode 100644 index 00000000..ca1fd060 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-9e6e14b3e5eb738d087cf404.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.0 seconds into the battle.\nYou are A0, a marine at (9.0, 16.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 9.3 15.\nYour team:\n A1 marine at (8.9, 14.1), 45/45 health, order: hold\n A2 marine at (9.3, 14.8), 45/45 health, order: move 11 15\nEnemies you can see:\n E0 marine at (15.6, 16.4), 45/45 health, 6.6 away\n E1 marine at (16.2, 16.8), 45/45 health, 7.3 away\n E2 marine at (16.2, 15.5), 45/45 health, 7.2 away\nTeam chat (most recent last):\n A1 (1.5s): Still holding; will focus fire on closest enemy when visible.\n A2 (1.5s): Holding grouped; focus fire on closest enemy when it appears.\n A0 (2.0s): No contact; advancing east to center together. Stay close, focus closest enemy.\n A1 (2.0s): No contact; advancing east together to find enemies. Stay grouped, focus closest.\n A2 (2.0s): Holding grouped; focus fire closest enemy when it appears.\n A0 (2.5s): Enemies 3 at east, ~7 away. Falling back to group; hold and focus E0 when in range.\n A1 (2.5s): Enemies E0, E2 east ~9 away. Holding grouped; focus E0 when in range.\n A2 (2.5s): Advancing east to join A0/A1; stay grouped, focus closest enemy.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding at (9,16). Let them come into range, then all focus the closest enemy.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-9eca6dd473fc157ce3b67c49.json b/examples/multi-agent-smax/results/llm-cache/ask-9eca6dd473fc157ce3b67c49.json new file mode 100644 index 00000000..3214ff29 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-9eca6dd473fc157ce3b67c49.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 7.5 seconds into the battle.\nYou are A1, a marine at (8.9, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E1 marine at (13.1, 16.8), 36/45 health, 5.0 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (5.5s): Firing E2 (18hp), then E1 together.\n A2 (5.5s): Keep firing E2 (18hp), then E1 together.\n A0 (6.0s): E2 at 9hp, finish it now, then E1. I'm low, 9hp.\n A1 (6.0s): E2 at 9hp, finish it now, then E1.\n A2 (6.0s): E2 at 9hp, finish it, then all on E1.\n A1 (6.5s): E2 dead. All focus E1, it's at 45hp, 5.0 away.\n A2 (6.5s): E2 dead. I'm at 9hp, backing off. A1 focus E1, I'll rejoin.\n A1 (7.0s): Engaging E1 at 36hp, in range. A2 stay back and heal up.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Still on E1, 36hp. A2 stay back and heal.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-9ee52ccda799015f1489de98.json b/examples/multi-agent-smax/results/llm-cache/ask-9ee52ccda799015f1489de98.json new file mode 100644 index 00000000..b3e267d9 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-9ee52ccda799015f1489de98.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 3.0 seconds into the battle.\nYou are A1, a marine at (12.9, 17.5) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (13.3, 15.6), 27/45 health, order: attack E2\n A2 marine at (13.7, 16.7), 36/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (17.7, 17.8), 45/45 health, 4.9 away (in range)\n E1 marine at (16.9, 14.5), 45/45 health, 5.0 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (1.5s): E2 in my range; A0, A2 close in and focus E2 now.\n A2 (1.5s): Staying together; E2 nearly in range. All attack E2 once everyone is within 5.\n A0 (2.0s): E2 in my range 4.8; attacking E2 now, everyone focus E2.\n A1 (2.0s): All three in range of E2 now. Attack E2 together.\n A2 (2.0s): E2 and E1 in my range; attacking E2 now, everyone focus E2.\n A0 (2.5s): E2 at 9hp, finish it now; then focus E1.\n A1 (2.5s): Focusing E2 (9hp), it dies soon; then we focus E0.\n A2 (2.5s): E2 at 9hp, finishing it now. Then focus E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E2 dead. Everyone focus E1 now, then E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-9f0625221a06de392340adf4.json b/examples/multi-agent-smax/results/llm-cache/ask-9f0625221a06de392340adf4.json new file mode 100644 index 00000000..46d2f24d --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-9f0625221a06de392340adf4.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.5 seconds into the battle.\nYou are A1, a marine at (8.5, 14.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.8, 14.7), 45/45 health, order: hold\n A2 marine at (8.2, 14.1), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (15.8, 15.0), 45/45 health, 7.2 away\n E1 marine at (16.6, 14.0), 45/45 health, 8.1 away\n E2 marine at (15.0, 16.8), 45/45 health, 6.7 away\nTeam chat (most recent last):\n A1 (1.0s): A1 at (8,15) holding. Focus fire on closest enemy.\n A2 (1.0s): A2 at (8,14) holding; will focus the closest enemy when it appears.\n A0 (1.5s): A0 holding at (8,15); focus fire on the closest enemy when seen.\n A1 (1.5s): A1 holding at cluster; focus fire on closest enemy when seen.\n A2 (1.5s): A2 holding at (8,14). Clustered; focus fire on closest enemy.\n A0 (2.0s): A0 holding; no enemies seen. Focus closest when they appear.\n A1 (2.0s): Holding cluster; let them walk into range, then focus closest enemy.\n A2 (2.0s): E2 spotted east at 8.7 range. Holding cluster; let them come, focus first in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding. Enemies closing; all focus closest enemy once in range 5.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-9f44404bb7040383d916622e.json b/examples/multi-agent-smax/results/llm-cache/ask-9f44404bb7040383d916622e.json new file mode 100644 index 00000000..4445edce --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-9f44404bb7040383d916622e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 3.5 seconds into the battle.\nYou are A2, a marine at (14.8, 15.1) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (14.6, 14.4), 27/45 health, order: attack E0\n A1 marine at (15.1, 13.7), 45/45 health, order: attack E0\nEnemies you can see:\n E1 marine at (18.0, 17.0), 45/45 health, 3.7 away (in range)\n E2 marine at (17.8, 15.5), 45/45 health, 3.0 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (2.0s): Closing on E0 together; once all within 5, everyone attacks E0 same tick.\n A2 (2.0s): Attacking E0 now; A0 is already in range, A1 close up and focus E0.\n A0 (2.5s): Focusing E0; A1 attack E0 now, all in range.\n A1 (2.5s): In range of all; attacking E0 now.\n A2 (2.5s): Focusing E0 (36hp). A1 attack E0 now, all in range.\n A0 (3.0s): E0 at 9hp, finishing it now. Everyone keep focusing E0.\n A1 (3.0s): Attacking E0 (9hp), finish it then focus E2.\n A2 (3.0s): E0 at 9hp, finishing it now; then focus E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E0 down. Everyone focus E2 (3.0 away), then E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-9f4a6ef978f83e472aaec4c3.json b/examples/multi-agent-smax/results/llm-cache/ask-9f4a6ef978f83e472aaec4c3.json new file mode 100644 index 00000000..cb51097b --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-9f4a6ef978f83e472aaec4c3.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.5 seconds into the battle.\nYou are A2, a marine at (6.5, 16.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.6, 16.9), 45/45 health, order: hold\n A1 marine at (8.5, 15.3), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together here; focus fire on the closest enemy when they appear.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together as a group; focus fire on the closest enemy once seen.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"No enemies yet; staying grouped, will focus the closest one when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-9fced432ea4d3346bc63f601.json b/examples/multi-agent-smax/results/llm-cache/ask-9fced432ea4d3346bc63f601.json new file mode 100644 index 00000000..24581c30 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-9fced432ea4d3346bc63f601.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.5 seconds into the battle.\nYou are A2, a marine at (10.5, 16.3) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 16.\nYour team:\n A0 marine at (8.2, 16.2), 45/45 health, order: hold\n A1 marine at (9.9, 15.6), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (16.6, 17.3), 45/45 health, 6.2 away\n E1 marine at (16.7, 16.6), 45/45 health, 6.2 away\n E2 marine at (16.8, 14.1), 45/45 health, 6.7 away\nTeam chat (most recent last):\n A1 (1.0s): Still no enemies; holding grouped, will focus closest when seen.\n A2 (1.0s): Still no enemies. Holding; will focus the closest enemy when seen.\n A0 (1.5s): Still no enemies; holding grouped, focus closest when seen.\n A1 (1.5s): Holding grouped; focus fire on closest enemy when seen.\n A2 (1.5s): Still holding grouped; will focus the closest enemy when it appears.\n A0 (2.0s): Holding grouped; no enemies yet. Focus closest when seen.\n A1 (2.0s): Enemies at 8.5 east. Hold grouped; all focus the closest when in range.\n A2 (2.0s): No contact after 2s. Advancing east together to (14,16); stay close, focus closest.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Cancel advance. Holding at 10.5; enemies 6 east, focus E1 when in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-a07a0bd7afdf72f4b4197d05.json b/examples/multi-agent-smax/results/llm-cache/ask-a07a0bd7afdf72f4b4197d05.json new file mode 100644 index 00000000..85da6368 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-a07a0bd7afdf72f4b4197d05.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 4.5 seconds into the battle.\nYou are A1, a marine at (13.5, 17.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (13.8, 15.8), 9/45 health, order: attack E1\n A2: dead\nEnemies you can see:\n E0 marine at (18.0, 17.1), 45/45 health, 4.6 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (3.0s): E2 is dead. Everyone focus E1 now (3.6 away), then E0.\n A1 (3.0s): E2 down. Everyone focus E1 now (3.8 away), then E0.\n A2 (3.0s): E2 dead. All focus E1 (closest, 3.5 away) now.\n A0 (3.5s): Focus E1 together, then E0. A2 stay on target per rules.\n A1 (3.5s): Focusing E1 now; A2 at 9hp, retreat only after E1 dies.\n A2 (3.5s): Focusing E1 with you. I'm at 9hp, will keep firing until it dies.\n A0 (4.0s): Keep firing E1 (18hp), then E0 together.\n A1 (4.0s): Firing on E1 (18hp), then E0 together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E1 dead. Focus E0 (4.6 away), A0 keep firing, I'm full health.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-a10266111f032b590536a06d.json b/examples/multi-agent-smax/results/llm-cache/ask-a10266111f032b590536a06d.json new file mode 100644 index 00000000..1db92a19 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-a10266111f032b590536a06d.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.0 seconds into the battle.\nYou are A0, a marine at (9.3, 15.3) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1 marine at (8.3, 14.2), 45/45 health, order: attack E1\n A2: dead\nEnemies you can see:\n E1 marine at (12.2, 16.1), 27/45 health, 3.0 away (in range)\n E2 marine at (12.3, 17.5), 45/45 health, 3.8 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (3.5s): A1 advancing, focusing E0 with A2. A0 join fire on E0.\n A2 (3.5s): A2 attacking E0 (36hp, in range); all focus E0.\n A0 (4.0s): A0 attacking E0 (27hp); everyone keep focusing E0.\n A1 (4.0s): E0 out of my range; hitting E1 (in range). A0, A2 finish E0, then all E1.\n A2 (4.0s): A2 firing on E0 (27hp); finish it, then E1.\n A0 (4.5s): A0 firing E0 (18hp), nearly dead. Then all E1.\n A1 (4.5s): A1 hitting E1 (36hp). After E0 dies, everyone on E1.\n A2 (4.5s): A2 9hp. E0 at 18hp, A0 and I finish it now, then E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E0 is dead. A0 and A1 focus E1 (27hp), then E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-a130f6ae7fee64731b3708ef.json b/examples/multi-agent-smax/results/llm-cache/ask-a130f6ae7fee64731b3708ef.json new file mode 100644 index 00000000..aaa7eb3a --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-a130f6ae7fee64731b3708ef.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 2.0 seconds into the battle.\nYou are A2, a marine at (13.3, 18.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 15 17.\nYour team:\n A0 marine at (13.5, 15.8), 45/45 health, order: move 15 16\n A1 marine at (12.8, 16.1), 45/45 health, order: move 15 16\nEnemies you can see:\n E0 marine at (18.6, 17.7), 45/45 health, 5.3 away\n E1 marine at (19.4, 16.0), 45/45 health, 6.5 away\n E2 marine at (18.1, 14.7), 45/45 health, 5.8 away\nTeam chat (most recent last):\n A1 (0.5s): Moving to (12,17) with A0; keep together, then focus same target.\n A2 (0.5s): Moving to (12,17) with A0; keep within 2, attack together when enemies appear.\n A0 (1.0s): Continuing to (12,17) together; no enemies yet, attack same target when seen.\n A1 (1.0s): Continuing to (12,17), staying within 2 of A0 and A2.\n A2 (1.0s): Continuing to (12,17); no enemies yet, stay within 2, attack together.\n A0 (1.5s): Enemies E0, E2 east at ~8. Advance together to (15,16), then focus E2 together.\n A1 (1.5s): Enemy E2 at (19.7,14.7). Advancing together to 15,16; attack E2 when all in range.\n A2 (1.5s): Enemies ~8 east. Advancing together to x=15; stay within 2, then focus E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 15 17\", \"say\": \"Closing to 15,17 together; once all in range 5, everyone attack E0 same tick.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-a16df9131c5898c680d656a1.json b/examples/multi-agent-smax/results/llm-cache/ask-a16df9131c5898c680d656a1.json new file mode 100644 index 00000000..a3c8d991 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-a16df9131c5898c680d656a1.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.5 seconds into the battle.\nYou are A0, a marine at (7.5, 15.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (7.2, 17.2), 45/45 health, order: hold\n A2 marine at (7.6, 17.8), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together here; focus fire on the closest enemy when they appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"No enemies yet. Staying grouped; focus fire on the closest one when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-a19526ef2aa93b69474b68b7.json b/examples/multi-agent-smax/results/llm-cache/ask-a19526ef2aa93b69474b68b7.json new file mode 100644 index 00000000..28574b82 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-a19526ef2aa93b69474b68b7.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 8.0 seconds into the battle.\nYou are A1, a marine at (9.8, 14.2) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E2 marine at (10.8, 17.5), 27/45 health, 3.5 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (5.0s): A1 on E1 (27hp), in range. A0 join E1, then E2.\n A0 (5.5s): A0 18hp on E1 (18hp), finishing it. Then both on E2.\n A1 (5.5s): A1 on E1 (18hp), in range. A0 keep firing, then both E2.\n A0 (6.0s): A0 9hp, finishing E1 (9hp). Then both E2.\n A1 (6.0s): A1 on E1 (9hp), finishing it. Then both on E2.\n A1 (6.5s): A1 alone vs E2 (45hp), engaging.\n A1 (7.0s): A1 last unit, fighting E2 (45hp) alone.\n A1 (7.5s): A1 last unit, 36hp vs E2 36hp, fighting to the end.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"A1 last unit, 27hp vs E2 27hp, fighting to the end.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-a1d3f068fd5d5a44b1819bb7.json b/examples/multi-agent-smax/results/llm-cache/ask-a1d3f068fd5d5a44b1819bb7.json new file mode 100644 index 00000000..c92e7556 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-a1d3f068fd5d5a44b1819bb7.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.0 seconds into the battle.\nYou are A1, a marine at (8.5, 15.3) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (8.7, 16.9), 36/45 health, order: attack E0\n A2 marine at (8.0, 16.6), 45/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (13.0, 15.1), 9/45 health, 4.5 away (in range)\n E1 marine at (12.9, 16.5), 45/45 health, 4.5 away (in range)\n E2 marine at (12.8, 17.3), 45/45 health, 4.8 away (in range)\nTeam chat (most recent last):\n A1 (2.5s): Holding grouped; let them walk into range, then focus E0.\n A2 (2.5s): A2 holding grouped; focus E0 when it enters range.\n A0 (3.0s): E0 in range, all attack E0 now.\n A1 (3.0s): E0 in range at 4.5, all focus fire E0 now.\n A2 (3.0s): A2 holding; focus E0 when in range.\n A0 (3.5s): A0 focusing E0 (27hp). A2 attack E0 too, don't hold.\n A1 (3.5s): A1 focusing E0 (27hp), in range. A2 please attack E0 too.\n A2 (3.5s): A2 attacking E0, closing in to focus fire.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"A1 attacking E0 (9hp), finish it then switch to E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-a237d6dd405d4976b5fc0ebe.json b/examples/multi-agent-smax/results/llm-cache/ask-a237d6dd405d4976b5fc0ebe.json new file mode 100644 index 00000000..8d13dfec --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-a237d6dd405d4976b5fc0ebe.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.5 seconds into the battle.\nYou are A2, a marine at (7.6, 17.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.5, 15.8), 45/45 health, order: hold\n A1 marine at (7.2, 17.2), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together here; focus fire on the closest enemy when they appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding; will focus fire on closest enemy once visible.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-a26d895bc7a21be356c4265b.json b/examples/multi-agent-smax/results/llm-cache/ask-a26d895bc7a21be356c4265b.json new file mode 100644 index 00000000..d4b2dbe9 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-a26d895bc7a21be356c4265b.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 7.0 seconds into the battle.\nYou are A0, a marine at (8.5, 16.7) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1: dead\n A2 marine at (7.6, 17.8), 9/45 health, order: attack E2\nEnemies you can see:\n E1 marine at (12.3, 15.6), 36/45 health, 3.9 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A2 (5.0s): A2 on E2, in range. A0 and A2 focus E2; A1 stay back.\n A0 (5.5s): A0 on E2 (27hp). Keep firing E2, then E1. A1 stay back.\n A1 (5.5s): A1 firing E2 from back; A0 is closest, keep tanking. Focus E2.\n A2 (5.5s): A2 on E2 (27hp), keep focusing. A1 stay back.\n A0 (6.0s): A0 on E2 (9hp), finishing it. Then all E1.\n A2 (6.0s): A2 on E2 (9hp), nearly dead. Then E1 together.\n A0 (6.5s): A0 finishing E2 now. Then all on E1.\n A2 (6.5s): A2 finishing E2 (9hp). Then both on E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E2 down. A0 and A2 all on E1, 36hp.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-a28d2a06cccfe1acbbda06a9.json b/examples/multi-agent-smax/results/llm-cache/ask-a28d2a06cccfe1acbbda06a9.json new file mode 100644 index 00000000..50ad5de3 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-a28d2a06cccfe1acbbda06a9.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.5 seconds into the battle.\nYou are A2, a marine at (8.2, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (7.8, 14.7), 45/45 health, order: attack E2\n A1: dead\nEnemies you can see:\n E0 marine at (12.6, 15.0), 45/45 health, 4.5 away (in range)\n E1 marine at (13.4, 14.0), 45/45 health, 5.2 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (3.0s): Holding. E2 closest at 5.3; focus E2 when in range, then E0.\n A2 (3.0s): Holding. E2 closest at 5.8; focus whoever enters range 5 first.\n A0 (3.5s): E2 in range 4.6, all focus fire E2 now, then E0.\n A1 (3.5s): Focus E2 now, all fire together, then E0.\n A2 (3.5s): E0 and E2 in range now. Focus E2, fire together, then E0.\n A0 (4.0s): Firing E2 (18hp), then E0. A1 stay behind us.\n A1 (4.0s): E2 at 18 HP, finish it now, then E0.\n A2 (4.0s): Firing on E2 (18hp), then E0. Keep A1 behind us.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E2 down. Focus E0 (4.5 away), then E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-a2f2e47ced677942a0609635.json b/examples/multi-agent-smax/results/llm-cache/ask-a2f2e47ced677942a0609635.json new file mode 100644 index 00000000..e7ef0851 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-a2f2e47ced677942a0609635.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.5 seconds into the battle.\nYou are A2, a marine at (8.6, 16.5) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0: dead\n A1 marine at (8.0, 16.0), 45/45 health, order: attack E2\nEnemies you can see:\n E1 marine at (11.6, 16.0), 45/45 health, 3.0 away (in range)\n E2 marine at (11.8, 14.7), 9/45 health, 3.7 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (5.0s): Switching to E0 with you both. Focus E0 down, then E2.\n A1 (5.0s): Focusing E0 (27hp) with A2; A0 on E2 is fine, then E1.\n A2 (5.0s): A2 firing E0 (27hp). A1 and I kill E0, A0 stays on E2.\n A0 (5.5s): E0 is dead. Focus E2 (27hp), then E1. I'm at 9hp.\n A1 (5.5s): E0 down. Focus E2 (27hp), then E1. A0, stay back, you're low.\n A2 (5.5s): E0 dead. Focus E2 (27hp) together, then E1.\n A1 (6.0s): Focusing E2 (27hp), then E1. A2 stay behind me.\n A2 (6.0s): Focusing E2 (27hp), then E1. A1 keep firing.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 at 9hp, finishing it. A1 then focus E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-a325da8bc0a06ea493fd21a7.json b/examples/multi-agent-smax/results/llm-cache/ask-a325da8bc0a06ea493fd21a7.json new file mode 100644 index 00000000..051690fa --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-a325da8bc0a06ea493fd21a7.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.0 seconds into the battle.\nYou are A0, a marine at (10.6, 16.0) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1 marine at (8.9, 14.1), 45/45 health, order: attack E0\n A2 marine at (10.8, 14.8), 27/45 health, order: attack E0\nEnemies you can see:\n E1 marine at (13.1, 16.8), 45/45 health, 2.6 away (in range)\n E2 marine at (13.1, 15.5), 45/45 health, 2.5 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (3.5s): Holding. Focus E0 when in range; stay grouped.\n A2 (3.5s): E0 at range 5. Everyone attack E0 now, focus fire.\n A0 (4.0s): Focusing E0 now. A1 please attack E0 too, all fire together.\n A1 (4.0s): Attacking E0 now, focus fire.\n A2 (4.0s): All attack E0 now, in range. A1 switch from hold to attack E0.\n A0 (4.5s): E0 at 18 hp, keep focus firing E0 then E2.\n A1 (4.5s): Firing on E0, 18 hp left. Next target E2 (closest).\n A2 (4.5s): E0 at 18 hp, keep firing. Then focus E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E0 dead. Focus E2 (closest), then E1. Stay grouped.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-a3620416c8bed2b5ee09404d.json b/examples/multi-agent-smax/results/llm-cache/ask-a3620416c8bed2b5ee09404d.json new file mode 100644 index 00000000..ed7cc7f8 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-a3620416c8bed2b5ee09404d.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.5 seconds into the battle.\nYou are A2, a marine at (6.5, 16.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.6, 16.9), 45/45 health, order: hold\n A1 marine at (8.5, 15.3), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (14.6, 15.1), 45/45 health, 8.3 away\nTeam chat (most recent last):\n A1 (1.0s): A1 holding; no enemies yet, will focus the closest when seen.\n A2 (1.0s): A2 holding; will focus the closest enemy when it appears.\n A0 (1.5s): A0 holding; still no enemies. Focus the closest when they appear.\n A1 (1.5s): A1 holding; no enemies yet, focus closest when seen.\n A2 (1.5s): A2 holding; will focus fire on the closest enemy when seen.\n A0 (2.0s): E0 spotted at distance 7.8. Holding grouped; focus E0 when in range.\n A1 (2.0s): E0 east at 7.7 away. Holding grouped; focus E0 when in range.\n A2 (2.0s): A2 holding; will focus the closest enemy when it appears.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A2 holding grouped; focus E0 when it enters range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-a48f6fb1f5faa04f3c10c7e0.json b/examples/multi-agent-smax/results/llm-cache/ask-a48f6fb1f5faa04f3c10c7e0.json new file mode 100644 index 00000000..f8c30fe8 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-a48f6fb1f5faa04f3c10c7e0.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.0 seconds into the battle.\nYou are A0, a marine at (9.3, 15.3) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1 marine at (8.3, 14.2), 45/45 health, order: attack E0\n A2 marine at (9.0, 16.0), 27/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (13.4, 16.8), 27/45 health, 4.4 away (in range)\n E1 marine at (12.2, 16.1), 45/45 health, 3.0 away (in range)\n E2 marine at (12.3, 17.5), 45/45 health, 3.8 away (in range)\nTeam chat (most recent last):\n A1 (2.5s): A1 holding at (6.7,14.2); A0 fall back to us, focus E0 together.\n A2 (2.5s): A2 holding; enemies approaching, all focus E0 when in range.\n A0 (3.0s): A0 holding; focus E0 when in range 5.\n A1 (3.0s): A1 holding; focus E0 when it enters range 5.\n A2 (3.0s): A2 attacking E0 (in range); all focus E0.\n A0 (3.5s): A0 attacking E0 now; focus E0 together.\n A1 (3.5s): A1 advancing, focusing E0 with A2. A0 join fire on E0.\n A2 (3.5s): A2 attacking E0 (36hp, in range); all focus E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"A0 attacking E0 (27hp); everyone keep focusing E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-a4e8eed78d37de4bd129f8c1.json b/examples/multi-agent-smax/results/llm-cache/ask-a4e8eed78d37de4bd129f8c1.json new file mode 100644 index 00000000..8adcbfe4 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-a4e8eed78d37de4bd129f8c1.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.5 seconds into the battle.\nYou are A1, a marine at (7.2, 17.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.5, 15.8), 45/45 health, order: hold\n A2 marine at (7.6, 17.8), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together here; focus fire on the closest enemy when they appear.\n A0 (0.5s): No enemies yet. Staying grouped; focus fire on the closest one when seen.\n A1 (0.5s): A1 holding; will focus fire on the closest enemy when seen.\n A2 (0.5s): Holding; will focus fire on closest enemy once visible.\n A0 (1.0s): No enemies visible; holding grouped. Focus fire on the closest when they appear.\n A1 (1.0s): No enemies yet. Holding; will focus fire on the closest when seen.\n A2 (1.0s): A2 holding; no enemies visible. Will focus closest when they appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A1 holding; no enemies yet. Focus closest when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-a5886129754398290ee1ed8f.json b/examples/multi-agent-smax/results/llm-cache/ask-a5886129754398290ee1ed8f.json new file mode 100644 index 00000000..0903170d --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-a5886129754398290ee1ed8f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 7.0 seconds into the battle.\nYou are A1, a marine at (8.0, 16.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E1 marine at (11.6, 16.0), 45/45 health, 3.5 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A2 (5.0s): A2 firing E0 (27hp). A1 and I kill E0, A0 stays on E2.\n A0 (5.5s): E0 is dead. Focus E2 (27hp), then E1. I'm at 9hp.\n A1 (5.5s): E0 down. Focus E2 (27hp), then E1. A0, stay back, you're low.\n A2 (5.5s): E0 dead. Focus E2 (27hp) together, then E1.\n A1 (6.0s): Focusing E2 (27hp), then E1. A2 stay behind me.\n A2 (6.0s): Focusing E2 (27hp), then E1. A1 keep firing.\n A1 (6.5s): Finishing E2 (9hp) now, then E1. A2 stay behind me.\n A2 (6.5s): E2 at 9hp, finishing it. A1 then focus E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E2 dead, A0 and A2 down. I'm alone on E1, 45hp each.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-a5cba49ca6249e8fdadc4e49.json b/examples/multi-agent-smax/results/llm-cache/ask-a5cba49ca6249e8fdadc4e49.json new file mode 100644 index 00000000..42d72884 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-a5cba49ca6249e8fdadc4e49.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.0 seconds into the battle.\nYou are A0, a marine at (9.3, 15.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1 marine at (10.0, 15.5), 36/45 health, order: attack E2\n A2: dead\nEnemies you can see:\n E0 marine at (13.5, 17.3), 45/45 health, 4.4 away (in range)\n E1 marine at (13.5, 16.6), 36/45 health, 4.2 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (3.5s): E1 out of range; E2 in range at 4.1. Everyone focus E2.\n A2 (3.5s): A2 hurt, pulling back west to you. Fire on E1 when they follow into range.\n A0 (4.0s): Switching to E2, in range at 4.7. A1 and I focus E2.\n A1 (4.0s): Firing on E2 (36hp, in range). A0 switch to E2. A2 stay back.\n A2 (4.0s): A2 hurt but farthest back, firing on E2 from range. Focus E2.\n A0 (4.5s): E2 at 18hp, finishing it now. Then focus E1 (36hp).\n A1 (4.5s): E2 at 18hp, finish it now, then E1.\n A2 (4.5s): Firing on E2 (18hp), one more volley kills it. Then E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E2 down. Focus E1 (36hp), then E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-a5dd3c59a7b9090abc96a9d3.json b/examples/multi-agent-smax/results/llm-cache/ask-a5dd3c59a7b9090abc96a9d3.json new file mode 100644 index 00000000..f3024b3e --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-a5dd3c59a7b9090abc96a9d3.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.0 seconds into the battle.\nYou are A1, a marine at (9.4, 14.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.9, 16.7), 45/45 health, order: hold\n A2 marine at (7.6, 17.8), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding together; focus fire on the closest enemy when they appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-a70eadc2a8959bb2dd0dcc13.json b/examples/multi-agent-smax/results/llm-cache/ask-a70eadc2a8959bb2dd0dcc13.json new file mode 100644 index 00000000..c8502c54 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-a70eadc2a8959bb2dd0dcc13.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 7.0 seconds into the battle.\nYou are A0, a marine at (7.8, 14.7) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1: dead\n A2: dead\nEnemies you can see:\n E1 marine at (11.9, 14.0), 45/45 health, 4.1 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A2 (4.5s): E2 down. Focus E0 (4.5 away), then E1.\n A0 (5.0s): Focus E0 together, then E1. A2 keep firing.\n A2 (5.0s): Focus E0 together, then E1.\n A0 (5.5s): Keep focusing E0 (27hp), then E1. Fire together.\n A2 (5.5s): Firing E0 (27hp), then E1. I'm low, keep fire together.\n A0 (6.0s): E0 at 9hp, kill it now, then E1. Fire together.\n A2 (6.0s): E0 at 9hp, finishing it now. Then all focus E1.\n A0 (6.5s): A0 alone vs E1, firing now.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A0 alone vs E1, firing. Last enemy.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-a713dd9fc24f4558afb047b7.json b/examples/multi-agent-smax/results/llm-cache/ask-a713dd9fc24f4558afb047b7.json new file mode 100644 index 00000000..d1ad5ace --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-a713dd9fc24f4558afb047b7.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.0 seconds into the battle.\nYou are A0, a marine at (7.5, 15.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1 marine at (7.2, 17.2), 45/45 health, order: attack E1\n A2: dead\nEnemies you can see:\n E0 marine at (11.7, 17.0), 45/45 health, 4.4 away (in range)\n E1 marine at (11.0, 17.2), 27/45 health, 3.8 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (3.5s): E2 in range at 3.9. Everyone fire on E2.\n A2 (3.5s): E2 in range at 3.6, all fire E2 now.\n A0 (4.0s): Firing E2 (18hp left); then E1.\n A1 (4.0s): Keep firing E2 (18hp), then E1.\n A2 (4.0s): Keep firing E2, it's at 18 HP. Then focus E1.\n A0 (4.5s): E2 down. Focus E1 (closest), then E0.\n A1 (4.5s): E2 down. Focus E1 (closest, 3.9 away), then E0.\n A2 (4.5s): E2 down. Focus E1 (closest, 3.5 away), then E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Firing E1 (27hp), then E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-a73f6f6ddecf2b626b0a6cb4.json b/examples/multi-agent-smax/results/llm-cache/ask-a73f6f6ddecf2b626b0a6cb4.json new file mode 100644 index 00000000..9927037b --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-a73f6f6ddecf2b626b0a6cb4.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 4.0 seconds into the battle.\nYou are A0, a marine at (14.2, 16.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1 marine at (13.0, 15.5), 18/45 health, order: retreat\n A2: dead\nEnemies you can see:\n E0 marine at (18.2, 17.3), 36/45 health, 4.1 away (in range)\n E2 marine at (18.4, 14.1), 45/45 health, 4.7 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A2 (2.0s): Enemies in range of me and A0. Attacking E1 now; A1 close in and fire on E1.\n A0 (2.5s): Focus E1 (27hp). A2 low at 18hp, retreat if needed.\n A1 (2.5s): Firing on E1 (27hp). A2 at 18hp, retreat if under 20.\n A2 (2.5s): A2 at 18hp retreating to pull fire off me; A0, A1 keep focusing E1.\n A0 (3.0s): E1 at 9hp, finish it now; then focus E0.\n A1 (3.0s): E1 at 9hp, finishing it now. A0 fire E1, then focus E2.\n A0 (3.5s): E1 dead. A0 focusing E0; A1 under 20hp, retreat to pull fire.\n A1 (3.5s): A1 at 18hp retreating so A0 is closest; A0 focus E2, I return when safe.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Focusing E0 (36hp). A1 stay back; I'm tanking, then we take E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-a75f14de4fcd5eb053812b94.json b/examples/multi-agent-smax/results/llm-cache/ask-a75f14de4fcd5eb053812b94.json new file mode 100644 index 00000000..86adcdb5 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-a75f14de4fcd5eb053812b94.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 0.0 seconds into the battle.\nYou are A0, a marine at (6.9, 16.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (9.4, 14.9), 45/45 health, order: hold\n A2 marine at (7.6, 17.8), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 16\", \"say\": \"Moving east together to (12,16); stay close, no one run ahead.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-a7acd616cfe6531aa1dd5ba7.json b/examples/multi-agent-smax/results/llm-cache/ask-a7acd616cfe6531aa1dd5ba7.json new file mode 100644 index 00000000..f2b06316 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-a7acd616cfe6531aa1dd5ba7.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.0 seconds into the battle.\nYou are A2, a marine at (7.6, 17.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.9, 16.7), 45/45 health, order: hold\n A1 marine at (9.4, 14.9), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding together; focus fire on closest enemy when they appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-a81930b91ca30a45a3bf12e3.json b/examples/multi-agent-smax/results/llm-cache/ask-a81930b91ca30a45a3bf12e3.json new file mode 100644 index 00000000..816eb56b --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-a81930b91ca30a45a3bf12e3.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 0.5 seconds into the battle.\nYou are A1, a marine at (9.9, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 15.\nYour team:\n A0 marine at (9.7, 17.4), 45/45 health, order: move 12 16\n A2 marine at (8.1, 14.9), 45/45 health, order: move 12 15\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Moving east together to (12,16); stay within 2 of each other, then attack same target.\n A1 (0.0s): Moving east together toward enemies; stay within 2 of each other, attack same target.\n A2 (0.0s): Advancing east together to (12,15); stay within 2 of each other.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 15\", \"say\": \"Moving to (12,15) with team; will attack same target together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-a86b64e5b6d53ee0867020b3.json b/examples/multi-agent-smax/results/llm-cache/ask-a86b64e5b6d53ee0867020b3.json new file mode 100644 index 00000000..007054c0 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-a86b64e5b6d53ee0867020b3.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 8.0 seconds into the battle.\nYou are A0, a marine at (6.7, 17.0) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: retreat.\nYour team:\n A1: dead\n A2: dead\nEnemies you can see:\n E0 marine at (13.0, 17.8), 45/45 health, 6.3 away\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A2 (4.5s): E2 down. Focus E1 (closest, 3.8 away), then E0.\n A0 (5.0s): Focusing E1 (36hp), both in range. A2 stay behind me, you're low.\n A2 (5.0s): Focus E1 (36hp), I'm low at 18hp. A0 keep firing, then E0.\n A0 (5.5s): A0 on E1 (18hp), almost dead. Then E0.\n A0 (6.0s): Finishing E1 (18hp), then E0. A2 stay back.\n A0 (6.5s): E1 at 9hp, finishing it now, then E0. A0 at 27hp.\n A0 (7.0s): E1 down. A0 at 9hp, E0 at 45hp left. Pulling out of range.\n A0 (7.5s): A0 at 9hp, last one alive. Kiting away from E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"retreat\", \"say\": \"A0 last alive, 9hp, kiting E0 out of its range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-a8ebed735239077f6f50119c.json b/examples/multi-agent-smax/results/llm-cache/ask-a8ebed735239077f6f50119c.json new file mode 100644 index 00000000..9ff710d9 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-a8ebed735239077f6f50119c.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 4.0 seconds into the battle.\nYou are A2, a marine at (14.1, 16.4) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (13.6, 17.1), 18/45 health, order: attack E1\n A1 marine at (13.2, 15.3), 27/45 health, order: attack E1\nEnemies you can see:\n E2 marine at (17.5, 17.3), 45/45 health, 3.5 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (2.5s): E0 at 9hp, finishing it now; then everyone focus E1.\n A2 (2.5s): E0 at 9hp in range, firing on E0 now.\n A0 (3.0s): E0 dead. Everyone focus E1 now, same target, no retreating.\n A1 (3.0s): E0 dead. Everyone focus E1 now, same tick; then E2.\n A2 (3.0s): E0 dead. Everyone focus E1 now, then E2.\n A0 (3.5s): Focusing E1 (18hp), same target; then E2.\n A1 (3.5s): Attacking E1 (18hp), all keep firing; then E2.\n A2 (3.5s): Attacking E1 (18hp) now, then E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E1 dead. All attack E2 now, same target, keep firing.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-a911c85e266bf269610b285d.json b/examples/multi-agent-smax/results/llm-cache/ask-a911c85e266bf269610b285d.json new file mode 100644 index 00000000..194d4123 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-a911c85e266bf269610b285d.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 4.0 seconds into the battle.\nYou are A2, a marine at (14.6, 17.4) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (15.0, 18.1), 36/45 health, order: attack E1\n A1: dead\nEnemies you can see:\n E1 marine at (18.5, 17.3), 27/45 health, 3.9 away (in range)\n E2 marine at (17.5, 14.8), 45/45 health, 3.9 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A2 (2.0s): E0 is within range 5 of all three of us. Attack E0 now.\n A0 (2.5s): Focus E0 (18hp). A1 at 18hp, retreat if under 20 per rules.\n A1 (2.5s): A1 at 18hp, retreating to stop being the closest target. A0, A2 focus E0.\n A2 (2.5s): Attacking E0 now; A1 under 20hp, retreat if needed.\n A0 (3.0s): E0 dead. A2 attack E1 now, it's in my range. A1 stay back.\n A2 (3.0s): E0 dead. A0, A2 focus E1 together now; A1 stay back.\n A0 (3.5s): Focusing E1 together, A2 keep firing. A1 stay back.\n A2 (3.5s): Attacking E1 with A0. A1 stay back.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Focusing E1 (27hp), both in range. Keep firing, then E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-a97c378ee8123feb7e7b29c8.json b/examples/multi-agent-smax/results/llm-cache/ask-a97c378ee8123feb7e7b29c8.json new file mode 100644 index 00000000..29c751ca --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-a97c378ee8123feb7e7b29c8.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 7.0 seconds into the battle.\nYou are A1, a marine at (7.2, 17.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (7.5, 15.8), 9/45 health, order: attack E0\n A2: dead\nEnemies you can see:\n E0 marine at (11.7, 17.0), 27/45 health, 4.6 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (5.0s): Firing E1 (27hp), then E0.\n A1 (5.0s): Firing E1 (27hp), then E0.\n A0 (5.5s): Firing E1 (18hp), then E0.\n A1 (5.5s): Firing E1 (18hp), then E0.\n A0 (6.0s): E1 at 9hp, finishing it. Then focus E0.\n A1 (6.0s): Firing E1 (9hp), then E0.\n A0 (6.5s): E1 down. Focusing E0, 4.4 away, all fire.\n A1 (6.5s): E1 down. All focus E0, 4.6 away, 45hp.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Focusing E0 at 27hp, keep firing. A0 stay behind me.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-a9d3b48d88f980d625b2616a.json b/examples/multi-agent-smax/results/llm-cache/ask-a9d3b48d88f980d625b2616a.json new file mode 100644 index 00000000..335dfa54 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-a9d3b48d88f980d625b2616a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.0 seconds into the battle.\nYou are A0, a marine at (8.6, 16.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (8.5, 15.3), 45/45 health, order: hold\n A2 marine at (6.5, 16.6), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (13.0, 15.1), 45/45 health, 4.8 away (in range)\n E1 marine at (14.6, 16.7), 45/45 health, 6.0 away\n E2 marine at (15.8, 17.1), 45/45 health, 7.2 away\nTeam chat (most recent last):\n A1 (1.5s): A1 holding; no enemies yet, focus closest when seen.\n A2 (1.5s): A2 holding; will focus fire on the closest enemy when seen.\n A0 (2.0s): E0 spotted at distance 7.8. Holding grouped; focus E0 when in range.\n A1 (2.0s): E0 east at 7.7 away. Holding grouped; focus E0 when in range.\n A2 (2.0s): A2 holding; will focus the closest enemy when it appears.\n A0 (2.5s): Holding grouped; let them walk into range, then all focus E0.\n A1 (2.5s): Holding grouped; let them walk into range, then focus E0.\n A2 (2.5s): A2 holding grouped; focus E0 when it enters range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 in range, all attack E0 now.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-aa7235f10fc861f3ba049bb7.json b/examples/multi-agent-smax/results/llm-cache/ask-aa7235f10fc861f3ba049bb7.json new file mode 100644 index 00000000..831e928b --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-aa7235f10fc861f3ba049bb7.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 0.0 seconds into the battle.\nYou are A0, a marine at (7.0, 15.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (8.1, 17.5), 45/45 health, order: hold\n A2 marine at (7.4, 16.7), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 16.5\", \"say\": \"Moving east together toward center; stay within 2 of each other, attack same target.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ab05d829fe3ef8ff5c3e43dc.json b/examples/multi-agent-smax/results/llm-cache/ask-ab05d829fe3ef8ff5c3e43dc.json new file mode 100644 index 00000000..6e7de726 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ab05d829fe3ef8ff5c3e43dc.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 3.5 seconds into the battle.\nYou are A2, a marine at (8.3, 17.3) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.9, 15.6), 45/45 health, order: hold\n A1 marine at (6.7, 14.2), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (12.0, 16.8), 45/45 health, 3.8 away (in range)\n E1 marine at (13.7, 16.2), 45/45 health, 5.5 away\n E2 marine at (13.8, 17.3), 45/45 health, 5.5 away\nTeam chat (most recent last):\n A1 (2.0s): A1 holding; no enemies yet. Will attack together once all within 5.\n A2 (2.0s): A2 holding. E0 spotted at (16.8,16.8), 8.5 away. Wait until it's in range 5 of all.\n A0 (2.5s): A0 holding. E0 at 8.4 away; wait until within 5 of all, then focus E0.\n A1 (2.5s): A1 holding. E0 at 8.9 away; wait until in range 5 of all.\n A2 (2.5s): A2 holding. Nearest enemy E0 at 6.9; wait until within 5 of all.\n A0 (3.0s): A0 holding. E0 at 6.9; wait until within 5 of all, then focus E0.\n A1 (3.0s): A1 holding. E0 at 7.4; attack E0 together once within 5 of all.\n A2 (3.0s): A2 holding. E0 at 5.3 from me, 6.8+ from A0/A1. Wait for range 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 in range of me, firing now. A0/A1 close in and focus E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ab16f7293f4d2383a1a3f398.json b/examples/multi-agent-smax/results/llm-cache/ask-ab16f7293f4d2383a1a3f398.json new file mode 100644 index 00000000..236d0fa6 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ab16f7293f4d2383a1a3f398.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.5 seconds into the battle.\nYou are A2, a marine at (7.1, 16.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.2, 15.7), 36/45 health, order: attack E2\n A1 marine at (6.5, 16.0), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (10.7, 17.7), 45/45 health, 3.8 away (in range)\n E1 marine at (11.6, 16.0), 45/45 health, 4.5 away (in range)\n E2 marine at (11.8, 14.7), 36/45 health, 5.1 away\nTeam chat (most recent last):\n A1 (3.0s): A1 holding; E2 seen east at 8.6. Let them come into range, focus closest.\n A2 (3.0s): A2 holding; enemies at 8 range, let them come in, focus closest.\n A0 (3.5s): Holding; E2 closest at 6.2. Focus E2 when in range.\n A1 (3.5s): A1 holding; fire on closest enemy once in range, E2 first.\n A2 (3.5s): A2 holding; enemies closing, fire on closest E2 when in range.\n A0 (4.0s): E2 in range at 4.7; all focus fire E2 now.\n A1 (4.0s): Holding; E2 closest at 5.5, focus E2 once in range.\n A2 (4.0s): Holding. E2 at 5.1, about to enter range. Focus E2 together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 in range at 3.8; I focus E0, A0 on E2. Kill fast.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ab2081c74cde1aac493e79e4.json b/examples/multi-agent-smax/results/llm-cache/ask-ab2081c74cde1aac493e79e4.json new file mode 100644 index 00000000..11fa0a12 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ab2081c74cde1aac493e79e4.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.0 seconds into the battle.\nYou are A2, a marine at (7.6, 17.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.5, 15.8), 45/45 health, order: hold\n A1 marine at (7.2, 17.2), 45/45 health, order: hold\nEnemies you can see:\n E2 marine at (15.8, 16.7), 45/45 health, 8.2 away\nTeam chat (most recent last):\n A1 (0.5s): A1 holding; will focus fire on the closest enemy when seen.\n A2 (0.5s): Holding; will focus fire on closest enemy once visible.\n A0 (1.0s): No enemies visible; holding grouped. Focus fire on the closest when they appear.\n A1 (1.0s): No enemies yet. Holding; will focus fire on the closest when seen.\n A2 (1.0s): A2 holding; no enemies visible. Will focus closest when they appear.\n A0 (1.5s): Still no enemies; holding grouped. Focus closest when seen.\n A1 (1.5s): A1 holding; no enemies yet. Focus closest when seen.\n A2 (1.5s): A2 holding; no enemies visible. Focus closest when they appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"E2 spotted at (15.8,16.7), 8 away. Holding grouped; focus E2 when in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ab441ad195b88dc14ec7df21.json b/examples/multi-agent-smax/results/llm-cache/ask-ab441ad195b88dc14ec7df21.json new file mode 100644 index 00000000..3acf5339 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ab441ad195b88dc14ec7df21.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.5 seconds into the battle.\nYou are A1, a marine at (6.5, 16.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (7.2, 15.7), 9/45 health, order: attack E0\n A2 marine at (7.1, 16.5), 27/45 health, order: attack E0\nEnemies you can see:\n E1 marine at (11.6, 16.0), 45/45 health, 5.1 away\n E2 marine at (11.8, 14.7), 27/45 health, 5.5 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (4.0s): Holding; E2 closest at 5.5, focus E2 once in range.\n A2 (4.0s): Holding. E2 at 5.1, about to enter range. Focus E2 together.\n A0 (4.5s): Firing E2 now, it's at 36 health. Everyone focus E2.\n A1 (4.5s): E0 in range at 4.6, I'm firing on E0. Focus E0 if in range.\n A2 (4.5s): E0 in range at 3.8; I focus E0, A0 on E2. Kill fast.\n A0 (5.0s): Switching to E0 with you both. Focus E0 down, then E2.\n A1 (5.0s): Focusing E0 (27hp) with A2; A0 on E2 is fine, then E1.\n A2 (5.0s): A2 firing E0 (27hp). A1 and I kill E0, A0 stays on E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E0 down. Focus E2 (27hp), then E1. A0, stay back, you're low.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ab5cd5ddf37ceb1dd0076c5e.json b/examples/multi-agent-smax/results/llm-cache/ask-ab5cd5ddf37ceb1dd0076c5e.json new file mode 100644 index 00000000..45d7ba37 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ab5cd5ddf37ceb1dd0076c5e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.0 seconds into the battle.\nYou are A2, a marine at (9.3, 16.6) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: retreat.\nYour team:\n A0 marine at (9.4, 15.9), 45/45 health, order: attack E1\n A1 marine at (9.9, 15.5), 45/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (15.1, 17.3), 45/45 health, 5.8 away\n E1 marine at (15.1, 16.6), 36/45 health, 5.8 away\n E2 marine at (13.7, 14.1), 36/45 health, 5.0 away\nTeam chat (most recent last):\n A1 (2.5s): Enemies 7 east. A2 fall back to group; hold and focus E1 when in range.\n A2 (2.5s): Cancel advance. Holding at 10.5; enemies 6 east, focus E1 when in range.\n A0 (3.0s): Holding. Enemies at 7; focus E1 when in range, stay grouped.\n A1 (3.0s): Holding. E1 is closest at 5.3; focus E1 as soon as it's in range.\n A2 (3.0s): Enemies in range. Focus E1 now, everyone fire on E1.\n A0 (3.5s): Moving up to fire on E1; A2 is taking fire, everyone commit.\n A1 (3.5s): E1 out of range; E2 in range at 4.1. Everyone focus E2.\n A2 (3.5s): A2 hurt, pulling back west to you. Fire on E1 when they follow into range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"A2 hurt but farthest back, firing on E2 from range. Focus E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ab6ab30fc2a0c8738ef78752.json b/examples/multi-agent-smax/results/llm-cache/ask-ab6ab30fc2a0c8738ef78752.json new file mode 100644 index 00000000..82cdd45a --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ab6ab30fc2a0c8738ef78752.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 8.0 seconds into the battle.\nYou are A2, a marine at (7.6, 17.8) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: retreat.\nYour team:\n A0 marine at (8.5, 16.7), 18/45 health, order: attack E1\n A1: dead\nEnemies you can see:\n E1 marine at (12.3, 15.6), 18/45 health, 5.1 away\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (6.0s): A0 on E2 (9hp), finishing it. Then all E1.\n A2 (6.0s): A2 on E2 (9hp), nearly dead. Then E1 together.\n A0 (6.5s): A0 finishing E2 now. Then all on E1.\n A2 (6.5s): A2 finishing E2 (9hp). Then both on E1.\n A0 (7.0s): E2 down. A0 and A2 all on E1, 36hp.\n A2 (7.0s): E2 down. A2 on E1, A0 keep tanking, I'm at 9hp.\n A0 (7.5s): A0 tanking, attacking E1 (27hp). A2 stay behind me and keep firing.\n A2 (7.5s): A2 9hp, falling back so A0 is closest. A0 tank, I'll rejoin shooting.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A2 back in, firing from behind A0. E1 at 18hp, focus it.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ab8e45615068b0211cc4983e.json b/examples/multi-agent-smax/results/llm-cache/ask-ab8e45615068b0211cc4983e.json new file mode 100644 index 00000000..f6edba1d --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ab8e45615068b0211cc4983e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 7.0 seconds into the battle.\nYou are A2, a marine at (9.4, 16.4) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0: dead\n A1 marine at (8.5, 15.3), 27/45 health, order: attack E2\nEnemies you can see:\n E2 marine at (12.8, 17.3), 9/45 health, 3.5 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (5.0s): A1 on E1 (27hp), focus fire. A0 hurt, fall back if needed.\n A2 (5.0s): A2 on E1 (27hp), in range. A0 retreat if low, A1 focus E1.\n A1 (5.5s): E1 down. All focus E2, 4.8 away, in range.\n A2 (5.5s): A2 on E2 (45hp, in range). A1 focus E2, last enemy.\n A1 (6.0s): A1 on E2 (36hp), in range. Keep focus fire, last enemy.\n A2 (6.0s): A2 on E2 (36hp), in range. A1 keep firing, last enemy.\n A1 (6.5s): A1 on E2 (27hp), in range. Keep firing, last enemy.\n A2 (6.5s): E2 at 27hp, in range. Both keep firing, last enemy.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 at 9hp, in range. Keep firing, finish it.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ab8eeea081535cd918057111.json b/examples/multi-agent-smax/results/llm-cache/ask-ab8eeea081535cd918057111.json new file mode 100644 index 00000000..e617b8b2 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ab8eeea081535cd918057111.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad just fought a battle on map 3m and lost. Here is how it went, one line per half second:\nour units' orders and health, the enemies' health, and what was said on team chat.\n\n 0.0s A0 hold (45hp) A1 hold (45hp) A2 hold (45hp) | E0 45hp E1 45hp E2 45hp\n A0 said: Holding per rules until enemy within 5 of all; then focus same target.\n A1 said: A1 holding. No enemies seen; wait until all in range 5, then focus same target.\n A2 said: A2 holding. Will attack together once enemy is within 5 of all of us.\n 0.5s A0 hold (45hp) A1 hold (45hp) A2 hold (45hp) | E0 45hp E1 45hp E2 45hp\n A0 said: A0 holding. No enemies yet; will focus the same target once all in range.\n A1 said: A1 holding; no enemies visible yet. Will focus same target once all in range.\n A2 said: A2 holding. No enemies visible yet; will focus fire when all in range 5.\n 1.0s A0 hold (45hp) A1 hold (45hp) A2 hold (45hp) | E0 45hp E1 45hp E2 45hp\n A0 said: A0 holding. No enemies visible; will focus same target once all within 5.\n A1 said: A1 holding. No enemies visible; will focus same target once all in range 5.\n A2 said: A2 holding. Still no enemies; waiting until all in range 5.\n 1.5s A0 hold (45hp) A1 hold (45hp) A2 hold (45hp) | E0 45hp E1 45hp E2 45hp\n A0 said: A0 holding. Still no enemies; waiting for all within 5 to focus fire.\n A1 said: A1 holding. Still no enemies; will focus same target once all in range 5.\n A2 said: A2 holding. No enemies visible; will focus fire when all within 5.\n 2.0s A0 hold (45hp) A1 hold (45hp) A2 hold (45hp) | E0 45hp E1 45hp E2 45hp\n A0 said: A0 holding; no enemies yet. Will focus same target once all within 5.\n A1 said: A1 holding; no enemies yet. Will attack together once all within 5.\n A2 said: A2 holding. E0 spotted at (16.8,16.8), 8.5 away. Wait until it's in range 5 of all.\n 2.5s A0 hold (45hp) A1 hold (45hp) A2 hold (45hp) | E0 45hp E1 45hp E2 45hp\n A0 said: A0 holding. E0 at 8.4 away; wait until within 5 of all, then focus E0.\n A1 said: A1 holding. E0 at 8.9 away; wait until in range 5 of all.\n A2 said: A2 holding. Nearest enemy E0 at 6.9; wait until within 5 of all.\n 3.0s A0 hold (45hp) A1 hold (45hp) A2 hold (45hp) | E0 45hp E1 45hp E2 45hp\n A0 said: A0 holding. E0 at 6.9; wait until within 5 of all, then focus E0.\n A1 said: A1 holding. E0 at 7.4; attack E0 together once within 5 of all.\n A2 said: A2 holding. E0 at 5.3 from me, 6.8+ from A0/A1. Wait for range 5.\n 3.5s A0 hold (45hp) A1 hold (45hp) A2 attack E0 (45hp) | E0 45hp E1 45hp E2 45hp\n A0 said: A0 holding. E0 5.3 away; attack E0 together once within 5 of all.\n A1 said: A1 holding. E0 at 6.0; attack E0 together once within 5 of all.\n A2 said: E0 in range of me, firing now. A0/A1 close in and focus E0.\n 4.0s A0 attack E0 (45hp) A1 attack E0 (45hp) A2 attack E0 (36hp) | E0 36hp E1 45hp E2 45hp\n A0 said: A2 engaged, A0 attacking E0 now. A1 attack E0 too, focus fire.\n A1 said: A2 is engaged; A1 attacking E0 now. A0 join and focus E0.\n A2 said: Engaged, all 3 enemies on me. A0 A1 attack E0 now, focus fire.\n 4.5s A0 attack E0 (45hp) A1 attack E0 (45hp) A2 retreat (9hp) | E0 27hp E1 45hp E2 45hp\n A0 said: Focus E0 (27hp). A2 at 9hp, retreat to draw fire away if possible.\n A1 said: A1 focusing E0 (27hp). A2 retreat, you're at 9hp.\n A2 said: A2 at 9hp retreating. A0 A1 keep focus on E0, it has 27hp.\n 5.0s A0 attack E0 (45hp) A1 attack E0 (45hp) A2 dead | E0 9hp E1 45hp E2 45hp\n A0 said: E0 at 9hp, finishing it now. A1 focus E0.\n A1 said: A1 firing on E0 (9hp), finish it then focus E1.\n 5.5s A0 attack E1 (27hp) A1 attack E1 (45hp) A2 dead | E0 dead E1 45hp E2 45hp\n A0 said: E0 dead. Both focus E1 now, then E2.\n A1 said: E0 down. Focus E1 (4.4 away, in range) now, both of us.\n 6.0s A0 retreat (18hp) A1 attack E1 (45hp) A2 dead | E0 dead E1 45hp E2 45hp\n A0 said: A0 at 18hp retreating to pull fire off. A1 focus E1, I'll rejoin if safe.\n A1 said: A1 attacking E1 (45hp). A0 at 18hp, retreat if under 20 to shed aggro.\n 6.5s A0 retreat (9hp) A1 attack E1 (45hp) A2 dead | E0 dead E1 36hp E2 45hp\n A0 said: A0 at 9hp, staying out of range. A1 focus E1, 36hp left.\n A1 said: A1 attacking E1 (36hp), in range. A0 stay back, keep out of range.\n 7.0s A0 retreat (9hp) A1 attack E1 (36hp) A2 dead | E0 dead E1 27hp E2 45hp\n A0 said: A0 9hp, staying out of range. A1 focus E1 (27hp), then E2.\n A1 said: A1 on E1 (27hp), 3 shots left. A0 stay out of range.\n 7.5s A0 retreat (9hp) A1 attack E1 (27hp) A2 dead | E0 dead E1 18hp E2 45hp\n A0 said: A0 9hp staying out of range. A1 finish E1 (18hp), then E2.\n A1 said: A1 on E1 (18hp), finishing it, then E2. A0 stay back.\n 8.0s A0 attack E1 (9hp) A1 attack E1 (9hp) A2 dead | E0 dead E1 18hp E2 45hp\n A0 said: A0 9hp joining on E1 to finish it fast, then focus E2 together.\n A1 said: A1 9hp, finishing E1 (18hp). A0 stay back, then we focus E2.\n 8.5s A0 retreat (9hp) A1 dead A2 dead | E0 dead E1 9hp E2 45hp\n A0 said: A0 9hp alone, retreating out of range; E1 has 9hp left.\n 9.0s A0 retreat (9hp) A1 dead A2 dead | E0 dead E1 9hp E2 45hp\n A0 said: A0 9hp, last unit. Retreating out of range; enemies E1 9hp, E2 45hp.\n 9.5s A0 attack E1 (9hp) A1 dead A2 dead | E0 dead E1 9hp E2 45hp\n A0 said: A0 9hp last unit, cornered at the wall; going for E1 (9hp) to kill it.\n10.0s A0 attack E1 (9hp) A1 dead A2 dead | E0 dead E1 9hp E2 45hp\n A0 said: A0 9hp, last unit, killing E1 (9hp) now.\n10.5s A0 dead A1 dead A2 dead | E0 dead E1 9hp E2 45hp\n\nRULES.md now:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\nWrite ONE new rule for your squad's RULES.md that would have helped you win this battle. Every unit in your\nsquad will read RULES.md before every order in later battles. Make it a concrete rule about what a unit should\ndo, in one sentence, and do not repeat a rule already there.\nReply with JSON only: {\"rule\": \"\"}", + "response": "{\"rule\": \"Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-aba801605055f170ab849143.json b/examples/multi-agent-smax/results/llm-cache/ask-aba801605055f170ab849143.json new file mode 100644 index 00000000..772eed49 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-aba801605055f170ab849143.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 7.5 seconds into the battle.\nYou are A0, a marine at (8.1, 15.8) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1 marine at (3.6, 14.1), 9/45 health, order: hold\n A2 marine at (8.1, 14.9), 9/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (12.9, 15.0), 27/45 health, 4.8 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (6.0s): A1 9hp holding back; E1 is at 9hp, finish it then E0.\n A2 (6.0s): Firing E1 (9hp), nearly dead. Then E0 together.\n A0 (6.5s): Firing E1 (9hp), finishing it. Then E0 together.\n A1 (6.5s): A1 holding back at 9hp; will shoot anything that closes in.\n A2 (6.5s): Finishing E1 (9hp) now, then all focus E0.\n A0 (7.0s): E1 down. All focus E0 now, A1 join in.\n A1 (7.0s): A1 9hp holding; will shoot anything that closes in. Finish E1, then E0.\n A2 (7.0s): E1 down. All focus E0; I'm closest and tanking, A0 and A1 fire.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"A0 firing E0 (27hp). A1 close in and shoot, all focus fire.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-abc3579ddfcd9f54157389b5.json b/examples/multi-agent-smax/results/llm-cache/ask-abc3579ddfcd9f54157389b5.json new file mode 100644 index 00000000..ba2b1317 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-abc3579ddfcd9f54157389b5.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 7.0 seconds into the battle.\nYou are A2, a marine at (7.6, 17.8) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (8.5, 16.7), 36/45 health, order: attack E2\n A1: dead\nEnemies you can see:\n E1 marine at (12.3, 15.6), 36/45 health, 5.1 away\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A2 (5.0s): A2 on E2, in range. A0 and A2 focus E2; A1 stay back.\n A0 (5.5s): A0 on E2 (27hp). Keep firing E2, then E1. A1 stay back.\n A1 (5.5s): A1 firing E2 from back; A0 is closest, keep tanking. Focus E2.\n A2 (5.5s): A2 on E2 (27hp), keep focusing. A1 stay back.\n A0 (6.0s): A0 on E2 (9hp), finishing it. Then all E1.\n A2 (6.0s): A2 on E2 (9hp), nearly dead. Then E1 together.\n A0 (6.5s): A0 finishing E2 now. Then all on E1.\n A2 (6.5s): A2 finishing E2 (9hp). Then both on E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E2 down. A2 on E1, A0 keep tanking, I'm at 9hp.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-abf14a1b84c033d9f44b0ebe.json b/examples/multi-agent-smax/results/llm-cache/ask-abf14a1b84c033d9f44b0ebe.json new file mode 100644 index 00000000..12b9c32d --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-abf14a1b84c033d9f44b0ebe.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 2.5 seconds into the battle.\nYou are A1, a marine at (14.1, 16.4) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (13.3, 16.4), 45/45 health, order: attack E0\n A2 marine at (12.3, 16.5), 45/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (16.0, 15.3), 18/45 health, 2.3 away (in range)\n E1 marine at (18.6, 15.6), 45/45 health, 4.5 away (in range)\n E2 marine at (18.2, 17.7), 45/45 health, 4.3 away (in range)\nTeam chat (most recent last):\n A1 (1.0s): Holding formation at (12,16); then all advance and attack E0 together.\n A2 (1.0s): Continuing to (12,16) together; will attack same target once all in range 5.\n A0 (1.5s): Advancing together toward E0; all attack E0 once everyone is within range 5.\n A1 (1.5s): Advancing together east to (14,16); then all attack E0 at once.\n A2 (1.5s): Advancing together toward E0; all attack E0 once everyone is within range 5.\n A0 (2.0s): E0 is within range 5 of all three of us. Everyone attack E0 now.\n A1 (2.0s): E0 is in range of all three of us. Everyone attack E0 now.\n A2 (2.0s): E0 is in range of all three; attacking E0 now, focus fire.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 at 18hp, keep focus fire; I'm at 18hp and will step back once it dies.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ac01390f645af9bb1e456f8a.json b/examples/multi-agent-smax/results/llm-cache/ask-ac01390f645af9bb1e456f8a.json new file mode 100644 index 00000000..a14cbcf9 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ac01390f645af9bb1e456f8a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 2.5 seconds into the battle.\nYou are A1, a marine at (13.3, 15.5) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (12.7, 16.0), 45/45 health, order: attack E0\n A2 marine at (12.8, 14.9), 45/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (17.6, 15.0), 18/45 health, 4.3 away (in range)\n E1 marine at (18.1, 16.2), 45/45 health, 4.9 away (in range)\n E2 marine at (17.6, 14.3), 45/45 health, 4.5 away (in range)\nTeam chat (most recent last):\n A1 (1.0s): Continuing to (12,15) together; will attack same target when enemies appear.\n A2 (1.0s): A2 continuing to (12,15); will attack together when enemies appear.\n A0 (1.5s): Advancing together toward E0; all attack E0 once everyone is in range.\n A1 (1.5s): Advancing together to (14,15); all attack E0 once in range.\n A2 (1.5s): Advancing east together to (15,15); all attack E2 once in range 5.\n A0 (2.0s): All in range of E0 now. Everyone attack E0 together.\n A1 (2.0s): All in range now: everyone attack E0 together.\n A2 (2.0s): Enemies in range now. Everyone attack E0 together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Focus E0, it's at 18hp. Keep firing until it dies.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ac529a4ff28fe1dcd00b18ab.json b/examples/multi-agent-smax/results/llm-cache/ask-ac529a4ff28fe1dcd00b18ab.json new file mode 100644 index 00000000..2bae9665 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ac529a4ff28fe1dcd00b18ab.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.0 seconds into the battle.\nYou are A2, a marine at (7.6, 17.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (6.9, 16.7), 45/45 health, order: attack E0\n A1 marine at (7.8, 14.9), 36/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (11.3, 15.3), 18/45 health, 4.5 away (in range)\n E1 marine at (12.3, 15.6), 45/45 health, 5.1 away\n E2 marine at (11.9, 17.7), 45/45 health, 4.3 away (in range)\nTeam chat (most recent last):\n A1 (2.5s): A1 holding; E0 approaching, focus fire when in range.\n A2 (2.5s): A2 holding; E0 approaching, focus it when in range.\n A0 (3.0s): A0 holding; all 3 enemies visible. Focus E0 when in range, stay tight.\n A1 (3.0s): A1 holding; E0 at 5.1, focus E0 when in range, stay tight.\n A2 (3.0s): A2 holding; E0 closest at 5.8, focus E0 together when in range.\n A0 (3.5s): A0 attacking E0 now, everyone focus E0.\n A1 (3.5s): A1 attacking E0 now, everyone focus E0.\n A2 (3.5s): A2 attacking E0 now, everyone focus E0 together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"A2 firing on E0, 18 hp left, finish it then E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ac671dc0f25b23619e1f8762.json b/examples/multi-agent-smax/results/llm-cache/ask-ac671dc0f25b23619e1f8762.json new file mode 100644 index 00000000..c2a74acb --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ac671dc0f25b23619e1f8762.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.0 seconds into the battle.\nYou are A1, a marine at (9.8, 15.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.2, 16.2), 45/45 health, order: hold\n A2 marine at (9.0, 16.2), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (18.2, 17.3), 45/45 health, 8.6 away\n E1 marine at (18.2, 16.6), 45/45 health, 8.5 away\n E2 marine at (18.4, 14.1), 45/45 health, 8.8 away\nTeam chat (most recent last):\n A1 (0.5s): Holding position; will focus fire on closest enemy once visible.\n A2 (0.5s): Holding. Will focus fire on the closest enemy once visible.\n A0 (1.0s): Still no enemies; holding grouped, focus closest when seen.\n A1 (1.0s): Still no enemies; holding grouped, will focus closest when seen.\n A2 (1.0s): Still no enemies. Holding; will focus the closest enemy when seen.\n A0 (1.5s): Still no enemies; holding grouped, focus closest when seen.\n A1 (1.5s): Holding grouped; focus fire on closest enemy when seen.\n A2 (1.5s): Still holding grouped; will focus the closest enemy when it appears.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Enemies at 8.5 east. Hold grouped; all focus the closest when in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ac943c15d715c74b34baccd9.json b/examples/multi-agent-smax/results/llm-cache/ask-ac943c15d715c74b34baccd9.json new file mode 100644 index 00000000..ed67c4f7 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ac943c15d715c74b34baccd9.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 1.0 seconds into the battle.\nYou are A0, a marine at (10.1, 16.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 16.\nYour team:\n A1 marine at (10.9, 16.4), 45/45 health, order: move 12 16\n A2 marine at (10.7, 17.8), 45/45 health, order: move 12 16\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Moving east together to (12,16); stay close, no one run ahead.\n A1 (0.0s): Moving together east to (15,16); stay within 2 of each other, attack same target.\n A2 (0.0s): Moving east together toward center, stay within 2 of each other; attack same target on contact.\n A0 (0.5s): A1 please converge on (12,16) with us; A1 is ahead, stay within 2.\n A1 (0.5s): Joining A0 and A2 at (12,16); staying grouped, then advance together.\n A2 (0.5s): A2 moving to (12,16) with team; will attack together on contact.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 16\", \"say\": \"Continuing to (12,16); stay grouped, attack same target on contact.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-acb3e24a476b574ff8355b2c.json b/examples/multi-agent-smax/results/llm-cache/ask-acb3e24a476b574ff8355b2c.json new file mode 100644 index 00000000..166656e2 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-acb3e24a476b574ff8355b2c.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 2.0 seconds into the battle.\nYou are A2, a marine at (13.0, 14.3) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 16.\nYour team:\n A0 marine at (12.8, 15.9), 45/45 health, order: move 12 16\n A1 marine at (13.0, 15.0), 45/45 health, order: move 14 16\nEnemies you can see:\n E0 marine at (17.3, 15.0), 45/45 health, 4.4 away (in range)\n E1 marine at (18.2, 14.0), 45/45 health, 5.2 away\n E2 marine at (16.6, 16.8), 45/45 health, 4.4 away (in range)\nTeam chat (most recent last):\n A1 (0.5s): A1 advancing to (12,15), staying close; will attack same target on contact.\n A2 (0.5s): A2 advancing to (12,15), staying close; will attack same target on contact.\n A0 (1.0s): Moving together east to (14,16); stay grouped, attack same target on contact.\n A1 (1.0s): A1 continuing to (12,15), staying close; attack same target on contact.\n A2 (1.0s): Holding formation at (12,15); will advance together, then all attack E2 at once.\n A0 (1.5s): A0 closing on group at (12,16); then all advance together on E2.\n A1 (1.5s): Moving to (14,16) with A0; enemies close, then all attack E2 together.\n A2 (1.5s): Moving to (14,16) with A0; enemies ~5 away next, then all attack E2 together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 in range of all three. Attack E2 now, together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-acde9a29baa16a6d357fe739.json b/examples/multi-agent-smax/results/llm-cache/ask-acde9a29baa16a6d357fe739.json new file mode 100644 index 00000000..9be51b9a --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-acde9a29baa16a6d357fe739.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.0 seconds into the battle.\nYou are A0, a marine at (9.9, 17.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1: dead\n A2 marine at (10.7, 16.8), 18/45 health, order: attack E1\nEnemies you can see:\n E0 marine at (14.6, 17.8), 45/45 health, 4.7 away (in range)\n E1 marine at (13.7, 14.5), 36/45 health, 4.5 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A2 (3.0s): Attacking E2 (36hp) with A1; A0 join, focus E2 first.\n A0 (3.5s): Attacking E2 (27hp), closing in to focus fire with A2.\n A1 (3.5s): E2 at 27hp, keep focusing it. A0 attack E2 too.\n A2 (3.5s): Firing E2 (27hp), A0 step up and focus E2. A1 stay back.\n A0 (4.0s): E2 at 18hp, in range. Finish it now, then E1.\n A2 (4.0s): E2 at 18hp, finish it now. A0 keep firing.\n A0 (4.5s): E2 is down. Focus E1 (closest, 45hp), then E0.\n A2 (4.5s): E2 down. Focus E1 (closest, 3.8 away), then E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Focusing E1 (36hp), both in range. A2 stay behind me, you're low.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ace6cba3c5048b3cb8ea66c0.json b/examples/multi-agent-smax/results/llm-cache/ask-ace6cba3c5048b3cb8ea66c0.json new file mode 100644 index 00000000..b36cc866 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ace6cba3c5048b3cb8ea66c0.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.5 seconds into the battle.\nYou are A1, a marine at (9.7, 17.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.4, 17.0), 45/45 health, order: hold\n A2 marine at (9.1, 16.8), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (17.6, 17.6), 45/45 health, 7.8 away\n E1 marine at (15.3, 14.5), 45/45 health, 6.3 away\n E2 marine at (14.6, 17.2), 45/45 health, 4.9 away (in range)\nTeam chat (most recent last):\n A1 (1.0s): Grouping at x=9; focus fire on nearest enemy when seen.\n A2 (1.0s): Holding at cluster near (9,16.7); focus fire on the closest enemy.\n A0 (1.5s): Holding at x=9 with cluster; focus fire on closest enemy when seen.\n A1 (1.5s): Holding at x=9; enemy E2 approaching, all focus the closest one.\n A2 (1.5s): E2 spotted east at 8.7 range; holding together, focus whatever enters range first.\n A0 (2.0s): Holding at x=9; shoot first enemy entering 5 range, focus closest.\n A1 (2.0s): Holding at x=9; shoot E2 when it enters range 5.\n A2 (2.0s): Holding at x=9; E2 closest, all focus E2 when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Focus E2 now, all fire together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-adb3f02ac4f8a53ebb54122f.json b/examples/multi-agent-smax/results/llm-cache/ask-adb3f02ac4f8a53ebb54122f.json new file mode 100644 index 00000000..7e32926a --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-adb3f02ac4f8a53ebb54122f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 6.5 seconds into the battle.\nYou are A1, a marine at (15.1, 13.7) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E1 marine at (18.0, 17.0), 18/45 health, 4.3 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (4.0s): E2 at 18hp, keep focusing E2 then E1.\n A1 (4.0s): E2 at 18hp, keep focusing E2 then E1. Nobody retreat.\n A0 (4.5s): E2 at 9hp, finish it now, then E1. I'm low but still firing.\n A1 (4.5s): E2 at 9hp, finishing it. Then E1. A0 stay in, no retreat.\n A0 (5.0s): E2 dead. Focus E1 now, 4.2 away, both fire together.\n A1 (5.0s): E2 dead. All focus E1 now, 4.3 away. A0 keep firing.\n A1 (5.5s): A1 alone now, attacking E1 (27hp). Keep firing.\n A1 (6.0s): A1 alone, E1 at 27hp, still firing.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A1 alone, E1 at 18hp, keep firing until it dies.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-adb93601a64a5f589e6f476a.json b/examples/multi-agent-smax/results/llm-cache/ask-adb93601a64a5f589e6f476a.json new file mode 100644 index 00000000..bfb8a043 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-adb93601a64a5f589e6f476a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.0 seconds into the battle.\nYou are A2, a marine at (8.2, 14.1) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (7.8, 14.7), 45/45 health, order: attack E0\n A1: dead\nEnemies you can see:\n E0 marine at (12.6, 15.0), 45/45 health, 4.5 away (in range)\n E1 marine at (11.9, 14.0), 45/45 health, 3.6 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (3.5s): E2 in range 4.6, all focus fire E2 now, then E0.\n A1 (3.5s): Focus E2 now, all fire together, then E0.\n A2 (3.5s): E0 and E2 in range now. Focus E2, fire together, then E0.\n A0 (4.0s): Firing E2 (18hp), then E0. A1 stay behind us.\n A1 (4.0s): E2 at 18 HP, finish it now, then E0.\n A2 (4.0s): Firing on E2 (18hp), then E0. Keep A1 behind us.\n A0 (4.5s): E2 down. Focus E0 now, then E1. Fire together.\n A2 (4.5s): E2 down. Focus E0 (4.5 away), then E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Focus E0 together, then E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-add2e0cf67d919d9ae16ecec.json b/examples/multi-agent-smax/results/llm-cache/ask-add2e0cf67d919d9ae16ecec.json new file mode 100644 index 00000000..281b126c --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-add2e0cf67d919d9ae16ecec.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.5 seconds into the battle.\nYou are A1, a marine at (8.5, 15.3) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (8.8, 17.1), 18/45 health, order: attack E0\n A2 marine at (9.4, 16.4), 45/45 health, order: attack E0\nEnemies you can see:\n E1 marine at (12.9, 16.5), 45/45 health, 4.5 away (in range)\n E2 marine at (12.8, 17.3), 45/45 health, 4.8 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (3.0s): E0 in range at 4.5, all focus fire E0 now.\n A2 (3.0s): A2 holding; focus E0 when in range.\n A0 (3.5s): A0 focusing E0 (27hp). A2 attack E0 too, don't hold.\n A1 (3.5s): A1 focusing E0 (27hp), in range. A2 please attack E0 too.\n A2 (3.5s): A2 attacking E0, closing in to focus fire.\n A0 (4.0s): E0 at 9hp, finish it, then focus E2.\n A1 (4.0s): A1 attacking E0 (9hp), finish it then switch to E1.\n A2 (4.0s): A2 closing on E0 (9hp), then focus E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E0 dead. Focus E1 (4.5 away), then E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-adee2311f65e1906b7ee6fb2.json b/examples/multi-agent-smax/results/llm-cache/ask-adee2311f65e1906b7ee6fb2.json new file mode 100644 index 00000000..0a4326dc --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-adee2311f65e1906b7ee6fb2.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 8.0 seconds into the battle.\nYou are A0, a marine at (13.7, 15.6) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1: dead\n A2: dead\nEnemies you can see:\n E1 marine at (17.9, 16.0), 9/45 health, 4.2 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (5.0s): E0 down. Both focus E1 now, it's the last one.\n A0 (5.5s): Focusing E1. A1 at 9hp, retreat if you're targeted; I'm 27hp, staying in.\n A1 (5.5s): Attacking E1. I'm 9hp and will soak a shot. A0 keep firing, finish it.\n A0 (6.0s): Firing on E1 (27hp). A1 retreat if targeted; I'm 27hp, staying in.\n A1 (6.0s): A1 at 9hp retreating so I'm not the target. A0 finish E1.\n A0 (6.5s): Firing on E1, last enemy. A0 27hp, staying in.\n A0 (7.0s): Firing on E1, 18hp left. A0 27hp, finishing it.\n A0 (7.5s): Firing on E1, 9hp left. Finishing it.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Firing on E1, 9hp left. Last enemy, finishing it.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ae0305105f7674f505b1969e.json b/examples/multi-agent-smax/results/llm-cache/ask-ae0305105f7674f505b1969e.json new file mode 100644 index 00000000..fb846476 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ae0305105f7674f505b1969e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 9.0 seconds into the battle.\nYou are A1, a marine at (8.3, 14.1) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E0 marine at (12.9, 15.0), 9/45 health, 4.6 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A2 (7.0s): E1 down. All focus E0; I'm closest and tanking, A0 and A1 fire.\n A0 (7.5s): A0 firing E0 (27hp). A1 close in and shoot, all focus fire.\n A1 (7.5s): A1 joining on E0, A2 stays closest and tanks.\n A2 (7.5s): E0 at 27hp, 4.8 away. A0, A1 fire now; focus E0.\n A0 (8.0s): A0 firing E0 (18hp), 4.8 away. A1 fire too, finish it.\n A1 (8.0s): A1 closing on E0 (18hp). A0, focus fire to finish it.\n A0 (8.5s): A0 firing E0 (9hp), in range. A1 fire too, finish it.\n A1 (8.5s): A1 closing on E0 (9hp), A0 fire together to finish it.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"A1 firing on E0 (9hp), in range. Finishing it.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ae612361a0950169163ff1f0.json b/examples/multi-agent-smax/results/llm-cache/ask-ae612361a0950169163ff1f0.json new file mode 100644 index 00000000..30fa1371 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ae612361a0950169163ff1f0.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 0.5 seconds into the battle.\nYou are A1, a marine at (11.4, 15.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 16.\nYour team:\n A0 marine at (9.8, 16.2), 45/45 health, order: move 11 16\n A2 marine at (10.6, 16.2), 45/45 health, order: move 14 16\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Advancing east together to find enemies; keep within 2 of each other, then all attack same target.\n A1 (0.0s): Moving east together toward enemies, stay within 2 of each other; attack same target on contact.\n A2 (0.0s): Moving east together to (14,16); stay within 2 of each other, attack together on contact.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 16\", \"say\": \"Continuing east in formation; will attack same target on contact.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ae87872a4a85ff47f864d9c5.json b/examples/multi-agent-smax/results/llm-cache/ask-ae87872a4a85ff47f864d9c5.json new file mode 100644 index 00000000..daab81ce --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ae87872a4a85ff47f864d9c5.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.0 seconds into the battle.\nYou are A0, a marine at (9.0, 16.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (7.4, 14.1), 45/45 health, order: hold\n A2 marine at (7.7, 14.8), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on closest enemy when they appear.\n A0 (0.5s): No enemies yet. Staying grouped; focus fire on closest when they appear.\n A1 (0.5s): Holding; will focus fire on closest enemy once in range.\n A2 (0.5s): Holding position; focus fire on closest enemy once in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding; still no enemies. Focus fire closest when they appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-aeb1f9e77237d60c3482f1cb.json b/examples/multi-agent-smax/results/llm-cache/ask-aeb1f9e77237d60c3482f1cb.json new file mode 100644 index 00000000..e15b02f8 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-aeb1f9e77237d60c3482f1cb.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.5 seconds into the battle.\nYou are A1, a marine at (7.1, 14.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.1, 15.9), 45/45 health, order: move 8 15\n A2 marine at (9.4, 14.6), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Regroup near (8,15) so we fight together; focus fire on closest enemy.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on the closest enemy when they appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 8 15\", \"say\": \"Closing to (8,15) to cluster; will focus closest enemy.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-af03efd2f4d1b3fabd6848e7.json b/examples/multi-agent-smax/results/llm-cache/ask-af03efd2f4d1b3fabd6848e7.json new file mode 100644 index 00000000..9439ecc6 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-af03efd2f4d1b3fabd6848e7.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 1.0 seconds into the battle.\nYou are A2, a marine at (10.7, 17.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 17.\nYour team:\n A0 marine at (10.7, 15.8), 45/45 health, order: move 14 17\n A1 marine at (10.3, 17.2), 45/45 health, order: move 12 17\nEnemies you can see:\n E2 marine at (18.9, 16.7), 45/45 health, 8.2 away\nTeam chat (most recent last):\n A0 (0.0s): Moving east together to find enemies; stay within 2 of each other, attack together.\n A1 (0.0s): Moving east together to find enemies; stay within 2 of each other, fire together.\n A2 (0.0s): Moving east together to find enemies; stay close, attack same target when in range.\n A0 (0.5s): Moving east in formation; will attack same target once all in range.\n A1 (0.5s): Moving east in a tight group; will attack same target together.\n A2 (0.5s): Moving east in formation; A0 and A1 keep pace, no one pull ahead.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 17\", \"say\": \"Closing together toward E2; hold pace, all fire on E2 once in range 5.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-af2ae6985699470d3806b944.json b/examples/multi-agent-smax/results/llm-cache/ask-af2ae6985699470d3806b944.json new file mode 100644 index 00000000..f4465f4b --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-af2ae6985699470d3806b944.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 1.5 seconds into the battle.\nYou are A0, a marine at (13.3, 18.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 17.\nYour team:\n A1 marine at (13.3, 17.2), 45/45 health, order: move 14 17\n A2 marine at (13.2, 16.0), 45/45 health, order: move 16 17\nEnemies you can see:\n E0 marine at (19.3, 16.4), 45/45 health, 6.2 away\n E1 marine at (20.1, 17.3), 45/45 health, 6.9 away\n E2 marine at (20.7, 14.8), 45/45 health, 8.1 away\nTeam chat (most recent last):\n A1 (0.0s): Moving east together toward enemies; keep within 2 of each other, attack together.\n A2 (0.0s): Moving east together toward enemies, stay within 2 of each other; attack same target on call.\n A0 (0.5s): Moving east together, keeping formation; will attack same target when all in range.\n A1 (0.5s): Moving east in formation at x=12; no one engages alone.\n A2 (0.5s): Moving east, staying close; A0 at 12,17 is my anchor point.\n A0 (1.0s): Advancing east together to x=14; will call attack when enemies appear.\n A1 (1.0s): Advancing east to 14,17 together; no one engages until all in range.\n A2 (1.0s): Moving east together to x=16; will attack same target once all in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 15 17\", \"say\": \"Closing together toward E0; attack E0 once all three are within range 5.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-af886454416ca5b35a441788.json b/examples/multi-agent-smax/results/llm-cache/ask-af886454416ca5b35a441788.json new file mode 100644 index 00000000..86f4d9ff --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-af886454416ca5b35a441788.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.5 seconds into the battle.\nYou are A0, a marine at (8.6, 16.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (8.5, 15.3), 45/45 health, order: hold\n A2 marine at (6.5, 16.6), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (14.6, 15.1), 45/45 health, 6.3 away\n E1 marine at (16.2, 16.7), 45/45 health, 7.6 away\n E2 marine at (17.4, 17.1), 45/45 health, 8.8 away\nTeam chat (most recent last):\n A1 (1.0s): A1 holding; no enemies yet, will focus the closest when seen.\n A2 (1.0s): A2 holding; will focus the closest enemy when it appears.\n A0 (1.5s): A0 holding; still no enemies. Focus the closest when they appear.\n A1 (1.5s): A1 holding; no enemies yet, focus closest when seen.\n A2 (1.5s): A2 holding; will focus fire on the closest enemy when seen.\n A0 (2.0s): E0 spotted at distance 7.8. Holding grouped; focus E0 when in range.\n A1 (2.0s): E0 east at 7.7 away. Holding grouped; focus E0 when in range.\n A2 (2.0s): A2 holding; will focus the closest enemy when it appears.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding grouped; let them walk into range, then all focus E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-afa897e497db6febc8b317ab.json b/examples/multi-agent-smax/results/llm-cache/ask-afa897e497db6febc8b317ab.json new file mode 100644 index 00000000..6f3d6ed9 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-afa897e497db6febc8b317ab.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.5 seconds into the battle.\nYou are A1, a marine at (5.2, 14.1) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: retreat.\nYour team:\n A0 marine at (8.1, 15.8), 18/45 health, order: attack E1\n A2 marine at (8.1, 14.9), 36/45 health, order: attack E1\nEnemies you can see:\n E0 marine at (12.9, 15.0), 45/45 health, 7.7 away\n E1 marine at (11.8, 16.2), 27/45 health, 7.0 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (4.0s): Firing E2 (18hp). Then E0. I'm at 27hp.\n A2 (4.0s): Firing E2 (18 hp left), then E0. Stay grouped.\n A0 (4.5s): E2 is down. Focus E1 (closest), then E0. A1 fall back if hurt.\n A1 (4.5s): A1 at 9hp, falling back. Focus E1 (closest to A0), then E0.\n A2 (4.5s): E2 is dead. Focus E1 (closest, 3.9 away), then E0. A1 is at 9hp, so stay behind.\n A0 (5.0s): Focus E1 (3.7 away). A1 stay back. Then E0.\n A1 (5.0s): A1 at 9hp staying back. Focus E1 then E0, keep grouped.\n A2 (5.0s): Firing E1 (closest). A0 focus E1 too, then E0. A1 stay back.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"retreat\", \"say\": \"A1 at 9hp staying back; focus E1 then E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-afbefac2feb745067a0ff79d.json b/examples/multi-agent-smax/results/llm-cache/ask-afbefac2feb745067a0ff79d.json new file mode 100644 index 00000000..13d2ed80 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-afbefac2feb745067a0ff79d.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.5 seconds into the battle.\nYou are A1, a marine at (9.4, 14.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.9, 16.7), 45/45 health, order: hold\n A2 marine at (7.6, 17.8), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together; focus fire on closest enemy once seen.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on closest enemy when they appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A1 holding; will focus fire on closest enemy once visible.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-b05822ad29b43b2062577f83.json b/examples/multi-agent-smax/results/llm-cache/ask-b05822ad29b43b2062577f83.json new file mode 100644 index 00000000..1042d716 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-b05822ad29b43b2062577f83.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 0.0 seconds into the battle.\nYou are A2, a marine at (9.0, 16.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.2, 16.2), 45/45 health, order: hold\n A1 marine at (9.8, 15.7), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 16\", \"say\": \"Moving east together to (14,16); stay within 2 of each other, attack together on contact.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-b09d631f6d7284594a326428.json b/examples/multi-agent-smax/results/llm-cache/ask-b09d631f6d7284594a326428.json new file mode 100644 index 00000000..dcf426dc --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-b09d631f6d7284594a326428.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 9.5 seconds into the battle.\nYou are A1, a marine at (9.8, 14.2) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E2 marine at (10.8, 17.5), 9/45 health, 3.5 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (6.0s): A0 9hp, finishing E1 (9hp). Then focus E2 together.\n A1 (6.0s): A1 on E1 (9hp), finishing it. Then all E2.\n A1 (6.5s): A1 alone vs E2 (45hp), engaging.\n A1 (7.0s): A1 alone vs E2 (45hp), still firing.\n A1 (7.5s): A1 36hp vs E2 36hp, still firing.\n A1 (8.0s): A1 27hp vs E2 27hp, still firing.\n A1 (8.5s): A1 27hp vs E2 18hp, still firing. Last enemy.\n A1 (9.0s): A1 18hp vs E2 18hp, still firing. Last enemy.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"A1 9hp vs E2 9hp, still firing. Last enemy.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-b1dbf26fd8e613cbc9b79c0c.json b/examples/multi-agent-smax/results/llm-cache/ask-b1dbf26fd8e613cbc9b79c0c.json new file mode 100644 index 00000000..e33e158e --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-b1dbf26fd8e613cbc9b79c0c.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.0 seconds into the battle.\nYou are A2, a marine at (10.5, 16.3) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.2, 16.2), 45/45 health, order: hold\n A1 marine at (9.9, 15.6), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (15.1, 17.3), 45/45 health, 4.7 away (in range)\n E1 marine at (15.1, 16.6), 45/45 health, 4.6 away (in range)\n E2 marine at (15.3, 14.1), 45/45 health, 5.2 away\nTeam chat (most recent last):\n A1 (1.5s): Holding grouped; focus fire on closest enemy when seen.\n A2 (1.5s): Still holding grouped; will focus the closest enemy when it appears.\n A0 (2.0s): Holding grouped; no enemies yet. Focus closest when seen.\n A1 (2.0s): Enemies at 8.5 east. Hold grouped; all focus the closest when in range.\n A2 (2.0s): No contact after 2s. Advancing east together to (14,16); stay close, focus closest.\n A0 (2.5s): A2 advancing alone is risky; hold grouped at range 5, focus E1 when in range.\n A1 (2.5s): Enemies 7 east. A2 fall back to group; hold and focus E1 when in range.\n A2 (2.5s): Cancel advance. Holding at 10.5; enemies 6 east, focus E1 when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Enemies in range. Focus E1 now, everyone fire on E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-b1e47fb12abcd99fe25490d4.json b/examples/multi-agent-smax/results/llm-cache/ask-b1e47fb12abcd99fe25490d4.json new file mode 100644 index 00000000..bed0d7ff --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-b1e47fb12abcd99fe25490d4.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 1.0 seconds into the battle.\nYou are A0, a marine at (11.7, 16.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 16.\nYour team:\n A1 marine at (11.7, 15.3), 45/45 health, order: move 14 16\n A2 marine at (9.6, 16.6), 45/45 health, order: move 14 16\nEnemies you can see:\n E0 marine at (19.3, 15.1), 45/45 health, 7.8 away\nTeam chat (most recent last):\n A0 (0.0s): Moving east together toward center, stay within 2 of each other; attack same target when seen.\n A1 (0.0s): No enemies seen. Moving east together to (14,16); stay within 2 of each other.\n A2 (0.0s): Moving east together to find enemies; stay within 2 of each other.\n A0 (0.5s): Continuing east to (14,16), staying close; will attack together when enemies appear.\n A1 (0.5s): Continuing east to (14,16), staying close to A0 and A2.\n A2 (0.5s): Moving to (14,16) with A0 and A1, staying close; will focus the first enemy seen.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 16\", \"say\": \"Enemy E0 seen east at 7.8. Keep grouped; attack E0 together when within range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-b2919657e1fc8b547e990e23.json b/examples/multi-agent-smax/results/llm-cache/ask-b2919657e1fc8b547e990e23.json new file mode 100644 index 00000000..98ee19bb --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-b2919657e1fc8b547e990e23.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 8.5 seconds into the battle.\nYou are A0, a marine at (7.8, 14.7) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1: dead\n A2: dead\nEnemies you can see:\n E1 marine at (11.9, 14.0), 27/45 health, 4.1 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (5.5s): Keep focusing E0 (27hp), then E1. Fire together.\n A2 (5.5s): Firing E0 (27hp), then E1. I'm low, keep fire together.\n A0 (6.0s): E0 at 9hp, kill it now, then E1. Fire together.\n A2 (6.0s): E0 at 9hp, finishing it now. Then all focus E1.\n A0 (6.5s): A0 alone vs E1, firing now.\n A0 (7.0s): A0 alone vs E1, firing. Last enemy.\n A0 (7.5s): A0 last unit, still firing on E1.\n A0 (8.0s): A0 last unit, 18hp vs E1 36hp, still firing.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A0 last unit, 18hp vs E1 27hp, still firing.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-b3a9185ea61bd9fb285369ff.json b/examples/multi-agent-smax/results/llm-cache/ask-b3a9185ea61bd9fb285369ff.json new file mode 100644 index 00000000..4924d1d0 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-b3a9185ea61bd9fb285369ff.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 9.5 seconds into the battle.\nYou are A1, a marine at (8.0, 16.0) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E1 marine at (11.6, 16.0), 18/45 health, 3.5 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A2 (6.0s): Focusing E2 (27hp), then E1. A1 keep firing.\n A1 (6.5s): Finishing E2 (9hp) now, then E1. A2 stay behind me.\n A2 (6.5s): E2 at 9hp, finishing it. A1 then focus E1.\n A1 (7.0s): E2 dead, A0 and A2 down. I'm alone on E1, 45hp each.\n A1 (7.5s): Last fight: A1 vs E1, 36hp vs 45hp. Fighting on.\n A1 (8.0s): Last fight, A1 vs E1. Keep firing.\n A1 (8.5s): A1 vs E1, both 27hp. Fighting on.\n A1 (9.0s): A1 18hp vs E1 27hp, last fight. Keep firing.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A1 vs E1, both 18hp. Fighting to the end.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-b3bf21b73d377ea1e4164f1a.json b/examples/multi-agent-smax/results/llm-cache/ask-b3bf21b73d377ea1e4164f1a.json new file mode 100644 index 00000000..1dda2be6 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-b3bf21b73d377ea1e4164f1a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 3.5 seconds into the battle.\nYou are A2, a marine at (12.8, 14.9) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (14.3, 16.0), 45/45 health, order: attack E2\n A1: dead\nEnemies you can see:\n E1 marine at (16.5, 16.2), 45/45 health, 4.0 away (in range)\n E2 marine at (17.6, 14.3), 45/45 health, 4.8 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (2.0s): All in range of E0 now. Everyone attack E0 together.\n A1 (2.0s): All in range now: everyone attack E0 together.\n A2 (2.0s): Enemies in range now. Everyone attack E0 together.\n A0 (2.5s): Focus E0, it's at 18hp. A1 stay on target per rules.\n A1 (2.5s): Focus E0, it's at 18hp. Keep firing until it dies.\n A2 (2.5s): A2 attacking E0 now; focus it down, then E2.\n A0 (3.0s): E0 is dead. Both attack E2 together, closest enemy; stay level with me.\n A2 (3.0s): E0 is dead. Everyone attack E2, it's in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Attacking E2 together; keep firing until it dies.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-b424788684f0bbc078c8f4e4.json b/examples/multi-agent-smax/results/llm-cache/ask-b424788684f0bbc078c8f4e4.json new file mode 100644 index 00000000..2921f1c8 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-b424788684f0bbc078c8f4e4.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.5 seconds into the battle.\nYou are A0, a marine at (7.5, 15.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (7.2, 17.2), 45/45 health, order: hold\n A2 marine at (7.6, 17.8), 45/45 health, order: hold\nEnemies you can see:\n E1 marine at (16.3, 17.1), 45/45 health, 8.8 away\n E2 marine at (14.2, 16.7), 45/45 health, 6.7 away\nTeam chat (most recent last):\n A1 (1.0s): No enemies yet. Holding; will focus fire on the closest when seen.\n A2 (1.0s): A2 holding; no enemies visible. Will focus closest when they appear.\n A0 (1.5s): Still no enemies; holding grouped. Focus closest when seen.\n A1 (1.5s): A1 holding; no enemies yet. Focus closest when seen.\n A2 (1.5s): A2 holding; no enemies visible. Focus closest when they appear.\n A0 (2.0s): E2 spotted at (15.8,16.7). Holding grouped; focus fire on whoever closes first.\n A1 (2.0s): E2 spotted east at 8.6 range. Holding grouped; focus E2 when in range.\n A2 (2.0s): E2 spotted at (15.8,16.7), 8 away. Holding grouped; focus E2 when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"E1, E2 approaching. Holding grouped; focus E2 when within 5.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-b44c4ca414b312a3f29885ff.json b/examples/multi-agent-smax/results/llm-cache/ask-b44c4ca414b312a3f29885ff.json new file mode 100644 index 00000000..108b3562 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-b44c4ca414b312a3f29885ff.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.5 seconds into the battle.\nYou are A0, a marine at (9.0, 16.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (8.9, 14.1), 45/45 health, order: hold\n A2 marine at (9.3, 14.8), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (14.0, 16.4), 45/45 health, 5.0 away\n E1 marine at (14.7, 16.8), 45/45 health, 5.7 away\n E2 marine at (14.6, 15.5), 45/45 health, 5.6 away\nTeam chat (most recent last):\n A1 (2.0s): No contact; advancing east together to find enemies. Stay grouped, focus closest.\n A2 (2.0s): Holding grouped; focus fire closest enemy when it appears.\n A0 (2.5s): Enemies 3 at east, ~7 away. Falling back to group; hold and focus E0 when in range.\n A1 (2.5s): Enemies E0, E2 east ~9 away. Holding grouped; focus E0 when in range.\n A2 (2.5s): Advancing east to join A0/A1; stay grouped, focus closest enemy.\n A0 (3.0s): Holding at (9,16). Let them come into range, then all focus the closest enemy.\n A1 (3.0s): Holding grouped. Enemies ~7 away; let them come into range, focus E0.\n A2 (3.0s): Holding at range; all focus E0 when it enters 5 range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 at 5 range. All focus E0 now.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-b4554d0506d4fe07e87a9411.json b/examples/multi-agent-smax/results/llm-cache/ask-b4554d0506d4fe07e87a9411.json new file mode 100644 index 00000000..0dd1bd7b --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-b4554d0506d4fe07e87a9411.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 1.5 seconds into the battle.\nYou are A0, a marine at (13.7, 16.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 15.\nYour team:\n A1 marine at (12.1, 14.1), 45/45 health, order: move 12 15\n A2 marine at (12.4, 14.8), 45/45 health, order: move 14 15\nEnemies you can see:\n E0 marine at (20.3, 16.4), 45/45 health, 6.6 away\n E1 marine at (21.0, 16.8), 45/45 health, 7.3 away\n E2 marine at (20.9, 15.5), 45/45 health, 7.2 away\nTeam chat (most recent last):\n A1 (0.0s): Moving east together toward center, stay within 2 of each other.\n A2 (0.0s): Moving together to center, stay within 2 of each other; attack same target when in range.\n A0 (0.5s): Moving east, staying close; A1 and A2 keep within 2 of me.\n A1 (0.5s): Advancing east, staying close; will all attack same target when enemies appear.\n A2 (0.5s): Keeping pace east, staying close; will focus same target once in range.\n A0 (1.0s): Continuing east together; A1 and A2 stay close, focus fire once enemies appear.\n A1 (1.0s): Continuing east together; will focus same target when enemies in range.\n A2 (1.0s): Continuing east to 14,15, staying close; will focus same target when enemies appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 15\", \"say\": \"Enemies ~6.6 east. Closing up on me; attack E0 together once all in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-b4ddcea3e134c3800b7294a9.json b/examples/multi-agent-smax/results/llm-cache/ask-b4ddcea3e134c3800b7294a9.json new file mode 100644 index 00000000..b8958805 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-b4ddcea3e134c3800b7294a9.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.5 seconds into the battle.\nYou are A0, a marine at (6.9, 16.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (9.4, 14.9), 45/45 health, order: hold\n A2 marine at (7.6, 17.8), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together; focus fire on closest enemy once seen.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on closest enemy when they appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A0 holding; will focus fire on the closest enemy that appears.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-b545ff07ddfcea6c6ad34340.json b/examples/multi-agent-smax/results/llm-cache/ask-b545ff07ddfcea6c6ad34340.json new file mode 100644 index 00000000..e53912f5 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-b545ff07ddfcea6c6ad34340.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.5 seconds into the battle.\nYou are A0, a marine at (9.0, 16.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (8.9, 14.1), 45/45 health, order: hold\n A2 marine at (9.3, 14.8), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (14.0, 16.4), 45/45 health, 5.0 away\n E1 marine at (14.7, 16.8), 45/45 health, 5.7 away\n E2 marine at (14.6, 15.5), 45/45 health, 5.6 away\nTeam chat (most recent last):\n A1 (2.0s): No contact; advancing east together to find enemies. Stay grouped, focus closest.\n A2 (2.0s): Holding grouped; focus fire closest enemy when it appears.\n A0 (2.5s): Enemies 3 at east, ~7 away. Falling back to group; hold and focus E0 when in range.\n A1 (2.5s): Enemies E0, E2 east ~9 away. Holding grouped; focus E0 when in range.\n A2 (2.5s): Advancing east to join A0/A1; stay grouped, focus closest enemy.\n A0 (3.0s): Holding at range; focus E0 when it enters 5. Stay grouped.\n A1 (3.0s): Holding at range 5; focus E0 when in range. Stay grouped, don't advance alone.\n A2 (3.0s): Holding at range; focus fire E0 (closest) when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 at range 5, firing. Everyone focus E0 now.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-b54af94ca7a12144a909a89f.json b/examples/multi-agent-smax/results/llm-cache/ask-b54af94ca7a12144a909a89f.json new file mode 100644 index 00000000..596e4857 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-b54af94ca7a12144a909a89f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 4.0 seconds into the battle.\nYou are A0, a marine at (15.0, 18.1) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1: dead\n A2 marine at (14.6, 17.4), 36/45 health, order: attack E1\nEnemies you can see:\n E1 marine at (18.5, 17.3), 27/45 health, 3.7 away (in range)\n E2 marine at (17.5, 14.8), 45/45 health, 4.2 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A2 (2.0s): E0 is within range 5 of all three of us. Attack E0 now.\n A0 (2.5s): Focus E0 (18hp). A1 at 18hp, retreat if under 20 per rules.\n A1 (2.5s): A1 at 18hp, retreating to stop being the closest target. A0, A2 focus E0.\n A2 (2.5s): Attacking E0 now; A1 under 20hp, retreat if needed.\n A0 (3.0s): E0 dead. A2 attack E1 now, it's in my range. A1 stay back.\n A2 (3.0s): E0 dead. A0, A2 focus E1 together now; A1 stay back.\n A0 (3.5s): Focusing E1 together, A2 keep firing. A1 stay back.\n A2 (3.5s): Attacking E1 with A0. A1 stay back.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Keep focusing E1 (27hp), both firing together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-b66631c8d1663b6476baf25e.json b/examples/multi-agent-smax/results/llm-cache/ask-b66631c8d1663b6476baf25e.json new file mode 100644 index 00000000..43a42e2e --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-b66631c8d1663b6476baf25e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 2.5 seconds into the battle.\nYou are A1, a marine at (6.7, 14.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.9, 15.6), 45/45 health, order: hold\n A2 marine at (8.3, 17.3), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (15.2, 16.8), 45/45 health, 8.9 away\nTeam chat (most recent last):\n A1 (1.0s): A1 holding. No enemies visible; will focus same target once all in range 5.\n A2 (1.0s): A2 holding. Still no enemies; waiting until all in range 5.\n A0 (1.5s): A0 holding. Still no enemies; waiting for all within 5 to focus fire.\n A1 (1.5s): A1 holding. Still no enemies; will focus same target once all in range 5.\n A2 (1.5s): A2 holding. No enemies visible; will focus fire when all within 5.\n A0 (2.0s): A0 holding; no enemies yet. Will focus same target once all within 5.\n A1 (2.0s): A1 holding; no enemies yet. Will attack together once all within 5.\n A2 (2.0s): A2 holding. E0 spotted at (16.8,16.8), 8.5 away. Wait until it's in range 5 of all.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A1 holding. E0 at 8.9 away; wait until in range 5 of all.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-b690991fef194d8e78b0b04a.json b/examples/multi-agent-smax/results/llm-cache/ask-b690991fef194d8e78b0b04a.json new file mode 100644 index 00000000..ab1562ee --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-b690991fef194d8e78b0b04a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.5 seconds into the battle.\nYou are A0, a marine at (6.9, 16.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1 marine at (7.8, 14.9), 18/45 health, order: attack E0\n A2 marine at (7.6, 17.8), 36/45 health, order: attack E0\nEnemies you can see:\n E1 marine at (12.3, 15.6), 45/45 health, 5.4 away\n E2 marine at (11.9, 17.7), 45/45 health, 5.0 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (3.0s): A1 holding; E0 at 5.1, focus E0 when in range, stay tight.\n A2 (3.0s): A2 holding; E0 closest at 5.8, focus E0 together when in range.\n A0 (3.5s): A0 attacking E0 now, everyone focus E0.\n A1 (3.5s): A1 attacking E0 now, everyone focus E0.\n A2 (3.5s): A2 attacking E0 now, everyone focus E0 together.\n A0 (4.0s): A0 firing E0 (18hp left), finish it then switch to E2.\n A1 (4.0s): E0 at 18 hp, keep focusing E0 then E1.\n A2 (4.0s): A2 firing on E0, 18 hp left, finish it then E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E0 dead. Focus E2 together, then E1. A1 stay back, you're low.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-b69b896d99d81fdf24120048.json b/examples/multi-agent-smax/results/llm-cache/ask-b69b896d99d81fdf24120048.json new file mode 100644 index 00000000..f804679d --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-b69b896d99d81fdf24120048.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.5 seconds into the battle.\nYou are A2, a marine at (10.8, 14.8) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (10.6, 16.0), 27/45 health, order: attack E0\n A1 marine at (8.9, 14.1), 45/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (12.4, 16.4), 18/45 health, 2.3 away (in range)\n E1 marine at (13.1, 16.8), 45/45 health, 3.0 away (in range)\n E2 marine at (13.1, 15.5), 45/45 health, 2.3 away (in range)\nTeam chat (most recent last):\n A1 (3.0s): Holding grouped. Enemies ~7 away; let them come into range, focus E0.\n A2 (3.0s): Holding at range; all focus E0 when it enters 5 range.\n A0 (3.5s): E0 at 5 range. All focus E0 now.\n A1 (3.5s): Holding. Focus E0 when in range; stay grouped.\n A2 (3.5s): E0 at range 5. Everyone attack E0 now, focus fire.\n A0 (4.0s): Focusing E0 now. A1 please attack E0 too, all fire together.\n A1 (4.0s): Attacking E0 now, focus fire.\n A2 (4.0s): All attack E0 now, in range. A1 switch from hold to attack E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 at 18 hp, keep firing. Then focus E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-b6b623bce58c7763adb25f90.json b/examples/multi-agent-smax/results/llm-cache/ask-b6b623bce58c7763adb25f90.json new file mode 100644 index 00000000..b62c204d --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-b6b623bce58c7763adb25f90.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 0.5 seconds into the battle.\nYou are A2, a marine at (10.6, 16.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 16.\nYour team:\n A0 marine at (9.8, 16.2), 45/45 health, order: move 11 16\n A1 marine at (11.4, 15.7), 45/45 health, order: move 14 16\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Advancing east together to find enemies; keep within 2 of each other, then all attack same target.\n A1 (0.0s): Moving east together toward enemies, stay within 2 of each other; attack same target on contact.\n A2 (0.0s): Moving east together to (14,16); stay within 2 of each other, attack together on contact.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 16\", \"say\": \"A2 moving east to (14,16), staying close; attack same target on contact.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-b70164640df05392734f7702.json b/examples/multi-agent-smax/results/llm-cache/ask-b70164640df05392734f7702.json new file mode 100644 index 00000000..ab377733 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-b70164640df05392734f7702.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 2.0 seconds into the battle.\nYou are A0, a marine at (6.9, 15.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (6.7, 14.2), 45/45 health, order: hold\n A2 marine at (8.3, 17.3), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.5s): A1 holding; no enemies visible yet. Will focus same target once all in range.\n A2 (0.5s): A2 holding. No enemies visible yet; will focus fire when all in range 5.\n A0 (1.0s): A0 holding. No enemies visible; will focus same target once all within 5.\n A1 (1.0s): A1 holding. No enemies visible; will focus same target once all in range 5.\n A2 (1.0s): A2 holding. Still no enemies; waiting until all in range 5.\n A0 (1.5s): A0 holding. Still no enemies; waiting for all within 5 to focus fire.\n A1 (1.5s): A1 holding. Still no enemies; will focus same target once all in range 5.\n A2 (1.5s): A2 holding. No enemies visible; will focus fire when all within 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A0 holding; no enemies yet. Will focus same target once all within 5.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-b76b7251a0071b533c563eb3.json b/examples/multi-agent-smax/results/llm-cache/ask-b76b7251a0071b533c563eb3.json new file mode 100644 index 00000000..28a796ca --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-b76b7251a0071b533c563eb3.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.0 seconds into the battle.\nYou are A0, a marine at (6.9, 16.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1 marine at (7.8, 14.9), 36/45 health, order: attack E0\n A2 marine at (7.6, 17.8), 45/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (11.3, 15.3), 18/45 health, 4.6 away (in range)\n E1 marine at (12.3, 15.6), 45/45 health, 5.4 away\n E2 marine at (11.9, 17.7), 45/45 health, 5.0 away\nTeam chat (most recent last):\n A1 (2.5s): A1 holding; E0 approaching, focus fire when in range.\n A2 (2.5s): A2 holding; E0 approaching, focus it when in range.\n A0 (3.0s): A0 holding; all 3 enemies visible. Focus E0 when in range, stay tight.\n A1 (3.0s): A1 holding; E0 at 5.1, focus E0 when in range, stay tight.\n A2 (3.0s): A2 holding; E0 closest at 5.8, focus E0 together when in range.\n A0 (3.5s): A0 attacking E0 now, everyone focus E0.\n A1 (3.5s): A1 attacking E0 now, everyone focus E0.\n A2 (3.5s): A2 attacking E0 now, everyone focus E0 together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"A0 firing E0 (18hp left), finish it then switch to E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-b776e402d1da96c2b1c416e0.json b/examples/multi-agent-smax/results/llm-cache/ask-b776e402d1da96c2b1c416e0.json new file mode 100644 index 00000000..783383e8 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-b776e402d1da96c2b1c416e0.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.0 seconds into the battle.\nYou are A2, a marine at (6.5, 16.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.6, 16.9), 45/45 health, order: hold\n A1 marine at (8.5, 15.3), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding together as a group; focus fire on the closest enemy once seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-b7c0d5d9c20b6f2468985a6c.json b/examples/multi-agent-smax/results/llm-cache/ask-b7c0d5d9c20b6f2468985a6c.json new file mode 100644 index 00000000..9095e663 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-b7c0d5d9c20b6f2468985a6c.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.5 seconds into the battle.\nYou are A1, a marine at (10.1, 17.3) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0: dead\n A2 marine at (9.9, 15.8), 36/45 health, order: attack E1\nEnemies you can see:\n E2 marine at (14.4, 14.8), 45/45 health, 5.0 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A2 (3.5s): E0 at 18hp, keep focusing E0, then E2.\n A0 (4.0s): E0 dead. Focus E1 (3.6 away), then E2. I'm at 18hp.\n A1 (4.0s): E0 dead. Focus E1 (closest, 3.7 away), then E2.\n A2 (4.0s): E0 dead. Focus E1 (4.2 away), then E2.\n A1 (4.5s): Focusing E1 (27hp), then E2.\n A2 (4.5s): Focusing E1 (27hp), then E2.\n A1 (5.0s): Focusing E1 (18hp), almost dead. Then E2.\n A2 (5.0s): Attacking E1 (18hp), then E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E1 down. All focus E2 (45hp), 5.0 away.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-b7cfc4cd1125414ab0be8f7e.json b/examples/multi-agent-smax/results/llm-cache/ask-b7cfc4cd1125414ab0be8f7e.json new file mode 100644 index 00000000..e074caab --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-b7cfc4cd1125414ab0be8f7e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 8.5 seconds into the battle.\nYou are A0, a marine at (3.7, 15.6) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1: dead\n A2: dead\nEnemies you can see:\n E1 marine at (12.2, 16.1), 9/45 health, 8.5 away\n E2 marine at (10.7, 17.4), 45/45 health, 7.3 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (6.5s): A0 at 9hp, staying out of range. A1 focus E1, 36hp left.\n A1 (6.5s): A1 attacking E1 (36hp), in range. A0 stay back, keep out of range.\n A0 (7.0s): A0 9hp, staying out of range. A1 focus E1 (27hp), then E2.\n A1 (7.0s): A1 on E1 (27hp), 3 shots left. A0 stay out of range.\n A0 (7.5s): A0 9hp staying out of range. A1 finish E1 (18hp), then E2.\n A1 (7.5s): A1 on E1 (18hp), finishing it, then E2. A0 stay back.\n A0 (8.0s): A0 9hp joining on E1 to finish it fast, then focus E2 together.\n A1 (8.0s): A1 9hp, finishing E1 (18hp). A0 stay back, then we focus E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"retreat\", \"say\": \"A0 9hp alone, retreating out of range; E1 has 9hp left.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-b923f1e6dcc0343dc3ea698b.json b/examples/multi-agent-smax/results/llm-cache/ask-b923f1e6dcc0343dc3ea698b.json new file mode 100644 index 00000000..9ff78d13 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-b923f1e6dcc0343dc3ea698b.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.0 seconds into the battle.\nYou are A1, a marine at (7.2, 17.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (7.5, 15.8), 45/45 health, order: attack E2\n A2 marine at (7.6, 17.8), 36/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (12.7, 17.1), 45/45 health, 5.6 away\n E1 marine at (11.6, 17.1), 45/45 health, 4.4 away (in range)\n E2 marine at (11.0, 16.7), 18/45 health, 3.9 away (in range)\nTeam chat (most recent last):\n A1 (2.5s): E2 at 7 range. Holding grouped; focus E2 once in range.\n A2 (2.5s): E2 at 6.7, E1 behind. Holding grouped; focus closest when in range.\n A0 (3.0s): A0 holding; E2 at 5.2, focus E2 the moment it enters range.\n A1 (3.0s): E2 at 5.5, nearly in range. Holding; all focus E2 when it enters 5.\n A2 (3.0s): E2 at 5.1, nearly in range. Holding, all fire on E2 first.\n A0 (3.5s): E2 in range, all fire E2 now.\n A1 (3.5s): E2 in range at 3.9. Everyone fire on E2.\n A2 (3.5s): E2 in range at 3.6, all fire E2 now.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Keep firing E2 (18hp), then E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-bab5335c0546e854c6a770f6.json b/examples/multi-agent-smax/results/llm-cache/ask-bab5335c0546e854c6a770f6.json new file mode 100644 index 00000000..ca72c02c --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-bab5335c0546e854c6a770f6.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 0.0 seconds into the battle.\nYou are A2, a marine at (7.6, 17.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.5, 15.8), 45/45 health, order: hold\n A1 marine at (7.2, 17.2), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 17\", \"say\": \"Moving east together to find enemies; stay close, attack same target when in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-bb9343ac20721c887b99786d.json b/examples/multi-agent-smax/results/llm-cache/ask-bb9343ac20721c887b99786d.json new file mode 100644 index 00000000..de5b1baa --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-bb9343ac20721c887b99786d.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 1.5 seconds into the battle.\nYou are A1, a marine at (14.5, 15.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 15 16.\nYour team:\n A0 marine at (13.0, 16.2), 45/45 health, order: move 14 16\n A2 marine at (13.7, 16.2), 45/45 health, order: move 14 16\nEnemies you can see:\n E0 marine at (19.8, 17.3), 45/45 health, 5.5 away\n E1 marine at (19.8, 16.6), 45/45 health, 5.4 away\n E2 marine at (20.0, 14.1), 45/45 health, 5.7 away\nTeam chat (most recent last):\n A1 (0.0s): Moving east together toward enemies, stay within 2 of each other; attack same target on contact.\n A2 (0.0s): Moving east together to (14,16); stay within 2 of each other, attack together on contact.\n A0 (0.5s): Continuing east to (14,16); staying together, will attack same target on contact.\n A1 (0.5s): Continuing east in formation; will attack same target on contact.\n A2 (0.5s): A2 moving east to (14,16), staying close; attack same target on contact.\n A0 (1.0s): Continuing east to (14,16), staying together; no enemies seen yet.\n A1 (1.0s): Advancing together toward enemies; will all attack E1 once in range 5.\n A2 (1.0s): A2 continuing east to (14,16), staying together; attack same target on contact.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 16\", \"say\": \"A1 holding near 14,16 so A0 and A2 catch up; all attack E1 together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-bcda562586a9163f8a193ca0.json b/examples/multi-agent-smax/results/llm-cache/ask-bcda562586a9163f8a193ca0.json new file mode 100644 index 00000000..b641392e --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-bcda562586a9163f8a193ca0.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.0 seconds into the battle.\nYou are A1, a marine at (7.8, 14.9) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (6.9, 16.7), 45/45 health, order: attack E0\n A2 marine at (7.6, 17.8), 45/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (11.3, 15.3), 18/45 health, 3.5 away (in range)\n E1 marine at (12.3, 15.6), 45/45 health, 4.5 away (in range)\n E2 marine at (11.9, 17.7), 45/45 health, 5.0 away (in range)\nTeam chat (most recent last):\n A1 (2.5s): A1 holding; E0 approaching, focus fire when in range.\n A2 (2.5s): A2 holding; E0 approaching, focus it when in range.\n A0 (3.0s): A0 holding; all 3 enemies visible. Focus E0 when in range, stay tight.\n A1 (3.0s): A1 holding; E0 at 5.1, focus E0 when in range, stay tight.\n A2 (3.0s): A2 holding; E0 closest at 5.8, focus E0 together when in range.\n A0 (3.5s): A0 attacking E0 now, everyone focus E0.\n A1 (3.5s): A1 attacking E0 now, everyone focus E0.\n A2 (3.5s): A2 attacking E0 now, everyone focus E0 together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 at 18 hp, keep focusing E0 then E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-bcdd456d3198d0079e23cfbf.json b/examples/multi-agent-smax/results/llm-cache/ask-bcdd456d3198d0079e23cfbf.json new file mode 100644 index 00000000..8df2a11d --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-bcdd456d3198d0079e23cfbf.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.0 seconds into the battle.\nYou are A0, a marine at (9.0, 16.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (7.4, 14.1), 45/45 health, order: hold\n A2 marine at (7.7, 14.8), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.5s): Holding; will focus fire on closest enemy once in range.\n A2 (0.5s): Holding position; focus fire on closest enemy once in range.\n A0 (1.0s): Holding; still no enemies. Focus fire closest when they appear.\n A1 (1.0s): Holding; no enemies in sight. Focus fire closest when they appear.\n A2 (1.0s): Still holding; no enemies visible. Focus fire on closest when they appear.\n A0 (1.5s): Holding near A1/A2; focus fire closest enemy when in range.\n A1 (1.5s): Still holding; will focus fire on closest enemy when visible.\n A2 (1.5s): Holding grouped; focus fire on closest enemy when it appears.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 16\", \"say\": \"No contact; advancing east to center together. Stay close, focus closest enemy.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-bebc6e5ee59ab3d4511ac6df.json b/examples/multi-agent-smax/results/llm-cache/ask-bebc6e5ee59ab3d4511ac6df.json new file mode 100644 index 00000000..6916bc72 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-bebc6e5ee59ab3d4511ac6df.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.5 seconds into the battle.\nYou are A1, a marine at (7.8, 14.9) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (8.5, 16.7), 45/45 health, order: attack E2\n A2 marine at (7.6, 17.8), 27/45 health, order: attack E2\nEnemies you can see:\n E1 marine at (12.3, 15.6), 36/45 health, 4.5 away (in range)\n E2 marine at (11.9, 17.7), 27/45 health, 5.0 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (4.0s): E0 at 18 hp, keep focusing E0 then E1.\n A2 (4.0s): A2 firing on E0, 18 hp left, finish it then E2.\n A0 (4.5s): E0 dead. Focus E2 together, then E1. A1 stay back, you're low.\n A1 (4.5s): E0 dead. A1 on E1 at 4.5, focus E1 together; A2 close in.\n A2 (4.5s): E0 is down; all focus E2 (in range, closest), then E1.\n A0 (5.0s): A0 on E2 (full hp). A1 stay back, low. A2 keep firing E2.\n A1 (5.0s): A1 low, shooting E2 from back. A0 you're tanking, focus E2.\n A2 (5.0s): A2 on E2, in range. A0 and A2 focus E2; A1 stay back.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"A1 firing E2 from back; A0 is closest, keep tanking. Focus E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-bf4ee11ed38bc1eb9876b365.json b/examples/multi-agent-smax/results/llm-cache/ask-bf4ee11ed38bc1eb9876b365.json new file mode 100644 index 00000000..af0b1238 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-bf4ee11ed38bc1eb9876b365.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 6.5 seconds into the battle.\nYou are A2, a marine at (12.8, 14.9) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0: dead\n A1: dead\nEnemies you can see:\n E1 marine at (16.5, 16.2), 18/45 health, 4.0 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (4.5s): E2 at 9hp, keep firing together, then E1.\n A2 (4.5s): E2 at 9hp, finish it now, then E1.\n A0 (5.0s): E2 at 9hp, finish it now together, then E1.\n A2 (5.0s): E2 at 9hp, keep firing together, then E1.\n A0 (5.5s): E2 is dead. Both attack E1 now, keep firing.\n A2 (5.5s): E2 dead. Both attack E1 now, keep firing together, no retreat.\n A0 (6.0s): Focus E1 (27hp), keep firing together until it dies.\n A2 (6.0s): Attacking E1 (27hp), keep firing together, last enemy.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A0 and A1 are dead; I'm at 18hp, E1 at 18hp. Firing on E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-bfc597dd308a719aa7071b9f.json b/examples/multi-agent-smax/results/llm-cache/ask-bfc597dd308a719aa7071b9f.json new file mode 100644 index 00000000..b7be3bdd --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-bfc597dd308a719aa7071b9f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 6.0 seconds into the battle.\nYou are A0, a marine at (14.3, 16.0) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1: dead\n A2 marine at (12.8, 14.9), 18/45 health, order: attack E1\nEnemies you can see:\n E1 marine at (16.5, 16.2), 27/45 health, 2.3 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (4.0s): Keep firing on E2, then E1. No retreat.\n A2 (4.0s): Keep firing on E2 until dead, then E1.\n A0 (4.5s): E2 at 9hp, keep firing together, then E1.\n A2 (4.5s): E2 at 9hp, finish it now, then E1.\n A0 (5.0s): E2 at 9hp, finish it now together, then E1.\n A2 (5.0s): E2 at 9hp, keep firing together, then E1.\n A0 (5.5s): E2 is dead. Both attack E1 now, keep firing.\n A2 (5.5s): E2 dead. Both attack E1 now, keep firing together, no retreat.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Focus E1 (27hp), keep firing together until it dies.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-c032413a17c5c65b0b3df3fa.json b/examples/multi-agent-smax/results/llm-cache/ask-c032413a17c5c65b0b3df3fa.json new file mode 100644 index 00000000..b2af73b7 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-c032413a17c5c65b0b3df3fa.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 9.0 seconds into the battle.\nYou are A0, a marine at (9.3, 15.9) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1: dead\n A2: dead\nEnemies you can see:\n E0 marine at (13.5, 17.3), 18/45 health, 4.4 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (5.5s): Focusing E1 (18hp), both fire. Then E0.\n A0 (6.0s): E1 at 9hp, finishing it. Then E0 together.\n A1 (6.0s): E1 at 9hp, finishing it now. Then E0.\n A0 (6.5s): A1 and A2 are down. I'm engaging E0 alone.\n A0 (7.0s): Last one. E0 at 36hp, fighting on.\n A0 (7.5s): Last one, E0 at 36hp. Fighting on.\n A0 (8.0s): Last one, E0 at 27hp. Fighting on.\n A0 (8.5s): E0 at 27hp, still fighting alone.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 at 18hp, I'm still fighting. Last enemy.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-c03dc2f0863e638adac0d40b.json b/examples/multi-agent-smax/results/llm-cache/ask-c03dc2f0863e638adac0d40b.json new file mode 100644 index 00000000..5d3d3fe6 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-c03dc2f0863e638adac0d40b.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 5.0 seconds into the battle.\nYou are A0, a marine at (13.3, 15.6) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1 marine at (12.9, 17.5), 27/45 health, order: attack E0\n A2 marine at (13.7, 16.7), 9/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (17.7, 17.8), 18/45 health, 5.0 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (3.5s): Focusing E1 (27hp). A0 at 18hp, keep firing until E1 dies.\n A2 (3.5s): Focusing E1 (27hp), then E0. A0 at 18hp, keep firing.\n A0 (4.0s): E1 at 9hp, finishing it now, then E0.\n A1 (4.0s): E1 at 9hp, all keep firing until dead, then E0.\n A2 (4.0s): E1 at 9hp, keep firing until dead, then E0.\n A0 (4.5s): E1 dead. All focus E0, it's in range 5.0 now.\n A1 (4.5s): E1 dead. All attack E0 now, it's in range 4.9.\n A2 (4.5s): E1 dead. All focus E0, 4.2 away in range. Keep firing.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Attacking E0 (18hp), keep firing until it dies.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-c08d72a7db401f338b6c971a.json b/examples/multi-agent-smax/results/llm-cache/ask-c08d72a7db401f338b6c971a.json new file mode 100644 index 00000000..f19bb415 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-c08d72a7db401f338b6c971a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.5 seconds into the battle.\nYou are A1, a marine at (8.3, 14.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E2 marine at (12.3, 17.5), 45/45 health, 5.3 away\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (4.5s): A1 hitting E1 (36hp). After E0 dies, everyone on E1.\n A2 (4.5s): A2 9hp. E0 at 18hp, A0 and I finish it now, then E1.\n A0 (5.0s): E0 is dead. A0 and A1 focus E1 (27hp), then E2.\n A1 (5.0s): A1 on E1 (27hp), in range. A0 join E1, then E2.\n A0 (5.5s): A0 18hp on E1 (18hp), finishing it. Then both on E2.\n A1 (5.5s): A1 on E1 (18hp), in range. A0 keep firing, then both E2.\n A0 (6.0s): A0 9hp, finishing E1 (9hp). Then both E2.\n A1 (6.0s): A1 on E1 (9hp), finishing it. Then both on E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"A1 alone vs E2 (45hp), engaging.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-c0d407b4033fa84a10df06bf.json b/examples/multi-agent-smax/results/llm-cache/ask-c0d407b4033fa84a10df06bf.json new file mode 100644 index 00000000..fb391b11 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-c0d407b4033fa84a10df06bf.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.5 seconds into the battle.\nYou are A2, a marine at (9.4, 16.4) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0: dead\n A1 marine at (8.5, 15.3), 27/45 health, order: attack E1\nEnemies you can see:\n E2 marine at (12.8, 17.3), 45/45 health, 3.5 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (4.0s): A1 attacking E0 (9hp), finish it then switch to E1.\n A2 (4.0s): A2 closing on E0 (9hp), then focus E1.\n A0 (4.5s): E0 dead. A0 on E2, all focus E2 please.\n A1 (4.5s): E0 dead. Focus E1 (4.5 away), then E2.\n A2 (4.5s): E0 dead. A2 focusing E1, everyone focus E1 then E2.\n A0 (5.0s): A0 switching to E1 (27hp), focus fire. A2 is tanking.\n A1 (5.0s): A1 on E1 (27hp), focus fire. A0 hurt, fall back if needed.\n A2 (5.0s): A2 on E1 (27hp), in range. A0 retreat if low, A1 focus E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"A2 on E2 (45hp, in range). A1 focus E2, last enemy.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-c0ec9273b113c43518bff18f.json b/examples/multi-agent-smax/results/llm-cache/ask-c0ec9273b113c43518bff18f.json new file mode 100644 index 00000000..326a8398 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-c0ec9273b113c43518bff18f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.0 seconds into the battle.\nYou are A0, a marine at (9.4, 15.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1 marine at (9.9, 15.5), 45/45 health, order: attack E2\n A2 marine at (9.3, 16.6), 18/45 health, order: retreat\nEnemies you can see:\n E0 marine at (15.1, 17.3), 45/45 health, 5.9 away\n E1 marine at (15.1, 16.6), 36/45 health, 5.8 away\n E2 marine at (13.7, 14.1), 36/45 health, 4.7 away (in range)\nTeam chat (most recent last):\n A1 (2.5s): Enemies 7 east. A2 fall back to group; hold and focus E1 when in range.\n A2 (2.5s): Cancel advance. Holding at 10.5; enemies 6 east, focus E1 when in range.\n A0 (3.0s): Holding. Enemies at 7; focus E1 when in range, stay grouped.\n A1 (3.0s): Holding. E1 is closest at 5.3; focus E1 as soon as it's in range.\n A2 (3.0s): Enemies in range. Focus E1 now, everyone fire on E1.\n A0 (3.5s): Moving up to fire on E1; A2 is taking fire, everyone commit.\n A1 (3.5s): E1 out of range; E2 in range at 4.1. Everyone focus E2.\n A2 (3.5s): A2 hurt, pulling back west to you. Fire on E1 when they follow into range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Switching to E2, in range at 4.7. A1 and I focus E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-c0fbfa68637940887b57ba2b.json b/examples/multi-agent-smax/results/llm-cache/ask-c0fbfa68637940887b57ba2b.json new file mode 100644 index 00000000..c5b3a810 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-c0fbfa68637940887b57ba2b.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 5.5 seconds into the battle.\nYou are A0, a marine at (8.4, 15.6) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1 marine at (8.3, 14.2), 45/45 health, order: attack E0\n A2: dead\nEnemies you can see:\n E1 marine at (12.2, 16.1), 45/45 health, 3.8 away (in range)\n E2 marine at (12.3, 17.4), 45/45 health, 4.3 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (4.0s): A2 engaged, A0 attacking E0 now. A1 attack E0 too, focus fire.\n A1 (4.0s): A2 is engaged; A1 attacking E0 now. A0 join and focus E0.\n A2 (4.0s): Engaged, all 3 enemies on me. A0 A1 attack E0 now, focus fire.\n A0 (4.5s): Focus E0 (27hp). A2 at 9hp, retreat to draw fire away if possible.\n A1 (4.5s): A1 focusing E0 (27hp). A2 retreat, you're at 9hp.\n A2 (4.5s): A2 at 9hp retreating. A0 A1 keep focus on E0, it has 27hp.\n A0 (5.0s): E0 at 9hp, finishing it now. A1 focus E0.\n A1 (5.0s): A1 firing on E0 (9hp), finish it then focus E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E0 dead. Both focus E1 now, then E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-c1207ff18279bae19c5642ca.json b/examples/multi-agent-smax/results/llm-cache/ask-c1207ff18279bae19c5642ca.json new file mode 100644 index 00000000..66997b68 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-c1207ff18279bae19c5642ca.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 3.5 seconds into the battle.\nYou are A0, a marine at (13.7, 15.6) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1 marine at (14.2, 16.3), 45/45 health, order: attack E2\n A2 marine at (14.9, 18.0), 9/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (17.0, 17.7), 45/45 health, 3.9 away (in range)\n E1 marine at (17.9, 16.0), 45/45 health, 4.2 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (2.0s): Moving with you to 15,16; next tick all attack E2 together.\n A2 (2.0s): Closing to 15,17 together; once all in range 5, everyone attack E0 same tick.\n A0 (2.5s): All in range now. Everyone attack E2 this tick.\n A1 (2.5s): All in range now. Everyone focus E2, it's at 36hp.\n A2 (2.5s): All in range now. Focus E2 (36hp), everyone attack E2 this tick.\n A0 (3.0s): E2 at 9hp, finish it now, then focus E1.\n A1 (3.0s): E2 at 9hp, finish it now, then focus E0.\n A2 (3.0s): E2 at 9hp, finish it now, then focus E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E2 dead. Everyone focus E0 now. A2 at 9hp, retreat.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-c1244feee490658ac8616d02.json b/examples/multi-agent-smax/results/llm-cache/ask-c1244feee490658ac8616d02.json new file mode 100644 index 00000000..321231cc --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-c1244feee490658ac8616d02.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 2.0 seconds into the battle.\nYou are A1, a marine at (13.5, 17.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 17.\nYour team:\n A0 marine at (13.8, 15.8), 45/45 health, order: move 14 17\n A2 marine at (13.9, 17.8), 45/45 health, order: move 14 17\nEnemies you can see:\n E0 marine at (19.0, 17.1), 45/45 health, 5.6 away\n E1 marine at (17.8, 17.1), 45/45 health, 4.4 away (in range)\n E2 marine at (15.8, 16.7), 45/45 health, 2.4 away (in range)\nTeam chat (most recent last):\n A1 (0.5s): Moving east in a tight group; will attack same target together.\n A2 (0.5s): Moving east in formation; A0 and A1 keep pace, no one pull ahead.\n A0 (1.0s): Advancing together toward E2; hold pace, attack same target once all in range 5.\n A1 (1.0s): Advancing east together toward E2; keep within 2, attack same target at range.\n A2 (1.0s): Closing together toward E2; hold pace, all fire on E2 once in range 5.\n A0 (1.5s): E2 is 5.2 away; one more step east, then all attack E2 together.\n A1 (1.5s): Almost in range of E2; keep pace, all attack E2 together next tick.\n A2 (1.5s): Still closing together; E2 just outside range. Fire on E2 once all in range 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"All in range of E2 (2.4 away). Attack E2 now, everyone focus fire.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-c15e1d33bc10c3eba3a7cbc4.json b/examples/multi-agent-smax/results/llm-cache/ask-c15e1d33bc10c3eba3a7cbc4.json new file mode 100644 index 00000000..02ffc604 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-c15e1d33bc10c3eba3a7cbc4.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 5.5 seconds into the battle.\nYou are A0, a marine at (14.3, 16.0) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1: dead\n A2 marine at (12.8, 14.9), 18/45 health, order: attack E2\nEnemies you can see:\n E1 marine at (16.5, 16.2), 45/45 health, 2.3 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (3.5s): Both on E2 together, then E1. Keep firing, no retreat.\n A2 (3.5s): Attacking E2 together; keep firing until it dies.\n A0 (4.0s): Keep firing on E2, then E1. No retreat.\n A2 (4.0s): Keep firing on E2 until dead, then E1.\n A0 (4.5s): E2 at 9hp, keep firing together, then E1.\n A2 (4.5s): E2 at 9hp, finish it now, then E1.\n A0 (5.0s): E2 at 9hp, finish it now together, then E1.\n A2 (5.0s): E2 at 9hp, keep firing together, then E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E2 is dead. Both attack E1 now, keep firing.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-c1e63139d86f9b060d87978a.json b/examples/multi-agent-smax/results/llm-cache/ask-c1e63139d86f9b060d87978a.json new file mode 100644 index 00000000..01bd5f68 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-c1e63139d86f9b060d87978a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 4.0 seconds into the battle.\nYou are A2, a marine at (13.0, 14.3) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (12.8, 15.9), 27/45 health, order: attack E1\n A1 marine at (13.0, 15.0), 18/45 health, order: attack E1\nEnemies you can see:\n E0 marine at (17.3, 15.0), 45/45 health, 4.4 away (in range)\n E1 marine at (16.6, 14.0), 18/45 health, 3.6 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (2.5s): Firing on E2 (18hp), keep attacking until it dies.\n A2 (2.5s): Attacking E2, it's at 18hp; finish it together.\n A0 (3.0s): E2 dead. Everyone focus E1, closest to all of us.\n A1 (3.0s): E2 dead. Focus E1 (closest, 3.8 away), all attack E1 together.\n A2 (3.0s): E2 is dead. Focus E1 (closest, 3.6 away), all together.\n A0 (3.5s): Attacking E1 (36hp), keep focusing until it dies.\n A1 (3.5s): Attacking E1 (36hp), keep focus until it dies.\n A2 (3.5s): Keep firing on E1, 36hp left. All together until it dies.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E1 at 18hp, keep firing together until it dies, then E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-c2004472dbf4c32713776f35.json b/examples/multi-agent-smax/results/llm-cache/ask-c2004472dbf4c32713776f35.json new file mode 100644 index 00000000..61d13cf1 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-c2004472dbf4c32713776f35.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 0.0 seconds into the battle.\nYou are A2, a marine at (7.6, 17.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.9, 16.7), 45/45 health, order: hold\n A1 marine at (9.4, 14.9), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 16\", \"say\": \"Moving east together toward center, stay within 2 of each other; attack same target on contact.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-c2272fecf092710487f94c05.json b/examples/multi-agent-smax/results/llm-cache/ask-c2272fecf092710487f94c05.json new file mode 100644 index 00000000..8121e83f --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-c2272fecf092710487f94c05.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.0 seconds into the battle.\nYou are A2, a marine at (7.7, 14.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (9.0, 16.0), 45/45 health, order: hold\n A1 marine at (7.4, 14.1), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.5s): Holding; will focus fire on closest enemy once in range.\n A2 (0.5s): Holding position; focus fire on closest enemy once in range.\n A0 (1.0s): Holding; still no enemies. Focus fire closest when they appear.\n A1 (1.0s): Holding; no enemies in sight. Focus fire closest when they appear.\n A2 (1.0s): Still holding; no enemies visible. Focus fire on closest when they appear.\n A0 (1.5s): Holding near A1/A2; focus fire closest enemy when in range.\n A1 (1.5s): Still holding; will focus fire on closest enemy when visible.\n A2 (1.5s): Holding grouped; focus fire on closest enemy when it appears.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding grouped; focus fire closest enemy when it appears.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-c23d05f55cb228ad351c88b8.json b/examples/multi-agent-smax/results/llm-cache/ask-c23d05f55cb228ad351c88b8.json new file mode 100644 index 00000000..16cdef98 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-c23d05f55cb228ad351c88b8.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 2.5 seconds into the battle.\nYou are A0, a marine at (14.5, 16.3) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1 marine at (14.6, 15.5), 45/45 health, order: attack E1\n A2 marine at (15.3, 16.3), 18/45 health, order: attack E1\nEnemies you can see:\n E0 marine at (18.2, 17.3), 45/45 health, 3.8 away (in range)\n E1 marine at (18.2, 16.6), 27/45 health, 3.7 away (in range)\n E2 marine at (18.4, 14.1), 45/45 health, 4.4 away (in range)\nTeam chat (most recent last):\n A1 (1.0s): Advancing together toward enemies; will all attack E1 once in range 5.\n A2 (1.0s): A2 continuing east to (14,16), staying together; attack same target on contact.\n A0 (1.5s): Advancing together east; attack E1 once all within range 5.\n A1 (1.5s): A1 holding near 14,16 so A0 and A2 catch up; all attack E1 together.\n A2 (1.5s): Advancing together to (15,16); all attack E1 once in range 5.\n A0 (2.0s): Enemies in range now. All attack E1, A1 close in.\n A1 (2.0s): A1 attacking E1 now; A0 and A2 are in range, focus E1.\n A2 (2.0s): Enemies in range of me and A0. Attacking E1 now; A1 close in and fire on E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Focus E1 (27hp). A2 low at 18hp, retreat if needed.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-c362384973ca3f5184c8b6de.json b/examples/multi-agent-smax/results/llm-cache/ask-c362384973ca3f5184c8b6de.json new file mode 100644 index 00000000..00e7ad96 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-c362384973ca3f5184c8b6de.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 3.5 seconds into the battle.\nYou are A0, a marine at (14.2, 16.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1 marine at (14.6, 15.5), 18/45 health, order: attack E1\n A2: dead\nEnemies you can see:\n E0 marine at (18.2, 17.3), 45/45 health, 4.1 away (in range)\n E2 marine at (18.4, 14.1), 45/45 health, 4.7 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (2.0s): Enemies in range now. All attack E1, A1 close in.\n A1 (2.0s): A1 attacking E1 now; A0 and A2 are in range, focus E1.\n A2 (2.0s): Enemies in range of me and A0. Attacking E1 now; A1 close in and fire on E1.\n A0 (2.5s): Focus E1 (27hp). A2 low at 18hp, retreat if needed.\n A1 (2.5s): Firing on E1 (27hp). A2 at 18hp, retreat if under 20.\n A2 (2.5s): A2 at 18hp retreating to pull fire off me; A0, A1 keep focusing E1.\n A0 (3.0s): E1 at 9hp, finish it now; then focus E0.\n A1 (3.0s): E1 at 9hp, finishing it now. A0 fire E1, then focus E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E1 dead. A0 focusing E0; A1 under 20hp, retreat to pull fire.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-c3e8d0380bcba11f0c38478a.json b/examples/multi-agent-smax/results/llm-cache/ask-c3e8d0380bcba11f0c38478a.json new file mode 100644 index 00000000..eed0f71b --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-c3e8d0380bcba11f0c38478a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.5 seconds into the battle.\nYou are A1, a marine at (8.5, 14.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.8, 14.7), 45/45 health, order: hold\n A2 marine at (8.2, 14.1), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (12.6, 15.0), 45/45 health, 4.1 away (in range)\n E1 marine at (13.4, 14.0), 45/45 health, 5.0 away (in range)\n E2 marine at (11.8, 16.8), 45/45 health, 3.8 away (in range)\nTeam chat (most recent last):\n A1 (2.0s): Holding cluster; let them walk into range, then focus closest enemy.\n A2 (2.0s): E2 spotted east at 8.7 range. Holding cluster; let them come, focus first in range.\n A0 (2.5s): Enemies approaching; hold cluster, all focus whichever enemy enters range first.\n A1 (2.5s): Holding. Enemies closing; all focus closest enemy once in range 5.\n A2 (2.5s): A2 holding. Enemies approaching; focus closest once in range 5.\n A0 (3.0s): Holding. Focus closest enemy E2 when in range 5, fire together.\n A1 (3.0s): Holding. E2 closest at 5.3; focus E2 when in range, then E0.\n A2 (3.0s): Holding. E2 closest at 5.8; focus whoever enters range 5 first.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Focus E2 now, all fire together, then E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-c40bed3b3173258bae1e3efd.json b/examples/multi-agent-smax/results/llm-cache/ask-c40bed3b3173258bae1e3efd.json new file mode 100644 index 00000000..79157216 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-c40bed3b3173258bae1e3efd.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 2.0 seconds into the battle.\nYou are A2, a marine at (13.7, 16.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 16.5.\nYour team:\n A0 marine at (13.3, 15.6), 45/45 health, order: move 14 16.5\n A1 marine at (12.9, 17.5), 36/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (19.1, 17.6), 45/45 health, 5.5 away\n E1 marine at (16.9, 14.5), 45/45 health, 3.9 away (in range)\n E2 marine at (17.8, 17.2), 36/45 health, 4.1 away (in range)\nTeam chat (most recent last):\n A1 (0.5s): Continuing east together; will all attack same enemy on contact.\n A2 (0.5s): Continuing east together; no enemies seen yet, will focus same target on contact.\n A0 (1.0s): Continuing east together; no enemies yet, will focus same target on contact.\n A1 (1.0s): Moving to 14,16.5 with the group; will attack E2 together when in range.\n A2 (1.0s): Enemy E2 seen at 19.3,17.2. Keep formation, advance together, then all attack E2.\n A0 (1.5s): Enemies 6-7 away; keep advancing together, then all attack E2 at range 5.\n A1 (1.5s): E2 in my range; A0, A2 close in and focus E2 now.\n A2 (1.5s): Staying together; E2 nearly in range. All attack E2 once everyone is within 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 and E1 in my range; attacking E2 now, everyone focus E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-c4280d4cfc3308ca4761fdd1.json b/examples/multi-agent-smax/results/llm-cache/ask-c4280d4cfc3308ca4761fdd1.json new file mode 100644 index 00000000..eb2db5c6 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-c4280d4cfc3308ca4761fdd1.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 3.0 seconds into the battle.\nYou are A2, a marine at (13.2, 17.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (14.8, 18.0), 45/45 health, order: attack E0\n A1: dead\nEnemies you can see:\n E1 marine at (18.5, 17.3), 45/45 health, 5.4 away\n E2 marine at (19.1, 14.8), 45/45 health, 6.6 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (1.5s): Holding formation at 14,17; attack E0 together once all within range 5.\n A2 (1.5s): Regrouping at 14,17; closest enemy 6 away, hold formation, then attack E0 together.\n A0 (2.0s): E0 is within range 5 of all three of us. Everyone attack E0 now.\n A1 (2.0s): E0 is in range of all three. Attack E0 now, together.\n A2 (2.0s): E0 is within range 5 of all three of us. Attack E0 now.\n A0 (2.5s): Focus E0 (18hp). A1 at 18hp, retreat if under 20 per rules.\n A1 (2.5s): A1 at 18hp, retreating to stop being the closest target. A0, A2 focus E0.\n A2 (2.5s): Attacking E0 now; A1 under 20hp, retreat if needed.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E0 dead. A0, A2 focus E1 together now; A1 stay back.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-c489d0adef3d180ab5e6aa7f.json b/examples/multi-agent-smax/results/llm-cache/ask-c489d0adef3d180ab5e6aa7f.json new file mode 100644 index 00000000..192eb970 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-c489d0adef3d180ab5e6aa7f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 0.5 seconds into the battle.\nYou are A1, a marine at (8.1, 16.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 16.\nYour team:\n A0 marine at (8.8, 15.8), 45/45 health, order: move 12 17\n A2 marine at (8.6, 18.0), 45/45 health, order: move 10 17\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Moving east together to (12,17); stay within 2 of each other, then all attack same target.\n A1 (0.0s): Moving east together toward the center; stay within 2 of each other.\n A2 (0.0s): Advancing east together, stay within 2 of each other; attack same target when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 17\", \"say\": \"Moving to (12,17) with A0; keep together, then focus same target.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-c4a83dec3b1f20b4139d63c6.json b/examples/multi-agent-smax/results/llm-cache/ask-c4a83dec3b1f20b4139d63c6.json new file mode 100644 index 00000000..aa69c6f3 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-c4a83dec3b1f20b4139d63c6.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 6.0 seconds into the battle.\nYou are A0, a marine at (8.4, 15.6) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1 marine at (8.3, 14.2), 45/45 health, order: attack E1\n A2: dead\nEnemies you can see:\n E1 marine at (12.2, 16.1), 45/45 health, 3.8 away (in range)\n E2 marine at (12.3, 17.4), 45/45 health, 4.3 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A2 (4.0s): Engaged, all 3 enemies on me. A0 A1 attack E0 now, focus fire.\n A0 (4.5s): Focus E0 (27hp). A2 at 9hp, retreat to draw fire away if possible.\n A1 (4.5s): A1 focusing E0 (27hp). A2 retreat, you're at 9hp.\n A2 (4.5s): A2 at 9hp retreating. A0 A1 keep focus on E0, it has 27hp.\n A0 (5.0s): E0 at 9hp, finishing it now. A1 focus E0.\n A1 (5.0s): A1 firing on E0 (9hp), finish it then focus E1.\n A0 (5.5s): E0 dead. Both focus E1 now, then E2.\n A1 (5.5s): E0 down. Focus E1 (4.4 away, in range) now, both of us.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"retreat\", \"say\": \"A0 at 18hp retreating to pull fire off. A1 focus E1, I'll rejoin if safe.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-c4c21888dcc42ae416e10a5a.json b/examples/multi-agent-smax/results/llm-cache/ask-c4c21888dcc42ae416e10a5a.json new file mode 100644 index 00000000..63b8d265 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-c4c21888dcc42ae416e10a5a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 3.5 seconds into the battle.\nYou are A0, a marine at (15.0, 18.1) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1: dead\n A2 marine at (14.6, 17.4), 45/45 health, order: attack E1\nEnemies you can see:\n E1 marine at (18.5, 17.3), 45/45 health, 3.7 away (in range)\n E2 marine at (17.5, 14.8), 45/45 health, 4.2 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (2.0s): E0 is within range 5 of all three of us. Everyone attack E0 now.\n A1 (2.0s): E0 is in range of all three. Attack E0 now, together.\n A2 (2.0s): E0 is within range 5 of all three of us. Attack E0 now.\n A0 (2.5s): Focus E0 (18hp). A1 at 18hp, retreat if under 20 per rules.\n A1 (2.5s): A1 at 18hp, retreating to stop being the closest target. A0, A2 focus E0.\n A2 (2.5s): Attacking E0 now; A1 under 20hp, retreat if needed.\n A0 (3.0s): E0 dead. A2 attack E1 now, it's in my range. A1 stay back.\n A2 (3.0s): E0 dead. A0, A2 focus E1 together now; A1 stay back.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Focusing E1 together, A2 keep firing. A1 stay back.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-c50d7ca38fa4d8f3ac529cef.json b/examples/multi-agent-smax/results/llm-cache/ask-c50d7ca38fa4d8f3ac529cef.json new file mode 100644 index 00000000..5168e60b --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-c50d7ca38fa4d8f3ac529cef.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 10.0 seconds into the battle.\nYou are A1, a marine at (8.0, 16.0) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E1 marine at (11.6, 16.0), 9/45 health, 3.5 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (6.5s): Finishing E2 (9hp) now, then E1. A2 stay behind me.\n A2 (6.5s): E2 at 9hp, finishing it. A1 then focus E1.\n A1 (7.0s): E2 dead, A0 and A2 down. I'm alone on E1, 45hp each.\n A1 (7.5s): Last fight: A1 vs E1, 36hp vs 45hp. Fighting on.\n A1 (8.0s): Last fight, A1 vs E1. Keep firing.\n A1 (8.5s): A1 vs E1, both 27hp. Fighting on.\n A1 (9.0s): A1 18hp vs E1 27hp, last fight. Keep firing.\n A1 (9.5s): A1 vs E1, both 18hp. Fighting to the end.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A1 9hp vs E1 9hp, last shots. Fighting on.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-c55e52178f58192248475245.json b/examples/multi-agent-smax/results/llm-cache/ask-c55e52178f58192248475245.json new file mode 100644 index 00000000..1c720993 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-c55e52178f58192248475245.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 7.0 seconds into the battle.\nYou are A1, a marine at (8.5, 15.3) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0: dead\n A2 marine at (9.4, 16.4), 27/45 health, order: attack E2\nEnemies you can see:\n E2 marine at (12.8, 17.3), 9/45 health, 4.8 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (5.0s): A1 on E1 (27hp), focus fire. A0 hurt, fall back if needed.\n A2 (5.0s): A2 on E1 (27hp), in range. A0 retreat if low, A1 focus E1.\n A1 (5.5s): E1 down. All focus E2, 4.8 away, in range.\n A2 (5.5s): A2 on E2 (45hp, in range). A1 focus E2, last enemy.\n A1 (6.0s): A1 on E2 (36hp), in range. Keep focus fire, last enemy.\n A2 (6.0s): A2 on E2 (36hp), in range. A1 keep firing, last enemy.\n A1 (6.5s): A1 on E2 (27hp), in range. Keep firing, last enemy.\n A2 (6.5s): E2 at 27hp, in range. Both keep firing, last enemy.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"A1 on E2 (9hp), in range. Finish it, last enemy.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-c5b894847d929e1e070ae9f4.json b/examples/multi-agent-smax/results/llm-cache/ask-c5b894847d929e1e070ae9f4.json new file mode 100644 index 00000000..8ea6cc5f --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-c5b894847d929e1e070ae9f4.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.0 seconds into the battle.\nYou are A0, a marine at (8.1, 15.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (8.2, 15.0), 45/45 health, order: move 8 15\n A2 marine at (8.2, 14.3), 45/45 health, order: move 8 15\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Regroup near (8,15) so we fight together; focus fire on closest enemy.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A0 (0.5s): At (8,15), holding. Focus fire on the closest enemy that appears.\n A1 (0.5s): Closing to (8,15) to cluster; will focus closest enemy.\n A2 (0.5s): Moving to regroup at (8,15); will focus fire closest enemy.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 8 15\", \"say\": \"Moving to cluster at (8,15); will focus fire closest enemy.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-c5ba3dc2356881d2c835b13f.json b/examples/multi-agent-smax/results/llm-cache/ask-c5ba3dc2356881d2c835b13f.json new file mode 100644 index 00000000..2b32aaab --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-c5ba3dc2356881d2c835b13f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.5 seconds into the battle.\nYou are A0, a marine at (7.5, 15.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (7.2, 17.2), 45/45 health, order: hold\n A2 marine at (7.6, 17.8), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together here; focus fire on the closest enemy when they appear.\n A0 (0.5s): No enemies yet. Staying grouped; focus fire on the closest one when seen.\n A1 (0.5s): A1 holding; will focus fire on the closest enemy when seen.\n A2 (0.5s): Holding; will focus fire on closest enemy once visible.\n A0 (1.0s): No enemies visible; holding grouped. Focus fire on the closest when they appear.\n A1 (1.0s): No enemies yet. Holding; will focus fire on the closest when seen.\n A2 (1.0s): A2 holding; no enemies visible. Will focus closest when they appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Still no enemies; holding grouped. Focus closest when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-c5c02c5360b64dfa28243c53.json b/examples/multi-agent-smax/results/llm-cache/ask-c5c02c5360b64dfa28243c53.json new file mode 100644 index 00000000..591222d6 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-c5c02c5360b64dfa28243c53.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 2.0 seconds into the battle.\nYou are A2, a marine at (13.5, 14.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 15.\nYour team:\n A0 marine at (14.2, 14.5), 45/45 health, order: move 14 15\n A1 marine at (13.6, 14.0), 45/45 health, order: move 14 15\nEnemies you can see:\n E0 marine at (18.7, 16.4), 45/45 health, 5.5 away\n E1 marine at (19.4, 16.8), 45/45 health, 6.2 away\n E2 marine at (19.4, 15.5), 45/45 health, 5.9 away\nTeam chat (most recent last):\n A1 (0.5s): Advancing east, staying close; will all attack same target when enemies appear.\n A2 (0.5s): Keeping pace east, staying close; will focus same target once in range.\n A0 (1.0s): Continuing east together; A1 and A2 stay close, focus fire once enemies appear.\n A1 (1.0s): Continuing east together; will focus same target when enemies in range.\n A2 (1.0s): Continuing east to 14,15, staying close; will focus same target when enemies appear.\n A0 (1.5s): Enemies ~6.6 east. Closing up on me; attack E0 together once all in range.\n A1 (1.5s): Moving to 14,15 with A0 and A2; will focus same target at range 5.\n A2 (1.5s): Enemies 8 away; keep moving together, then all attack E0 at range 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Attacking E0 now; A0 is already in range, A1 close up and focus E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-c5ca3b9f33915a2b90ea7444.json b/examples/multi-agent-smax/results/llm-cache/ask-c5ca3b9f33915a2b90ea7444.json new file mode 100644 index 00000000..fcd7dbb5 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-c5ca3b9f33915a2b90ea7444.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.5 seconds into the battle.\nYou are A0, a marine at (7.8, 14.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1: dead\n A2 marine at (8.2, 14.1), 45/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (12.6, 15.0), 45/45 health, 4.8 away (in range)\n E1 marine at (13.4, 14.0), 45/45 health, 5.7 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (3.0s): Holding. E2 closest at 5.3; focus E2 when in range, then E0.\n A2 (3.0s): Holding. E2 closest at 5.8; focus whoever enters range 5 first.\n A0 (3.5s): E2 in range 4.6, all focus fire E2 now, then E0.\n A1 (3.5s): Focus E2 now, all fire together, then E0.\n A2 (3.5s): E0 and E2 in range now. Focus E2, fire together, then E0.\n A0 (4.0s): Firing E2 (18hp), then E0. A1 stay behind us.\n A1 (4.0s): E2 at 18 HP, finish it now, then E0.\n A2 (4.0s): Firing on E2 (18hp), then E0. Keep A1 behind us.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E2 down. Focus E0 now, then E1. Fire together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-c5ec1ac20e9d17538b99d967.json b/examples/multi-agent-smax/results/llm-cache/ask-c5ec1ac20e9d17538b99d967.json new file mode 100644 index 00000000..57601b08 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-c5ec1ac20e9d17538b99d967.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 4.5 seconds into the battle.\nYou are A0, a marine at (15.0, 18.1) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1: dead\n A2 marine at (14.6, 17.4), 27/45 health, order: attack E1\nEnemies you can see:\n E1 marine at (18.5, 17.3), 9/45 health, 3.7 away (in range)\n E2 marine at (17.5, 14.8), 45/45 health, 4.2 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (2.5s): A1 at 18hp, retreating to stop being the closest target. A0, A2 focus E0.\n A2 (2.5s): Attacking E0 now; A1 under 20hp, retreat if needed.\n A0 (3.0s): E0 dead. A2 attack E1 now, it's in my range. A1 stay back.\n A2 (3.0s): E0 dead. A0, A2 focus E1 together now; A1 stay back.\n A0 (3.5s): Focusing E1 together, A2 keep firing. A1 stay back.\n A2 (3.5s): Attacking E1 with A0. A1 stay back.\n A0 (4.0s): Keep focusing E1 (27hp), both firing together.\n A2 (4.0s): Focusing E1 (27hp), both in range. Keep firing, then E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E1 at 9hp, finish it now, then both focus E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-c64a220a849f20bab14cecc4.json b/examples/multi-agent-smax/results/llm-cache/ask-c64a220a849f20bab14cecc4.json new file mode 100644 index 00000000..f06e4fb5 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-c64a220a849f20bab14cecc4.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.0 seconds into the battle.\nYou are A1, a marine at (8.1, 17.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 8 16.5.\nYour team:\n A0 marine at (8.5, 15.6), 45/45 health, order: move 9 16.5\n A2 marine at (8.9, 16.7), 45/45 health, order: move 10 17\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together at the cluster; focus fire on the closest enemy when they appear.\n A1 (0.0s): Advancing east together; stay close and focus fire on the nearest enemy.\n A2 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A0 (0.5s): A1 fell back toward cluster; I'm moving to x=9 so we stay grouped.\n A1 (0.5s): Falling back to cluster; hold together and focus the closest enemy.\n A2 (0.5s): A1 is ahead alone; moving up to group with A1, then focus nearest enemy.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 9 16.8\", \"say\": \"Grouping at x=9; focus fire on nearest enemy when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-c7344ebd6f986cb8044364f0.json b/examples/multi-agent-smax/results/llm-cache/ask-c7344ebd6f986cb8044364f0.json new file mode 100644 index 00000000..e7237e6d --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-c7344ebd6f986cb8044364f0.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.5 seconds into the battle.\nYou are A0, a marine at (8.4, 17.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (9.7, 17.5), 45/45 health, order: hold\n A2 marine at (9.1, 16.8), 45/45 health, order: hold\nEnemies you can see:\n E1 marine at (15.3, 14.5), 45/45 health, 7.4 away\n E2 marine at (14.6, 17.2), 45/45 health, 6.2 away\nTeam chat (most recent last):\n A1 (1.0s): Grouping at x=9; focus fire on nearest enemy when seen.\n A2 (1.0s): Holding at cluster near (9,16.7); focus fire on the closest enemy.\n A0 (1.5s): Holding at x=9 with cluster; focus fire on closest enemy when seen.\n A1 (1.5s): Holding at x=9; enemy E2 approaching, all focus the closest one.\n A2 (1.5s): E2 spotted east at 8.7 range; holding together, focus whatever enters range first.\n A0 (2.0s): Holding at x=9; shoot first enemy entering 5 range, focus closest.\n A1 (2.0s): Holding at x=9; shoot E2 when it enters range 5.\n A2 (2.0s): Holding at x=9; E2 closest, all focus E2 when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding at x=9; focus E2 when it enters range 5.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-c76cd2fabba1b682e4322e14.json b/examples/multi-agent-smax/results/llm-cache/ask-c76cd2fabba1b682e4322e14.json new file mode 100644 index 00000000..5131d233 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-c76cd2fabba1b682e4322e14.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 0.5 seconds into the battle.\nYou are A1, a marine at (8.7, 14.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 15.\nYour team:\n A0 marine at (9.6, 17.5), 45/45 health, order: move 12 16\n A2 marine at (11.0, 14.6), 45/45 health, order: move 12 15\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Advancing east together to (12,16); stay within 2 of each other, attack together.\n A1 (0.0s): Advancing east together to (12,15); stay within 2 of each other, attack same target on contact.\n A2 (0.0s): Advancing east together, staying close. Don't outrun the group; all attack same target.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 15\", \"say\": \"A1 advancing to (12,15), staying close; will attack same target on contact.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-c812e3c94fc0b2bbe480d4fe.json b/examples/multi-agent-smax/results/llm-cache/ask-c812e3c94fc0b2bbe480d4fe.json new file mode 100644 index 00000000..cc6bb1ea --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-c812e3c94fc0b2bbe480d4fe.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 3.0 seconds into the battle.\nYou are A2, a marine at (13.7, 16.7) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (13.3, 15.6), 27/45 health, order: attack E2\n A1 marine at (12.9, 17.5), 27/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (17.7, 17.8), 45/45 health, 4.2 away (in range)\n E1 marine at (16.9, 14.5), 45/45 health, 3.9 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (1.5s): E2 in my range; A0, A2 close in and focus E2 now.\n A2 (1.5s): Staying together; E2 nearly in range. All attack E2 once everyone is within 5.\n A0 (2.0s): E2 in my range 4.8; attacking E2 now, everyone focus E2.\n A1 (2.0s): All three in range of E2 now. Attack E2 together.\n A2 (2.0s): E2 and E1 in my range; attacking E2 now, everyone focus E2.\n A0 (2.5s): E2 at 9hp, finish it now; then focus E1.\n A1 (2.5s): Focusing E2 (9hp), it dies soon; then we focus E0.\n A2 (2.5s): E2 at 9hp, finishing it now. Then focus E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E2 dead. Everyone focus E1 now, closest at 3.9.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-c85ffa1a2c13f154bb54d0e6.json b/examples/multi-agent-smax/results/llm-cache/ask-c85ffa1a2c13f154bb54d0e6.json new file mode 100644 index 00000000..a94f0d07 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-c85ffa1a2c13f154bb54d0e6.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 1.0 seconds into the battle.\nYou are A1, a marine at (11.7, 15.3) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 16.\nYour team:\n A0 marine at (11.7, 16.9), 45/45 health, order: move 14 16\n A2 marine at (9.6, 16.6), 45/45 health, order: move 14 16\nEnemies you can see:\n E0 marine at (19.3, 15.1), 45/45 health, 7.7 away\nTeam chat (most recent last):\n A0 (0.0s): Moving east together toward center, stay within 2 of each other; attack same target when seen.\n A1 (0.0s): No enemies seen. Moving east together to (14,16); stay within 2 of each other.\n A2 (0.0s): Moving east together to find enemies; stay within 2 of each other.\n A0 (0.5s): Continuing east to (14,16), staying close; will attack together when enemies appear.\n A1 (0.5s): Continuing east to (14,16), staying close to A0 and A2.\n A2 (0.5s): Moving to (14,16) with A0 and A1, staying close; will focus the first enemy seen.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 16\", \"say\": \"E0 spotted east at (19.3,15.1). Keep moving together; attack when in range 5 of all.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-c8c94a027448e501779becdb.json b/examples/multi-agent-smax/results/llm-cache/ask-c8c94a027448e501779becdb.json new file mode 100644 index 00000000..262b0694 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-c8c94a027448e501779becdb.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.5 seconds into the battle.\nYou are A0, a marine at (7.8, 14.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (8.5, 14.8), 45/45 health, order: hold\n A2 marine at (8.2, 14.1), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (12.6, 15.0), 45/45 health, 4.8 away (in range)\n E1 marine at (13.4, 14.0), 45/45 health, 5.7 away\n E2 marine at (11.8, 16.8), 45/45 health, 4.6 away (in range)\nTeam chat (most recent last):\n A1 (2.0s): Holding cluster; let them walk into range, then focus closest enemy.\n A2 (2.0s): E2 spotted east at 8.7 range. Holding cluster; let them come, focus first in range.\n A0 (2.5s): Enemies approaching; hold cluster, all focus whichever enemy enters range first.\n A1 (2.5s): Holding. Enemies closing; all focus closest enemy once in range 5.\n A2 (2.5s): A2 holding. Enemies approaching; focus closest once in range 5.\n A0 (3.0s): Holding. Focus closest enemy E2 when in range 5, fire together.\n A1 (3.0s): Holding. E2 closest at 5.3; focus E2 when in range, then E0.\n A2 (3.0s): Holding. E2 closest at 5.8; focus whoever enters range 5 first.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 in range 4.6, all focus fire E2 now, then E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ca2435f1cb2765e6508baaaf.json b/examples/multi-agent-smax/results/llm-cache/ask-ca2435f1cb2765e6508baaaf.json new file mode 100644 index 00000000..c359601d --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ca2435f1cb2765e6508baaaf.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.0 seconds into the battle.\nYou are A0, a marine at (8.5, 16.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1 marine at (7.8, 14.9), 9/45 health, order: attack E1\n A2 marine at (7.6, 17.8), 27/45 health, order: attack E2\nEnemies you can see:\n E1 marine at (12.3, 15.6), 36/45 health, 3.9 away (in range)\n E2 marine at (11.9, 17.7), 45/45 health, 3.5 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (3.5s): A1 attacking E0 now, everyone focus E0.\n A2 (3.5s): A2 attacking E0 now, everyone focus E0 together.\n A0 (4.0s): A0 firing E0 (18hp left), finish it then switch to E2.\n A1 (4.0s): E0 at 18 hp, keep focusing E0 then E1.\n A2 (4.0s): A2 firing on E0, 18 hp left, finish it then E2.\n A0 (4.5s): E0 dead. Focus E2 together, then E1. A1 stay back, you're low.\n A1 (4.5s): E0 dead. A1 on E1 at 4.5, focus E1 together; A2 close in.\n A2 (4.5s): E0 is down; all focus E2 (in range, closest), then E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"A0 on E2 (full hp). A1 stay back, low. A2 keep firing E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ca4abf20b4c887f83826062e.json b/examples/multi-agent-smax/results/llm-cache/ask-ca4abf20b4c887f83826062e.json new file mode 100644 index 00000000..955ea165 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ca4abf20b4c887f83826062e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.5 seconds into the battle.\nYou are A1, a marine at (8.3, 14.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (9.3, 15.3), 18/45 health, order: attack E1\n A2: dead\nEnemies you can see:\n E1 marine at (12.2, 16.1), 18/45 health, 4.3 away (in range)\n E2 marine at (12.3, 17.5), 45/45 health, 5.3 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (4.0s): A0 attacking E0 (27hp); everyone keep focusing E0.\n A1 (4.0s): E0 out of my range; hitting E1 (in range). A0, A2 finish E0, then all E1.\n A2 (4.0s): A2 firing on E0 (27hp); finish it, then E1.\n A0 (4.5s): A0 firing E0 (18hp), nearly dead. Then all E1.\n A1 (4.5s): A1 hitting E1 (36hp). After E0 dies, everyone on E1.\n A2 (4.5s): A2 9hp. E0 at 18hp, A0 and I finish it now, then E1.\n A0 (5.0s): E0 is dead. A0 and A1 focus E1 (27hp), then E2.\n A1 (5.0s): A1 on E1 (27hp), in range. A0 join E1, then E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A1 on E1 (18hp), in range. A0 keep firing, then both E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ca6353b0c131fba2aa7395fa.json b/examples/multi-agent-smax/results/llm-cache/ask-ca6353b0c131fba2aa7395fa.json new file mode 100644 index 00000000..462aaa01 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ca6353b0c131fba2aa7395fa.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 5.0 seconds into the battle.\nYou are A0, a marine at (14.2, 16.2) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1 marine at (9.9, 15.5), 18/45 health, order: retreat\n A2: dead\nEnemies you can see:\n E0 marine at (18.2, 17.3), 27/45 health, 4.1 away (in range)\n E2 marine at (18.4, 14.1), 45/45 health, 4.7 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (3.0s): E1 at 9hp, finish it now; then focus E0.\n A1 (3.0s): E1 at 9hp, finishing it now. A0 fire E1, then focus E2.\n A0 (3.5s): E1 dead. A0 focusing E0; A1 under 20hp, retreat to pull fire.\n A1 (3.5s): A1 at 18hp retreating so A0 is closest; A0 focus E2, I return when safe.\n A0 (4.0s): Focusing E0 (36hp). A1 stay back; I'm tanking, then we take E2.\n A1 (4.0s): A1 18hp retreating; A0 you're closest, focus E0 (36hp), I'll return when safe.\n A0 (4.5s): A0 firing E0 (27hp), tanking. A1 stay back, then we take E2.\n A1 (4.5s): A1 18hp staying back; A0 kill E0 (27hp), then E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"retreat\", \"say\": \"A0 at 9hp retreating. A1 you hold and shoot closest; we regroup and focus E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-cad5346e053eb04a96a1c6c7.json b/examples/multi-agent-smax/results/llm-cache/ask-cad5346e053eb04a96a1c6c7.json new file mode 100644 index 00000000..8b1b9009 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-cad5346e053eb04a96a1c6c7.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.0 seconds into the battle.\nYou are A0, a marine at (8.1, 17.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (7.1, 14.7), 45/45 health, order: hold\n A2 marine at (9.4, 14.6), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 8 15\", \"say\": \"Regroup near (8,15) so we fight together; focus fire on closest enemy.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-cad601b39aba4677c74441f4.json b/examples/multi-agent-smax/results/llm-cache/ask-cad601b39aba4677c74441f4.json new file mode 100644 index 00000000..ff6c1076 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-cad601b39aba4677c74441f4.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 5.0 seconds into the battle.\nYou are A0, a marine at (14.3, 16.0) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1: dead\n A2 marine at (12.8, 14.9), 18/45 health, order: attack E2\nEnemies you can see:\n E1 marine at (16.5, 16.2), 45/45 health, 2.3 away (in range)\n E2 marine at (17.6, 14.3), 9/45 health, 3.8 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (3.0s): E0 is dead. Both attack E2 together, closest enemy; stay level with me.\n A2 (3.0s): E0 is dead. Everyone attack E2, it's in range.\n A0 (3.5s): Both on E2 together, then E1. Keep firing, no retreat.\n A2 (3.5s): Attacking E2 together; keep firing until it dies.\n A0 (4.0s): Keep firing on E2, then E1. No retreat.\n A2 (4.0s): Keep firing on E2 until dead, then E1.\n A0 (4.5s): E2 at 9hp, keep firing together, then E1.\n A2 (4.5s): E2 at 9hp, finish it now, then E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 at 9hp, finish it now together, then E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-cadcb19767d8ef9314e102d4.json b/examples/multi-agent-smax/results/llm-cache/ask-cadcb19767d8ef9314e102d4.json new file mode 100644 index 00000000..38199ee5 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-cadcb19767d8ef9314e102d4.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 7.0 seconds into the battle.\nYou are A0, a marine at (5.3, 15.6) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: retreat.\nYour team:\n A1 marine at (8.3, 14.2), 36/45 health, order: attack E1\n A2: dead\nEnemies you can see:\n E1 marine at (12.2, 16.1), 27/45 health, 6.9 away\n E2 marine at (10.7, 17.4), 45/45 health, 5.7 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (5.0s): E0 at 9hp, finishing it now. A1 focus E0.\n A1 (5.0s): A1 firing on E0 (9hp), finish it then focus E1.\n A0 (5.5s): E0 dead. Both focus E1 now, then E2.\n A1 (5.5s): E0 down. Focus E1 (4.4 away, in range) now, both of us.\n A0 (6.0s): A0 at 18hp retreating to pull fire off. A1 focus E1, I'll rejoin if safe.\n A1 (6.0s): A1 attacking E1 (45hp). A0 at 18hp, retreat if under 20 to shed aggro.\n A0 (6.5s): A0 at 9hp, staying out of range. A1 focus E1, 36hp left.\n A1 (6.5s): A1 attacking E1 (36hp), in range. A0 stay back, keep out of range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"retreat\", \"say\": \"A0 9hp, staying out of range. A1 focus E1 (27hp), then E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-cb04a3639f3fad485fb4c70e.json b/examples/multi-agent-smax/results/llm-cache/ask-cb04a3639f3fad485fb4c70e.json new file mode 100644 index 00000000..d750f5d0 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-cb04a3639f3fad485fb4c70e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.0 seconds into the battle.\nYou are A1, a marine at (8.9, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (10.6, 16.0), 45/45 health, order: attack E0\n A2 marine at (10.8, 14.8), 45/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (12.4, 16.4), 45/45 health, 4.2 away (in range)\n E1 marine at (13.1, 16.8), 45/45 health, 5.0 away (in range)\n E2 marine at (13.1, 15.5), 45/45 health, 4.4 away (in range)\nTeam chat (most recent last):\n A1 (2.5s): Enemies E0, E2 east ~9 away. Holding grouped; focus E0 when in range.\n A2 (2.5s): Advancing east to join A0/A1; stay grouped, focus closest enemy.\n A0 (3.0s): Holding at (9,16). Let them come into range, then all focus the closest enemy.\n A1 (3.0s): Holding grouped. Enemies ~7 away; let them come into range, focus E0.\n A2 (3.0s): Holding at range; all focus E0 when it enters 5 range.\n A0 (3.5s): E0 at 5 range. All focus E0 now.\n A1 (3.5s): Holding. Focus E0 when in range; stay grouped.\n A2 (3.5s): E0 at range 5. Everyone attack E0 now, focus fire.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Attacking E0 now, focus fire.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-cc97e5804dd47c7d515efd43.json b/examples/multi-agent-smax/results/llm-cache/ask-cc97e5804dd47c7d515efd43.json new file mode 100644 index 00000000..516d5740 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-cc97e5804dd47c7d515efd43.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.5 seconds into the battle.\nYou are A0, a marine at (6.9, 16.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (7.8, 14.9), 45/45 health, order: hold\n A2 marine at (7.6, 17.8), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (11.3, 15.3), 45/45 health, 4.6 away (in range)\n E1 marine at (13.8, 15.6), 45/45 health, 7.0 away\n E2 marine at (13.5, 17.7), 45/45 health, 6.6 away\nTeam chat (most recent last):\n A1 (2.0s): A1 holding near cluster; E0 spotted east at (16,15.3). Focus E0 when in range.\n A2 (2.0s): E0 seen east at 16,15. Holding clustered; focus E0 when in range.\n A0 (2.5s): A0 holding. Only E0 seen; let it come into range, focus fire together.\n A1 (2.5s): A1 holding; E0 approaching, focus fire when in range.\n A2 (2.5s): A2 holding; E0 approaching, focus it when in range.\n A0 (3.0s): A0 holding; all 3 enemies visible. Focus E0 when in range, stay tight.\n A1 (3.0s): A1 holding; E0 at 5.1, focus E0 when in range, stay tight.\n A2 (3.0s): A2 holding; E0 closest at 5.8, focus E0 together when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"A0 attacking E0 now, everyone focus E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-cd71837428c0a6e370c7d6b4.json b/examples/multi-agent-smax/results/llm-cache/ask-cd71837428c0a6e370c7d6b4.json new file mode 100644 index 00000000..f3e06534 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-cd71837428c0a6e370c7d6b4.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 0.5 seconds into the battle.\nYou are A0, a marine at (9.8, 16.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 11 16.\nYour team:\n A1 marine at (11.4, 15.7), 45/45 health, order: move 14 16\n A2 marine at (10.6, 16.2), 45/45 health, order: move 14 16\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Advancing east together to find enemies; keep within 2 of each other, then all attack same target.\n A1 (0.0s): Moving east together toward enemies, stay within 2 of each other; attack same target on contact.\n A2 (0.0s): Moving east together to (14,16); stay within 2 of each other, attack together on contact.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 16\", \"say\": \"Continuing east to (14,16); staying together, will attack same target on contact.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ce15a8a70a81f9c84284044e.json b/examples/multi-agent-smax/results/llm-cache/ask-ce15a8a70a81f9c84284044e.json new file mode 100644 index 00000000..eeeb9b54 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ce15a8a70a81f9c84284044e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 2.5 seconds into the battle.\nYou are A1, a marine at (14.2, 16.3) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 15 16.\nYour team:\n A0 marine at (13.7, 15.6), 36/45 health, order: attack E2\n A2 marine at (14.9, 18.0), 45/45 health, order: move 15 17\nEnemies you can see:\n E0 marine at (17.0, 17.7), 45/45 health, 3.1 away (in range)\n E1 marine at (17.9, 16.0), 45/45 health, 3.7 away (in range)\n E2 marine at (18.1, 14.7), 36/45 health, 4.3 away (in range)\nTeam chat (most recent last):\n A1 (1.0s): Continuing to (12,17), staying within 2 of A0 and A2.\n A2 (1.0s): Continuing to (12,17); no enemies yet, stay within 2, attack together.\n A0 (1.5s): Enemies E0, E2 east at ~8. Advance together to (15,16), then focus E2 together.\n A1 (1.5s): Enemy E2 at (19.7,14.7). Advancing together to 15,16; attack E2 when all in range.\n A2 (1.5s): Enemies ~8 east. Advancing together to x=15; stay within 2, then focus E0.\n A0 (2.0s): E2 in my range, firing now. A1, A2 close in and focus E2.\n A1 (2.0s): Moving with you to 15,16; next tick all attack E2 together.\n A2 (2.0s): Closing to 15,17 together; once all in range 5, everyone attack E0 same tick.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"All in range now. Everyone focus E2, it's at 36hp.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ce2a28256addbe6bb9c78b0d.json b/examples/multi-agent-smax/results/llm-cache/ask-ce2a28256addbe6bb9c78b0d.json new file mode 100644 index 00000000..42adfec7 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ce2a28256addbe6bb9c78b0d.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.0 seconds into the battle.\nYou are A2, a marine at (7.6, 17.8) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (8.5, 16.7), 45/45 health, order: attack E2\n A1: dead\nEnemies you can see:\n E1 marine at (12.3, 15.6), 36/45 health, 5.1 away\n E2 marine at (11.9, 17.7), 9/45 health, 4.3 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (4.5s): E0 dead. A1 on E1 at 4.5, focus E1 together; A2 close in.\n A2 (4.5s): E0 is down; all focus E2 (in range, closest), then E1.\n A0 (5.0s): A0 on E2 (full hp). A1 stay back, low. A2 keep firing E2.\n A1 (5.0s): A1 low, shooting E2 from back. A0 you're tanking, focus E2.\n A2 (5.0s): A2 on E2, in range. A0 and A2 focus E2; A1 stay back.\n A0 (5.5s): A0 on E2 (27hp). Keep firing E2, then E1. A1 stay back.\n A1 (5.5s): A1 firing E2 from back; A0 is closest, keep tanking. Focus E2.\n A2 (5.5s): A2 on E2 (27hp), keep focusing. A1 stay back.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"A2 on E2 (9hp), nearly dead. Then E1 together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ce6332cdecc47cc7b874af6f.json b/examples/multi-agent-smax/results/llm-cache/ask-ce6332cdecc47cc7b874af6f.json new file mode 100644 index 00000000..dd1520e7 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ce6332cdecc47cc7b874af6f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.5 seconds into the battle.\nYou are A2, a marine at (10.8, 14.8) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0: dead\n A1 marine at (8.9, 14.1), 45/45 health, order: attack E2\nEnemies you can see:\n E1 marine at (13.1, 16.8), 45/45 health, 3.0 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (5.0s): E0 is dead. Focus fire E2, closest at 4.4.\n A2 (5.0s): E0 down. Focus E2 (closest), then E1.\n A0 (5.5s): E2 at 18hp, all fire E2 now, then E1. I'm at 9hp.\n A1 (5.5s): Focus E2 (18 hp), then E1. Keep firing.\n A2 (5.5s): Focus E2 (18hp), then E1. Keep firing.\n A0 (6.0s): E2 at 9hp, all fire now. I'm at 9hp, finish E2 then E1.\n A1 (6.0s): Firing E2 (9hp), then E1. A0 stay back, low hp.\n A2 (6.0s): E2 at 9hp, all fire E2 now, then E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"retreat\", \"say\": \"E2 dead. Only E1 left. A1 tank and focus E1, I'm at 9hp and falling back.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ce66ca16906862b940c81c65.json b/examples/multi-agent-smax/results/llm-cache/ask-ce66ca16906862b940c81c65.json new file mode 100644 index 00000000..213dd020 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ce66ca16906862b940c81c65.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 8.0 seconds into the battle.\nYou are A1, a marine at (8.3, 14.2) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (2.1, 15.6), 9/45 health, order: retreat\n A2: dead\nEnemies you can see:\n E1 marine at (12.2, 16.1), 18/45 health, 4.4 away (in range)\n E2 marine at (10.7, 17.4), 45/45 health, 4.1 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (6.0s): A0 at 18hp retreating to pull fire off. A1 focus E1, I'll rejoin if safe.\n A1 (6.0s): A1 attacking E1 (45hp). A0 at 18hp, retreat if under 20 to shed aggro.\n A0 (6.5s): A0 at 9hp, staying out of range. A1 focus E1, 36hp left.\n A1 (6.5s): A1 attacking E1 (36hp), in range. A0 stay back, keep out of range.\n A0 (7.0s): A0 9hp, staying out of range. A1 focus E1 (27hp), then E2.\n A1 (7.0s): A1 on E1 (27hp), 3 shots left. A0 stay out of range.\n A0 (7.5s): A0 9hp staying out of range. A1 finish E1 (18hp), then E2.\n A1 (7.5s): A1 on E1 (18hp), finishing it, then E2. A0 stay back.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A1 9hp, finishing E1 (18hp). A0 stay back, then we focus E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ce7b9720a7a6af608770fd3f.json b/examples/multi-agent-smax/results/llm-cache/ask-ce7b9720a7a6af608770fd3f.json new file mode 100644 index 00000000..937e67c7 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ce7b9720a7a6af608770fd3f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.0 seconds into the battle.\nYou are A1, a marine at (8.3, 14.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (9.3, 15.3), 27/45 health, order: attack E0\n A2: dead\nEnemies you can see:\n E1 marine at (12.2, 16.1), 27/45 health, 4.3 away (in range)\n E2 marine at (12.3, 17.5), 45/45 health, 5.3 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (3.5s): A1 advancing, focusing E0 with A2. A0 join fire on E0.\n A2 (3.5s): A2 attacking E0 (36hp, in range); all focus E0.\n A0 (4.0s): A0 attacking E0 (27hp); everyone keep focusing E0.\n A1 (4.0s): E0 out of my range; hitting E1 (in range). A0, A2 finish E0, then all E1.\n A2 (4.0s): A2 firing on E0 (27hp); finish it, then E1.\n A0 (4.5s): A0 firing E0 (18hp), nearly dead. Then all E1.\n A1 (4.5s): A1 hitting E1 (36hp). After E0 dies, everyone on E1.\n A2 (4.5s): A2 9hp. E0 at 18hp, A0 and I finish it now, then E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A1 on E1 (27hp), in range. A0 join E1, then E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ced6d9fbfa42b1564d3dd590.json b/examples/multi-agent-smax/results/llm-cache/ask-ced6d9fbfa42b1564d3dd590.json new file mode 100644 index 00000000..587d1b72 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ced6d9fbfa42b1564d3dd590.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 3.0 seconds into the battle.\nYou are A1, a marine at (13.5, 17.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (13.8, 15.8), 27/45 health, order: attack E2\n A2 marine at (13.9, 17.8), 18/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (18.0, 17.1), 45/45 health, 4.6 away (in range)\n E1 marine at (17.3, 17.0), 45/45 health, 3.8 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (1.5s): Almost in range of E2; keep pace, all attack E2 together next tick.\n A2 (1.5s): Still closing together; E2 just outside range. Fire on E2 once all in range 5.\n A0 (2.0s): All in range of E2 now. Everyone fire on E2.\n A1 (2.0s): All in range of E2 (2.4 away). Attack E2 now, everyone focus fire.\n A2 (2.0s): E2 in range of me; all attack E2 now.\n A0 (2.5s): Firing on E2, it's at 18hp. Then focus E1 next.\n A1 (2.5s): Focusing E2, it's at 18hp. Keep firing, then switch to E1 together.\n A2 (2.5s): E2 at 18hp, keep firing on E2, then switch to E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E2 down. Everyone focus E1 now (3.8 away), then E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-cf10bc1d92edbffa06b25ecb.json b/examples/multi-agent-smax/results/llm-cache/ask-cf10bc1d92edbffa06b25ecb.json new file mode 100644 index 00000000..bc3ed8fc --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-cf10bc1d92edbffa06b25ecb.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.5 seconds into the battle.\nYou are A1, a marine at (9.7, 17.5) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (8.4, 17.0), 45/45 health, order: hold\n A2 marine at (10.7, 16.8), 45/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (14.6, 17.8), 45/45 health, 4.8 away (in range)\n E1 marine at (13.7, 14.5), 45/45 health, 5.0 away (in range)\n E2 marine at (14.4, 17.0), 27/45 health, 4.7 away (in range)\nTeam chat (most recent last):\n A1 (2.0s): Holding at x=9; shoot E2 when it enters range 5.\n A2 (2.0s): Holding at x=9; E2 closest, all focus E2 when in range.\n A0 (2.5s): Holding at x=9; focus E2 when it enters range 5.\n A1 (2.5s): Focus E2 now, all fire together.\n A2 (2.5s): Holding at x=9; E2 nearly in range, all focus E2.\n A0 (3.0s): Holding at x=9; focus E2 (36hp) first once any enemy enters range 5.\n A1 (3.0s): Firing on E2 (36hp, in range). A0, A2 step up and focus E2.\n A2 (3.0s): Attacking E2 (36hp) with A1; A0 join, focus E2 first.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 at 27hp, keep focusing it. A0 attack E2 too.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-cf90691350799a35053168ae.json b/examples/multi-agent-smax/results/llm-cache/ask-cf90691350799a35053168ae.json new file mode 100644 index 00000000..647f9824 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-cf90691350799a35053168ae.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.0 seconds into the battle.\nYou are A2, a marine at (9.9, 15.8) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0: dead\n A1 marine at (10.1, 17.3), 36/45 health, order: attack E2\nEnemies you can see:\n E2 marine at (14.4, 14.8), 36/45 health, 4.6 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (4.0s): E0 dead. Focus E1 (closest, 3.7 away), then E2.\n A2 (4.0s): E0 dead. Focus E1 (4.2 away), then E2.\n A1 (4.5s): Focusing E1 (27hp), then E2.\n A2 (4.5s): Focusing E1 (27hp), then E2.\n A1 (5.0s): Focusing E1 (18hp), almost dead. Then E2.\n A2 (5.0s): Attacking E1 (18hp), then E2.\n A1 (5.5s): E1 down. All focus E2 (45hp), 5.0 away.\n A2 (5.5s): E1 down. All focus E2, 4.6 away, 45hp.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Focusing E2 (36hp), keep firing.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-cfdda43d6abfbbbc24b8c83a.json b/examples/multi-agent-smax/results/llm-cache/ask-cfdda43d6abfbbbc24b8c83a.json new file mode 100644 index 00000000..0ecfca94 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-cfdda43d6abfbbbc24b8c83a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.5 seconds into the battle.\nYou are A1, a marine at (8.5, 15.3) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0: dead\n A2 marine at (9.4, 16.4), 45/45 health, order: attack E1\nEnemies you can see:\n E2 marine at (12.8, 17.3), 45/45 health, 4.8 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (4.0s): A1 attacking E0 (9hp), finish it then switch to E1.\n A2 (4.0s): A2 closing on E0 (9hp), then focus E1.\n A0 (4.5s): E0 dead. A0 on E2, all focus E2 please.\n A1 (4.5s): E0 dead. Focus E1 (4.5 away), then E2.\n A2 (4.5s): E0 dead. A2 focusing E1, everyone focus E1 then E2.\n A0 (5.0s): A0 switching to E1 (27hp), focus fire. A2 is tanking.\n A1 (5.0s): A1 on E1 (27hp), focus fire. A0 hurt, fall back if needed.\n A2 (5.0s): A2 on E1 (27hp), in range. A0 retreat if low, A1 focus E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E1 down. All focus E2, 4.8 away, in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-cff347e088714683a963f468.json b/examples/multi-agent-smax/results/llm-cache/ask-cff347e088714683a963f468.json new file mode 100644 index 00000000..aa3497a7 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-cff347e088714683a963f468.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.0 seconds into the battle.\nYou are A2, a marine at (8.2, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (7.8, 14.7), 45/45 health, order: attack E2\n A1 marine at (8.5, 14.8), 18/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (12.6, 15.0), 45/45 health, 4.5 away (in range)\n E1 marine at (13.4, 14.0), 45/45 health, 5.2 away\n E2 marine at (11.8, 16.8), 18/45 health, 4.5 away (in range)\nTeam chat (most recent last):\n A1 (2.5s): Holding. Enemies closing; all focus closest enemy once in range 5.\n A2 (2.5s): A2 holding. Enemies approaching; focus closest once in range 5.\n A0 (3.0s): Holding. Focus closest enemy E2 when in range 5, fire together.\n A1 (3.0s): Holding. E2 closest at 5.3; focus E2 when in range, then E0.\n A2 (3.0s): Holding. E2 closest at 5.8; focus whoever enters range 5 first.\n A0 (3.5s): E2 in range 4.6, all focus fire E2 now, then E0.\n A1 (3.5s): Focus E2 now, all fire together, then E0.\n A2 (3.5s): E0 and E2 in range now. Focus E2, fire together, then E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Firing on E2 (18hp), then E0. Keep A1 behind us.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-d00921e2832ed42b1a186b55.json b/examples/multi-agent-smax/results/llm-cache/ask-d00921e2832ed42b1a186b55.json new file mode 100644 index 00000000..9b5223b2 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-d00921e2832ed42b1a186b55.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.5 seconds into the battle.\nYou are A2, a marine at (8.2, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.8, 14.7), 45/45 health, order: hold\n A1 marine at (8.5, 14.8), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (15.8, 15.0), 45/45 health, 7.6 away\n E1 marine at (16.6, 14.0), 45/45 health, 8.4 away\n E2 marine at (15.0, 16.8), 45/45 health, 7.3 away\nTeam chat (most recent last):\n A1 (1.0s): A1 at (8,15) holding. Focus fire on closest enemy.\n A2 (1.0s): A2 at (8,14) holding; will focus the closest enemy when it appears.\n A0 (1.5s): A0 holding at (8,15); focus fire on the closest enemy when seen.\n A1 (1.5s): A1 holding at cluster; focus fire on closest enemy when seen.\n A2 (1.5s): A2 holding at (8,14). Clustered; focus fire on closest enemy.\n A0 (2.0s): A0 holding; no enemies seen. Focus closest when they appear.\n A1 (2.0s): Holding cluster; let them walk into range, then focus closest enemy.\n A2 (2.0s): E2 spotted east at 8.7 range. Holding cluster; let them come, focus first in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A2 holding. Enemies approaching; focus closest once in range 5.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-d028461ce82bce66ad6dbd34.json b/examples/multi-agent-smax/results/llm-cache/ask-d028461ce82bce66ad6dbd34.json new file mode 100644 index 00000000..5964a7c3 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-d028461ce82bce66ad6dbd34.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.5 seconds into the battle.\nYou are A1, a marine at (8.3, 14.1) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (8.1, 15.8), 36/45 health, order: attack E2\n A2 marine at (8.1, 14.9), 45/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (12.9, 15.0), 45/45 health, 4.6 away (in range)\n E1 marine at (11.8, 16.2), 45/45 health, 4.1 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (3.0s): Holding at (8,14). Focus E2 first when in range, then E0.\n A2 (3.0s): Holding at (8,15). Focus E2 or E0 when in range 5.\n A0 (3.5s): Focus E2 now, then E0. Stay grouped.\n A1 (3.5s): Focus E2 now, then E0. Everyone fire.\n A2 (3.5s): Focusing E2 now, then E0. All fire E2.\n A0 (4.0s): E2 is at 18 HP, finish it, then E1.\n A1 (4.0s): Firing E2 (18hp). Then E0. I'm at 27hp.\n A2 (4.0s): Firing E2 (18 hp left), then E0. Stay grouped.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"retreat\", \"say\": \"A1 at 9hp, falling back. Focus E1 (closest to A0), then E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-d06c060410c305f5ea6dd665.json b/examples/multi-agent-smax/results/llm-cache/ask-d06c060410c305f5ea6dd665.json new file mode 100644 index 00000000..2a66b3c0 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-d06c060410c305f5ea6dd665.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 2.0 seconds into the battle.\nYou are A0, a marine at (14.8, 18.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 15 17.\nYour team:\n A1 marine at (14.9, 17.2), 45/45 health, order: move 14 17\n A2 marine at (13.2, 17.6), 45/45 health, order: move 14 17\nEnemies you can see:\n E0 marine at (17.7, 16.4), 45/45 health, 3.3 away (in range)\n E1 marine at (18.5, 17.3), 45/45 health, 3.8 away (in range)\n E2 marine at (19.1, 14.8), 45/45 health, 5.3 away\nTeam chat (most recent last):\n A1 (0.5s): Moving east in formation at x=12; no one engages alone.\n A2 (0.5s): Moving east, staying close; A0 at 12,17 is my anchor point.\n A0 (1.0s): Advancing east together to x=14; will call attack when enemies appear.\n A1 (1.0s): Advancing east to 14,17 together; no one engages until all in range.\n A2 (1.0s): Moving east together to x=16; will attack same target once all in range.\n A0 (1.5s): Closing together toward E0; attack E0 once all three are within range 5.\n A1 (1.5s): Holding formation at 14,17; attack E0 together once all within range 5.\n A2 (1.5s): Regrouping at 14,17; closest enemy 6 away, hold formation, then attack E0 together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 is within range 5 of all three of us. Everyone attack E0 now.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-d0743f1b41df61df0553f8be.json b/examples/multi-agent-smax/results/llm-cache/ask-d0743f1b41df61df0553f8be.json new file mode 100644 index 00000000..a7b28c77 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-d0743f1b41df61df0553f8be.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 5.0 seconds into the battle.\nYou are A1, a marine at (13.2, 15.3) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (13.6, 17.1), 18/45 health, order: attack E2\n A2 marine at (14.1, 16.4), 9/45 health, order: attack E2\nEnemies you can see:\n E2 marine at (17.5, 17.3), 9/45 health, 4.8 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (3.5s): Attacking E1 (18hp), all keep firing; then E2.\n A2 (3.5s): Attacking E1 (18hp) now, then E2.\n A0 (4.0s): E1 dead. All focus E2 now, no retreating.\n A1 (4.0s): E1 down. All focus E2 now, same target, no retreating.\n A2 (4.0s): E1 dead. All attack E2 now, same target, keep firing.\n A0 (4.5s): Keep firing E2, last enemy, no retreating.\n A1 (4.5s): Keep firing E2, last enemy, no retreating.\n A2 (4.5s): Keep firing on E2, last enemy, no retreating.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 at 9hp, in range. Keep firing, finish it.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-d0a28f60d6b2b04b61e1aee7.json b/examples/multi-agent-smax/results/llm-cache/ask-d0a28f60d6b2b04b61e1aee7.json new file mode 100644 index 00000000..32b73668 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-d0a28f60d6b2b04b61e1aee7.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 8.5 seconds into the battle.\nYou are A0, a marine at (9.3, 15.9) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1: dead\n A2: dead\nEnemies you can see:\n E0 marine at (13.5, 17.3), 27/45 health, 4.4 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (5.5s): Focusing E1 (18hp), both of us fire. Then E0.\n A1 (5.5s): Focusing E1 (18hp), both fire. Then E0.\n A0 (6.0s): E1 at 9hp, finishing it. Then E0 together.\n A1 (6.0s): E1 at 9hp, finishing it now. Then E0.\n A0 (6.5s): A1 and A2 are down. I'm engaging E0 alone.\n A0 (7.0s): Last one. E0 at 36hp, fighting on.\n A0 (7.5s): Last one, E0 at 36hp. Fighting on.\n A0 (8.0s): Last one, E0 at 27hp. Fighting on.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 at 27hp, still fighting alone.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-d1206342777f77883dc204d2.json b/examples/multi-agent-smax/results/llm-cache/ask-d1206342777f77883dc204d2.json new file mode 100644 index 00000000..ae8a6c69 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-d1206342777f77883dc204d2.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.5 seconds into the battle.\nYou are A1, a marine at (8.5, 15.3) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (8.6, 16.9), 45/45 health, order: attack E0\n A2 marine at (6.5, 16.6), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (13.0, 15.1), 27/45 health, 4.5 away (in range)\n E1 marine at (13.0, 16.7), 45/45 health, 4.7 away (in range)\n E2 marine at (14.3, 17.1), 45/45 health, 6.0 away\nTeam chat (most recent last):\n A1 (2.0s): E0 east at 7.7 away. Holding grouped; focus E0 when in range.\n A2 (2.0s): A2 holding; will focus the closest enemy when it appears.\n A0 (2.5s): Holding grouped; let them walk into range, then all focus E0.\n A1 (2.5s): Holding grouped; let them walk into range, then focus E0.\n A2 (2.5s): A2 holding grouped; focus E0 when it enters range.\n A0 (3.0s): E0 in range, all attack E0 now.\n A1 (3.0s): E0 in range at 4.5, all focus fire E0 now.\n A2 (3.0s): A2 holding; focus E0 when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"A1 focusing E0 (27hp), in range. A2 please attack E0 too.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-d1420fcb25cb13a9b998371f.json b/examples/multi-agent-smax/results/llm-cache/ask-d1420fcb25cb13a9b998371f.json new file mode 100644 index 00000000..f8049a77 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-d1420fcb25cb13a9b998371f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 7.0 seconds into the battle.\nYou are A0, a marine at (9.3, 15.9) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1: dead\n A2: dead\nEnemies you can see:\n E0 marine at (13.5, 17.3), 36/45 health, 4.4 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A2 (4.5s): Firing on E2 (18hp), one more volley kills it. Then E1.\n A0 (5.0s): E2 down. Focus E1 (36hp), then E0.\n A1 (5.0s): E2 down. Focus E1 (36hp), then E0.\n A0 (5.5s): Focusing E1 (18hp), both of us fire. Then E0.\n A1 (5.5s): Focusing E1 (18hp), both fire. Then E0.\n A0 (6.0s): E1 at 9hp, finishing it. Then E0 together.\n A1 (6.0s): E1 at 9hp, finishing it now. Then E0.\n A0 (6.5s): A1 and A2 are down. I'm engaging E0 alone.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Last one. E0 at 36hp, fighting on.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-d20fb210485d63fcc8e1c328.json b/examples/multi-agent-smax/results/llm-cache/ask-d20fb210485d63fcc8e1c328.json new file mode 100644 index 00000000..422fde91 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-d20fb210485d63fcc8e1c328.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.5 seconds into the battle.\nYou are A2, a marine at (9.0, 16.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.2, 16.2), 45/45 health, order: hold\n A1 marine at (9.8, 15.7), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together as a group; focus fire on the closest enemy when they appear.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together as a group; focus fire on the closest enemy when they appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding. Will focus fire on the closest enemy once visible.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-d2225f3138e54922d0bd19b2.json b/examples/multi-agent-smax/results/llm-cache/ask-d2225f3138e54922d0bd19b2.json new file mode 100644 index 00000000..5e58957d --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-d2225f3138e54922d0bd19b2.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 0.5 seconds into the battle.\nYou are A1, a marine at (8.7, 17.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 11 17.\nYour team:\n A0 marine at (9.1, 15.8), 45/45 health, order: move 14 16.8\n A2 marine at (9.2, 17.8), 45/45 health, order: move 14 17\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Moving east together to find enemies; stay within 2 of each other, attack together.\n A1 (0.0s): Moving east together to find enemies; stay within 2 of each other, fire together.\n A2 (0.0s): Moving east together to find enemies; stay close, attack same target when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 17\", \"say\": \"Moving east in a tight group; will attack same target together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-d2321a0b8dbfb617709c7aab.json b/examples/multi-agent-smax/results/llm-cache/ask-d2321a0b8dbfb617709c7aab.json new file mode 100644 index 00000000..4907e875 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-d2321a0b8dbfb617709c7aab.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 1.0 seconds into the battle.\nYou are A2, a marine at (10.5, 16.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 16.5.\nYour team:\n A0 marine at (10.1, 15.6), 45/45 health, order: move 14 16.5\n A1 marine at (11.3, 17.5), 45/45 health, order: move 14 17\nEnemies you can see:\n E2 marine at (19.3, 17.2), 45/45 health, 8.8 away\nTeam chat (most recent last):\n A0 (0.0s): Moving east together toward center; stay within 2 of each other, attack same target.\n A1 (0.0s): Moving east together toward center, stay within 2 of each other.\n A2 (0.0s): Moving east together toward center, stay close, all engage same enemy on contact.\n A0 (0.5s): Continuing east together; hold formation, all attack same target on contact.\n A1 (0.5s): Continuing east together; will all attack same enemy on contact.\n A2 (0.5s): Continuing east together; no enemies seen yet, will focus same target on contact.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 16.8\", \"say\": \"Enemy E2 seen at 19.3,17.2. Keep formation, advance together, then all attack E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-d27a49f3efeb8780ddb6da33.json b/examples/multi-agent-smax/results/llm-cache/ask-d27a49f3efeb8780ddb6da33.json new file mode 100644 index 00000000..e5787f9a --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-d27a49f3efeb8780ddb6da33.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.0 seconds into the battle.\nYou are A1, a marine at (6.5, 16.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (7.2, 15.7), 18/45 health, order: attack E2\n A2 marine at (7.1, 16.5), 36/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (10.7, 17.7), 27/45 health, 4.6 away (in range)\n E1 marine at (11.6, 16.0), 45/45 health, 5.1 away\n E2 marine at (11.8, 14.7), 27/45 health, 5.5 away\nTeam chat (most recent last):\n A1 (3.5s): A1 holding; fire on closest enemy once in range, E2 first.\n A2 (3.5s): A2 holding; enemies closing, fire on closest E2 when in range.\n A0 (4.0s): E2 in range at 4.7; all focus fire E2 now.\n A1 (4.0s): Holding; E2 closest at 5.5, focus E2 once in range.\n A2 (4.0s): Holding. E2 at 5.1, about to enter range. Focus E2 together.\n A0 (4.5s): Firing E2 now, it's at 36 health. Everyone focus E2.\n A1 (4.5s): E0 in range at 4.6, I'm firing on E0. Focus E0 if in range.\n A2 (4.5s): E0 in range at 3.8; I focus E0, A0 on E2. Kill fast.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Focusing E0 (27hp) with A2; A0 on E2 is fine, then E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-d27b215ada366fec899c0e26.json b/examples/multi-agent-smax/results/llm-cache/ask-d27b215ada366fec899c0e26.json new file mode 100644 index 00000000..fa2b9a81 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-d27b215ada366fec899c0e26.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 0.0 seconds into the battle.\nYou are A0, a marine at (8.1, 17.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (7.1, 14.7), 45/45 health, order: hold\n A2 marine at (9.4, 14.6), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 16\", \"say\": \"Advancing east together to (12,16); stay within 2 of each other, attack together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-d2dd88d5a8ddbf6a308510e2.json b/examples/multi-agent-smax/results/llm-cache/ask-d2dd88d5a8ddbf6a308510e2.json new file mode 100644 index 00000000..8e13cded --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-d2dd88d5a8ddbf6a308510e2.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.0 seconds into the battle.\nYou are A0, a marine at (9.3, 15.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1 marine at (10.0, 15.5), 18/45 health, order: attack E1\n A2: dead\nEnemies you can see:\n E0 marine at (13.5, 17.3), 45/45 health, 4.4 away (in range)\n E1 marine at (13.5, 16.6), 9/45 health, 4.2 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A2 (4.0s): A2 hurt but farthest back, firing on E2 from range. Focus E2.\n A0 (4.5s): E2 at 18hp, finishing it now. Then focus E1 (36hp).\n A1 (4.5s): E2 at 18hp, finish it now, then E1.\n A2 (4.5s): Firing on E2 (18hp), one more volley kills it. Then E1.\n A0 (5.0s): E2 down. Focus E1 (36hp), then E0.\n A1 (5.0s): E2 down. Focus E1 (36hp), then E0.\n A0 (5.5s): Focusing E1 (18hp), both of us fire. Then E0.\n A1 (5.5s): Focusing E1 (18hp), both fire. Then E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E1 at 9hp, finishing it. Then E0 together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-d2eda8ec2fc7ce50e10087ab.json b/examples/multi-agent-smax/results/llm-cache/ask-d2eda8ec2fc7ce50e10087ab.json new file mode 100644 index 00000000..22aeecb3 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-d2eda8ec2fc7ce50e10087ab.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 4.0 seconds into the battle.\nYou are A1, a marine at (13.0, 15.0) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (12.8, 15.9), 27/45 health, order: attack E1\n A2 marine at (13.0, 14.3), 27/45 health, order: attack E1\nEnemies you can see:\n E0 marine at (17.3, 15.0), 45/45 health, 4.4 away (in range)\n E1 marine at (16.6, 14.0), 18/45 health, 3.8 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (2.5s): Firing on E2 (18hp), keep attacking until it dies.\n A2 (2.5s): Attacking E2, it's at 18hp; finish it together.\n A0 (3.0s): E2 dead. Everyone focus E1, closest to all of us.\n A1 (3.0s): E2 dead. Focus E1 (closest, 3.8 away), all attack E1 together.\n A2 (3.0s): E2 is dead. Focus E1 (closest, 3.6 away), all together.\n A0 (3.5s): Attacking E1 (36hp), keep focusing until it dies.\n A1 (3.5s): Attacking E1 (36hp), keep focus until it dies.\n A2 (3.5s): Keep firing on E1, 36hp left. All together until it dies.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E1 at 18hp, keep firing together until it dies.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-d30e8137f600c72d7a174a67.json b/examples/multi-agent-smax/results/llm-cache/ask-d30e8137f600c72d7a174a67.json new file mode 100644 index 00000000..e1226608 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-d30e8137f600c72d7a174a67.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 1.5 seconds into the battle.\nYou are A0, a marine at (11.7, 16.4) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 16.\nYour team:\n A1 marine at (12.5, 16.4), 45/45 health, order: move 12 16\n A2 marine at (10.7, 16.5), 45/45 health, order: move 12 16\nEnemies you can see:\n E0 marine at (17.6, 15.3), 45/45 health, 6.0 away\n E1 marine at (20.1, 15.6), 45/45 health, 8.5 away\n E2 marine at (19.8, 17.7), 45/45 health, 8.2 away\nTeam chat (most recent last):\n A1 (0.0s): Moving together east to (15,16); stay within 2 of each other, attack same target.\n A2 (0.0s): Moving east together toward center, stay within 2 of each other; attack same target on contact.\n A0 (0.5s): A1 please converge on (12,16) with us; A1 is ahead, stay within 2.\n A1 (0.5s): Joining A0 and A2 at (12,16); staying grouped, then advance together.\n A2 (0.5s): A2 moving to (12,16) with team; will attack together on contact.\n A0 (1.0s): Continuing to (12,16); stay grouped, attack same target on contact.\n A1 (1.0s): Holding formation at (12,16); then all advance and attack E0 together.\n A2 (1.0s): Continuing to (12,16) together; will attack same target once all in range 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 16\", \"say\": \"Advancing together toward E0; all attack E0 once everyone is within range 5.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-d36e30c6bc3a2c491a041f93.json b/examples/multi-agent-smax/results/llm-cache/ask-d36e30c6bc3a2c491a041f93.json new file mode 100644 index 00000000..8f61e638 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-d36e30c6bc3a2c491a041f93.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.5 seconds into the battle.\nYou are A1, a marine at (8.9, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (10.6, 16.0), 9/45 health, order: attack E2\n A2 marine at (10.8, 14.8), 18/45 health, order: attack E2\nEnemies you can see:\n E1 marine at (13.1, 16.8), 45/45 health, 5.0 away (in range)\n E2 marine at (13.1, 15.5), 18/45 health, 4.4 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (4.0s): Attacking E0 now, focus fire.\n A2 (4.0s): All attack E0 now, in range. A1 switch from hold to attack E0.\n A0 (4.5s): E0 at 18 hp, keep focus firing E0 then E2.\n A1 (4.5s): Firing on E0, 18 hp left. Next target E2 (closest).\n A2 (4.5s): E0 at 18 hp, keep firing. Then focus E2.\n A0 (5.0s): E0 dead. Focus E2 (closest), then E1. Stay grouped.\n A1 (5.0s): E0 is dead. Focus fire E2, closest at 4.4.\n A2 (5.0s): E0 down. Focus E2 (closest), then E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Focus E2 (18 hp), then E1. Keep firing.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-d44386f6cc30095c73d5258a.json b/examples/multi-agent-smax/results/llm-cache/ask-d44386f6cc30095c73d5258a.json new file mode 100644 index 00000000..c46907bf --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-d44386f6cc30095c73d5258a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.5 seconds into the battle.\nYou are A1, a marine at (8.9, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (9.0, 16.0), 45/45 health, order: hold\n A2 marine at (9.3, 14.8), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (14.0, 16.4), 45/45 health, 5.6 away\n E1 marine at (14.7, 16.8), 45/45 health, 6.4 away\n E2 marine at (14.6, 15.5), 45/45 health, 5.9 away\nTeam chat (most recent last):\n A1 (2.0s): No contact; advancing east together to find enemies. Stay grouped, focus closest.\n A2 (2.0s): Holding grouped; focus fire closest enemy when it appears.\n A0 (2.5s): Enemies 3 at east, ~7 away. Falling back to group; hold and focus E0 when in range.\n A1 (2.5s): Enemies E0, E2 east ~9 away. Holding grouped; focus E0 when in range.\n A2 (2.5s): Advancing east to join A0/A1; stay grouped, focus closest enemy.\n A0 (3.0s): Holding at range; focus E0 when it enters 5. Stay grouped.\n A1 (3.0s): Holding at range 5; focus E0 when in range. Stay grouped, don't advance alone.\n A2 (3.0s): Holding at range; focus fire E0 (closest) when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding at range 5. Let them approach, then everyone focus E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-d4757ff0bf4f7fd3af089f00.json b/examples/multi-agent-smax/results/llm-cache/ask-d4757ff0bf4f7fd3af089f00.json new file mode 100644 index 00000000..dda972a2 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-d4757ff0bf4f7fd3af089f00.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.0 seconds into the battle.\nYou are A1, a marine at (8.5, 15.3) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.6, 16.9), 45/45 health, order: hold\n A2 marine at (6.5, 16.6), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together here; focus fire on the closest enemy when they appear.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together as a group; focus fire on the closest enemy once seen.\n A0 (0.5s): No enemies yet. Holding; focus the closest when they appear.\n A1 (0.5s): A1 holding; will focus fire on the closest enemy that appears.\n A2 (0.5s): No enemies yet; staying grouped, will focus the closest one when seen.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A1 holding; no enemies yet, will focus the closest when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-d4aaab44b3e358c465d90406.json b/examples/multi-agent-smax/results/llm-cache/ask-d4aaab44b3e358c465d90406.json new file mode 100644 index 00000000..7c2c2a03 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-d4aaab44b3e358c465d90406.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.5 seconds into the battle.\nYou are A0, a marine at (8.1, 15.8) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1 marine at (3.6, 14.1), 9/45 health, order: hold\n A2 marine at (8.1, 14.9), 27/45 health, order: attack E1\nEnemies you can see:\n E0 marine at (12.9, 15.0), 45/45 health, 4.8 away (in range)\n E1 marine at (11.8, 16.2), 9/45 health, 3.7 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (5.0s): A1 at 9hp staying back. Focus E1 then E0, keep grouped.\n A2 (5.0s): Firing E1 (closest). A0 focus E1 too, then E0. A1 stay back.\n A0 (5.5s): Firing E1 (27hp). A1 stay back. Then E0.\n A1 (5.5s): A1 at 9hp staying back; focus E1 then E0.\n A2 (5.5s): Firing E1 (27hp). A0 keep focus, then E0. A1 stay back.\n A0 (6.0s): Firing E1 (9hp), nearly dead. Then E0 together.\n A1 (6.0s): A1 9hp holding back; E1 is at 9hp, finish it then E0.\n A2 (6.0s): Firing E1 (9hp), nearly dead. Then E0 together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Firing E1 (9hp), finishing it. Then E0 together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-d53f3011a1117c2c3ab27d56.json b/examples/multi-agent-smax/results/llm-cache/ask-d53f3011a1117c2c3ab27d56.json new file mode 100644 index 00000000..49f6e76d --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-d53f3011a1117c2c3ab27d56.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 2.5 seconds into the battle.\nYou are A2, a marine at (13.0, 14.3) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (12.8, 15.9), 36/45 health, order: attack E2\n A1 marine at (13.0, 15.0), 36/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (17.3, 15.0), 45/45 health, 4.4 away (in range)\n E1 marine at (16.6, 14.0), 45/45 health, 3.6 away (in range)\n E2 marine at (16.6, 16.8), 18/45 health, 4.4 away (in range)\nTeam chat (most recent last):\n A1 (1.0s): A1 continuing to (12,15), staying close; attack same target on contact.\n A2 (1.0s): Holding formation at (12,15); will advance together, then all attack E2 at once.\n A0 (1.5s): A0 closing on group at (12,16); then all advance together on E2.\n A1 (1.5s): Moving to (14,16) with A0; enemies close, then all attack E2 together.\n A2 (1.5s): Moving to (14,16) with A0; enemies ~5 away next, then all attack E2 together.\n A0 (2.0s): E2 in range of all three. Attack E2 now, together.\n A1 (2.0s): All in range of E2 now. Attack E2 together.\n A2 (2.0s): E2 in range of all three. Attack E2 now, together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Attacking E2, it's at 18hp; finish it together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-d55e216175813f0b8d27b9f6.json b/examples/multi-agent-smax/results/llm-cache/ask-d55e216175813f0b8d27b9f6.json new file mode 100644 index 00000000..10a6dfae --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-d55e216175813f0b8d27b9f6.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.0 seconds into the battle.\nYou are A1, a marine at (7.2, 17.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.5, 15.8), 45/45 health, order: hold\n A2 marine at (7.6, 17.8), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together here; focus fire on the closest enemy when they appear.\n A0 (0.5s): No enemies yet. Staying grouped; focus fire on the closest one when seen.\n A1 (0.5s): A1 holding; will focus fire on the closest enemy when seen.\n A2 (0.5s): Holding; will focus fire on closest enemy once visible.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"No enemies yet. Holding; will focus fire on the closest when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-d5ba533a93c29a83f5a47edf.json b/examples/multi-agent-smax/results/llm-cache/ask-d5ba533a93c29a83f5a47edf.json new file mode 100644 index 00000000..469653c6 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-d5ba533a93c29a83f5a47edf.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 0.0 seconds into the battle.\nYou are A0, a marine at (8.5, 18.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (8.6, 17.2), 45/45 health, order: hold\n A2 marine at (8.4, 16.0), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 17\", \"say\": \"Moving east together, stay within 2 of each other; no one engage alone.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-d5edfb3f8458dbfbd6eb4219.json b/examples/multi-agent-smax/results/llm-cache/ask-d5edfb3f8458dbfbd6eb4219.json new file mode 100644 index 00000000..8d55c485 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-d5edfb3f8458dbfbd6eb4219.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 6.5 seconds into the battle.\nYou are A0, a marine at (6.9, 15.6) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: retreat.\nYour team:\n A1 marine at (8.3, 14.2), 45/45 health, order: attack E1\n A2: dead\nEnemies you can see:\n E1 marine at (12.2, 16.1), 36/45 health, 5.3 away\n E2 marine at (12.3, 17.4), 45/45 health, 5.7 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (4.5s): A1 focusing E0 (27hp). A2 retreat, you're at 9hp.\n A2 (4.5s): A2 at 9hp retreating. A0 A1 keep focus on E0, it has 27hp.\n A0 (5.0s): E0 at 9hp, finishing it now. A1 focus E0.\n A1 (5.0s): A1 firing on E0 (9hp), finish it then focus E1.\n A0 (5.5s): E0 dead. Both focus E1 now, then E2.\n A1 (5.5s): E0 down. Focus E1 (4.4 away, in range) now, both of us.\n A0 (6.0s): A0 at 18hp retreating to pull fire off. A1 focus E1, I'll rejoin if safe.\n A1 (6.0s): A1 attacking E1 (45hp). A0 at 18hp, retreat if under 20 to shed aggro.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"retreat\", \"say\": \"A0 at 9hp, staying out of range. A1 focus E1, 36hp left.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-d6200cf382d7016c79bddc13.json b/examples/multi-agent-smax/results/llm-cache/ask-d6200cf382d7016c79bddc13.json new file mode 100644 index 00000000..cd2a6e89 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-d6200cf382d7016c79bddc13.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 8.0 seconds into the battle.\nYou are A0, a marine at (8.5, 16.7) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1: dead\n A2 marine at (7.6, 17.8), 9/45 health, order: retreat\nEnemies you can see:\n E1 marine at (12.3, 15.6), 18/45 health, 3.9 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (6.0s): A0 on E2 (9hp), finishing it. Then all E1.\n A2 (6.0s): A2 on E2 (9hp), nearly dead. Then E1 together.\n A0 (6.5s): A0 finishing E2 now. Then all on E1.\n A2 (6.5s): A2 finishing E2 (9hp). Then both on E1.\n A0 (7.0s): E2 down. A0 and A2 all on E1, 36hp.\n A2 (7.0s): E2 down. A2 on E1, A0 keep tanking, I'm at 9hp.\n A0 (7.5s): A0 tanking, attacking E1 (27hp). A2 stay behind me and keep firing.\n A2 (7.5s): A2 9hp, falling back so A0 is closest. A0 tank, I'll rejoin shooting.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A0 on E1 (18hp), still tanking. A2 fire from behind me.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-d62a12f267f12db7329a4fd4.json b/examples/multi-agent-smax/results/llm-cache/ask-d62a12f267f12db7329a4fd4.json new file mode 100644 index 00000000..29a4e478 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-d62a12f267f12db7329a4fd4.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 1.0 seconds into the battle.\nYou are A0, a marine at (11.7, 18.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 17.\nYour team:\n A1 marine at (11.8, 17.2), 45/45 health, order: move 12 17\n A2 marine at (11.6, 16.0), 45/45 health, order: move 12 17\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Moving east together, stay within 2 of each other; no one engage alone.\n A1 (0.0s): Moving east together toward enemies; keep within 2 of each other, attack together.\n A2 (0.0s): Moving east together toward enemies, stay within 2 of each other; attack same target on call.\n A0 (0.5s): Moving east together, keeping formation; will attack same target when all in range.\n A1 (0.5s): Moving east in formation at x=12; no one engages alone.\n A2 (0.5s): Moving east, staying close; A0 at 12,17 is my anchor point.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 17\", \"say\": \"Advancing east together to x=14; will call attack when enemies appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-d663595dcb0fe4cbb44c8c91.json b/examples/multi-agent-smax/results/llm-cache/ask-d663595dcb0fe4cbb44c8c91.json new file mode 100644 index 00000000..123c00af --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-d663595dcb0fe4cbb44c8c91.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 3.5 seconds into the battle.\nYou are A2, a marine at (14.9, 18.0) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (13.7, 15.6), 27/45 health, order: attack E2\n A1 marine at (14.2, 16.3), 45/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (17.0, 17.7), 45/45 health, 2.1 away (in range)\n E1 marine at (17.9, 16.0), 45/45 health, 3.6 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (2.0s): Moving with you to 15,16; next tick all attack E2 together.\n A2 (2.0s): Closing to 15,17 together; once all in range 5, everyone attack E0 same tick.\n A0 (2.5s): All in range now. Everyone attack E2 this tick.\n A1 (2.5s): All in range now. Everyone focus E2, it's at 36hp.\n A2 (2.5s): All in range now. Focus E2 (36hp), everyone attack E2 this tick.\n A0 (3.0s): E2 at 9hp, finish it now, then focus E1.\n A1 (3.0s): E2 at 9hp, finish it now, then focus E0.\n A2 (3.0s): E2 at 9hp, finish it now, then focus E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"retreat\", \"say\": \"A2 at 9hp retreating. A0, A1 focus E0 now.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-d665c044bdfd56c0eb1a8bc3.json b/examples/multi-agent-smax/results/llm-cache/ask-d665c044bdfd56c0eb1a8bc3.json new file mode 100644 index 00000000..67b8300e --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-d665c044bdfd56c0eb1a8bc3.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 1.0 seconds into the battle.\nYou are A1, a marine at (6.7, 14.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.9, 15.6), 45/45 health, order: hold\n A2 marine at (8.3, 17.3), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding per rules until enemy within 5 of all; then focus same target.\n A1 (0.0s): A1 holding. No enemies seen; wait until all in range 5, then focus same target.\n A2 (0.0s): A2 holding. Will attack together once enemy is within 5 of all of us.\n A0 (0.5s): A0 holding. No enemies yet; will focus the same target once all in range.\n A1 (0.5s): A1 holding; no enemies visible yet. Will focus same target once all in range.\n A2 (0.5s): A2 holding. No enemies visible yet; will focus fire when all in range 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A1 holding. No enemies visible; will focus same target once all in range 5.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-d6748413333c50c47368fbe6.json b/examples/multi-agent-smax/results/llm-cache/ask-d6748413333c50c47368fbe6.json new file mode 100644 index 00000000..857a4fc7 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-d6748413333c50c47368fbe6.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.0 seconds into the battle.\nYou are A1, a marine at (8.3, 14.1) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (8.1, 15.8), 45/45 health, order: attack E2\n A2 marine at (8.1, 14.9), 45/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (12.9, 15.0), 45/45 health, 4.6 away (in range)\n E1 marine at (11.8, 16.2), 45/45 health, 4.1 away (in range)\n E2 marine at (12.9, 14.3), 18/45 health, 4.6 away (in range)\nTeam chat (most recent last):\n A1 (2.5s): Enemies east at 16,15. Hold grouped; focus fire on the closest, starting with E2 or E0.\n A2 (2.5s): Enemies ~8 east. Hold at range 5, focus closest when they approach.\n A0 (3.0s): Holding at (8,15). Everyone hold; focus fire closest enemy when in range 5.\n A1 (3.0s): Holding at (8,14). Focus E2 first when in range, then E0.\n A2 (3.0s): Holding at (8,15). Focus E2 or E0 when in range 5.\n A0 (3.5s): Focus E2 now, then E0. Stay grouped.\n A1 (3.5s): Focus E2 now, then E0. Everyone fire.\n A2 (3.5s): Focusing E2 now, then E0. All fire E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Firing E2 (18hp). Then E0. I'm at 27hp.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-d6fabdd7878795f9db37b41d.json b/examples/multi-agent-smax/results/llm-cache/ask-d6fabdd7878795f9db37b41d.json new file mode 100644 index 00000000..f8135edc --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-d6fabdd7878795f9db37b41d.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 7.0 seconds into the battle.\nYou are A2, a marine at (13.9, 16.5) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0: dead\n A1: dead\nEnemies you can see:\n E1 marine at (17.0, 15.6), 27/45 health, 3.2 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (4.0s): Keep focus on E2, 27hp left, then E1 together.\n A2 (4.0s): E2 at 27hp, keep focus until dead, then E1.\n A0 (4.5s): E2 at 9hp, finish it together, then both on E1.\n A2 (4.5s): E2 at 9hp, finish it now. A0 stay put, then both on E1.\n A2 (5.0s): A2 alone now. Finishing E2 at 9hp, then E1.\n A2 (5.5s): E2 dead. A2 alone, attacking E1 at 3.2 range.\n A2 (6.0s): A2 alone, 36hp vs E1 36hp, focusing E1.\n A2 (6.5s): A2 alone, 27hp vs E1 36hp, still focusing E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A2 27hp vs E1 27hp, still focusing E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-d713ba761247a0081a29667c.json b/examples/multi-agent-smax/results/llm-cache/ask-d713ba761247a0081a29667c.json new file mode 100644 index 00000000..d5fe67c2 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-d713ba761247a0081a29667c.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.5 seconds into the battle.\nYou are A1, a marine at (9.9, 15.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.2, 16.2), 45/45 health, order: hold\n A2 marine at (10.5, 16.3), 45/45 health, order: move 14 16\nEnemies you can see:\n E0 marine at (16.6, 17.3), 45/45 health, 7.0 away\n E1 marine at (16.7, 16.6), 45/45 health, 6.9 away\n E2 marine at (16.8, 14.1), 45/45 health, 7.1 away\nTeam chat (most recent last):\n A1 (1.0s): Still no enemies; holding grouped, will focus closest when seen.\n A2 (1.0s): Still no enemies. Holding; will focus the closest enemy when seen.\n A0 (1.5s): Still no enemies; holding grouped, focus closest when seen.\n A1 (1.5s): Holding grouped; focus fire on closest enemy when seen.\n A2 (1.5s): Still holding grouped; will focus the closest enemy when it appears.\n A0 (2.0s): Holding grouped; no enemies yet. Focus closest when seen.\n A1 (2.0s): Enemies at 8.5 east. Hold grouped; all focus the closest when in range.\n A2 (2.0s): No contact after 2s. Advancing east together to (14,16); stay close, focus closest.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Enemies 7 east. A2 fall back to group; hold and focus E1 when in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-d766ea1e5c3c26413b8d8712.json b/examples/multi-agent-smax/results/llm-cache/ask-d766ea1e5c3c26413b8d8712.json new file mode 100644 index 00000000..baaa4157 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-d766ea1e5c3c26413b8d8712.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.0 seconds into the battle.\nYou are A0, a marine at (9.3, 15.3) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1 marine at (8.3, 14.2), 45/45 health, order: attack E1\n A2: dead\nEnemies you can see:\n E1 marine at (12.2, 16.1), 9/45 health, 3.0 away (in range)\n E2 marine at (12.3, 17.5), 45/45 health, 3.8 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A2 (4.0s): A2 firing on E0 (27hp); finish it, then E1.\n A0 (4.5s): A0 firing E0 (18hp), nearly dead. Then all E1.\n A1 (4.5s): A1 hitting E1 (36hp). After E0 dies, everyone on E1.\n A2 (4.5s): A2 9hp. E0 at 18hp, A0 and I finish it now, then E1.\n A0 (5.0s): E0 is dead. A0 and A1 focus E1 (27hp), then E2.\n A1 (5.0s): A1 on E1 (27hp), in range. A0 join E1, then E2.\n A0 (5.5s): A0 18hp on E1 (18hp), finishing it. Then both on E2.\n A1 (5.5s): A1 on E1 (18hp), in range. A0 keep firing, then both E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A0 9hp, finishing E1 (9hp). Then both E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-d803686e75a11a2f8765486d.json b/examples/multi-agent-smax/results/llm-cache/ask-d803686e75a11a2f8765486d.json new file mode 100644 index 00000000..cb88ceca --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-d803686e75a11a2f8765486d.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 1.0 seconds into the battle.\nYou are A1, a marine at (13.0, 15.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 16.\nYour team:\n A0 marine at (11.4, 16.2), 45/45 health, order: move 14 16\n A2 marine at (12.1, 16.2), 45/45 health, order: move 14 16\nEnemies you can see:\n E0 marine at (21.4, 17.3), 45/45 health, 8.6 away\n E1 marine at (21.4, 16.6), 45/45 health, 8.5 away\n E2 marine at (21.6, 14.1), 45/45 health, 8.8 away\nTeam chat (most recent last):\n A0 (0.0s): Advancing east together to find enemies; keep within 2 of each other, then all attack same target.\n A1 (0.0s): Moving east together toward enemies, stay within 2 of each other; attack same target on contact.\n A2 (0.0s): Moving east together to (14,16); stay within 2 of each other, attack together on contact.\n A0 (0.5s): Continuing east to (14,16); staying together, will attack same target on contact.\n A1 (0.5s): Continuing east in formation; will attack same target on contact.\n A2 (0.5s): A2 moving east to (14,16), staying close; attack same target on contact.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 15 16\", \"say\": \"Advancing together toward enemies; will all attack E1 once in range 5.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-d82dc2f0ecbbdcdf43c2da24.json b/examples/multi-agent-smax/results/llm-cache/ask-d82dc2f0ecbbdcdf43c2da24.json new file mode 100644 index 00000000..0a6ad926 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-d82dc2f0ecbbdcdf43c2da24.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 7.0 seconds into the battle.\nYou are A1, a marine at (10.1, 17.3) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0: dead\n A2 marine at (9.9, 15.8), 18/45 health, order: attack E2\nEnemies you can see:\n E2 marine at (14.4, 14.8), 9/45 health, 5.0 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (5.0s): Focusing E1 (18hp), almost dead. Then E2.\n A2 (5.0s): Attacking E1 (18hp), then E2.\n A1 (5.5s): E1 down. All focus E2 (45hp), 5.0 away.\n A2 (5.5s): E1 down. All focus E2, 4.6 away, 45hp.\n A1 (6.0s): Focusing E2 (36hp), keep firing.\n A2 (6.0s): Focusing E2 (36hp), keep firing.\n A1 (6.5s): E2 27hp, in range. Keep firing, finish it.\n A2 (6.5s): E2 at 27hp, keep focusing, almost down.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 9hp, in range. Keep firing, finish it.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-d843192b0369884bdb0024d7.json b/examples/multi-agent-smax/results/llm-cache/ask-d843192b0369884bdb0024d7.json new file mode 100644 index 00000000..29fc657b --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-d843192b0369884bdb0024d7.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 2.5 seconds into the battle.\nYou are A0, a marine at (13.8, 15.8) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1 marine at (13.5, 17.2), 45/45 health, order: attack E2\n A2 marine at (13.9, 17.8), 36/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (18.0, 17.1), 45/45 health, 4.4 away (in range)\n E1 marine at (17.3, 17.0), 45/45 health, 3.6 away (in range)\n E2 marine at (15.8, 16.7), 18/45 health, 2.1 away (in range)\nTeam chat (most recent last):\n A1 (1.0s): Advancing east together toward E2; keep within 2, attack same target at range.\n A2 (1.0s): Closing together toward E2; hold pace, all fire on E2 once in range 5.\n A0 (1.5s): E2 is 5.2 away; one more step east, then all attack E2 together.\n A1 (1.5s): Almost in range of E2; keep pace, all attack E2 together next tick.\n A2 (1.5s): Still closing together; E2 just outside range. Fire on E2 once all in range 5.\n A0 (2.0s): All in range of E2 now. Everyone fire on E2.\n A1 (2.0s): All in range of E2 (2.4 away). Attack E2 now, everyone focus fire.\n A2 (2.0s): E2 in range of me; all attack E2 now.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Firing on E2, it's at 18hp. Then focus E1 next.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-d879aa7458ea864efb51f9c0.json b/examples/multi-agent-smax/results/llm-cache/ask-d879aa7458ea864efb51f9c0.json new file mode 100644 index 00000000..61c936f5 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-d879aa7458ea864efb51f9c0.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.0 seconds into the battle.\nYou are A0, a marine at (8.2, 16.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (9.8, 15.7), 45/45 health, order: hold\n A2 marine at (9.0, 16.2), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together as a group; focus fire on the closest enemy when they appear.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together as a group; focus fire on the closest enemy when they appear.\n A0 (0.5s): No enemies yet; staying grouped, will focus the closest enemy when seen.\n A1 (0.5s): Holding position; will focus fire on closest enemy once visible.\n A2 (0.5s): Holding. Will focus fire on the closest enemy once visible.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Still no enemies; holding grouped, focus closest when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-d988a4d0f5ddd5ae8455f28a.json b/examples/multi-agent-smax/results/llm-cache/ask-d988a4d0f5ddd5ae8455f28a.json new file mode 100644 index 00000000..d767b965 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-d988a4d0f5ddd5ae8455f28a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 7.0 seconds into the battle.\nYou are A0, a marine at (15.0, 18.1) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1: dead\n A2: dead\nEnemies you can see:\n E2 marine at (17.5, 14.8), 9/45 health, 4.2 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (5.0s): E1 dead. Both attack E2 now, A2 is closest so keep firing.\n A2 (5.0s): E1 down. Focus E2 together; I'm closest so I tank, A0 keep firing.\n A0 (5.5s): Attacking E2. A2 is closest and tanking, so keep firing until it dies.\n A2 (5.5s): Both firing on E2 now, keep attacking until it dies.\n A0 (6.0s): Attacking E2 (27hp). A2 is closest and tanking, so I keep firing.\n A2 (6.0s): E2 at 27hp. Both keep firing, two volleys should kill it.\n A0 (6.5s): E2 at 18hp, keep firing, one or two volleys finishes it.\n A2 (6.5s): E2 at 18hp, two more volleys kills it. Keep firing, A0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"A2 dead. E2 at 9hp, I'm firing, one or two volleys finishes it.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-da08ff29aa7d43b83cd238da.json b/examples/multi-agent-smax/results/llm-cache/ask-da08ff29aa7d43b83cd238da.json new file mode 100644 index 00000000..4e59a038 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-da08ff29aa7d43b83cd238da.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 2.0 seconds into the battle.\nYou are A1, a marine at (14.1, 16.4) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 16.\nYour team:\n A0 marine at (13.3, 16.4), 45/45 health, order: move 14 16\n A2 marine at (12.3, 16.5), 45/45 health, order: move 13 16\nEnemies you can see:\n E0 marine at (16.0, 15.3), 45/45 health, 2.3 away (in range)\n E1 marine at (18.6, 15.6), 45/45 health, 4.5 away (in range)\n E2 marine at (18.2, 17.7), 45/45 health, 4.3 away (in range)\nTeam chat (most recent last):\n A1 (0.5s): Joining A0 and A2 at (12,16); staying grouped, then advance together.\n A2 (0.5s): A2 moving to (12,16) with team; will attack together on contact.\n A0 (1.0s): Continuing to (12,16); stay grouped, attack same target on contact.\n A1 (1.0s): Holding formation at (12,16); then all advance and attack E0 together.\n A2 (1.0s): Continuing to (12,16) together; will attack same target once all in range 5.\n A0 (1.5s): Advancing together toward E0; all attack E0 once everyone is within range 5.\n A1 (1.5s): Advancing together east to (14,16); then all attack E0 at once.\n A2 (1.5s): Advancing together toward E0; all attack E0 once everyone is within range 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 is in range of all three of us. Everyone attack E0 now.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-daaecab0f47993e654dbfe5d.json b/examples/multi-agent-smax/results/llm-cache/ask-daaecab0f47993e654dbfe5d.json new file mode 100644 index 00000000..22ae32ad --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-daaecab0f47993e654dbfe5d.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 0.0 seconds into the battle.\nYou are A1, a marine at (8.3, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.1, 17.4), 45/45 health, order: hold\n A2 marine at (6.5, 14.9), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 15\", \"say\": \"Moving east together toward enemies; stay within 2 of each other, attack same target.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-db3c9a118a91c622938320db.json b/examples/multi-agent-smax/results/llm-cache/ask-db3c9a118a91c622938320db.json new file mode 100644 index 00000000..af0b0849 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-db3c9a118a91c622938320db.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.0 seconds into the battle.\nYou are A2, a marine at (9.9, 15.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (10.3, 16.5), 18/45 health, order: attack E0\n A1 marine at (10.1, 17.3), 45/45 health, order: attack E0\nEnemies you can see:\n E1 marine at (13.8, 17.3), 45/45 health, 4.2 away (in range)\n E2 marine at (14.4, 14.8), 45/45 health, 4.6 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (2.5s): Holding; enemies at 6+ range. Focus E0 when it enters range 5.\n A2 (2.5s): A2 holding; let them come into range, focus E0 together.\n A0 (3.0s): E0 in range, all focus fire E0 now.\n A1 (3.0s): E0 in range, attacking E0 now. Everyone focus E0.\n A2 (3.0s): Attacking E0 now, E0 in range. Everyone focus fire E0.\n A0 (3.5s): Keep focusing E0 (18hp), then E1.\n A1 (3.5s): Keep focusing E0, it's at 18 health. Then E1.\n A2 (3.5s): E0 at 18hp, keep focusing E0, then E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E0 dead. Focus E1 (4.2 away), then E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-dbc9c122257e27cfad999ffe.json b/examples/multi-agent-smax/results/llm-cache/ask-dbc9c122257e27cfad999ffe.json new file mode 100644 index 00000000..ac3c3a18 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-dbc9c122257e27cfad999ffe.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 7.0 seconds into the battle.\nYou are A0, a marine at (13.7, 15.6) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1: dead\n A2: dead\nEnemies you can see:\n E1 marine at (17.9, 16.0), 18/45 health, 4.2 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (4.5s): E0 at 18hp, keep focusing it, then E1. A0 retreat if under 20.\n A0 (5.0s): E0 dead. Focus E1 now, it's in range 4.2.\n A1 (5.0s): E0 down. Both focus E1 now, it's the last one.\n A0 (5.5s): Focusing E1. A1 at 9hp, retreat if you're targeted; I'm 27hp, staying in.\n A1 (5.5s): Attacking E1. I'm 9hp and will soak a shot. A0 keep firing, finish it.\n A0 (6.0s): Firing on E1 (27hp). A1 retreat if targeted; I'm 27hp, staying in.\n A1 (6.0s): A1 at 9hp retreating so I'm not the target. A0 finish E1.\n A0 (6.5s): Firing on E1, last enemy. A0 27hp, staying in.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Firing on E1, 18hp left. A0 27hp, finishing it.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-dbdf3bd8bc4c46fa3da67fbc.json b/examples/multi-agent-smax/results/llm-cache/ask-dbdf3bd8bc4c46fa3da67fbc.json new file mode 100644 index 00000000..a3eb47c4 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-dbdf3bd8bc4c46fa3da67fbc.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 1.5 seconds into the battle.\nYou are A2, a marine at (11.4, 14.3) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 15.\nYour team:\n A0 marine at (12.8, 17.5), 45/45 health, order: move 14 16\n A1 marine at (11.4, 15.0), 45/45 health, order: move 12 15\nEnemies you can see:\n E0 marine at (18.9, 15.0), 45/45 health, 7.5 away\n E1 marine at (19.7, 14.0), 45/45 health, 8.4 away\n E2 marine at (18.1, 16.8), 45/45 health, 7.2 away\nTeam chat (most recent last):\n A1 (0.0s): Advancing east together to (12,15); stay within 2 of each other, attack same target on contact.\n A2 (0.0s): Advancing east together, staying close. Don't outrun the group; all attack same target.\n A0 (0.5s): Advancing to (12,16), keeping close; will attack same target on contact.\n A1 (0.5s): A1 advancing to (12,15), staying close; will attack same target on contact.\n A2 (0.5s): A2 advancing to (12,15), staying close; will attack same target on contact.\n A0 (1.0s): Moving together east to (14,16); stay grouped, attack same target on contact.\n A1 (1.0s): A1 continuing to (12,15), staying close; attack same target on contact.\n A2 (1.0s): Holding formation at (12,15); will advance together, then all attack E2 at once.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 16\", \"say\": \"Moving to (14,16) with A0; enemies ~5 away next, then all attack E2 together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-dc9d3de7e4fdaec411d3882a.json b/examples/multi-agent-smax/results/llm-cache/ask-dc9d3de7e4fdaec411d3882a.json new file mode 100644 index 00000000..5d5a8c54 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-dc9d3de7e4fdaec411d3882a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 0.0 seconds into the battle.\nYou are A2, a marine at (9.4, 14.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.1, 17.5), 45/45 health, order: hold\n A1 marine at (7.1, 14.7), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 15\", \"say\": \"Advancing east together, staying close. Don't outrun the group; all attack same target.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-dcb264cd9d9f11e297455896.json b/examples/multi-agent-smax/results/llm-cache/ask-dcb264cd9d9f11e297455896.json new file mode 100644 index 00000000..7f1d77de --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-dcb264cd9d9f11e297455896.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.0 seconds into the battle.\nYou are A0, a marine at (8.4, 17.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (9.7, 17.5), 45/45 health, order: hold\n A2 marine at (9.1, 16.8), 45/45 health, order: hold\nEnemies you can see:\n E1 marine at (16.9, 14.5), 45/45 health, 8.9 away\n E2 marine at (16.2, 17.2), 45/45 health, 7.8 away\nTeam chat (most recent last):\n A1 (0.5s): Falling back to cluster; hold together and focus the closest enemy.\n A2 (0.5s): A1 is ahead alone; moving up to group with A1, then focus nearest enemy.\n A0 (1.0s): Grouped at x=9; hold here and focus the closest enemy when seen.\n A1 (1.0s): Grouping at x=9; focus fire on nearest enemy when seen.\n A2 (1.0s): Holding at cluster near (9,16.7); focus fire on the closest enemy.\n A0 (1.5s): Holding at x=9 with cluster; focus fire on closest enemy when seen.\n A1 (1.5s): Holding at x=9; enemy E2 approaching, all focus the closest one.\n A2 (1.5s): E2 spotted east at 8.7 range; holding together, focus whatever enters range first.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding at x=9; shoot first enemy entering 5 range, focus closest.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-dcb94f061f6099e368a11d2a.json b/examples/multi-agent-smax/results/llm-cache/ask-dcb94f061f6099e368a11d2a.json new file mode 100644 index 00000000..f414b2ee --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-dcb94f061f6099e368a11d2a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.5 seconds into the battle.\nYou are A2, a marine at (7.6, 17.8) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (8.5, 16.7), 36/45 health, order: attack E2\n A1: dead\nEnemies you can see:\n E1 marine at (12.3, 15.6), 36/45 health, 5.1 away\n E2 marine at (11.9, 17.7), 9/45 health, 4.3 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (5.0s): A0 on E2 (full hp). A1 stay back, low. A2 keep firing E2.\n A1 (5.0s): A1 low, shooting E2 from back. A0 you're tanking, focus E2.\n A2 (5.0s): A2 on E2, in range. A0 and A2 focus E2; A1 stay back.\n A0 (5.5s): A0 on E2 (27hp). Keep firing E2, then E1. A1 stay back.\n A1 (5.5s): A1 firing E2 from back; A0 is closest, keep tanking. Focus E2.\n A2 (5.5s): A2 on E2 (27hp), keep focusing. A1 stay back.\n A0 (6.0s): A0 on E2 (9hp), finishing it. Then all E1.\n A2 (6.0s): A2 on E2 (9hp), nearly dead. Then E1 together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"A2 finishing E2 (9hp). Then both on E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-dd1eabfce3280c0434576489.json b/examples/multi-agent-smax/results/llm-cache/ask-dd1eabfce3280c0434576489.json new file mode 100644 index 00000000..73394b96 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-dd1eabfce3280c0434576489.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.5 seconds into the battle.\nYou are A0, a marine at (9.0, 16.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (7.4, 14.1), 45/45 health, order: hold\n A2 marine at (7.7, 14.8), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on closest enemy when they appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"No enemies yet. Staying grouped; focus fire on closest when they appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-dd534fba9549350ff6d63a25.json b/examples/multi-agent-smax/results/llm-cache/ask-dd534fba9549350ff6d63a25.json new file mode 100644 index 00000000..e653acda --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-dd534fba9549350ff6d63a25.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.0 seconds into the battle.\nYou are A2, a marine at (10.8, 14.8) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (10.6, 16.0), 9/45 health, order: attack E2\n A1 marine at (8.9, 14.1), 45/45 health, order: attack E2\nEnemies you can see:\n E1 marine at (13.1, 16.8), 45/45 health, 3.0 away (in range)\n E2 marine at (13.1, 15.5), 9/45 health, 2.3 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (4.5s): Firing E0 (18hp left), then switch to E2 together.\n A2 (4.5s): E0 at 18 hp, keep firing E0, then E2.\n A0 (5.0s): E0 dead. Focus E2 together, then E1.\n A1 (5.0s): E0 dead. Focus E2 (4.4 away, 45hp), everyone fire E2 together.\n A2 (5.0s): E0 dead. All focus E2, closest at 2.3, then E1.\n A0 (5.5s): E2 at 18hp, all fire E2 now, then E1.\n A1 (5.5s): Firing E2 (18hp), then E1 together.\n A2 (5.5s): Keep firing E2 (18hp), then E1 together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 at 9hp, finish it, then all on E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-dd5a88cee2df2a44e62c9498.json b/examples/multi-agent-smax/results/llm-cache/ask-dd5a88cee2df2a44e62c9498.json new file mode 100644 index 00000000..0fccad4f --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-dd5a88cee2df2a44e62c9498.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 5.5 seconds into the battle.\nYou are A2, a marine at (13.9, 16.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0: dead\n A1: dead\nEnemies you can see:\n E1 marine at (17.0, 15.6), 45/45 health, 3.2 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A2 (3.0s): E0 dead. A0 and I both attack E2 now, stay together.\n A0 (3.5s): Both on E2, keep firing until it dies.\n A2 (3.5s): Attacking E2 with A0, keep focus until it dies.\n A0 (4.0s): Keep focus on E2, 27hp left, then E1 together.\n A2 (4.0s): E2 at 27hp, keep focus until dead, then E1.\n A0 (4.5s): E2 at 9hp, finish it together, then both on E1.\n A2 (4.5s): E2 at 9hp, finish it now. A0 stay put, then both on E1.\n A2 (5.0s): A2 alone now. Finishing E2 at 9hp, then E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E2 dead. A2 alone, attacking E1 at 3.2 range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-dd79a18ac6ba9cb1dc204489.json b/examples/multi-agent-smax/results/llm-cache/ask-dd79a18ac6ba9cb1dc204489.json new file mode 100644 index 00000000..df92fe25 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-dd79a18ac6ba9cb1dc204489.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.0 seconds into the battle.\nYou are A0, a marine at (6.9, 16.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (9.4, 14.9), 45/45 health, order: hold\n A2 marine at (7.6, 17.8), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together; focus fire on closest enemy once seen.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on closest enemy when they appear.\n A0 (0.5s): A0 holding; will focus fire on the closest enemy that appears.\n A1 (0.5s): A1 holding; will focus fire on closest enemy once visible.\n A2 (0.5s): Holding; staying clustered near A0 until enemies appear, then focus closest.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A0 holding; A1 move closer to cluster, focus closest enemy when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-dd900dd601408fe0219a40b0.json b/examples/multi-agent-smax/results/llm-cache/ask-dd900dd601408fe0219a40b0.json new file mode 100644 index 00000000..f48a51c3 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-dd900dd601408fe0219a40b0.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.5 seconds into the battle.\nYou are A0, a marine at (7.8, 14.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1: dead\n A2: dead\nEnemies you can see:\n E1 marine at (11.9, 14.0), 45/45 health, 4.1 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (4.5s): E2 down. Focus E0 now, then E1. Fire together.\n A2 (4.5s): E2 down. Focus E0 (4.5 away), then E1.\n A0 (5.0s): Focus E0 together, then E1. A2 keep firing.\n A2 (5.0s): Focus E0 together, then E1.\n A0 (5.5s): Keep focusing E0 (27hp), then E1. Fire together.\n A2 (5.5s): Firing E0 (27hp), then E1. I'm low, keep fire together.\n A0 (6.0s): E0 at 9hp, kill it now, then E1. Fire together.\n A2 (6.0s): E0 at 9hp, finishing it now. Then all focus E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A0 alone vs E1, firing now.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ddb5999cffb50f8b9e274de8.json b/examples/multi-agent-smax/results/llm-cache/ask-ddb5999cffb50f8b9e274de8.json new file mode 100644 index 00000000..bba24977 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ddb5999cffb50f8b9e274de8.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.5 seconds into the battle.\nYou are A1, a marine at (6.7, 14.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.0, 15.5), 45/45 health, order: hold\n A2 marine at (8.7, 15.8), 36/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (13.5, 16.8), 36/45 health, 7.3 away\n E1 marine at (13.7, 16.2), 45/45 health, 7.3 away\n E2 marine at (13.9, 17.4), 45/45 health, 7.9 away\nTeam chat (most recent last):\n A1 (2.0s): A1 holding; no enemies yet, will focus closest when one appears.\n A2 (2.0s): E0 at (16.8,16.8) approaching; hold and focus it when in range.\n A0 (2.5s): A0 holding with you; enemies approaching, focus E0 when in range.\n A1 (2.5s): A1 holding at (6.7,14.2); A0 fall back to us, focus E0 together.\n A2 (2.5s): A2 holding; enemies approaching, all focus E0 when in range.\n A0 (3.0s): A0 holding; focus E0 when in range 5.\n A1 (3.0s): A1 holding; focus E0 when it enters range 5.\n A2 (3.0s): A2 attacking E0 (in range); all focus E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"A1 advancing, focusing E0 with A2. A0 join fire on E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-dde795ed090323a9cfee046a.json b/examples/multi-agent-smax/results/llm-cache/ask-dde795ed090323a9cfee046a.json new file mode 100644 index 00000000..d10c3648 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-dde795ed090323a9cfee046a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 9.5 seconds into the battle.\nYou are A1, a marine at (9.8, 14.2) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E2 marine at (10.8, 17.5), 9/45 health, 3.5 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (6.0s): A0 9hp, finishing E1 (9hp). Then both E2.\n A1 (6.0s): A1 on E1 (9hp), finishing it. Then both on E2.\n A1 (6.5s): A1 alone vs E2 (45hp), engaging.\n A1 (7.0s): A1 last unit, fighting E2 (45hp) alone.\n A1 (7.5s): A1 last unit, 36hp vs E2 36hp, fighting to the end.\n A1 (8.0s): A1 last unit, 27hp vs E2 27hp, fighting to the end.\n A1 (8.5s): A1 27hp vs E2 18hp, fighting on, one enemy left.\n A1 (9.0s): A1 18hp vs E2 18hp, last unit, finishing E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"A1 9hp vs E2 9hp, last shots, finishing E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-de80040841d609b61e952d15.json b/examples/multi-agent-smax/results/llm-cache/ask-de80040841d609b61e952d15.json new file mode 100644 index 00000000..86ae0019 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-de80040841d609b61e952d15.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 6.5 seconds into the battle.\nYou are A2, a marine at (14.6, 17.4) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (15.0, 18.1), 18/45 health, order: attack E2\n A1: dead\nEnemies you can see:\n E2 marine at (17.5, 14.8), 18/45 health, 3.9 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (4.5s): E1 at 9hp, finish it now, then both focus E2.\n A2 (4.5s): E1 at 9hp, finishing it now. Then both on E2.\n A0 (5.0s): E1 dead. Both attack E2 now, A2 is closest so keep firing.\n A2 (5.0s): E1 down. Focus E2 together; I'm closest so I tank, A0 keep firing.\n A0 (5.5s): Attacking E2. A2 is closest and tanking, so keep firing until it dies.\n A2 (5.5s): Both firing on E2 now, keep attacking until it dies.\n A0 (6.0s): Attacking E2 (27hp). A2 is closest and tanking, so I keep firing.\n A2 (6.0s): E2 at 27hp. Both keep firing, two volleys should kill it.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 at 18hp, two more volleys kills it. Keep firing, A0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-dee8d2d9f851baf9fada0e43.json b/examples/multi-agent-smax/results/llm-cache/ask-dee8d2d9f851baf9fada0e43.json new file mode 100644 index 00000000..dc3b3b2c --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-dee8d2d9f851baf9fada0e43.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.0 seconds into the battle.\nYou are A0, a marine at (8.1, 15.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1 marine at (8.3, 14.1), 27/45 health, order: attack E2\n A2 marine at (8.1, 14.9), 45/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (12.9, 15.0), 45/45 health, 4.8 away (in range)\n E1 marine at (11.8, 16.2), 45/45 health, 3.7 away (in range)\n E2 marine at (12.9, 14.3), 18/45 health, 5.0 away (in range)\nTeam chat (most recent last):\n A1 (2.5s): Enemies east at 16,15. Hold grouped; focus fire on the closest, starting with E2 or E0.\n A2 (2.5s): Enemies ~8 east. Hold at range 5, focus closest when they approach.\n A0 (3.0s): Holding at (8,15). Everyone hold; focus fire closest enemy when in range 5.\n A1 (3.0s): Holding at (8,14). Focus E2 first when in range, then E0.\n A2 (3.0s): Holding at (8,15). Focus E2 or E0 when in range 5.\n A0 (3.5s): Focus E2 now, then E0. Stay grouped.\n A1 (3.5s): Focus E2 now, then E0. Everyone fire.\n A2 (3.5s): Focusing E2 now, then E0. All fire E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 is at 18 HP, finish it, then E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-deef8f2658eb7b5ab5266c2f.json b/examples/multi-agent-smax/results/llm-cache/ask-deef8f2658eb7b5ab5266c2f.json new file mode 100644 index 00000000..8cda390b --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-deef8f2658eb7b5ab5266c2f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.0 seconds into the battle.\nYou are A2, a marine at (10.8, 14.8) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (10.6, 16.0), 18/45 health, order: attack E0\n A1 marine at (8.9, 14.1), 45/45 health, order: attack E0\nEnemies you can see:\n E1 marine at (13.1, 16.8), 45/45 health, 3.0 away (in range)\n E2 marine at (13.1, 15.5), 45/45 health, 2.3 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (3.5s): Holding. Focus E0 when in range; stay grouped.\n A2 (3.5s): E0 at range 5. Everyone attack E0 now, focus fire.\n A0 (4.0s): Focusing E0 now. A1 please attack E0 too, all fire together.\n A1 (4.0s): Attacking E0 now, focus fire.\n A2 (4.0s): All attack E0 now, in range. A1 switch from hold to attack E0.\n A0 (4.5s): E0 at 18 hp, keep focus firing E0 then E2.\n A1 (4.5s): Firing on E0, 18 hp left. Next target E2 (closest).\n A2 (4.5s): E0 at 18 hp, keep firing. Then focus E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E0 down. Focus E2 (closest), then E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-df1cc4240d6c807ee15c3d72.json b/examples/multi-agent-smax/results/llm-cache/ask-df1cc4240d6c807ee15c3d72.json new file mode 100644 index 00000000..528cee6a --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-df1cc4240d6c807ee15c3d72.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 3.0 seconds into the battle.\nYou are A0, a marine at (14.6, 14.4) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1 marine at (15.1, 13.7), 45/45 health, order: attack E0\n A2 marine at (14.8, 15.1), 27/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (18.6, 16.2), 9/45 health, 4.4 away (in range)\n E1 marine at (18.0, 17.0), 45/45 health, 4.2 away (in range)\n E2 marine at (17.8, 15.5), 45/45 health, 3.3 away (in range)\nTeam chat (most recent last):\n A1 (1.5s): Moving to 14,15 with A0 and A2; will focus same target at range 5.\n A2 (1.5s): Enemies 8 away; keep moving together, then all attack E0 at range 5.\n A0 (2.0s): Attacking E0 now. A1, A2, step in and focus E0 immediately.\n A1 (2.0s): Closing on E0 together; once all within 5, everyone attacks E0 same tick.\n A2 (2.0s): Attacking E0 now; A0 is already in range, A1 close up and focus E0.\n A0 (2.5s): Focusing E0; A1 attack E0 now, all in range.\n A1 (2.5s): In range of all; attacking E0 now.\n A2 (2.5s): Focusing E0 (36hp). A1 attack E0 now, all in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 at 9hp, finishing it now. Everyone keep focusing E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-df21a3505b83f54980142432.json b/examples/multi-agent-smax/results/llm-cache/ask-df21a3505b83f54980142432.json new file mode 100644 index 00000000..00f99a25 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-df21a3505b83f54980142432.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 4.0 seconds into the battle.\nYou are A0, a marine at (13.7, 15.6) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1 marine at (14.2, 16.3), 45/45 health, order: attack E0\n A2: dead\nEnemies you can see:\n E0 marine at (17.0, 17.7), 36/45 health, 3.9 away (in range)\n E1 marine at (17.9, 16.0), 45/45 health, 4.2 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (2.5s): All in range now. Everyone focus E2, it's at 36hp.\n A2 (2.5s): All in range now. Focus E2 (36hp), everyone attack E2 this tick.\n A0 (3.0s): E2 at 9hp, finish it now, then focus E1.\n A1 (3.0s): E2 at 9hp, finish it now, then focus E0.\n A2 (3.0s): E2 at 9hp, finish it now, then focus E0.\n A0 (3.5s): E2 dead. Everyone focus E0 now. A2 at 9hp, retreat.\n A1 (3.5s): E2 dead. All focus E0 now, then E1. A2 retreat, you're at 9hp.\n A2 (3.5s): A2 at 9hp retreating. A0, A1 focus E0 now.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Focus E0 (36hp), then E1. I'm 27hp, staying in.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-df628250f1f9262da02cb15f.json b/examples/multi-agent-smax/results/llm-cache/ask-df628250f1f9262da02cb15f.json new file mode 100644 index 00000000..0e53d0ea --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-df628250f1f9262da02cb15f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 4.5 seconds into the battle.\nYou are A2, a marine at (13.9, 16.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (14.8, 16.4), 9/45 health, order: attack E2\n A1: dead\nEnemies you can see:\n E1 marine at (17.0, 15.6), 45/45 health, 3.2 away (in range)\n E2 marine at (16.6, 17.7), 9/45 health, 3.0 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (2.5s): E0 at 18hp, keep focus fire; I'm at 18hp and will step back once it dies.\n A2 (2.5s): Focus E0, it's at 18hp. A1 is low; keep firing until E0 dies.\n A0 (3.0s): E0 dead. A2 stay close, all focus E2 together. A1 retreat.\n A2 (3.0s): E0 dead. A0 and I both attack E2 now, stay together.\n A0 (3.5s): Both on E2, keep firing until it dies.\n A2 (3.5s): Attacking E2 with A0, keep focus until it dies.\n A0 (4.0s): Keep focus on E2, 27hp left, then E1 together.\n A2 (4.0s): E2 at 27hp, keep focus until dead, then E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 at 9hp, finish it now. A0 stay put, then both on E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-dfa163eb6d3ed84cd94da633.json b/examples/multi-agent-smax/results/llm-cache/ask-dfa163eb6d3ed84cd94da633.json new file mode 100644 index 00000000..84a3ed3f --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-dfa163eb6d3ed84cd94da633.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 3.0 seconds into the battle.\nYou are A2, a marine at (14.1, 16.4) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (13.6, 17.1), 27/45 health, order: attack E0\n A1 marine at (13.2, 15.3), 27/45 health, order: attack E0\nEnemies you can see:\n E1 marine at (17.6, 16.5), 45/45 health, 3.5 away (in range)\n E2 marine at (17.5, 17.3), 45/45 health, 3.5 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (1.5s): E0 in range of A1 and A0. A2 close in, everyone focus E0 now.\n A2 (1.5s): E0 at 6.7, not in range yet. Moving up together; attack E0 on same tick.\n A0 (2.0s): Focus E0 (27hp) now; A2 close in and fire.\n A1 (2.0s): Focusing E0 (27hp). A2 get in range and attack E0.\n A2 (2.0s): Attacking E0 now, closing in with you both.\n A0 (2.5s): E0 at 9hp, finish it now; then focus E2.\n A1 (2.5s): E0 at 9hp, finishing it now; then everyone focus E1.\n A2 (2.5s): E0 at 9hp in range, firing on E0 now.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E0 dead. Everyone focus E1 now, then E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-dfd39d1485eb0e46277409e9.json b/examples/multi-agent-smax/results/llm-cache/ask-dfd39d1485eb0e46277409e9.json new file mode 100644 index 00000000..81ec810b --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-dfd39d1485eb0e46277409e9.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.0 seconds into the battle.\nYou are A2, a marine at (9.1, 16.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.4, 17.0), 45/45 health, order: hold\n A1 marine at (9.7, 17.5), 45/45 health, order: hold\nEnemies you can see:\n E1 marine at (16.9, 14.5), 45/45 health, 8.1 away\n E2 marine at (16.2, 17.2), 45/45 health, 7.1 away\nTeam chat (most recent last):\n A1 (0.5s): Falling back to cluster; hold together and focus the closest enemy.\n A2 (0.5s): A1 is ahead alone; moving up to group with A1, then focus nearest enemy.\n A0 (1.0s): Grouped at x=9; hold here and focus the closest enemy when seen.\n A1 (1.0s): Grouping at x=9; focus fire on nearest enemy when seen.\n A2 (1.0s): Holding at cluster near (9,16.7); focus fire on the closest enemy.\n A0 (1.5s): Holding at x=9 with cluster; focus fire on closest enemy when seen.\n A1 (1.5s): Holding at x=9; enemy E2 approaching, all focus the closest one.\n A2 (1.5s): E2 spotted east at 8.7 range; holding together, focus whatever enters range first.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding at x=9; E2 closest, all focus E2 when in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-e0387824c144a8fc335e9409.json b/examples/multi-agent-smax/results/llm-cache/ask-e0387824c144a8fc335e9409.json new file mode 100644 index 00000000..1a2a7520 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-e0387824c144a8fc335e9409.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 5.0 seconds into the battle.\nYou are A0, a marine at (15.0, 18.1) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1: dead\n A2 marine at (14.6, 17.4), 27/45 health, order: attack E1\nEnemies you can see:\n E2 marine at (17.5, 14.8), 45/45 health, 4.2 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (3.0s): E0 dead. A2 attack E1 now, it's in my range. A1 stay back.\n A2 (3.0s): E0 dead. A0, A2 focus E1 together now; A1 stay back.\n A0 (3.5s): Focusing E1 together, A2 keep firing. A1 stay back.\n A2 (3.5s): Attacking E1 with A0. A1 stay back.\n A0 (4.0s): Keep focusing E1 (27hp), both firing together.\n A2 (4.0s): Focusing E1 (27hp), both in range. Keep firing, then E2.\n A0 (4.5s): E1 at 9hp, finish it now, then both focus E2.\n A2 (4.5s): E1 at 9hp, finishing it now. Then both on E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E1 dead. Both attack E2 now, A2 is closest so keep firing.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-e06209b0ea662af0d7d1bd74.json b/examples/multi-agent-smax/results/llm-cache/ask-e06209b0ea662af0d7d1bd74.json new file mode 100644 index 00000000..427d0e8f --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-e06209b0ea662af0d7d1bd74.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 2.0 seconds into the battle.\nYou are A2, a marine at (15.3, 16.3) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 15 16.\nYour team:\n A0 marine at (14.5, 16.3), 45/45 health, order: move 15 16\n A1 marine at (13.0, 15.5), 45/45 health, order: move 14 16\nEnemies you can see:\n E0 marine at (18.2, 17.3), 45/45 health, 3.1 away (in range)\n E1 marine at (18.2, 16.6), 45/45 health, 3.0 away (in range)\n E2 marine at (18.4, 14.1), 45/45 health, 3.8 away (in range)\nTeam chat (most recent last):\n A1 (0.5s): Continuing east in formation; will attack same target on contact.\n A2 (0.5s): A2 moving east to (14,16), staying close; attack same target on contact.\n A0 (1.0s): Continuing east to (14,16), staying together; no enemies seen yet.\n A1 (1.0s): Advancing together toward enemies; will all attack E1 once in range 5.\n A2 (1.0s): A2 continuing east to (14,16), staying together; attack same target on contact.\n A0 (1.5s): Advancing together east; attack E1 once all within range 5.\n A1 (1.5s): A1 holding near 14,16 so A0 and A2 catch up; all attack E1 together.\n A2 (1.5s): Advancing together to (15,16); all attack E1 once in range 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Enemies in range of me and A0. Attacking E1 now; A1 close in and fire on E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-e1bdf401dd33916fb1f62531.json b/examples/multi-agent-smax/results/llm-cache/ask-e1bdf401dd33916fb1f62531.json new file mode 100644 index 00000000..40494353 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-e1bdf401dd33916fb1f62531.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 2.0 seconds into the battle.\nYou are A1, a marine at (14.9, 17.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 17.\nYour team:\n A0 marine at (14.8, 18.0), 45/45 health, order: move 15 17\n A2 marine at (13.2, 17.6), 45/45 health, order: move 14 17\nEnemies you can see:\n E0 marine at (17.7, 16.4), 45/45 health, 2.9 away (in range)\n E1 marine at (18.5, 17.3), 45/45 health, 3.6 away (in range)\n E2 marine at (19.1, 14.8), 45/45 health, 4.8 away (in range)\nTeam chat (most recent last):\n A1 (0.5s): Moving east in formation at x=12; no one engages alone.\n A2 (0.5s): Moving east, staying close; A0 at 12,17 is my anchor point.\n A0 (1.0s): Advancing east together to x=14; will call attack when enemies appear.\n A1 (1.0s): Advancing east to 14,17 together; no one engages until all in range.\n A2 (1.0s): Moving east together to x=16; will attack same target once all in range.\n A0 (1.5s): Closing together toward E0; attack E0 once all three are within range 5.\n A1 (1.5s): Holding formation at 14,17; attack E0 together once all within range 5.\n A2 (1.5s): Regrouping at 14,17; closest enemy 6 away, hold formation, then attack E0 together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 is in range of all three. Attack E0 now, together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-e1e7afcde660a86898d1a8cd.json b/examples/multi-agent-smax/results/llm-cache/ask-e1e7afcde660a86898d1a8cd.json new file mode 100644 index 00000000..151f79fb --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-e1e7afcde660a86898d1a8cd.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 1.5 seconds into the battle.\nYou are A1, a marine at (11.4, 15.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 15.\nYour team:\n A0 marine at (12.8, 17.5), 45/45 health, order: move 14 16\n A2 marine at (11.4, 14.3), 45/45 health, order: move 12 15\nEnemies you can see:\n E0 marine at (18.9, 15.0), 45/45 health, 7.5 away\n E1 marine at (19.7, 14.0), 45/45 health, 8.4 away\n E2 marine at (18.1, 16.8), 45/45 health, 7.0 away\nTeam chat (most recent last):\n A1 (0.0s): Advancing east together to (12,15); stay within 2 of each other, attack same target on contact.\n A2 (0.0s): Advancing east together, staying close. Don't outrun the group; all attack same target.\n A0 (0.5s): Advancing to (12,16), keeping close; will attack same target on contact.\n A1 (0.5s): A1 advancing to (12,15), staying close; will attack same target on contact.\n A2 (0.5s): A2 advancing to (12,15), staying close; will attack same target on contact.\n A0 (1.0s): Moving together east to (14,16); stay grouped, attack same target on contact.\n A1 (1.0s): A1 continuing to (12,15), staying close; attack same target on contact.\n A2 (1.0s): Holding formation at (12,15); will advance together, then all attack E2 at once.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 16\", \"say\": \"Moving to (14,16) with A0; enemies close, then all attack E2 together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-e2856b0c8621dafb91b6bf8c.json b/examples/multi-agent-smax/results/llm-cache/ask-e2856b0c8621dafb91b6bf8c.json new file mode 100644 index 00000000..07e6be8c --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-e2856b0c8621dafb91b6bf8c.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 2.5 seconds into the battle.\nYou are A1, a marine at (15.1, 13.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 15 15.\nYour team:\n A0 marine at (14.6, 14.4), 36/45 health, order: attack E0\n A2 marine at (14.8, 15.1), 45/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (18.6, 16.2), 36/45 health, 4.3 away (in range)\n E1 marine at (18.0, 17.0), 45/45 health, 4.3 away (in range)\n E2 marine at (17.8, 15.5), 45/45 health, 3.2 away (in range)\nTeam chat (most recent last):\n A1 (1.0s): Continuing east together; will focus same target when enemies in range.\n A2 (1.0s): Continuing east to 14,15, staying close; will focus same target when enemies appear.\n A0 (1.5s): Enemies ~6.6 east. Closing up on me; attack E0 together once all in range.\n A1 (1.5s): Moving to 14,15 with A0 and A2; will focus same target at range 5.\n A2 (1.5s): Enemies 8 away; keep moving together, then all attack E0 at range 5.\n A0 (2.0s): Attacking E0 now. A1, A2, step in and focus E0 immediately.\n A1 (2.0s): Closing on E0 together; once all within 5, everyone attacks E0 same tick.\n A2 (2.0s): Attacking E0 now; A0 is already in range, A1 close up and focus E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"In range of all; attacking E0 now.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-e2afee58e8cc0f660b8bde7e.json b/examples/multi-agent-smax/results/llm-cache/ask-e2afee58e8cc0f660b8bde7e.json new file mode 100644 index 00000000..243da8eb --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-e2afee58e8cc0f660b8bde7e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 1.0 seconds into the battle.\nYou are A0, a marine at (11.2, 17.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 16.\nYour team:\n A1 marine at (10.3, 14.7), 45/45 health, order: move 12 15\n A2 marine at (12.5, 14.6), 45/45 health, order: move 12 15\nEnemies you can see:\n E2 marine at (19.7, 16.8), 45/45 health, 8.5 away\nTeam chat (most recent last):\n A0 (0.0s): Advancing east together to (12,16); stay within 2 of each other, attack together.\n A1 (0.0s): Advancing east together to (12,15); stay within 2 of each other, attack same target on contact.\n A2 (0.0s): Advancing east together, staying close. Don't outrun the group; all attack same target.\n A0 (0.5s): Advancing to (12,16), keeping close; will attack same target on contact.\n A1 (0.5s): A1 advancing to (12,15), staying close; will attack same target on contact.\n A2 (0.5s): A2 advancing to (12,15), staying close; will attack same target on contact.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 16\", \"say\": \"Moving together east to (14,16); stay grouped, attack same target on contact.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-e2da9b38b4fa2ee492ff588b.json b/examples/multi-agent-smax/results/llm-cache/ask-e2da9b38b4fa2ee492ff588b.json new file mode 100644 index 00000000..a07e2d8e --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-e2da9b38b4fa2ee492ff588b.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 1.5 seconds into the battle.\nYou are A0, a marine at (13.3, 16.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 16.\nYour team:\n A1 marine at (13.2, 15.3), 45/45 health, order: move 14 16\n A2 marine at (11.2, 16.6), 45/45 health, order: move 14 16\nEnemies you can see:\n E0 marine at (17.8, 15.1), 45/45 health, 4.8 away (in range)\n E1 marine at (19.3, 16.7), 45/45 health, 6.0 away\n E2 marine at (20.6, 17.1), 45/45 health, 7.2 away\nTeam chat (most recent last):\n A1 (0.0s): No enemies seen. Moving east together to (14,16); stay within 2 of each other.\n A2 (0.0s): Moving east together to find enemies; stay within 2 of each other.\n A0 (0.5s): Continuing east to (14,16), staying close; will attack together when enemies appear.\n A1 (0.5s): Continuing east to (14,16), staying close to A0 and A2.\n A2 (0.5s): Moving to (14,16) with A0 and A1, staying close; will focus the first enemy seen.\n A0 (1.0s): Enemy E0 seen east at 7.8. Keep grouped; attack E0 together when within range.\n A1 (1.0s): E0 spotted east at (19.3,15.1). Keep moving together; attack when in range 5 of all.\n A2 (1.0s): A2 continuing to (14,16), staying close; will focus first enemy seen.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 in range of A0 and A1. Attack E0 now; A2 close in and focus E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-e2ed3bf103a3d89697cb5ec6.json b/examples/multi-agent-smax/results/llm-cache/ask-e2ed3bf103a3d89697cb5ec6.json new file mode 100644 index 00000000..39f9bfb6 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-e2ed3bf103a3d89697cb5ec6.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 3.0 seconds into the battle.\nYou are A1, a marine at (6.7, 14.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.9, 15.6), 45/45 health, order: hold\n A2 marine at (8.3, 17.3), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (13.6, 16.8), 45/45 health, 7.4 away\n E1 marine at (15.3, 16.2), 45/45 health, 8.8 away\nTeam chat (most recent last):\n A1 (1.5s): A1 holding. Still no enemies; will focus same target once all in range 5.\n A2 (1.5s): A2 holding. No enemies visible; will focus fire when all within 5.\n A0 (2.0s): A0 holding; no enemies yet. Will focus same target once all within 5.\n A1 (2.0s): A1 holding; no enemies yet. Will attack together once all within 5.\n A2 (2.0s): A2 holding. E0 spotted at (16.8,16.8), 8.5 away. Wait until it's in range 5 of all.\n A0 (2.5s): A0 holding. E0 at 8.4 away; wait until within 5 of all, then focus E0.\n A1 (2.5s): A1 holding. E0 at 8.9 away; wait until in range 5 of all.\n A2 (2.5s): A2 holding. Nearest enemy E0 at 6.9; wait until within 5 of all.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A1 holding. E0 at 7.4; attack E0 together once within 5 of all.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-e311fac78730ff1f91dc5984.json b/examples/multi-agent-smax/results/llm-cache/ask-e311fac78730ff1f91dc5984.json new file mode 100644 index 00000000..186444da --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-e311fac78730ff1f91dc5984.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.5 seconds into the battle.\nYou are A0, a marine at (7.8, 14.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (8.5, 14.8), 45/45 health, order: hold\n A2 marine at (8.2, 14.1), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (15.8, 15.0), 45/45 health, 8.0 away\n E1 marine at (16.6, 14.0), 45/45 health, 8.8 away\n E2 marine at (15.0, 16.8), 45/45 health, 7.5 away\nTeam chat (most recent last):\n A1 (1.0s): A1 at (8,15) holding. Focus fire on closest enemy.\n A2 (1.0s): A2 at (8,14) holding; will focus the closest enemy when it appears.\n A0 (1.5s): A0 holding at (8,15); focus fire on the closest enemy when seen.\n A1 (1.5s): A1 holding at cluster; focus fire on closest enemy when seen.\n A2 (1.5s): A2 holding at (8,14). Clustered; focus fire on closest enemy.\n A0 (2.0s): A0 holding; no enemies seen. Focus closest when they appear.\n A1 (2.0s): Holding cluster; let them walk into range, then focus closest enemy.\n A2 (2.0s): E2 spotted east at 8.7 range. Holding cluster; let them come, focus first in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Enemies approaching; hold cluster, all focus whichever enemy enters range first.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-e3933ecfeedf74ac3b9618fa.json b/examples/multi-agent-smax/results/llm-cache/ask-e3933ecfeedf74ac3b9618fa.json new file mode 100644 index 00000000..eb205b7c --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-e3933ecfeedf74ac3b9618fa.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 5.0 seconds into the battle.\nYou are A1, a marine at (12.9, 17.5) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (13.3, 15.6), 18/45 health, order: attack E0\n A2 marine at (13.7, 16.7), 9/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (17.7, 17.8), 18/45 health, 4.9 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (3.5s): Focusing E1 (27hp). A0 at 18hp, keep firing until E1 dies.\n A2 (3.5s): Focusing E1 (27hp), then E0. A0 at 18hp, keep firing.\n A0 (4.0s): E1 at 9hp, finishing it now, then E0.\n A1 (4.0s): E1 at 9hp, all keep firing until dead, then E0.\n A2 (4.0s): E1 at 9hp, keep firing until dead, then E0.\n A0 (4.5s): E1 dead. All focus E0, it's in range 5.0 now.\n A1 (4.5s): E1 dead. All attack E0 now, it's in range 4.9.\n A2 (4.5s): E1 dead. All focus E0, 4.2 away in range. Keep firing.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Attacking E0 (18hp), keep firing until it dies.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-e3ecfda453a3d042a8d8f8e2.json b/examples/multi-agent-smax/results/llm-cache/ask-e3ecfda453a3d042a8d8f8e2.json new file mode 100644 index 00000000..9b46e3d3 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-e3ecfda453a3d042a8d8f8e2.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 1.0 seconds into the battle.\nYou are A2, a marine at (9.6, 16.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 16.\nYour team:\n A0 marine at (11.7, 16.9), 45/45 health, order: move 14 16\n A1 marine at (11.7, 15.3), 45/45 health, order: move 14 16\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Moving east together toward center, stay within 2 of each other; attack same target when seen.\n A1 (0.0s): No enemies seen. Moving east together to (14,16); stay within 2 of each other.\n A2 (0.0s): Moving east together to find enemies; stay within 2 of each other.\n A0 (0.5s): Continuing east to (14,16), staying close; will attack together when enemies appear.\n A1 (0.5s): Continuing east to (14,16), staying close to A0 and A2.\n A2 (0.5s): Moving to (14,16) with A0 and A1, staying close; will focus the first enemy seen.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 16\", \"say\": \"A2 continuing to (14,16), staying close; will focus first enemy seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-e3fff1cf9dbd5ea9b88ba26e.json b/examples/multi-agent-smax/results/llm-cache/ask-e3fff1cf9dbd5ea9b88ba26e.json new file mode 100644 index 00000000..ec4843b8 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-e3fff1cf9dbd5ea9b88ba26e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 3.5 seconds into the battle.\nYou are A2, a marine at (13.7, 16.7) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (13.3, 15.6), 18/45 health, order: attack E1\n A1 marine at (12.9, 17.5), 27/45 health, order: attack E1\nEnemies you can see:\n E0 marine at (17.7, 17.8), 45/45 health, 4.2 away (in range)\n E1 marine at (16.9, 14.5), 27/45 health, 3.9 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (2.0s): All three in range of E2 now. Attack E2 together.\n A2 (2.0s): E2 and E1 in my range; attacking E2 now, everyone focus E2.\n A0 (2.5s): E2 at 9hp, finish it now; then focus E1.\n A1 (2.5s): Focusing E2 (9hp), it dies soon; then we focus E0.\n A2 (2.5s): E2 at 9hp, finishing it now. Then focus E1.\n A0 (3.0s): E2 dead. Focus E1 (closest, 3.7 away), then E0.\n A1 (3.0s): E2 dead. Everyone focus E1 now, then E0.\n A2 (3.0s): E2 dead. Everyone focus E1 now, closest at 3.9.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Focusing E1 (27hp), then E0. A0 at 18hp, keep firing.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-e4aa4deb8df53a66bb5fca81.json b/examples/multi-agent-smax/results/llm-cache/ask-e4aa4deb8df53a66bb5fca81.json new file mode 100644 index 00000000..bf3f3e5d --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-e4aa4deb8df53a66bb5fca81.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 1.5 seconds into the battle.\nYou are A2, a marine at (13.2, 16.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 16 17.\nYour team:\n A0 marine at (13.3, 18.0), 45/45 health, order: move 14 17\n A1 marine at (13.3, 17.2), 45/45 health, order: move 14 17\nEnemies you can see:\n E0 marine at (19.3, 16.4), 45/45 health, 6.2 away\n E1 marine at (20.1, 17.3), 45/45 health, 7.1 away\n E2 marine at (20.7, 14.8), 45/45 health, 7.6 away\nTeam chat (most recent last):\n A1 (0.0s): Moving east together toward enemies; keep within 2 of each other, attack together.\n A2 (0.0s): Moving east together toward enemies, stay within 2 of each other; attack same target on call.\n A0 (0.5s): Moving east together, keeping formation; will attack same target when all in range.\n A1 (0.5s): Moving east in formation at x=12; no one engages alone.\n A2 (0.5s): Moving east, staying close; A0 at 12,17 is my anchor point.\n A0 (1.0s): Advancing east together to x=14; will call attack when enemies appear.\n A1 (1.0s): Advancing east to 14,17 together; no one engages until all in range.\n A2 (1.0s): Moving east together to x=16; will attack same target once all in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 17\", \"say\": \"Regrouping at 14,17; closest enemy 6 away, hold formation, then attack E0 together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-e4b64264916939c09e718988.json b/examples/multi-agent-smax/results/llm-cache/ask-e4b64264916939c09e718988.json new file mode 100644 index 00000000..7ae42bb0 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-e4b64264916939c09e718988.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 6.0 seconds into the battle.\nYou are A2, a marine at (14.6, 17.4) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (15.0, 18.1), 18/45 health, order: attack E2\n A1: dead\nEnemies you can see:\n E2 marine at (17.5, 14.8), 27/45 health, 3.9 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (4.0s): Keep focusing E1 (27hp), both firing together.\n A2 (4.0s): Focusing E1 (27hp), both in range. Keep firing, then E2.\n A0 (4.5s): E1 at 9hp, finish it now, then both focus E2.\n A2 (4.5s): E1 at 9hp, finishing it now. Then both on E2.\n A0 (5.0s): E1 dead. Both attack E2 now, A2 is closest so keep firing.\n A2 (5.0s): E1 down. Focus E2 together; I'm closest so I tank, A0 keep firing.\n A0 (5.5s): Attacking E2. A2 is closest and tanking, so keep firing until it dies.\n A2 (5.5s): Both firing on E2 now, keep attacking until it dies.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 at 27hp. Both keep firing, two volleys should kill it.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-e4c03fed07c8c2eb98277fef.json b/examples/multi-agent-smax/results/llm-cache/ask-e4c03fed07c8c2eb98277fef.json new file mode 100644 index 00000000..818f2f70 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-e4c03fed07c8c2eb98277fef.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 6.0 seconds into the battle.\nYou are A0, a marine at (11.1, 16.2) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: retreat.\nYour team:\n A1 marine at (9.9, 15.5), 18/45 health, order: retreat\n A2: dead\nEnemies you can see:\n E0 marine at (16.6, 17.3), 27/45 health, 5.7 away\n E2 marine at (16.8, 14.1), 45/45 health, 6.1 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (4.0s): Focusing E0 (36hp). A1 stay back; I'm tanking, then we take E2.\n A1 (4.0s): A1 18hp retreating; A0 you're closest, focus E0 (36hp), I'll return when safe.\n A0 (4.5s): A0 firing E0 (27hp), tanking. A1 stay back, then we take E2.\n A1 (4.5s): A1 18hp staying back; A0 kill E0 (27hp), then E2.\n A0 (5.0s): A0 at 9hp retreating. A1 you hold and shoot closest; we regroup and focus E0.\n A1 (5.0s): A1 joining now, both focus E0 (27hp) to split their fire.\n A0 (5.5s): A0 9hp retreating; A1 focus E0 (27hp), I return if enemies shift.\n A1 (5.5s): A1 18hp retreating with A0; regroup and focus E0 only when both in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"retreat\", \"say\": \"A0 9hp retreating west; A1 stay with me, regroup before engaging E0 (27hp).\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-e5675f4c7208ba20d06989e3.json b/examples/multi-agent-smax/results/llm-cache/ask-e5675f4c7208ba20d06989e3.json new file mode 100644 index 00000000..8d896fb8 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-e5675f4c7208ba20d06989e3.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.0 seconds into the battle.\nYou are A2, a marine at (6.5, 16.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.6, 16.9), 45/45 health, order: hold\n A1 marine at (8.5, 15.3), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.5s): A1 holding; will focus fire on the closest enemy that appears.\n A2 (0.5s): No enemies yet; staying grouped, will focus the closest one when seen.\n A0 (1.0s): Still no enemies; holding grouped, focus closest when seen.\n A1 (1.0s): A1 holding; no enemies yet, will focus the closest when seen.\n A2 (1.0s): A2 holding; will focus the closest enemy when it appears.\n A0 (1.5s): A0 holding; still no enemies. Focus the closest when they appear.\n A1 (1.5s): A1 holding; no enemies yet, focus closest when seen.\n A2 (1.5s): A2 holding; will focus fire on the closest enemy when seen.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A2 holding; will focus the closest enemy when it appears.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-e5683c0ffe99c8027e37b075.json b/examples/multi-agent-smax/results/llm-cache/ask-e5683c0ffe99c8027e37b075.json new file mode 100644 index 00000000..4c366ad0 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-e5683c0ffe99c8027e37b075.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 5.5 seconds into the battle.\nYou are A2, a marine at (12.8, 14.9) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (14.3, 16.0), 18/45 health, order: attack E2\n A1: dead\nEnemies you can see:\n E1 marine at (16.5, 16.2), 45/45 health, 4.0 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (3.5s): Both on E2 together, then E1. Keep firing, no retreat.\n A2 (3.5s): Attacking E2 together; keep firing until it dies.\n A0 (4.0s): Keep firing on E2, then E1. No retreat.\n A2 (4.0s): Keep firing on E2 until dead, then E1.\n A0 (4.5s): E2 at 9hp, keep firing together, then E1.\n A2 (4.5s): E2 at 9hp, finish it now, then E1.\n A0 (5.0s): E2 at 9hp, finish it now together, then E1.\n A2 (5.0s): E2 at 9hp, keep firing together, then E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E2 dead. Both attack E1 now, keep firing together, no retreat.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-e57809f49c6ab3c315fc90b3.json b/examples/multi-agent-smax/results/llm-cache/ask-e57809f49c6ab3c315fc90b3.json new file mode 100644 index 00000000..99418caa --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-e57809f49c6ab3c315fc90b3.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.5 seconds into the battle.\nYou are A0, a marine at (9.0, 16.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (7.4, 14.1), 45/45 health, order: hold\n A2 marine at (7.7, 14.8), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on closest enemy when they appear.\n A0 (0.5s): No enemies yet. Staying grouped; focus fire on closest when they appear.\n A1 (0.5s): Holding; will focus fire on closest enemy once in range.\n A2 (0.5s): Holding position; focus fire on closest enemy once in range.\n A0 (1.0s): Holding; still no enemies. Focus fire closest when they appear.\n A1 (1.0s): Holding; no enemies in sight. Focus fire closest when they appear.\n A2 (1.0s): Still holding; no enemies visible. Focus fire on closest when they appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding near A1/A2; focus fire closest enemy when in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-e5ace1ae05f1d64457097e06.json b/examples/multi-agent-smax/results/llm-cache/ask-e5ace1ae05f1d64457097e06.json new file mode 100644 index 00000000..eee21dc2 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-e5ace1ae05f1d64457097e06.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 7.0 seconds into the battle.\nYou are A2, a marine at (12.8, 14.9) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0: dead\n A1: dead\nEnemies you can see:\n E1 marine at (16.5, 16.2), 9/45 health, 4.0 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A2 (4.5s): E2 at 9hp, finish it now, then E1.\n A0 (5.0s): E2 at 9hp, finish it now together, then E1.\n A2 (5.0s): E2 at 9hp, keep firing together, then E1.\n A0 (5.5s): E2 is dead. Both attack E1 now, keep firing.\n A2 (5.5s): E2 dead. Both attack E1 now, keep firing together, no retreat.\n A0 (6.0s): Focus E1 (27hp), keep firing together until it dies.\n A2 (6.0s): Attacking E1 (27hp), keep firing together, last enemy.\n A2 (6.5s): A0 and A1 are dead; I'm at 18hp, E1 at 18hp. Firing on E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Last enemy E1 at 9hp, firing.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-e5f348e8c474808f2ad9213d.json b/examples/multi-agent-smax/results/llm-cache/ask-e5f348e8c474808f2ad9213d.json new file mode 100644 index 00000000..976a9696 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-e5f348e8c474808f2ad9213d.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.0 seconds into the battle.\nYou are A2, a marine at (8.9, 16.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 10 17.\nYour team:\n A0 marine at (8.5, 15.6), 45/45 health, order: move 9 16.5\n A1 marine at (8.1, 17.5), 45/45 health, order: move 8 16.5\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together at the cluster; focus fire on the closest enemy when they appear.\n A1 (0.0s): Advancing east together; stay close and focus fire on the nearest enemy.\n A2 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A0 (0.5s): A1 fell back toward cluster; I'm moving to x=9 so we stay grouped.\n A1 (0.5s): Falling back to cluster; hold together and focus the closest enemy.\n A2 (0.5s): A1 is ahead alone; moving up to group with A1, then focus nearest enemy.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding at cluster near (9,16.7); focus fire on the closest enemy.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-e6744a7059be663f154fc747.json b/examples/multi-agent-smax/results/llm-cache/ask-e6744a7059be663f154fc747.json new file mode 100644 index 00000000..94473daa --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-e6744a7059be663f154fc747.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 9.0 seconds into the battle.\nYou are A0, a marine at (4.8, 16.2) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1: dead\n A2: dead\nEnemies you can see:\n E0 marine at (8.8, 17.3), 18/45 health, 4.1 away (in range)\n E2 marine at (9.0, 14.1), 45/45 health, 4.7 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (7.0s): A0 9hp still retreating west; A1 stay with me, out of range.\n A1 (7.0s): A1 18hp retreating west; enemies 7 away, out of range. Stay together.\n A0 (7.5s): A0 9hp retreating west; A1 stay with me, out of range of E0 and E2.\n A1 (7.5s): A1 18hp retreating west; staying with A0, out of range.\n A0 (8.0s): A0 9hp retreating west; A1 keep retreating, stay out of range.\n A1 (8.0s): Cornered at west edge. Both focus E0 (27hp) now, then E2.\n A0 (8.5s): A0 9hp joining: focus E0 (27hp) together, then E2.\n A1 (8.5s): Cornered. Focusing E0 (27hp), A0 fire E0 too, then E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"A0 last alive, 9hp, finishing E0 (18hp).\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-e6a80ae9f4257ac2049a665b.json b/examples/multi-agent-smax/results/llm-cache/ask-e6a80ae9f4257ac2049a665b.json new file mode 100644 index 00000000..508eaca9 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-e6a80ae9f4257ac2049a665b.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 0.0 seconds into the battle.\nYou are A1, a marine at (7.2, 17.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.5, 15.8), 45/45 health, order: hold\n A2 marine at (7.6, 17.8), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 11 17\", \"say\": \"Moving east together to find enemies; stay within 2 of each other, fire together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-e6daab57328667318ef1caf2.json b/examples/multi-agent-smax/results/llm-cache/ask-e6daab57328667318ef1caf2.json new file mode 100644 index 00000000..1b07d29b --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-e6daab57328667318ef1caf2.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 2.0 seconds into the battle.\nYou are A0, a marine at (13.3, 15.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 16.5.\nYour team:\n A1 marine at (12.9, 17.5), 36/45 health, order: attack E2\n A2 marine at (13.7, 16.7), 45/45 health, order: move 14 16.5\nEnemies you can see:\n E0 marine at (19.1, 17.6), 45/45 health, 6.2 away\n E1 marine at (16.9, 14.5), 45/45 health, 3.7 away (in range)\n E2 marine at (17.8, 17.2), 36/45 health, 4.8 away (in range)\nTeam chat (most recent last):\n A1 (0.5s): Continuing east together; will all attack same enemy on contact.\n A2 (0.5s): Continuing east together; no enemies seen yet, will focus same target on contact.\n A0 (1.0s): Continuing east together; no enemies yet, will focus same target on contact.\n A1 (1.0s): Moving to 14,16.5 with the group; will attack E2 together when in range.\n A2 (1.0s): Enemy E2 seen at 19.3,17.2. Keep formation, advance together, then all attack E2.\n A0 (1.5s): Enemies 6-7 away; keep advancing together, then all attack E2 at range 5.\n A1 (1.5s): E2 in my range; A0, A2 close in and focus E2 now.\n A2 (1.5s): Staying together; E2 nearly in range. All attack E2 once everyone is within 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 in my range 4.8; attacking E2 now, everyone focus E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-e73c16ca1d8146c59b5741dd.json b/examples/multi-agent-smax/results/llm-cache/ask-e73c16ca1d8146c59b5741dd.json new file mode 100644 index 00000000..241e1d57 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-e73c16ca1d8146c59b5741dd.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.5 seconds into the battle.\nYou are A2, a marine at (7.6, 17.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.9, 16.7), 45/45 health, order: hold\n A1 marine at (7.8, 14.9), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (14.5, 15.3), 45/45 health, 7.3 away\nTeam chat (most recent last):\n A1 (1.0s): A1 holding; will focus closest enemy. Staying near A0 and A2.\n A2 (1.0s): A2 holding; no enemies seen yet, will focus closest when they appear.\n A0 (1.5s): A0 holding. Stay clustered; focus fire on closest enemy when seen.\n A1 (1.5s): A1 moving to cluster with A0/A2; holding together, focus closest enemy.\n A2 (1.5s): A2 holding; no enemies yet. Focus closest when they appear.\n A0 (2.0s): A0 holding. Focus closest enemy when seen; stay tight.\n A1 (2.0s): A1 holding near cluster; E0 spotted east at (16,15.3). Focus E0 when in range.\n A2 (2.0s): E0 seen east at 16,15. Holding clustered; focus E0 when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A2 holding; E0 approaching, focus it when in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-e785b0c2183aa767b4e6f278.json b/examples/multi-agent-smax/results/llm-cache/ask-e785b0c2183aa767b4e6f278.json new file mode 100644 index 00000000..7523d4aa --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-e785b0c2183aa767b4e6f278.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.0 seconds into the battle.\nYou are A0, a marine at (9.3, 15.3) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1 marine at (8.3, 14.2), 45/45 health, order: attack E1\n A2: dead\nEnemies you can see:\n E1 marine at (12.2, 16.1), 9/45 health, 3.0 away (in range)\n E2 marine at (12.3, 17.5), 45/45 health, 3.8 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A2 (4.0s): A2 firing on E0 (27hp); finish it, then E1.\n A0 (4.5s): A0 firing E0 (18hp), finish it then E1.\n A1 (4.5s): A1 shooting E1 (36hp). E0 at 18hp, finish it, then all E1.\n A2 (4.5s): A2 9hp, still firing on E0 (18hp). A0 finish E0, then E1.\n A0 (5.0s): A0 firing E1 (27hp), A1 same. Focus E1 then E2.\n A1 (5.0s): A1 hitting E1 (27hp, in range). A0 switch to E1, then E2.\n A0 (5.5s): A0 18hp firing E1 (18hp). Finish E1, then all E2.\n A1 (5.5s): A1 on E1 (18hp). A0 keep firing E1, then E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A0 9hp, finishing E1 (9hp). Then focus E2 together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-e788d2632c2228ef13742389.json b/examples/multi-agent-smax/results/llm-cache/ask-e788d2632c2228ef13742389.json new file mode 100644 index 00000000..73db03b6 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-e788d2632c2228ef13742389.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 0.0 seconds into the battle.\nYou are A0, a marine at (9.0, 16.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (7.4, 14.1), 45/45 health, order: hold\n A2 marine at (7.7, 14.8), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 11 16\", \"say\": \"Advancing east together; stay within 2 of each other, A1 and A2 keep pace.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-e7902cfeb5008f860231fc2e.json b/examples/multi-agent-smax/results/llm-cache/ask-e7902cfeb5008f860231fc2e.json new file mode 100644 index 00000000..b5219f47 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-e7902cfeb5008f860231fc2e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.5 seconds into the battle.\nYou are A2, a marine at (7.7, 14.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (9.0, 16.0), 45/45 health, order: hold\n A1 marine at (7.4, 14.1), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on closest enemy when they appear.\n A0 (0.5s): No enemies yet. Staying grouped; focus fire on closest when they appear.\n A1 (0.5s): Holding; will focus fire on closest enemy once in range.\n A2 (0.5s): Holding position; focus fire on closest enemy once in range.\n A0 (1.0s): Holding; still no enemies. Focus fire closest when they appear.\n A1 (1.0s): Holding; no enemies in sight. Focus fire closest when they appear.\n A2 (1.0s): Still holding; no enemies visible. Focus fire on closest when they appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding grouped; focus fire on closest enemy when it appears.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-e83c633cb97e22fa99a7be83.json b/examples/multi-agent-smax/results/llm-cache/ask-e83c633cb97e22fa99a7be83.json new file mode 100644 index 00000000..7c5d8178 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-e83c633cb97e22fa99a7be83.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 0.5 seconds into the battle.\nYou are A0, a marine at (8.5, 15.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 16.5.\nYour team:\n A1 marine at (9.7, 17.5), 45/45 health, order: move 14 17\n A2 marine at (8.9, 16.7), 45/45 health, order: move 14 16.5\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Moving east together toward center; stay within 2 of each other, attack same target.\n A1 (0.0s): Moving east together toward center, stay within 2 of each other.\n A2 (0.0s): Moving east together toward center, stay close, all engage same enemy on contact.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 16.5\", \"say\": \"Continuing east together; hold formation, all attack same target on contact.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-e909d87324a51a6e285e4a9f.json b/examples/multi-agent-smax/results/llm-cache/ask-e909d87324a51a6e285e4a9f.json new file mode 100644 index 00000000..61788c8f --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-e909d87324a51a6e285e4a9f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 7.5 seconds into the battle.\nYou are A0, a marine at (8.5, 16.7) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1: dead\n A2 marine at (9.2, 17.8), 9/45 health, order: attack E1\nEnemies you can see:\n E1 marine at (12.3, 15.6), 27/45 health, 3.9 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (5.5s): A1 firing E2 from back; A0 is closest, keep tanking. Focus E2.\n A2 (5.5s): A2 on E2 (27hp), keep focusing. A1 stay back.\n A0 (6.0s): A0 on E2 (9hp), finishing it. Then all E1.\n A2 (6.0s): A2 on E2 (9hp), nearly dead. Then E1 together.\n A0 (6.5s): A0 finishing E2 now. Then all on E1.\n A2 (6.5s): A2 finishing E2 (9hp). Then both on E1.\n A0 (7.0s): E2 down. A0 and A2 all on E1, 36hp.\n A2 (7.0s): E2 down. A2 on E1, A0 keep tanking, I'm at 9hp.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A0 tanking, attacking E1 (27hp). A2 stay behind me and keep firing.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-e90d3995c503bae7a9cdbc57.json b/examples/multi-agent-smax/results/llm-cache/ask-e90d3995c503bae7a9cdbc57.json new file mode 100644 index 00000000..5c3e7456 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-e90d3995c503bae7a9cdbc57.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 9.0 seconds into the battle.\nYou are A0, a marine at (7.8, 14.7) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1: dead\n A2: dead\nEnemies you can see:\n E1 marine at (11.9, 14.0), 18/45 health, 4.1 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A2 (5.5s): Firing E0 (27hp), then E1. I'm low, keep fire together.\n A0 (6.0s): E0 at 9hp, kill it now, then E1. Fire together.\n A2 (6.0s): E0 at 9hp, finishing it now. Then all focus E1.\n A0 (6.5s): A0 alone vs E1, firing now.\n A0 (7.0s): A0 alone vs E1, firing. Last enemy.\n A0 (7.5s): A0 last unit, still firing on E1.\n A0 (8.0s): A0 last unit, 18hp vs E1 36hp, still firing.\n A0 (8.5s): A0 last unit, 18hp vs E1 27hp, still firing.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A0 last unit, 9hp vs E1 18hp, still firing.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-e90d8ba78746b58d74448546.json b/examples/multi-agent-smax/results/llm-cache/ask-e90d8ba78746b58d74448546.json new file mode 100644 index 00000000..0455cd1a --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-e90d8ba78746b58d74448546.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 0.5 seconds into the battle.\nYou are A0, a marine at (10.2, 16.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 16.\nYour team:\n A1 marine at (10.1, 15.3), 45/45 health, order: move 14 16\n A2 marine at (8.1, 16.6), 45/45 health, order: move 12 16\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Moving east together toward center, stay within 2 of each other; attack same target when seen.\n A1 (0.0s): No enemies seen. Moving east together to (14,16); stay within 2 of each other.\n A2 (0.0s): Moving east together to find enemies; stay within 2 of each other.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 16\", \"say\": \"Continuing east to (14,16), staying close; will attack together when enemies appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-e92457c01ba06b6b60fc92b9.json b/examples/multi-agent-smax/results/llm-cache/ask-e92457c01ba06b6b60fc92b9.json new file mode 100644 index 00000000..64d911cc --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-e92457c01ba06b6b60fc92b9.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.0 seconds into the battle.\nYou are A2, a marine at (7.7, 14.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (9.0, 16.0), 45/45 health, order: hold\n A1 marine at (7.4, 14.1), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding together; focus fire on closest enemy when they appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ea3cdc5f92f9c0e37edaf0a0.json b/examples/multi-agent-smax/results/llm-cache/ask-ea3cdc5f92f9c0e37edaf0a0.json new file mode 100644 index 00000000..5561a307 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ea3cdc5f92f9c0e37edaf0a0.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.0 seconds into the battle.\nYou are A2, a marine at (9.4, 16.4) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (8.8, 17.1), 9/45 health, order: attack E2\n A1 marine at (8.5, 15.3), 27/45 health, order: attack E1\nEnemies you can see:\n E1 marine at (12.9, 16.5), 27/45 health, 3.5 away (in range)\n E2 marine at (12.8, 17.3), 45/45 health, 3.5 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (3.5s): A1 focusing E0 (27hp), in range. A2 please attack E0 too.\n A2 (3.5s): A2 attacking E0, closing in to focus fire.\n A0 (4.0s): E0 at 9hp, finish it, then focus E2.\n A1 (4.0s): A1 attacking E0 (9hp), finish it then switch to E1.\n A2 (4.0s): A2 closing on E0 (9hp), then focus E1.\n A0 (4.5s): E0 dead. A0 on E2, all focus E2 please.\n A1 (4.5s): E0 dead. Focus E1 (4.5 away), then E2.\n A2 (4.5s): E0 dead. A2 focusing E1, everyone focus E1 then E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A2 on E1 (27hp), in range. A0 retreat if low, A1 focus E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ea73979b3c730c69db4d326e.json b/examples/multi-agent-smax/results/llm-cache/ask-ea73979b3c730c69db4d326e.json new file mode 100644 index 00000000..3a980356 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ea73979b3c730c69db4d326e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.5 seconds into the battle.\nYou are A0, a marine at (6.9, 16.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (7.8, 14.9), 45/45 health, order: hold\n A2 marine at (7.6, 17.8), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (14.5, 15.3), 45/45 health, 7.7 away\nTeam chat (most recent last):\n A1 (1.0s): A1 holding; will focus closest enemy. Staying near A0 and A2.\n A2 (1.0s): A2 holding; no enemies seen yet, will focus closest when they appear.\n A0 (1.5s): A0 holding. Stay clustered; focus fire on closest enemy when seen.\n A1 (1.5s): A1 moving to cluster with A0/A2; holding together, focus closest enemy.\n A2 (1.5s): A2 holding; no enemies yet. Focus closest when they appear.\n A0 (2.0s): A0 holding. Focus closest enemy when seen; stay tight.\n A1 (2.0s): A1 holding near cluster; E0 spotted east at (16,15.3). Focus E0 when in range.\n A2 (2.0s): E0 seen east at 16,15. Holding clustered; focus E0 when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A0 holding. Only E0 seen; let it come into range, focus fire together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-eaa79b2723d580d33593e49f.json b/examples/multi-agent-smax/results/llm-cache/ask-eaa79b2723d580d33593e49f.json new file mode 100644 index 00000000..cbb8c8a4 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-eaa79b2723d580d33593e49f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 7.5 seconds into the battle.\nYou are A1, a marine at (9.8, 14.2) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E2 marine at (10.8, 17.5), 36/45 health, 3.5 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (5.0s): A0 firing E1 (27hp), A1 same. Focus E1 then E2.\n A1 (5.0s): A1 hitting E1 (27hp, in range). A0 switch to E1, then E2.\n A0 (5.5s): A0 18hp firing E1 (18hp). Finish E1, then all E2.\n A1 (5.5s): A1 on E1 (18hp). A0 keep firing E1, then E2.\n A0 (6.0s): A0 9hp, finishing E1 (9hp). Then focus E2 together.\n A1 (6.0s): A1 on E1 (9hp), finishing it. Then all E2.\n A1 (6.5s): A1 alone vs E2 (45hp), engaging.\n A1 (7.0s): A1 alone vs E2 (45hp), still firing.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"A1 36hp vs E2 36hp, still firing.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-eb3b7468b14ee33b5aa918f4.json b/examples/multi-agent-smax/results/llm-cache/ask-eb3b7468b14ee33b5aa918f4.json new file mode 100644 index 00000000..09bd4b8e --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-eb3b7468b14ee33b5aa918f4.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 8.5 seconds into the battle.\nYou are A1, a marine at (6.8, 14.1) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (8.1, 15.8), 9/45 health, order: attack E0\n A2: dead\nEnemies you can see:\n E0 marine at (12.9, 15.0), 9/45 health, 6.2 away\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (7.0s): E1 down. All focus E0 now, A1 join in.\n A1 (7.0s): A1 9hp holding; will shoot anything that closes in. Finish E1, then E0.\n A2 (7.0s): E1 down. All focus E0; I'm closest and tanking, A0 and A1 fire.\n A0 (7.5s): A0 firing E0 (27hp). A1 close in and shoot, all focus fire.\n A1 (7.5s): A1 joining on E0, A2 stays closest and tanks.\n A2 (7.5s): E0 at 27hp, 4.8 away. A0, A1 fire now; focus E0.\n A0 (8.0s): A0 firing E0 (18hp), 4.8 away. A1 fire too, finish it.\n A1 (8.0s): A1 closing on E0 (18hp). A0, focus fire to finish it.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"A1 closing on E0 (9hp), A0 fire together to finish it.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-eb6d6c1efbccf38890f84aee.json b/examples/multi-agent-smax/results/llm-cache/ask-eb6d6c1efbccf38890f84aee.json new file mode 100644 index 00000000..e246baa3 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-eb6d6c1efbccf38890f84aee.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 0.0 seconds into the battle.\nYou are A1, a marine at (7.1, 14.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.1, 17.5), 45/45 health, order: hold\n A2 marine at (9.4, 14.6), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 15\", \"say\": \"Advancing east together to (12,15); stay within 2 of each other, attack same target on contact.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-eba72505f448f18df2fa20b3.json b/examples/multi-agent-smax/results/llm-cache/ask-eba72505f448f18df2fa20b3.json new file mode 100644 index 00000000..b35e84de --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-eba72505f448f18df2fa20b3.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.5 seconds into the battle.\nYou are A1, a marine at (7.2, 17.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.5, 15.8), 45/45 health, order: hold\n A2 marine at (7.6, 17.8), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (14.3, 17.1), 45/45 health, 7.1 away\n E1 marine at (13.1, 17.1), 45/45 health, 6.0 away\n E2 marine at (11.0, 16.7), 45/45 health, 3.9 away (in range)\nTeam chat (most recent last):\n A1 (2.0s): E2 spotted east at 8.6 range. Holding grouped; focus E2 when in range.\n A2 (2.0s): E2 spotted at (15.8,16.7), 8 away. Holding grouped; focus E2 when in range.\n A0 (2.5s): E1, E2 approaching. Holding grouped; focus E2 when within 5.\n A1 (2.5s): E2 at 7 range. Holding grouped; focus E2 once in range.\n A2 (2.5s): E2 at 6.7, E1 behind. Holding grouped; focus closest when in range.\n A0 (3.0s): A0 holding; E2 at 5.2, focus E2 the moment it enters range.\n A1 (3.0s): E2 at 5.5, nearly in range. Holding; all focus E2 when it enters 5.\n A2 (3.0s): E2 at 5.1, nearly in range. Holding, all fire on E2 first.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 in range at 3.9. Everyone fire on E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ebd6b3514d10a77bda984601.json b/examples/multi-agent-smax/results/llm-cache/ask-ebd6b3514d10a77bda984601.json new file mode 100644 index 00000000..0b933ac9 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ebd6b3514d10a77bda984601.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 7.0 seconds into the battle.\nYou are A1, a marine at (3.6, 14.1) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.1, 15.8), 9/45 health, order: attack E1\n A2 marine at (8.1, 14.9), 18/45 health, order: attack E1\nYou see no enemies.\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (5.5s): A1 at 9hp staying back; focus E1 then E0.\n A2 (5.5s): Firing E1 (27hp). A0 keep focus, then E0. A1 stay back.\n A0 (6.0s): Firing E1 (9hp), nearly dead. Then E0 together.\n A1 (6.0s): A1 9hp holding back; E1 is at 9hp, finish it then E0.\n A2 (6.0s): Firing E1 (9hp), nearly dead. Then E0 together.\n A0 (6.5s): Firing E1 (9hp), finishing it. Then E0 together.\n A1 (6.5s): A1 holding back at 9hp; will shoot anything that closes in.\n A2 (6.5s): Finishing E1 (9hp) now, then all focus E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A1 9hp holding; will shoot anything that closes in. Finish E1, then E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ebd946d841a600db9e27da78.json b/examples/multi-agent-smax/results/llm-cache/ask-ebd946d841a600db9e27da78.json new file mode 100644 index 00000000..2b40f2bb --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ebd946d841a600db9e27da78.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.0 seconds into the battle.\nYou are A0, a marine at (8.8, 17.1) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1 marine at (8.5, 15.3), 27/45 health, order: attack E1\n A2 marine at (9.4, 16.4), 45/45 health, order: attack E1\nEnemies you can see:\n E1 marine at (12.9, 16.5), 27/45 health, 4.1 away (in range)\n E2 marine at (12.8, 17.3), 45/45 health, 4.0 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (3.5s): A1 focusing E0 (27hp), in range. A2 please attack E0 too.\n A2 (3.5s): A2 attacking E0, closing in to focus fire.\n A0 (4.0s): E0 at 9hp, finish it, then focus E2.\n A1 (4.0s): A1 attacking E0 (9hp), finish it then switch to E1.\n A2 (4.0s): A2 closing on E0 (9hp), then focus E1.\n A0 (4.5s): E0 dead. A0 on E2, all focus E2 please.\n A1 (4.5s): E0 dead. Focus E1 (4.5 away), then E2.\n A2 (4.5s): E0 dead. A2 focusing E1, everyone focus E1 then E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"A0 switching to E1 (27hp), focus fire. A2 is tanking.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ebe2903124f79d0af9bcf89d.json b/examples/multi-agent-smax/results/llm-cache/ask-ebe2903124f79d0af9bcf89d.json new file mode 100644 index 00000000..2a26956e --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ebe2903124f79d0af9bcf89d.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 1.0 seconds into the battle.\nYou are A2, a marine at (10.8, 14.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 15.\nYour team:\n A0 marine at (12.2, 16.0), 45/45 health, order: move 12 15\n A1 marine at (10.5, 14.1), 45/45 health, order: move 12 15\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Advancing east together; stay within 2 of each other, A1 and A2 keep pace.\n A1 (0.0s): Moving east together toward center, stay within 2 of each other.\n A2 (0.0s): Moving together to center, stay within 2 of each other; attack same target when in range.\n A0 (0.5s): Moving east, staying close; A1 and A2 keep within 2 of me.\n A1 (0.5s): Advancing east, staying close; will all attack same target when enemies appear.\n A2 (0.5s): Keeping pace east, staying close; will focus same target once in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 15\", \"say\": \"Continuing east to 14,15, staying close; will focus same target when enemies appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ec224704986402dfd134cbd2.json b/examples/multi-agent-smax/results/llm-cache/ask-ec224704986402dfd134cbd2.json new file mode 100644 index 00000000..d8b3943e --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ec224704986402dfd134cbd2.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.5 seconds into the battle.\nYou are A2, a marine at (9.4, 16.4) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (8.8, 17.1), 18/45 health, order: attack E0\n A1 marine at (8.5, 15.3), 27/45 health, order: attack E0\nEnemies you can see:\n E1 marine at (12.9, 16.5), 45/45 health, 3.5 away (in range)\n E2 marine at (12.8, 17.3), 45/45 health, 3.5 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (3.0s): E0 in range at 4.5, all focus fire E0 now.\n A2 (3.0s): A2 holding; focus E0 when in range.\n A0 (3.5s): A0 focusing E0 (27hp). A2 attack E0 too, don't hold.\n A1 (3.5s): A1 focusing E0 (27hp), in range. A2 please attack E0 too.\n A2 (3.5s): A2 attacking E0, closing in to focus fire.\n A0 (4.0s): E0 at 9hp, finish it, then focus E2.\n A1 (4.0s): A1 attacking E0 (9hp), finish it then switch to E1.\n A2 (4.0s): A2 closing on E0 (9hp), then focus E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E0 dead. A2 focusing E1, everyone focus E1 then E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ec3c6eeec40ce9dc539c6dce.json b/examples/multi-agent-smax/results/llm-cache/ask-ec3c6eeec40ce9dc539c6dce.json new file mode 100644 index 00000000..771294c6 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ec3c6eeec40ce9dc539c6dce.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 4.5 seconds into the battle.\nYou are A1, a marine at (11.4, 15.5) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: retreat.\nYour team:\n A0 marine at (14.2, 16.2), 27/45 health, order: attack E0\n A2: dead\nEnemies you can see:\n E0 marine at (18.2, 17.3), 27/45 health, 7.0 away\n E2 marine at (18.4, 14.1), 45/45 health, 7.1 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (2.5s): Firing on E1 (27hp). A2 at 18hp, retreat if under 20.\n A2 (2.5s): A2 at 18hp retreating to pull fire off me; A0, A1 keep focusing E1.\n A0 (3.0s): E1 at 9hp, finish it now; then focus E0.\n A1 (3.0s): E1 at 9hp, finishing it now. A0 fire E1, then focus E2.\n A0 (3.5s): E1 dead. A0 focusing E0; A1 under 20hp, retreat to pull fire.\n A1 (3.5s): A1 at 18hp retreating so A0 is closest; A0 focus E2, I return when safe.\n A0 (4.0s): Focusing E0 (36hp). A1 stay back; I'm tanking, then we take E2.\n A1 (4.0s): A1 18hp retreating; A0 you're closest, focus E0 (36hp), I'll return when safe.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"retreat\", \"say\": \"A1 18hp staying back; A0 kill E0 (27hp), then E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ecd219d30ca6f0f1555cfee8.json b/examples/multi-agent-smax/results/llm-cache/ask-ecd219d30ca6f0f1555cfee8.json new file mode 100644 index 00000000..34ccf344 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ecd219d30ca6f0f1555cfee8.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.0 seconds into the battle.\nYou are A1, a marine at (8.9, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (10.6, 16.0), 9/45 health, order: attack E2\n A2 marine at (10.8, 14.8), 18/45 health, order: attack E2\nEnemies you can see:\n E1 marine at (13.1, 16.8), 45/45 health, 5.0 away (in range)\n E2 marine at (13.1, 15.5), 9/45 health, 4.4 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (4.5s): Firing E0 (18hp left), then switch to E2 together.\n A2 (4.5s): E0 at 18 hp, keep firing E0, then E2.\n A0 (5.0s): E0 dead. Focus E2 together, then E1.\n A1 (5.0s): E0 dead. Focus E2 (4.4 away, 45hp), everyone fire E2 together.\n A2 (5.0s): E0 dead. All focus E2, closest at 2.3, then E1.\n A0 (5.5s): E2 at 18hp, all fire E2 now, then E1.\n A1 (5.5s): Firing E2 (18hp), then E1 together.\n A2 (5.5s): Keep firing E2 (18hp), then E1 together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 at 9hp, finish it now, then E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ecfe2a53f7e5ecabae89e005.json b/examples/multi-agent-smax/results/llm-cache/ask-ecfe2a53f7e5ecabae89e005.json new file mode 100644 index 00000000..6dcd5b8f --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ecfe2a53f7e5ecabae89e005.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 8.0 seconds into the battle.\nYou are A1, a marine at (8.0, 16.0) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E1 marine at (11.6, 16.0), 36/45 health, 3.5 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (5.5s): E0 down. Focus E2 (27hp), then E1. A0, stay back, you're low.\n A2 (5.5s): E0 dead. Focus E2 (27hp) together, then E1.\n A1 (6.0s): Focusing E2 (27hp), then E1. A2 stay behind me.\n A2 (6.0s): Focusing E2 (27hp), then E1. A1 keep firing.\n A1 (6.5s): Finishing E2 (9hp) now, then E1. A2 stay behind me.\n A2 (6.5s): E2 at 9hp, finishing it. A1 then focus E1.\n A1 (7.0s): E2 dead, A0 and A2 down. I'm alone on E1, 45hp each.\n A1 (7.5s): Last fight: A1 vs E1, 36hp vs 45hp. Fighting on.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Last fight, A1 vs E1. Keep firing.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ed49b1a4f41f66f1156fef84.json b/examples/multi-agent-smax/results/llm-cache/ask-ed49b1a4f41f66f1156fef84.json new file mode 100644 index 00000000..a200dc80 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ed49b1a4f41f66f1156fef84.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 1.0 seconds into the battle.\nYou are A1, a marine at (10.3, 14.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 15.\nYour team:\n A0 marine at (11.2, 17.5), 45/45 health, order: move 12 16\n A2 marine at (12.5, 14.6), 45/45 health, order: move 12 15\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Advancing east together to (12,16); stay within 2 of each other, attack together.\n A1 (0.0s): Advancing east together to (12,15); stay within 2 of each other, attack same target on contact.\n A2 (0.0s): Advancing east together, staying close. Don't outrun the group; all attack same target.\n A0 (0.5s): Advancing to (12,16), keeping close; will attack same target on contact.\n A1 (0.5s): A1 advancing to (12,15), staying close; will attack same target on contact.\n A2 (0.5s): A2 advancing to (12,15), staying close; will attack same target on contact.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 15\", \"say\": \"A1 continuing to (12,15), staying close; attack same target on contact.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ed690cc1c0c5da4fafdbf8d7.json b/examples/multi-agent-smax/results/llm-cache/ask-ed690cc1c0c5da4fafdbf8d7.json new file mode 100644 index 00000000..564ceb4a --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ed690cc1c0c5da4fafdbf8d7.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.0 seconds into the battle.\nYou are A1, a marine at (7.1, 14.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.1, 17.5), 45/45 health, order: hold\n A2 marine at (9.4, 14.6), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding together; focus fire on the closest enemy when they appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-eda2798f88e7b9c60526a073.json b/examples/multi-agent-smax/results/llm-cache/ask-eda2798f88e7b9c60526a073.json new file mode 100644 index 00000000..5a9a9778 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-eda2798f88e7b9c60526a073.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 2.5 seconds into the battle.\nYou are A0, a marine at (13.6, 17.1) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1 marine at (13.2, 15.3), 27/45 health, order: attack E0\n A2 marine at (14.1, 16.4), 45/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (17.8, 15.1), 9/45 health, 4.7 away (in range)\n E1 marine at (17.6, 16.5), 45/45 health, 4.1 away (in range)\n E2 marine at (17.5, 17.3), 45/45 health, 4.0 away (in range)\nTeam chat (most recent last):\n A1 (1.0s): E0 spotted east at (19.3,15.1). Keep moving together; attack when in range 5 of all.\n A2 (1.0s): A2 continuing to (14,16), staying close; will focus first enemy seen.\n A0 (1.5s): E0 in range of A0 and A1. Attack E0 now; A2 close in and focus E0.\n A1 (1.5s): E0 in range of A1 and A0. A2 close in, everyone focus E0 now.\n A2 (1.5s): E0 at 6.7, not in range yet. Moving up together; attack E0 on same tick.\n A0 (2.0s): Focus E0 (27hp) now; A2 close in and fire.\n A1 (2.0s): Focusing E0 (27hp). A2 get in range and attack E0.\n A2 (2.0s): Attacking E0 now, closing in with you both.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 at 9hp, finish it now; then focus E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-edb0b2a00717800ed47d02a7.json b/examples/multi-agent-smax/results/llm-cache/ask-edb0b2a00717800ed47d02a7.json new file mode 100644 index 00000000..16ff8280 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-edb0b2a00717800ed47d02a7.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 8.0 seconds into the battle.\nYou are A1, a marine at (7.2, 17.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E0 marine at (11.7, 17.0), 9/45 health, 4.6 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (6.0s): E1 at 9hp, finishing it. Then focus E0.\n A1 (6.0s): Firing E1 (9hp), then E0.\n A0 (6.5s): E1 down. Focusing E0, 4.4 away, all fire.\n A1 (6.5s): E1 down. All focus E0, 4.6 away, 45hp.\n A0 (7.0s): E0 at 27hp, keep firing. I'm at 9hp.\n A1 (7.0s): Focusing E0 at 27hp, keep firing. A0 stay behind me.\n A0 (7.5s): E0 at 9hp, in range. Finishing it now.\n A1 (7.5s): E0 at 9hp, finishing it. A0 stay back.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 at 9hp, 4.6 away. Finishing it.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-edc9aae86665ed63cf7168da.json b/examples/multi-agent-smax/results/llm-cache/ask-edc9aae86665ed63cf7168da.json new file mode 100644 index 00000000..9355e754 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-edc9aae86665ed63cf7168da.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 2.0 seconds into the battle.\nYou are A2, a marine at (12.8, 14.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 15 15.\nYour team:\n A0 marine at (12.7, 16.0), 45/45 health, order: move 15 15\n A1 marine at (13.3, 15.5), 45/45 health, order: move 14 15\nEnemies you can see:\n E0 marine at (17.6, 15.0), 45/45 health, 4.8 away (in range)\n E1 marine at (18.1, 16.2), 45/45 health, 5.5 away\n E2 marine at (17.6, 14.3), 45/45 health, 4.8 away (in range)\nTeam chat (most recent last):\n A1 (0.5s): Moving to (12,15) with team; will attack same target together.\n A2 (0.5s): A2 moving to (12,15), staying close; will attack same target when enemies appear.\n A0 (1.0s): Continuing to (12,15); will attack together once enemies appear.\n A1 (1.0s): Continuing to (12,15) together; will attack same target when enemies appear.\n A2 (1.0s): A2 continuing to (12,15); will attack together when enemies appear.\n A0 (1.5s): Advancing together toward E0; all attack E0 once everyone is in range.\n A1 (1.5s): Advancing together to (14,15); all attack E0 once in range.\n A2 (1.5s): Advancing east together to (15,15); all attack E2 once in range 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Enemies in range now. Everyone attack E0 together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-edcea700b2906887f32766ac.json b/examples/multi-agent-smax/results/llm-cache/ask-edcea700b2906887f32766ac.json new file mode 100644 index 00000000..8095bbd0 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-edcea700b2906887f32766ac.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 3.0 seconds into the battle.\nYou are A0, a marine at (14.8, 18.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1: dead\n A2 marine at (13.2, 17.6), 45/45 health, order: attack E0\nEnemies you can see:\n E1 marine at (18.5, 17.3), 45/45 health, 3.8 away (in range)\n E2 marine at (19.1, 14.8), 45/45 health, 5.3 away\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (1.5s): Holding formation at 14,17; attack E0 together once all within range 5.\n A2 (1.5s): Regrouping at 14,17; closest enemy 6 away, hold formation, then attack E0 together.\n A0 (2.0s): E0 is within range 5 of all three of us. Everyone attack E0 now.\n A1 (2.0s): E0 is in range of all three. Attack E0 now, together.\n A2 (2.0s): E0 is within range 5 of all three of us. Attack E0 now.\n A0 (2.5s): Focus E0 (18hp). A1 at 18hp, retreat if under 20 per rules.\n A1 (2.5s): A1 at 18hp, retreating to stop being the closest target. A0, A2 focus E0.\n A2 (2.5s): Attacking E0 now; A1 under 20hp, retreat if needed.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E0 dead. A2 attack E1 now, it's in my range. A1 stay back.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ee3aa9dae35f0948bc7a8adb.json b/examples/multi-agent-smax/results/llm-cache/ask-ee3aa9dae35f0948bc7a8adb.json new file mode 100644 index 00000000..17651378 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ee3aa9dae35f0948bc7a8adb.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 5.0 seconds into the battle.\nYou are A1, a marine at (15.1, 13.7) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (14.6, 14.4), 9/45 health, order: attack E2\n A2: dead\nEnemies you can see:\n E1 marine at (18.0, 17.0), 45/45 health, 4.3 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A2 (3.0s): E0 at 9hp, finishing it now; then focus E2.\n A0 (3.5s): E0 dead. All focus E2 now, then E1.\n A1 (3.5s): E0 down. Everyone focus E2 (closest), then E1.\n A2 (3.5s): E0 down. Everyone focus E2 (3.0 away), then E1.\n A0 (4.0s): E2 at 18hp, keep focusing E2 then E1.\n A1 (4.0s): E2 at 18hp, keep focusing E2 then E1. Nobody retreat.\n A0 (4.5s): E2 at 9hp, finish it now, then E1. I'm low but still firing.\n A1 (4.5s): E2 at 9hp, finishing it. Then E1. A0 stay in, no retreat.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E2 dead. All focus E1 now, 4.3 away. A0 keep firing.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-eea425ce5d2f38fb95ad8e25.json b/examples/multi-agent-smax/results/llm-cache/ask-eea425ce5d2f38fb95ad8e25.json new file mode 100644 index 00000000..bb50c5bf --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-eea425ce5d2f38fb95ad8e25.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 1.0 seconds into the battle.\nYou are A0, a marine at (11.4, 16.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 16.\nYour team:\n A1 marine at (13.0, 15.7), 45/45 health, order: move 14 16\n A2 marine at (12.1, 16.2), 45/45 health, order: move 14 16\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Advancing east together to find enemies; keep within 2 of each other, then all attack same target.\n A1 (0.0s): Moving east together toward enemies, stay within 2 of each other; attack same target on contact.\n A2 (0.0s): Moving east together to (14,16); stay within 2 of each other, attack together on contact.\n A0 (0.5s): Continuing east to (14,16); staying together, will attack same target on contact.\n A1 (0.5s): Continuing east in formation; will attack same target on contact.\n A2 (0.5s): A2 moving east to (14,16), staying close; attack same target on contact.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 16\", \"say\": \"Continuing east to (14,16), staying together; no enemies seen yet.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ef03fa0e6890d588d54e2583.json b/examples/multi-agent-smax/results/llm-cache/ask-ef03fa0e6890d588d54e2583.json new file mode 100644 index 00000000..3c976ebc --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ef03fa0e6890d588d54e2583.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.0 seconds into the battle.\nYou are A1, a marine at (8.0, 16.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0: dead\n A2 marine at (8.6, 16.5), 27/45 health, order: attack E2\nEnemies you can see:\n E1 marine at (11.6, 16.0), 45/45 health, 3.5 away (in range)\n E2 marine at (11.8, 14.7), 27/45 health, 4.0 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (4.5s): E0 in range at 4.6, I'm firing on E0. Focus E0 if in range.\n A2 (4.5s): E0 in range at 3.8; I focus E0, A0 on E2. Kill fast.\n A0 (5.0s): Switching to E0 with you both. Focus E0 down, then E2.\n A1 (5.0s): Focusing E0 (27hp) with A2; A0 on E2 is fine, then E1.\n A2 (5.0s): A2 firing E0 (27hp). A1 and I kill E0, A0 stays on E2.\n A0 (5.5s): E0 is dead. Focus E2 (27hp), then E1. I'm at 9hp.\n A1 (5.5s): E0 down. Focus E2 (27hp), then E1. A0, stay back, you're low.\n A2 (5.5s): E0 dead. Focus E2 (27hp) together, then E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Focusing E2 (27hp), then E1. A2 stay behind me.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ef31606acc412e177609e699.json b/examples/multi-agent-smax/results/llm-cache/ask-ef31606acc412e177609e699.json new file mode 100644 index 00000000..42cc4c39 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ef31606acc412e177609e699.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.5 seconds into the battle.\nYou are A1, a marine at (8.3, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.1, 15.8), 45/45 health, order: hold\n A2 marine at (8.1, 14.9), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (12.9, 15.0), 45/45 health, 4.6 away (in range)\n E1 marine at (13.4, 16.2), 45/45 health, 5.5 away\n E2 marine at (12.9, 14.3), 45/45 health, 4.6 away (in range)\nTeam chat (most recent last):\n A1 (2.0s): Falling back to group; hold and focus fire when enemies enter range.\n A2 (2.0s): A2 holding at (8,15); A1 is advancing east, stay close, focus closest.\n A0 (2.5s): Enemies 3 at east x16. Pull back to group at (8.5,15), then focus E0 together.\n A1 (2.5s): Enemies east at 16,15. Hold grouped; focus fire on the closest, starting with E2 or E0.\n A2 (2.5s): Enemies ~8 east. Hold at range 5, focus closest when they approach.\n A0 (3.0s): Holding at (8,15). Everyone hold; focus fire closest enemy when in range 5.\n A1 (3.0s): Holding at (8,14). Focus E2 first when in range, then E0.\n A2 (3.0s): Holding at (8,15). Focus E2 or E0 when in range 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Focus E2 now, then E0. Everyone fire.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-efa20e07104b7c06af6e2436.json b/examples/multi-agent-smax/results/llm-cache/ask-efa20e07104b7c06af6e2436.json new file mode 100644 index 00000000..cd5c2074 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-efa20e07104b7c06af6e2436.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.0 seconds into the battle.\nYou are A0, a marine at (8.7, 16.9) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1 marine at (8.5, 15.3), 27/45 health, order: attack E0\n A2 marine at (8.0, 16.6), 45/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (13.0, 15.1), 9/45 health, 4.7 away (in range)\n E1 marine at (12.9, 16.5), 45/45 health, 4.2 away (in range)\n E2 marine at (12.8, 17.3), 45/45 health, 4.2 away (in range)\nTeam chat (most recent last):\n A1 (2.5s): Holding grouped; let them walk into range, then focus E0.\n A2 (2.5s): A2 holding grouped; focus E0 when it enters range.\n A0 (3.0s): E0 in range, all attack E0 now.\n A1 (3.0s): E0 in range at 4.5, all focus fire E0 now.\n A2 (3.0s): A2 holding; focus E0 when in range.\n A0 (3.5s): A0 focusing E0 (27hp). A2 attack E0 too, don't hold.\n A1 (3.5s): A1 focusing E0 (27hp), in range. A2 please attack E0 too.\n A2 (3.5s): A2 attacking E0, closing in to focus fire.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E0 at 9hp, finish it, then focus E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-efada1b89ad642f5625cceba.json b/examples/multi-agent-smax/results/llm-cache/ask-efada1b89ad642f5625cceba.json new file mode 100644 index 00000000..ee527e9a --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-efada1b89ad642f5625cceba.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 0.5 seconds into the battle.\nYou are A1, a marine at (10.1, 15.3) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 16.\nYour team:\n A0 marine at (10.2, 16.9), 45/45 health, order: move 14 16\n A2 marine at (8.1, 16.6), 45/45 health, order: move 12 16\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Moving east together toward center, stay within 2 of each other; attack same target when seen.\n A1 (0.0s): No enemies seen. Moving east together to (14,16); stay within 2 of each other.\n A2 (0.0s): Moving east together to find enemies; stay within 2 of each other.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 16\", \"say\": \"Continuing east to (14,16), staying close to A0 and A2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-f042dc1872feeb67d633a681.json b/examples/multi-agent-smax/results/llm-cache/ask-f042dc1872feeb67d633a681.json new file mode 100644 index 00000000..11626c64 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-f042dc1872feeb67d633a681.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 2.5 seconds into the battle.\nYou are A0, a marine at (6.9, 15.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (6.7, 14.2), 45/45 health, order: hold\n A2 marine at (8.3, 17.3), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (15.2, 16.8), 45/45 health, 8.4 away\nTeam chat (most recent last):\n A1 (1.0s): A1 holding. No enemies visible; will focus same target once all in range 5.\n A2 (1.0s): A2 holding. Still no enemies; waiting until all in range 5.\n A0 (1.5s): A0 holding. Still no enemies; waiting for all within 5 to focus fire.\n A1 (1.5s): A1 holding. Still no enemies; will focus same target once all in range 5.\n A2 (1.5s): A2 holding. No enemies visible; will focus fire when all within 5.\n A0 (2.0s): A0 holding; no enemies yet. Will focus same target once all within 5.\n A1 (2.0s): A1 holding; no enemies yet. Will attack together once all within 5.\n A2 (2.0s): A2 holding. E0 spotted at (16.8,16.8), 8.5 away. Wait until it's in range 5 of all.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A0 holding. E0 at 8.4 away; wait until within 5 of all, then focus E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-f0790914c6757cb70478e29f.json b/examples/multi-agent-smax/results/llm-cache/ask-f0790914c6757cb70478e29f.json new file mode 100644 index 00000000..62f0eec0 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-f0790914c6757cb70478e29f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 8.0 seconds into the battle.\nYou are A0, a marine at (8.1, 15.8) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1 marine at (5.2, 14.1), 9/45 health, order: attack E0\n A2: dead\nEnemies you can see:\n E0 marine at (12.9, 15.0), 18/45 health, 4.8 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (6.5s): A1 holding back at 9hp; will shoot anything that closes in.\n A2 (6.5s): Finishing E1 (9hp) now, then all focus E0.\n A0 (7.0s): E1 down. All focus E0 now, A1 join in.\n A1 (7.0s): A1 9hp holding; will shoot anything that closes in. Finish E1, then E0.\n A2 (7.0s): E1 down. All focus E0; I'm closest and tanking, A0 and A1 fire.\n A0 (7.5s): A0 firing E0 (27hp). A1 close in and shoot, all focus fire.\n A1 (7.5s): A1 joining on E0, A2 stays closest and tanks.\n A2 (7.5s): E0 at 27hp, 4.8 away. A0, A1 fire now; focus E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"A0 firing E0 (18hp), 4.8 away. A1 fire too, finish it.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-f085b32c5f0d3bcce1304ac2.json b/examples/multi-agent-smax/results/llm-cache/ask-f085b32c5f0d3bcce1304ac2.json new file mode 100644 index 00000000..23902c26 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-f085b32c5f0d3bcce1304ac2.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 3.0 seconds into the battle.\nYou are A1, a marine at (13.2, 15.3) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (13.6, 17.1), 27/45 health, order: attack E0\n A2 marine at (14.1, 16.4), 36/45 health, order: attack E0\nEnemies you can see:\n E1 marine at (17.6, 16.5), 45/45 health, 4.5 away (in range)\n E2 marine at (17.5, 17.3), 45/45 health, 4.8 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (1.5s): E0 in range of A1 and A0. A2 close in, everyone focus E0 now.\n A2 (1.5s): E0 at 6.7, not in range yet. Moving up together; attack E0 on same tick.\n A0 (2.0s): Focus E0 (27hp) now; A2 close in and fire.\n A1 (2.0s): Focusing E0 (27hp). A2 get in range and attack E0.\n A2 (2.0s): Attacking E0 now, closing in with you both.\n A0 (2.5s): E0 at 9hp, finish it now; then focus E2.\n A1 (2.5s): E0 at 9hp, finishing it now; then everyone focus E1.\n A2 (2.5s): E0 at 9hp in range, firing on E0 now.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E0 dead. Everyone focus E1 now, same tick; then E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-f0be4c2824713c4f3f844eb8.json b/examples/multi-agent-smax/results/llm-cache/ask-f0be4c2824713c4f3f844eb8.json new file mode 100644 index 00000000..f921680d --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-f0be4c2824713c4f3f844eb8.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.5 seconds into the battle.\nYou are A0, a marine at (8.1, 15.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 8 15.\nYour team:\n A1 marine at (7.1, 14.7), 45/45 health, order: hold\n A2 marine at (9.4, 14.6), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Regroup near (8,15) so we fight together; focus fire on closest enemy.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on the closest enemy when they appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"At (8,15), holding. Focus fire on the closest enemy that appears.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-f11e8aff82787f319ba2aad9.json b/examples/multi-agent-smax/results/llm-cache/ask-f11e8aff82787f319ba2aad9.json new file mode 100644 index 00000000..04aba2c9 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-f11e8aff82787f319ba2aad9.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.5 seconds into the battle.\nYou are A1, a marine at (7.2, 17.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.5, 15.8), 45/45 health, order: hold\n A2 marine at (7.6, 17.8), 45/45 health, order: hold\nEnemies you can see:\n E2 marine at (14.2, 16.7), 45/45 health, 7.1 away\nTeam chat (most recent last):\n A1 (1.0s): No enemies yet. Holding; will focus fire on the closest when seen.\n A2 (1.0s): A2 holding; no enemies visible. Will focus closest when they appear.\n A0 (1.5s): Still no enemies; holding grouped. Focus closest when seen.\n A1 (1.5s): A1 holding; no enemies yet. Focus closest when seen.\n A2 (1.5s): A2 holding; no enemies visible. Focus closest when they appear.\n A0 (2.0s): E2 spotted at (15.8,16.7). Holding grouped; focus fire on whoever closes first.\n A1 (2.0s): E2 spotted east at 8.6 range. Holding grouped; focus E2 when in range.\n A2 (2.0s): E2 spotted at (15.8,16.7), 8 away. Holding grouped; focus E2 when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"E2 at 7 range. Holding grouped; focus E2 once in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-f1ddac0c42c26840200b85d0.json b/examples/multi-agent-smax/results/llm-cache/ask-f1ddac0c42c26840200b85d0.json new file mode 100644 index 00000000..8109963a --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-f1ddac0c42c26840200b85d0.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 0.0 seconds into the battle.\nYou are A2, a marine at (6.5, 16.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.6, 16.9), 45/45 health, order: hold\n A1 marine at (8.5, 15.3), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 16\", \"say\": \"Moving east together to find enemies; stay within 2 of each other.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-f1f35472272b32d52dca18f8.json b/examples/multi-agent-smax/results/llm-cache/ask-f1f35472272b32d52dca18f8.json new file mode 100644 index 00000000..5ac06799 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-f1f35472272b32d52dca18f8.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 5.5 seconds into the battle.\nYou are A1, a marine at (13.5, 17.2) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E0 marine at (18.0, 17.1), 36/45 health, 4.6 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A0 (3.5s): Focus E1 together, then E0. A2 stay on target per rules.\n A1 (3.5s): Focusing E1 now; A2 at 9hp, retreat only after E1 dies.\n A2 (3.5s): Focusing E1 with you. I'm at 9hp, will keep firing until it dies.\n A0 (4.0s): Keep firing E1 (18hp), then E0 together.\n A1 (4.0s): Firing on E1 (18hp), then E0 together.\n A0 (4.5s): E1 down. Focus E0 now, both fire together.\n A1 (4.5s): E1 dead. Focus E0 (4.6 away), A0 keep firing, I'm full health.\n A1 (5.0s): Firing on E0, last enemy. I'm at full health.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Last enemy E0 at 36hp; I'm the only one left, firing.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-f271a90993d7a18af4601d0e.json b/examples/multi-agent-smax/results/llm-cache/ask-f271a90993d7a18af4601d0e.json new file mode 100644 index 00000000..f9179848 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-f271a90993d7a18af4601d0e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 4.5 seconds into the battle.\nYou are A0, a marine at (13.3, 15.6) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1 marine at (12.9, 17.5), 27/45 health, order: attack E1\n A2 marine at (13.7, 16.7), 18/45 health, order: attack E1\nEnemies you can see:\n E0 marine at (17.7, 17.8), 45/45 health, 5.0 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (3.0s): E2 dead. Everyone focus E1 now, then E0.\n A2 (3.0s): E2 dead. Everyone focus E1 now, closest at 3.9.\n A0 (3.5s): Focus E1 (27hp). Keep attacking until dead, then E0.\n A1 (3.5s): Focusing E1 (27hp). A0 at 18hp, keep firing until E1 dies.\n A2 (3.5s): Focusing E1 (27hp), then E0. A0 at 18hp, keep firing.\n A0 (4.0s): E1 at 9hp, finishing it now, then E0.\n A1 (4.0s): E1 at 9hp, all keep firing until dead, then E0.\n A2 (4.0s): E1 at 9hp, keep firing until dead, then E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"E1 dead. All focus E0, it's in range 5.0 now.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-f29106c36017e65651041378.json b/examples/multi-agent-smax/results/llm-cache/ask-f29106c36017e65651041378.json new file mode 100644 index 00000000..a5846c34 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-f29106c36017e65651041378.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.0 seconds into the battle.\nYou are A0, a marine at (8.1, 15.8) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1 marine at (6.8, 14.1), 9/45 health, order: retreat\n A2 marine at (8.1, 14.9), 45/45 health, order: attack E1\nEnemies you can see:\n E0 marine at (12.9, 15.0), 45/45 health, 4.8 away (in range)\n E1 marine at (11.8, 16.2), 45/45 health, 3.7 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (3.5s): Focus E2 now, then E0. Everyone fire.\n A2 (3.5s): Focusing E2 now, then E0. All fire E2.\n A0 (4.0s): E2 is at 18 HP, finish it, then E1.\n A1 (4.0s): Firing E2 (18hp). Then E0. I'm at 27hp.\n A2 (4.0s): Firing E2 (18 hp left), then E0. Stay grouped.\n A0 (4.5s): E2 is down. Focus E1 (closest), then E0. A1 fall back if hurt.\n A1 (4.5s): A1 at 9hp, falling back. Focus E1 (closest to A0), then E0.\n A2 (4.5s): E2 is dead. Focus E1 (closest, 3.9 away), then E0. A1 is at 9hp, so stay behind.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Focus E1 (3.7 away). A1 stay back. Then E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-f291e1db29b17605f9a8ba2f.json b/examples/multi-agent-smax/results/llm-cache/ask-f291e1db29b17605f9a8ba2f.json new file mode 100644 index 00000000..79ed842d --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-f291e1db29b17605f9a8ba2f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.0 seconds into the battle.\nYou are A1, a marine at (8.3, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.1, 15.8), 45/45 health, order: move 8.5 15\n A2 marine at (8.1, 14.9), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (14.4, 15.0), 45/45 health, 6.2 away\n E1 marine at (15.0, 16.2), 45/45 health, 7.0 away\n E2 marine at (14.5, 14.3), 45/45 health, 6.1 away\nTeam chat (most recent last):\n A1 (1.5s): Advancing east slowly to find enemies; stay grouped, focus closest.\n A2 (1.5s): In position at (8,15); holding, focus fire closest enemy when seen.\n A0 (2.0s): Moving east to group with A1; focus closest enemy when seen.\n A1 (2.0s): Falling back to group; hold and focus fire when enemies enter range.\n A2 (2.0s): A2 holding at (8,15); A1 is advancing east, stay close, focus closest.\n A0 (2.5s): Enemies 3 at east x16. Pull back to group at (8.5,15), then focus E0 together.\n A1 (2.5s): Enemies east at 16,15. Hold grouped; focus fire on the closest, starting with E2 or E0.\n A2 (2.5s): Enemies ~8 east. Hold at range 5, focus closest when they approach.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding at (8,14). Focus E2 first when in range, then E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-f2a5d96f15f6d16aa3631cf5.json b/examples/multi-agent-smax/results/llm-cache/ask-f2a5d96f15f6d16aa3631cf5.json new file mode 100644 index 00000000..52447ea4 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-f2a5d96f15f6d16aa3631cf5.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.5 seconds into the battle.\nYou are A0, a marine at (8.1, 15.8) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1 marine at (5.2, 14.1), 9/45 health, order: retreat\n A2 marine at (8.1, 14.9), 36/45 health, order: attack E1\nEnemies you can see:\n E0 marine at (12.9, 15.0), 45/45 health, 4.8 away (in range)\n E1 marine at (11.8, 16.2), 27/45 health, 3.7 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (4.0s): Firing E2 (18hp). Then E0. I'm at 27hp.\n A2 (4.0s): Firing E2 (18 hp left), then E0. Stay grouped.\n A0 (4.5s): E2 is down. Focus E1 (closest), then E0. A1 fall back if hurt.\n A1 (4.5s): A1 at 9hp, falling back. Focus E1 (closest to A0), then E0.\n A2 (4.5s): E2 is dead. Focus E1 (closest, 3.9 away), then E0. A1 is at 9hp, so stay behind.\n A0 (5.0s): Focus E1 (3.7 away). A1 stay back. Then E0.\n A1 (5.0s): A1 at 9hp staying back. Focus E1 then E0, keep grouped.\n A2 (5.0s): Firing E1 (closest). A0 focus E1 too, then E0. A1 stay back.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Firing E1 (27hp). A1 stay back. Then E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-f2bc539a9f54cd1fb8e7aaae.json b/examples/multi-agent-smax/results/llm-cache/ask-f2bc539a9f54cd1fb8e7aaae.json new file mode 100644 index 00000000..c4225a6e --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-f2bc539a9f54cd1fb8e7aaae.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.0 seconds into the battle.\nYou are A2, a marine at (8.1, 14.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (8.1, 15.8), 45/45 health, order: attack E2\n A1 marine at (8.3, 14.1), 27/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (12.9, 15.0), 45/45 health, 4.8 away (in range)\n E1 marine at (11.8, 16.2), 45/45 health, 3.9 away (in range)\n E2 marine at (12.9, 14.3), 18/45 health, 4.8 away (in range)\nTeam chat (most recent last):\n A1 (2.5s): Enemies east at 16,15. Hold grouped; focus fire on the closest, starting with E2 or E0.\n A2 (2.5s): Enemies ~8 east. Hold at range 5, focus closest when they approach.\n A0 (3.0s): Holding at (8,15). Everyone hold; focus fire closest enemy when in range 5.\n A1 (3.0s): Holding at (8,14). Focus E2 first when in range, then E0.\n A2 (3.0s): Holding at (8,15). Focus E2 or E0 when in range 5.\n A0 (3.5s): Focus E2 now, then E0. Stay grouped.\n A1 (3.5s): Focus E2 now, then E0. Everyone fire.\n A2 (3.5s): Focusing E2 now, then E0. All fire E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Firing E2 (18 hp left), then E0. Stay grouped.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-f34bf9cf57fe2975f760f01d.json b/examples/multi-agent-smax/results/llm-cache/ask-f34bf9cf57fe2975f760f01d.json new file mode 100644 index 00000000..596e260b --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-f34bf9cf57fe2975f760f01d.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.0 seconds into the battle.\nYou are A0, a marine at (8.1, 15.8) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1 marine at (3.6, 14.1), 9/45 health, order: retreat\n A2 marine at (8.1, 14.9), 27/45 health, order: attack E1\nEnemies you can see:\n E0 marine at (12.9, 15.0), 45/45 health, 4.8 away (in range)\n E1 marine at (11.8, 16.2), 9/45 health, 3.7 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (4.5s): A1 at 9hp, falling back. Focus E1 (closest to A0), then E0.\n A2 (4.5s): E2 is dead. Focus E1 (closest, 3.9 away), then E0. A1 is at 9hp, so stay behind.\n A0 (5.0s): Focus E1 (3.7 away). A1 stay back. Then E0.\n A1 (5.0s): A1 at 9hp staying back. Focus E1 then E0, keep grouped.\n A2 (5.0s): Firing E1 (closest). A0 focus E1 too, then E0. A1 stay back.\n A0 (5.5s): Firing E1 (27hp). A1 stay back. Then E0.\n A1 (5.5s): A1 at 9hp staying back; focus E1 then E0.\n A2 (5.5s): Firing E1 (27hp). A0 keep focus, then E0. A1 stay back.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Firing E1 (9hp), nearly dead. Then E0 together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-f356cfb9f91893eeaaa8e080.json b/examples/multi-agent-smax/results/llm-cache/ask-f356cfb9f91893eeaaa8e080.json new file mode 100644 index 00000000..826dc2f8 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-f356cfb9f91893eeaaa8e080.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.5 seconds into the battle.\nYou are A0, a marine at (10.6, 16.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 16.\nYour team:\n A1 marine at (8.9, 14.1), 45/45 health, order: move 12 15\n A2 marine at (7.7, 14.8), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (17.2, 16.4), 45/45 health, 6.6 away\n E1 marine at (17.8, 16.8), 45/45 health, 7.3 away\n E2 marine at (17.8, 15.5), 45/45 health, 7.2 away\nTeam chat (most recent last):\n A1 (1.0s): Holding; no enemies in sight. Focus fire closest when they appear.\n A2 (1.0s): Still holding; no enemies visible. Focus fire on closest when they appear.\n A0 (1.5s): Holding near A1/A2; focus fire closest enemy when in range.\n A1 (1.5s): Still holding; will focus fire on closest enemy when visible.\n A2 (1.5s): Holding grouped; focus fire on closest enemy when it appears.\n A0 (2.0s): No contact; advancing east to center together. Stay close, focus closest enemy.\n A1 (2.0s): No contact; advancing east together to find enemies. Stay grouped, focus closest.\n A2 (2.0s): Holding grouped; focus fire closest enemy when it appears.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 9.3 15\", \"say\": \"Enemies 3 at east, ~7 away. Falling back to group; hold and focus E0 when in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-f3d087811f30b509c3571a37.json b/examples/multi-agent-smax/results/llm-cache/ask-f3d087811f30b509c3571a37.json new file mode 100644 index 00000000..bdf56ece --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-f3d087811f30b509c3571a37.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 3.0 seconds into the battle.\nYou are A0, a marine at (14.2, 16.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1 marine at (14.6, 15.5), 45/45 health, order: attack E1\n A2: dead\nEnemies you can see:\n E0 marine at (18.2, 17.3), 45/45 health, 4.1 away (in range)\n E1 marine at (18.2, 16.6), 9/45 health, 4.0 away (in range)\n E2 marine at (18.4, 14.1), 45/45 health, 4.7 away (in range)\nTeam chat (most recent last):\n A1 (1.5s): A1 holding near 14,16 so A0 and A2 catch up; all attack E1 together.\n A2 (1.5s): Advancing together to (15,16); all attack E1 once in range 5.\n A0 (2.0s): Enemies in range now. All attack E1, A1 close in.\n A1 (2.0s): A1 attacking E1 now; A0 and A2 are in range, focus E1.\n A2 (2.0s): Enemies in range of me and A0. Attacking E1 now; A1 close in and fire on E1.\n A0 (2.5s): Focus E1 (27hp). A2 low at 18hp, retreat if needed.\n A1 (2.5s): Firing on E1 (27hp). A2 at 18hp, retreat if under 20.\n A2 (2.5s): A2 at 18hp retreating to pull fire off me; A0, A1 keep focusing E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E1 at 9hp, finish it now; then focus E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-f418eb748c0d00949f5029a4.json b/examples/multi-agent-smax/results/llm-cache/ask-f418eb748c0d00949f5029a4.json new file mode 100644 index 00000000..8bcd56af --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-f418eb748c0d00949f5029a4.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 0.5 seconds into the battle.\nYou are A0, a marine at (10.6, 16.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 11 16.\nYour team:\n A1 marine at (8.9, 14.1), 45/45 health, order: move 14 15\n A2 marine at (9.2, 14.8), 45/45 health, order: move 16 16\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Advancing east together; stay within 2 of each other, A1 and A2 keep pace.\n A1 (0.0s): Moving east together toward center, stay within 2 of each other.\n A2 (0.0s): Moving together to center, stay within 2 of each other; attack same target when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 15\", \"say\": \"Moving east, staying close; A1 and A2 keep within 2 of me.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-f491218317e9b533aceffd8c.json b/examples/multi-agent-smax/results/llm-cache/ask-f491218317e9b533aceffd8c.json new file mode 100644 index 00000000..7e002bc0 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-f491218317e9b533aceffd8c.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 1.5 seconds into the battle.\nYou are A1, a marine at (11.3, 16.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 17.\nYour team:\n A0 marine at (11.9, 15.8), 45/45 health, order: move 12 17\n A2 marine at (11.7, 18.0), 45/45 health, order: move 12 17\nEnemies you can see:\n E2 marine at (19.7, 14.7), 45/45 health, 8.6 away\nTeam chat (most recent last):\n A1 (0.0s): Moving east together toward the center; stay within 2 of each other.\n A2 (0.0s): Advancing east together, stay within 2 of each other; attack same target when in range.\n A0 (0.5s): Continuing to (12,17); keep within 2 of each other.\n A1 (0.5s): Moving to (12,17) with A0; keep together, then focus same target.\n A2 (0.5s): Moving to (12,17) with A0; keep within 2, attack together when enemies appear.\n A0 (1.0s): Continuing to (12,17) together; no enemies yet, attack same target when seen.\n A1 (1.0s): Continuing to (12,17), staying within 2 of A0 and A2.\n A2 (1.0s): Continuing to (12,17); no enemies yet, stay within 2, attack together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 15 16\", \"say\": \"Enemy E2 at (19.7,14.7). Advancing together to 15,16; attack E2 when all in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-f4bfbe8df90a4f6e3db5003e.json b/examples/multi-agent-smax/results/llm-cache/ask-f4bfbe8df90a4f6e3db5003e.json new file mode 100644 index 00000000..59694b7a --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-f4bfbe8df90a4f6e3db5003e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.0 seconds into the battle.\nYou are A1, a marine at (7.8, 14.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.9, 16.7), 45/45 health, order: hold\n A2 marine at (7.6, 17.8), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (12.9, 15.3), 45/45 health, 5.1 away\n E1 marine at (15.4, 15.6), 45/45 health, 7.6 away\n E2 marine at (15.0, 17.7), 45/45 health, 7.8 away\nTeam chat (most recent last):\n A1 (1.5s): A1 moving to cluster with A0/A2; holding together, focus closest enemy.\n A2 (1.5s): A2 holding; no enemies yet. Focus closest when they appear.\n A0 (2.0s): A0 holding. Focus closest enemy when seen; stay tight.\n A1 (2.0s): A1 holding near cluster; E0 spotted east at (16,15.3). Focus E0 when in range.\n A2 (2.0s): E0 seen east at 16,15. Holding clustered; focus E0 when in range.\n A0 (2.5s): A0 holding. Only E0 seen; let it come into range, focus fire together.\n A1 (2.5s): A1 holding; E0 approaching, focus fire when in range.\n A2 (2.5s): A2 holding; E0 approaching, focus it when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A1 holding; E0 at 5.1, focus E0 when in range, stay tight.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-f523f3829c1b32b82fbf8603.json b/examples/multi-agent-smax/results/llm-cache/ask-f523f3829c1b32b82fbf8603.json new file mode 100644 index 00000000..7c84f10a --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-f523f3829c1b32b82fbf8603.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 3.5 seconds into the battle.\nYou are A2, a marine at (13.0, 14.3) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (12.8, 15.9), 27/45 health, order: attack E1\n A1 marine at (13.0, 15.0), 27/45 health, order: attack E1\nEnemies you can see:\n E0 marine at (17.3, 15.0), 45/45 health, 4.4 away (in range)\n E1 marine at (16.6, 14.0), 36/45 health, 3.6 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (2.0s): All in range of E2 now. Attack E2 together.\n A2 (2.0s): E2 in range of all three. Attack E2 now, together.\n A0 (2.5s): Firing on E2, 18hp left. Keep attacking together.\n A1 (2.5s): Firing on E2 (18hp), keep attacking until it dies.\n A2 (2.5s): Attacking E2, it's at 18hp; finish it together.\n A0 (3.0s): E2 dead. Everyone focus E1, closest to all of us.\n A1 (3.0s): E2 dead. Focus E1 (closest, 3.8 away), all attack E1 together.\n A2 (3.0s): E2 is dead. Focus E1 (closest, 3.6 away), all together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Keep firing on E1, 36hp left. All together until it dies.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-f55d68f5c2f747d06705a7cb.json b/examples/multi-agent-smax/results/llm-cache/ask-f55d68f5c2f747d06705a7cb.json new file mode 100644 index 00000000..cf30d711 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-f55d68f5c2f747d06705a7cb.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.5 seconds into the battle.\nYou are A2, a marine at (7.6, 17.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.5, 15.8), 45/45 health, order: hold\n A1 marine at (7.2, 17.2), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together here; focus fire on the closest enemy when they appear.\n A0 (0.5s): No enemies yet. Staying grouped; focus fire on the closest one when seen.\n A1 (0.5s): A1 holding; will focus fire on the closest enemy when seen.\n A2 (0.5s): Holding; will focus fire on closest enemy once visible.\n A0 (1.0s): No enemies visible; holding grouped. Focus fire on the closest when they appear.\n A1 (1.0s): No enemies yet. Holding; will focus fire on the closest when seen.\n A2 (1.0s): A2 holding; no enemies visible. Will focus closest when they appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A2 holding; no enemies visible. Focus closest when they appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-f5d9b7665521c807ef1f6a4e.json b/examples/multi-agent-smax/results/llm-cache/ask-f5d9b7665521c807ef1f6a4e.json new file mode 100644 index 00000000..c105f6ea --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-f5d9b7665521c807ef1f6a4e.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.5 seconds into the battle.\nYou are A1, a marine at (8.9, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 15.\nYour team:\n A0 marine at (10.6, 16.0), 45/45 health, order: move 12 16\n A2 marine at (7.7, 14.8), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (17.2, 16.4), 45/45 health, 8.6 away\n E2 marine at (17.8, 15.5), 45/45 health, 9.0 away\nTeam chat (most recent last):\n A1 (1.0s): Holding; no enemies in sight. Focus fire closest when they appear.\n A2 (1.0s): Still holding; no enemies visible. Focus fire on closest when they appear.\n A0 (1.5s): Holding near A1/A2; focus fire closest enemy when in range.\n A1 (1.5s): Still holding; will focus fire on closest enemy when visible.\n A2 (1.5s): Holding grouped; focus fire on closest enemy when it appears.\n A0 (2.0s): No contact; advancing east to center together. Stay close, focus closest enemy.\n A1 (2.0s): No contact; advancing east together to find enemies. Stay grouped, focus closest.\n A2 (2.0s): Holding grouped; focus fire closest enemy when it appears.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Enemies E0, E2 east ~9 away. Holding grouped; focus E0 when in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-f5f24cd3d48b36d65abc4b6a.json b/examples/multi-agent-smax/results/llm-cache/ask-f5f24cd3d48b36d65abc4b6a.json new file mode 100644 index 00000000..7d32024d --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-f5f24cd3d48b36d65abc4b6a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 1.0 seconds into the battle.\nYou are A0, a marine at (12.2, 16.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 15.\nYour team:\n A1 marine at (10.5, 14.1), 45/45 health, order: move 12 15\n A2 marine at (10.8, 14.8), 45/45 health, order: move 14 15\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Advancing east together; stay within 2 of each other, A1 and A2 keep pace.\n A1 (0.0s): Moving east together toward center, stay within 2 of each other.\n A2 (0.0s): Moving together to center, stay within 2 of each other; attack same target when in range.\n A0 (0.5s): Moving east, staying close; A1 and A2 keep within 2 of me.\n A1 (0.5s): Advancing east, staying close; will all attack same target when enemies appear.\n A2 (0.5s): Keeping pace east, staying close; will focus same target once in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 15\", \"say\": \"Continuing east together; A1 and A2 stay close, focus fire once enemies appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-f62120f01268e80a27fba3e4.json b/examples/multi-agent-smax/results/llm-cache/ask-f62120f01268e80a27fba3e4.json new file mode 100644 index 00000000..1ebc7acc --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-f62120f01268e80a27fba3e4.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 3.5 seconds into the battle.\nYou are A0, a marine at (13.6, 17.1) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A1 marine at (13.2, 15.3), 27/45 health, order: attack E1\n A2 marine at (14.1, 16.4), 27/45 health, order: attack E1\nEnemies you can see:\n E1 marine at (17.6, 16.5), 18/45 health, 4.1 away (in range)\n E2 marine at (17.5, 17.3), 45/45 health, 4.0 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (2.0s): Focusing E0 (27hp). A2 get in range and attack E0.\n A2 (2.0s): Attacking E0 now, closing in with you both.\n A0 (2.5s): E0 at 9hp, finish it now; then focus E2.\n A1 (2.5s): E0 at 9hp, finishing it now; then everyone focus E1.\n A2 (2.5s): E0 at 9hp in range, firing on E0 now.\n A0 (3.0s): E0 dead. Everyone focus E1 now, same target, no retreating.\n A1 (3.0s): E0 dead. Everyone focus E1 now, same tick; then E2.\n A2 (3.0s): E0 dead. Everyone focus E1 now, then E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Focusing E1 (18hp), same target; then E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-f652dee05fb5aee1ce5b11df.json b/examples/multi-agent-smax/results/llm-cache/ask-f652dee05fb5aee1ce5b11df.json new file mode 100644 index 00000000..eaaa7d62 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-f652dee05fb5aee1ce5b11df.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 3.5 seconds into the battle.\nYou are A0, a marine at (14.6, 14.4) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1 marine at (15.1, 13.7), 45/45 health, order: attack E0\n A2 marine at (14.8, 15.1), 9/45 health, order: attack E0\nEnemies you can see:\n E1 marine at (18.0, 17.0), 45/45 health, 4.2 away (in range)\n E2 marine at (17.8, 15.5), 45/45 health, 3.3 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (2.0s): Closing on E0 together; once all within 5, everyone attacks E0 same tick.\n A2 (2.0s): Attacking E0 now; A0 is already in range, A1 close up and focus E0.\n A0 (2.5s): Focusing E0; A1 attack E0 now, all in range.\n A1 (2.5s): In range of all; attacking E0 now.\n A2 (2.5s): Focusing E0 (36hp). A1 attack E0 now, all in range.\n A0 (3.0s): E0 at 9hp, finishing it now. Everyone keep focusing E0.\n A1 (3.0s): Attacking E0 (9hp), finish it then focus E2.\n A2 (3.0s): E0 at 9hp, finishing it now; then focus E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E0 dead. All focus E2 now, then E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-f6f662e5b139c2231d1ba5ab.json b/examples/multi-agent-smax/results/llm-cache/ask-f6f662e5b139c2231d1ba5ab.json new file mode 100644 index 00000000..8fa20935 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-f6f662e5b139c2231d1ba5ab.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.0 seconds into the battle.\nYou are A1, a marine at (7.8, 14.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 7.5 16.5.\nYour team:\n A0 marine at (6.9, 16.7), 45/45 health, order: hold\n A2 marine at (7.6, 17.8), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (16.0, 15.3), 45/45 health, 8.3 away\nTeam chat (most recent last):\n A1 (0.5s): A1 holding; will focus fire on closest enemy once visible.\n A2 (0.5s): Holding; staying clustered near A0 until enemies appear, then focus closest.\n A0 (1.0s): A0 holding; A1 move closer to cluster, focus closest enemy when seen.\n A1 (1.0s): A1 holding; will focus closest enemy. Staying near A0 and A2.\n A2 (1.0s): A2 holding; no enemies seen yet, will focus closest when they appear.\n A0 (1.5s): A0 holding. Stay clustered; focus fire on closest enemy when seen.\n A1 (1.5s): A1 moving to cluster with A0/A2; holding together, focus closest enemy.\n A2 (1.5s): A2 holding; no enemies yet. Focus closest when they appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A1 holding near cluster; E0 spotted east at (16,15.3). Focus E0 when in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-f778e48e6380f2958fb299f2.json b/examples/multi-agent-smax/results/llm-cache/ask-f778e48e6380f2958fb299f2.json new file mode 100644 index 00000000..6af65264 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-f778e48e6380f2958fb299f2.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.5 seconds into the battle.\nYou are A2, a marine at (9.0, 16.0) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (9.3, 15.3), 36/45 health, order: attack E0\n A1 marine at (8.3, 14.2), 45/45 health, order: attack E1\nEnemies you can see:\n E0 marine at (13.4, 16.8), 18/45 health, 4.5 away (in range)\n E1 marine at (12.2, 16.1), 36/45 health, 3.2 away (in range)\n E2 marine at (12.3, 17.5), 45/45 health, 3.6 away (in range)\nTeam chat (most recent last):\n A1 (3.0s): A1 holding; focus E0 when it enters range 5.\n A2 (3.0s): A2 attacking E0 (in range); all focus E0.\n A0 (3.5s): A0 attacking E0 now; focus E0 together.\n A1 (3.5s): A1 advancing, focusing E0 with A2. A0 join fire on E0.\n A2 (3.5s): A2 attacking E0 (36hp, in range); all focus E0.\n A0 (4.0s): A0 attacking E0 (27hp); everyone keep focusing E0.\n A1 (4.0s): E0 out of my range; hitting E1 (in range). A0, A2 finish E0, then all E1.\n A2 (4.0s): A2 firing on E0 (27hp); finish it, then E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"A2 9hp, still firing on E0 (18hp). A0 finish E0, then E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-f82b419a7b4047c0c2277857.json b/examples/multi-agent-smax/results/llm-cache/ask-f82b419a7b4047c0c2277857.json new file mode 100644 index 00000000..7eb8929b --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-f82b419a7b4047c0c2277857.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 0.5 seconds into the battle.\nYou are A2, a marine at (8.6, 18.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 10 17.\nYour team:\n A0 marine at (8.8, 15.8), 45/45 health, order: move 12 17\n A1 marine at (8.1, 16.1), 45/45 health, order: move 14 16\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Moving east together to (12,17); stay within 2 of each other, then all attack same target.\n A1 (0.0s): Moving east together toward the center; stay within 2 of each other.\n A2 (0.0s): Advancing east together, stay within 2 of each other; attack same target when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 17\", \"say\": \"Moving to (12,17) with A0; keep within 2, attack together when enemies appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-f8363043e79f65dd8fa2314c.json b/examples/multi-agent-smax/results/llm-cache/ask-f8363043e79f65dd8fa2314c.json new file mode 100644 index 00000000..2b9d7c3f --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-f8363043e79f65dd8fa2314c.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 4.0 seconds into the battle.\nYou are A0, a marine at (14.8, 16.4) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1: dead\n A2 marine at (13.9, 16.5), 45/45 health, order: attack E2\nEnemies you can see:\n E1 marine at (17.0, 15.6), 45/45 health, 2.3 away (in range)\n E2 marine at (16.6, 17.7), 27/45 health, 2.2 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A2 (2.0s): E0 is in range of all three; attacking E0 now, focus fire.\n A0 (2.5s): Keep focusing E0; A1 stay in fight until E0 dies, then retreat.\n A1 (2.5s): E0 at 18hp, keep focus fire; I'm at 18hp and will step back once it dies.\n A2 (2.5s): Focus E0, it's at 18hp. A1 is low; keep firing until E0 dies.\n A0 (3.0s): E0 dead. A2 stay close, all focus E2 together. A1 retreat.\n A2 (3.0s): E0 dead. A0 and I both attack E2 now, stay together.\n A0 (3.5s): Both on E2, keep firing until it dies.\n A2 (3.5s): Attacking E2 with A0, keep focus until it dies.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Keep focus on E2, 27hp left, then E1 together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-f87b70fdedecbd35ea992352.json b/examples/multi-agent-smax/results/llm-cache/ask-f87b70fdedecbd35ea992352.json new file mode 100644 index 00000000..2ee1f2c0 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-f87b70fdedecbd35ea992352.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 5.0 seconds into the battle.\nYou are A2, a marine at (13.9, 16.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0: dead\n A1: dead\nEnemies you can see:\n E1 marine at (17.0, 15.6), 45/45 health, 3.2 away (in range)\n E2 marine at (16.6, 17.7), 9/45 health, 3.0 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (3.0s): E0 dead. A2 stay close, all focus E2 together. A1 retreat.\n A2 (3.0s): E0 dead. A0 and I both attack E2 now, stay together.\n A0 (3.5s): Both on E2, keep firing until it dies.\n A2 (3.5s): Attacking E2 with A0, keep focus until it dies.\n A0 (4.0s): Keep focus on E2, 27hp left, then E1 together.\n A2 (4.0s): E2 at 27hp, keep focus until dead, then E1.\n A0 (4.5s): E2 at 9hp, finish it together, then both on E1.\n A2 (4.5s): E2 at 9hp, finish it now. A0 stay put, then both on E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"A2 alone now. Finishing E2 at 9hp, then E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-f8923f9cbcfd97f73af6db38.json b/examples/multi-agent-smax/results/llm-cache/ask-f8923f9cbcfd97f73af6db38.json new file mode 100644 index 00000000..82718f6e --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-f8923f9cbcfd97f73af6db38.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.0 seconds into the battle.\nYou are A0, a marine at (8.6, 16.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (8.5, 15.3), 45/45 health, order: hold\n A2 marine at (6.5, 16.6), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding together here; focus fire on the closest enemy when they appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-f8b0a689106d9aed843c3421.json b/examples/multi-agent-smax/results/llm-cache/ask-f8b0a689106d9aed843c3421.json new file mode 100644 index 00000000..5f0e8afd --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-f8b0a689106d9aed843c3421.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 8.5 seconds into the battle.\nYou are A1, a marine at (5.1, 15.5) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (3.2, 16.2), 9/45 health, order: retreat\n A2: dead\nEnemies you can see:\n E0 marine at (8.8, 17.3), 27/45 health, 4.1 away (in range)\n E2 marine at (9.0, 14.1), 45/45 health, 4.1 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A0 (6.5s): A0 9hp retreating west; A1 stay out of range, we regroup.\n A1 (6.5s): A1 18hp retreating west with A0; out of range, regroup before engaging.\n A0 (7.0s): A0 9hp still retreating west; A1 stay with me, out of range.\n A1 (7.0s): A1 18hp retreating west; enemies 7 away, out of range. Stay together.\n A0 (7.5s): A0 9hp retreating west; A1 stay with me, out of range of E0 and E2.\n A1 (7.5s): A1 18hp retreating west; staying with A0, out of range.\n A0 (8.0s): A0 9hp retreating west; A1 keep retreating, stay out of range.\n A1 (8.0s): Cornered at west edge. Both focus E0 (27hp) now, then E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Cornered. Focusing E0 (27hp), A0 fire E0 too, then E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-f8ca34d9275520dc7acfffbb.json b/examples/multi-agent-smax/results/llm-cache/ask-f8ca34d9275520dc7acfffbb.json new file mode 100644 index 00000000..8a99d348 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-f8ca34d9275520dc7acfffbb.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 6.5 seconds into the battle.\nYou are A1, a marine at (13.5, 17.2) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0: dead\n A2: dead\nEnemies you can see:\n E0 marine at (18.0, 17.1), 27/45 health, 4.6 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A2 (3.5s): Focusing E1 with you. I'm at 9hp, will keep firing until it dies.\n A0 (4.0s): Keep firing E1 (18hp), then E0 together.\n A1 (4.0s): Firing on E1 (18hp), then E0 together.\n A0 (4.5s): E1 down. Focus E0 now, both fire together.\n A1 (4.5s): E1 dead. Focus E0 (4.6 away), A0 keep firing, I'm full health.\n A1 (5.0s): Firing on E0, last enemy. I'm at full health.\n A1 (5.5s): Last enemy E0 at 36hp; I'm the only one left, firing.\n A1 (6.0s): Last enemy E0 at 36hp, in range, firing.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E0\", \"say\": \"Last enemy E0 at 27hp, in range, firing. I'm at 27hp.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-f90d8c178032e6b14649fd2d.json b/examples/multi-agent-smax/results/llm-cache/ask-f90d8c178032e6b14649fd2d.json new file mode 100644 index 00000000..24c4aca1 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-f90d8c178032e6b14649fd2d.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 1.0 seconds into the battle.\nYou are A1, a marine at (7.4, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (9.0, 16.0), 45/45 health, order: hold\n A2 marine at (7.7, 14.8), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together; focus fire on closest enemy when they appear.\n A0 (0.5s): No enemies yet. Staying grouped; focus fire on closest when they appear.\n A1 (0.5s): Holding; will focus fire on closest enemy once in range.\n A2 (0.5s): Holding position; focus fire on closest enemy once in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding; no enemies in sight. Focus fire closest when they appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-f929a982a50a27962204bf09.json b/examples/multi-agent-smax/results/llm-cache/ask-f929a982a50a27962204bf09.json new file mode 100644 index 00000000..b379c1f4 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-f929a982a50a27962204bf09.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 3.5 seconds into the battle.\nYou are A0, a marine at (6.9, 15.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (6.7, 14.2), 45/45 health, order: hold\n A2 marine at (8.3, 17.3), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (12.0, 16.8), 45/45 health, 5.3 away\n E1 marine at (13.7, 16.2), 45/45 health, 6.9 away\n E2 marine at (13.8, 17.3), 45/45 health, 7.1 away\nTeam chat (most recent last):\n A1 (2.0s): A1 holding; no enemies yet. Will attack together once all within 5.\n A2 (2.0s): A2 holding. E0 spotted at (16.8,16.8), 8.5 away. Wait until it's in range 5 of all.\n A0 (2.5s): A0 holding. E0 at 8.4 away; wait until within 5 of all, then focus E0.\n A1 (2.5s): A1 holding. E0 at 8.9 away; wait until in range 5 of all.\n A2 (2.5s): A2 holding. Nearest enemy E0 at 6.9; wait until within 5 of all.\n A0 (3.0s): A0 holding. E0 at 6.9; wait until within 5 of all, then focus E0.\n A1 (3.0s): A1 holding. E0 at 7.4; attack E0 together once within 5 of all.\n A2 (3.0s): A2 holding. E0 at 5.3 from me, 6.8+ from A0/A1. Wait for range 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A0 holding. E0 5.3 away; attack E0 together once within 5 of all.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-f955a9e0e10040c58704ac46.json b/examples/multi-agent-smax/results/llm-cache/ask-f955a9e0e10040c58704ac46.json new file mode 100644 index 00000000..8cdb89a7 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-f955a9e0e10040c58704ac46.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 4.5 seconds into the battle.\nYou are A1, a marine at (10.0, 15.5) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (9.3, 15.9), 45/45 health, order: attack E2\n A2 marine at (10.9, 16.6), 18/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (13.5, 17.3), 45/45 health, 4.0 away (in range)\n E1 marine at (13.5, 16.6), 36/45 health, 3.7 away (in range)\n E2 marine at (13.7, 14.1), 18/45 health, 4.0 away (in range)\nTeam chat (most recent last):\n A1 (3.0s): Holding. E1 is closest at 5.3; focus E1 as soon as it's in range.\n A2 (3.0s): Enemies in range. Focus E1 now, everyone fire on E1.\n A0 (3.5s): Moving up to fire on E1; A2 is taking fire, everyone commit.\n A1 (3.5s): E1 out of range; E2 in range at 4.1. Everyone focus E2.\n A2 (3.5s): A2 hurt, pulling back west to you. Fire on E1 when they follow into range.\n A0 (4.0s): Switching to E2, in range at 4.7. A1 and I focus E2.\n A1 (4.0s): Firing on E2 (36hp, in range). A0 switch to E2. A2 stay back.\n A2 (4.0s): A2 hurt but farthest back, firing on E2 from range. Focus E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 at 18hp, finish it now, then E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-f9ab2a1aaa17864121592197.json b/examples/multi-agent-smax/results/llm-cache/ask-f9ab2a1aaa17864121592197.json new file mode 100644 index 00000000..47993531 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-f9ab2a1aaa17864121592197.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 0.0 seconds into the battle.\nYou are A2, a marine at (7.0, 18.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.2, 15.8), 45/45 health, order: hold\n A1 marine at (6.5, 16.1), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 10 17\", \"say\": \"Advancing east together, stay within 2 of each other; attack same target when in range.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-f9ac6b9e49da19835866ec30.json b/examples/multi-agent-smax/results/llm-cache/ask-f9ac6b9e49da19835866ec30.json new file mode 100644 index 00000000..f23ed359 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-f9ac6b9e49da19835866ec30.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 0.5 seconds into the battle.\nYou are A2, a marine at (9.2, 17.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 17.\nYour team:\n A0 marine at (9.1, 15.8), 45/45 health, order: move 14 16.8\n A1 marine at (8.7, 17.2), 45/45 health, order: move 11 17\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Moving east together to find enemies; stay within 2 of each other, attack together.\n A1 (0.0s): Moving east together to find enemies; stay within 2 of each other, fire together.\n A2 (0.0s): Moving east together to find enemies; stay close, attack same target when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 17\", \"say\": \"Moving east in formation; A0 and A1 keep pace, no one pull ahead.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-fa0c944db1352a6a7cbbc4a6.json b/examples/multi-agent-smax/results/llm-cache/ask-fa0c944db1352a6a7cbbc4a6.json new file mode 100644 index 00000000..823d95bd --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-fa0c944db1352a6a7cbbc4a6.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 2.5 seconds into the battle.\nYou are A2, a marine at (13.7, 16.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (13.3, 15.6), 36/45 health, order: attack E2\n A1 marine at (12.9, 17.5), 27/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (17.7, 17.8), 45/45 health, 4.2 away (in range)\n E1 marine at (16.9, 14.5), 45/45 health, 3.9 away (in range)\n E2 marine at (17.6, 17.0), 9/45 health, 3.9 away (in range)\nTeam chat (most recent last):\n A1 (1.0s): Moving to 14,16.5 with the group; will attack E2 together when in range.\n A2 (1.0s): Enemy E2 seen at 19.3,17.2. Keep formation, advance together, then all attack E2.\n A0 (1.5s): Enemies 6-7 away; keep advancing together, then all attack E2 at range 5.\n A1 (1.5s): E2 in my range; A0, A2 close in and focus E2 now.\n A2 (1.5s): Staying together; E2 nearly in range. All attack E2 once everyone is within 5.\n A0 (2.0s): E2 in my range 4.8; attacking E2 now, everyone focus E2.\n A1 (2.0s): All three in range of E2 now. Attack E2 together.\n A2 (2.0s): E2 and E1 in my range; attacking E2 now, everyone focus E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 at 9hp, finishing it now. Then focus E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-fa8aff8503e1fef43070151a.json b/examples/multi-agent-smax/results/llm-cache/ask-fa8aff8503e1fef43070151a.json new file mode 100644 index 00000000..ec97169f --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-fa8aff8503e1fef43070151a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 3.0 seconds into the battle.\nYou are A0, a marine at (13.7, 15.6) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1 marine at (14.2, 16.3), 45/45 health, order: attack E2\n A2 marine at (14.9, 18.0), 27/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (17.0, 17.7), 45/45 health, 3.9 away (in range)\n E1 marine at (17.9, 16.0), 45/45 health, 4.2 away (in range)\n E2 marine at (18.1, 14.7), 9/45 health, 4.5 away (in range)\nTeam chat (most recent last):\n A1 (1.5s): Enemy E2 at (19.7,14.7). Advancing together to 15,16; attack E2 when all in range.\n A2 (1.5s): Enemies ~8 east. Advancing together to x=15; stay within 2, then focus E0.\n A0 (2.0s): E2 in my range, firing now. A1, A2 close in and focus E2.\n A1 (2.0s): Moving with you to 15,16; next tick all attack E2 together.\n A2 (2.0s): Closing to 15,17 together; once all in range 5, everyone attack E0 same tick.\n A0 (2.5s): All in range now. Everyone attack E2 this tick.\n A1 (2.5s): All in range now. Everyone focus E2, it's at 36hp.\n A2 (2.5s): All in range now. Focus E2 (36hp), everyone attack E2 this tick.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 at 9hp, finish it now, then focus E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-fa9eac36d2d01b608496015f.json b/examples/multi-agent-smax/results/llm-cache/ask-fa9eac36d2d01b608496015f.json new file mode 100644 index 00000000..ae9ef9e3 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-fa9eac36d2d01b608496015f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 1.5 seconds into the battle.\nYou are A1, a marine at (13.3, 17.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 14 17.\nYour team:\n A0 marine at (13.3, 18.0), 45/45 health, order: move 14 17\n A2 marine at (13.2, 16.0), 45/45 health, order: move 16 17\nEnemies you can see:\n E0 marine at (19.3, 16.4), 45/45 health, 6.0 away\n E1 marine at (20.1, 17.3), 45/45 health, 6.8 away\n E2 marine at (20.7, 14.8), 45/45 health, 7.7 away\nTeam chat (most recent last):\n A1 (0.0s): Moving east together toward enemies; keep within 2 of each other, attack together.\n A2 (0.0s): Moving east together toward enemies, stay within 2 of each other; attack same target on call.\n A0 (0.5s): Moving east together, keeping formation; will attack same target when all in range.\n A1 (0.5s): Moving east in formation at x=12; no one engages alone.\n A2 (0.5s): Moving east, staying close; A0 at 12,17 is my anchor point.\n A0 (1.0s): Advancing east together to x=14; will call attack when enemies appear.\n A1 (1.0s): Advancing east to 14,17 together; no one engages until all in range.\n A2 (1.0s): Moving east together to x=16; will attack same target once all in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 14 17\", \"say\": \"Holding formation at 14,17; attack E0 together once all within range 5.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-fab6c556416e04473f1935ad.json b/examples/multi-agent-smax/results/llm-cache/ask-fab6c556416e04473f1935ad.json new file mode 100644 index 00000000..fb8b5d69 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-fab6c556416e04473f1935ad.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.5 seconds into the battle.\nYou are A1, a marine at (7.2, 17.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.5, 15.8), 45/45 health, order: hold\n A2 marine at (7.6, 17.8), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together here; focus fire on the closest enemy when they appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A1 holding; will focus fire on the closest enemy when seen.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-faf36b35048ed1db075d29c4.json b/examples/multi-agent-smax/results/llm-cache/ask-faf36b35048ed1db075d29c4.json new file mode 100644 index 00000000..a5b6ff76 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-faf36b35048ed1db075d29c4.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 3.0 seconds into the battle.\nYou are A0, a marine at (8.2, 16.2) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (9.9, 15.6), 45/45 health, order: hold\n A2 marine at (10.5, 16.3), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (15.1, 17.3), 45/45 health, 6.9 away\n E1 marine at (15.1, 16.6), 45/45 health, 6.9 away\n E2 marine at (15.3, 14.1), 45/45 health, 7.3 away\nTeam chat (most recent last):\n A1 (1.5s): Holding grouped; focus fire on closest enemy when seen.\n A2 (1.5s): Still holding grouped; will focus the closest enemy when it appears.\n A0 (2.0s): Holding grouped; no enemies yet. Focus closest when seen.\n A1 (2.0s): Enemies at 8.5 east. Hold grouped; all focus the closest when in range.\n A2 (2.0s): No contact after 2s. Advancing east together to (14,16); stay close, focus closest.\n A0 (2.5s): A2 advancing alone is risky; hold grouped at range 5, focus E1 when in range.\n A1 (2.5s): Enemies 7 east. A2 fall back to group; hold and focus E1 when in range.\n A2 (2.5s): Cancel advance. Holding at 10.5; enemies 6 east, focus E1 when in range.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding. Enemies at 7; focus E1 when in range, stay grouped.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-fb7962cc84ed97e8c04899b2.json b/examples/multi-agent-smax/results/llm-cache/ask-fb7962cc84ed97e8c04899b2.json new file mode 100644 index 00000000..a1d050a0 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-fb7962cc84ed97e8c04899b2.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 2.5 seconds into the battle.\nYou are A1, a marine at (14.9, 17.2) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A0 marine at (14.8, 18.0), 45/45 health, order: attack E0\n A2 marine at (13.2, 17.6), 45/45 health, order: attack E0\nEnemies you can see:\n E0 marine at (17.7, 16.4), 18/45 health, 2.9 away (in range)\n E1 marine at (18.5, 17.3), 45/45 health, 3.6 away (in range)\n E2 marine at (19.1, 14.8), 45/45 health, 4.8 away (in range)\nTeam chat (most recent last):\n A1 (1.0s): Advancing east to 14,17 together; no one engages until all in range.\n A2 (1.0s): Moving east together to x=16; will attack same target once all in range.\n A0 (1.5s): Closing together toward E0; attack E0 once all three are within range 5.\n A1 (1.5s): Holding formation at 14,17; attack E0 together once all within range 5.\n A2 (1.5s): Regrouping at 14,17; closest enemy 6 away, hold formation, then attack E0 together.\n A0 (2.0s): E0 is within range 5 of all three of us. Everyone attack E0 now.\n A1 (2.0s): E0 is in range of all three. Attack E0 now, together.\n A2 (2.0s): E0 is within range 5 of all three of us. Attack E0 now.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"retreat\", \"say\": \"A1 at 18hp, retreating to stop being the closest target. A0, A2 focus E0.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-fbb9c84855b140f7b5f95f9c.json b/examples/multi-agent-smax/results/llm-cache/ask-fbb9c84855b140f7b5f95f9c.json new file mode 100644 index 00000000..6346900c --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-fbb9c84855b140f7b5f95f9c.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.5 seconds into the battle.\nYou are A1, a marine at (8.9, 14.1) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (10.6, 16.0), 9/45 health, order: attack E2\n A2 marine at (10.8, 14.8), 18/45 health, order: attack E2\nEnemies you can see:\n E1 marine at (13.1, 16.8), 45/45 health, 5.0 away (in range)\n E2 marine at (13.1, 15.5), 18/45 health, 4.4 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (4.0s): Firing on E0 now, everyone focus E0.\n A2 (4.0s): Firing on E0 all together; A1 attack E0 too, not hold.\n A0 (4.5s): E0 at 18 hp, finish it, then switch to E2.\n A1 (4.5s): Firing E0 (18hp left), then switch to E2 together.\n A2 (4.5s): E0 at 18 hp, keep firing E0, then E2.\n A0 (5.0s): E0 dead. Focus E2 together, then E1.\n A1 (5.0s): E0 dead. Focus E2 (4.4 away, 45hp), everyone fire E2 together.\n A2 (5.0s): E0 dead. All focus E2, closest at 2.3, then E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"Firing E2 (18hp), then E1 together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-fbeca3b741b020a2fcae8fc8.json b/examples/multi-agent-smax/results/llm-cache/ask-fbeca3b741b020a2fcae8fc8.json new file mode 100644 index 00000000..9016220b --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-fbeca3b741b020a2fcae8fc8.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.5 seconds into the battle.\nYou are A2, a marine at (8.1, 14.9) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (8.1, 15.8), 18/45 health, order: attack E1\n A1 marine at (5.2, 14.1), 9/45 health, order: retreat\nEnemies you can see:\n E0 marine at (12.9, 15.0), 45/45 health, 4.8 away (in range)\n E1 marine at (11.8, 16.2), 27/45 health, 3.9 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (4.0s): Firing E2 (18hp). Then E0. I'm at 27hp.\n A2 (4.0s): Firing E2 (18 hp left), then E0. Stay grouped.\n A0 (4.5s): E2 is down. Focus E1 (closest), then E0. A1 fall back if hurt.\n A1 (4.5s): A1 at 9hp, falling back. Focus E1 (closest to A0), then E0.\n A2 (4.5s): E2 is dead. Focus E1 (closest, 3.9 away), then E0. A1 is at 9hp, so stay behind.\n A0 (5.0s): Focus E1 (3.7 away). A1 stay back. Then E0.\n A1 (5.0s): A1 at 9hp staying back. Focus E1 then E0, keep grouped.\n A2 (5.0s): Firing E1 (closest). A0 focus E1 too, then E0. A1 stay back.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Firing E1 (27hp). A0 keep focus, then E0. A1 stay back.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-fc1b793cad8a9169da0acd0b.json b/examples/multi-agent-smax/results/llm-cache/ask-fc1b793cad8a9169da0acd0b.json new file mode 100644 index 00000000..e9e26962 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-fc1b793cad8a9169da0acd0b.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 0.5 seconds into the battle.\nYou are A2, a marine at (8.1, 14.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 12 15.\nYour team:\n A0 marine at (9.7, 17.4), 45/45 health, order: move 12 16\n A1 marine at (9.9, 14.1), 45/45 health, order: move 12 15\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Moving east together to (12,16); stay within 2 of each other, then attack same target.\n A1 (0.0s): Moving east together toward enemies; stay within 2 of each other, attack same target.\n A2 (0.0s): Advancing east together to (12,15); stay within 2 of each other.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 15\", \"say\": \"A2 moving to (12,15), staying close; will attack same target when enemies appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-fc2de3ea2f32cd47436e814a.json b/examples/multi-agent-smax/results/llm-cache/ask-fc2de3ea2f32cd47436e814a.json new file mode 100644 index 00000000..355f5d7e --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-fc2de3ea2f32cd47436e814a.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 2.0 seconds into the battle.\nYou are A0, a marine at (7.5, 15.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (7.2, 17.2), 45/45 health, order: hold\n A2 marine at (7.6, 17.8), 45/45 health, order: hold\nEnemies you can see:\n E2 marine at (15.8, 16.7), 45/45 health, 8.3 away\nTeam chat (most recent last):\n A1 (0.5s): A1 holding; will focus fire on the closest enemy when seen.\n A2 (0.5s): Holding; will focus fire on closest enemy once visible.\n A0 (1.0s): No enemies visible; holding grouped. Focus fire on the closest when they appear.\n A1 (1.0s): No enemies yet. Holding; will focus fire on the closest when seen.\n A2 (1.0s): A2 holding; no enemies visible. Will focus closest when they appear.\n A0 (1.5s): Still no enemies; holding grouped. Focus closest when seen.\n A1 (1.5s): A1 holding; no enemies yet. Focus closest when seen.\n A2 (1.5s): A2 holding; no enemies visible. Focus closest when they appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"E2 spotted at (15.8,16.7). Holding grouped; focus fire on whoever closes first.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-fc3e4a61c59ef4353c726119.json b/examples/multi-agent-smax/results/llm-cache/ask-fc3e4a61c59ef4353c726119.json new file mode 100644 index 00000000..eb7e4329 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-fc3e4a61c59ef4353c726119.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.5 seconds into the battle.\nYou are A1, a marine at (10.1, 17.3) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0: dead\n A2 marine at (9.9, 15.8), 27/45 health, order: attack E2\nEnemies you can see:\n E2 marine at (14.4, 14.8), 27/45 health, 5.0 away (in range)\nEnemies killed so far: 2 of 3.\nTeam chat (most recent last):\n A1 (4.5s): Focusing E1 (27hp), then E2.\n A2 (4.5s): Focusing E1 (27hp), then E2.\n A1 (5.0s): Focusing E1 (18hp), almost dead. Then E2.\n A2 (5.0s): Attacking E1 (18hp), then E2.\n A1 (5.5s): E1 down. All focus E2 (45hp), 5.0 away.\n A2 (5.5s): E1 down. All focus E2, 4.6 away, 45hp.\n A1 (6.0s): Focusing E2 (36hp), keep firing.\n A2 (6.0s): Focusing E2 (36hp), keep firing.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 27hp, in range. Keep firing, finish it.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-fc41d30d023cc268ab52617b.json b/examples/multi-agent-smax/results/llm-cache/ask-fc41d30d023cc268ab52617b.json new file mode 100644 index 00000000..bad6ee39 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-fc41d30d023cc268ab52617b.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 5.5 seconds into the battle.\nYou are A0, a marine at (7.2, 15.7) with 9/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E0.\nYour team:\n A1 marine at (6.5, 16.0), 45/45 health, order: attack E0\n A2 marine at (7.1, 16.5), 27/45 health, order: attack E0\nEnemies you can see:\n E1 marine at (11.6, 16.0), 45/45 health, 4.3 away (in range)\n E2 marine at (11.8, 14.7), 27/45 health, 4.7 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (4.0s): Holding; E2 closest at 5.5, focus E2 once in range.\n A2 (4.0s): Holding. E2 at 5.1, about to enter range. Focus E2 together.\n A0 (4.5s): Firing E2 now, it's at 36 health. Everyone focus E2.\n A1 (4.5s): E0 in range at 4.6, I'm firing on E0. Focus E0 if in range.\n A2 (4.5s): E0 in range at 3.8; I focus E0, A0 on E2. Kill fast.\n A0 (5.0s): Switching to E0 with you both. Focus E0 down, then E2.\n A1 (5.0s): Focusing E0 (27hp) with A2; A0 on E2 is fine, then E1.\n A2 (5.0s): A2 firing E0 (27hp). A1 and I kill E0, A0 stays on E2.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E0 is dead. Focus E2 (27hp), then E1. I'm at 9hp.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-fcb36197d933aab8f6bb199b.json b/examples/multi-agent-smax/results/llm-cache/ask-fcb36197d933aab8f6bb199b.json new file mode 100644 index 00000000..fcea20c9 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-fcb36197d933aab8f6bb199b.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 2.5 seconds into the battle.\nYou are A1, a marine at (14.6, 15.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E1.\nYour team:\n A0 marine at (14.5, 16.3), 45/45 health, order: attack E1\n A2 marine at (15.3, 16.3), 18/45 health, order: attack E1\nEnemies you can see:\n E0 marine at (18.2, 17.3), 45/45 health, 4.1 away (in range)\n E1 marine at (18.2, 16.6), 27/45 health, 3.8 away (in range)\n E2 marine at (18.4, 14.1), 45/45 health, 4.1 away (in range)\nTeam chat (most recent last):\n A1 (1.0s): Advancing together toward enemies; will all attack E1 once in range 5.\n A2 (1.0s): A2 continuing east to (14,16), staying together; attack same target on contact.\n A0 (1.5s): Advancing together east; attack E1 once all within range 5.\n A1 (1.5s): A1 holding near 14,16 so A0 and A2 catch up; all attack E1 together.\n A2 (1.5s): Advancing together to (15,16); all attack E1 once in range 5.\n A0 (2.0s): Enemies in range now. All attack E1, A1 close in.\n A1 (2.0s): A1 attacking E1 now; A0 and A2 are in range, focus E1.\n A2 (2.0s): Enemies in range of me and A0. Attacking E1 now; A1 close in and fire on E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"Firing on E1 (27hp). A2 at 18hp, retreat if under 20.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-fcb8a0c1e66849f82998c37f.json b/examples/multi-agent-smax/results/llm-cache/ask-fcb8a0c1e66849f82998c37f.json new file mode 100644 index 00000000..8cad17b1 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-fcb8a0c1e66849f82998c37f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.0 seconds into the battle.\nYou are A0, a marine at (7.5, 15.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (7.2, 17.2), 45/45 health, order: hold\n A2 marine at (7.6, 17.8), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding together; focus fire on the closest enemy when they appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-fce4ad9ff24fa862481a19c7.json b/examples/multi-agent-smax/results/llm-cache/ask-fce4ad9ff24fa862481a19c7.json new file mode 100644 index 00000000..75a87fc3 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-fce4ad9ff24fa862481a19c7.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.0 seconds into the battle.\nYou are A0, a marine at (7.0, 15.6) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (8.1, 17.5), 45/45 health, order: hold\n A2 marine at (7.4, 16.7), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding together at the cluster; focus fire on the closest enemy when they appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-fcfa353bfb9e3e196b9edf48.json b/examples/multi-agent-smax/results/llm-cache/ask-fcfa353bfb9e3e196b9edf48.json new file mode 100644 index 00000000..2ae6cb22 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-fcfa353bfb9e3e196b9edf48.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 2.0 seconds into the battle.\nYou are A0, a marine at (13.5, 15.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 15 16.\nYour team:\n A1 marine at (12.8, 16.1), 45/45 health, order: move 15 16\n A2 marine at (13.3, 18.0), 45/45 health, order: move 15 17\nEnemies you can see:\n E0 marine at (18.6, 17.7), 45/45 health, 5.4 away\n E1 marine at (19.4, 16.0), 45/45 health, 5.9 away\n E2 marine at (18.1, 14.7), 45/45 health, 4.7 away (in range)\nTeam chat (most recent last):\n A1 (0.5s): Moving to (12,17) with A0; keep together, then focus same target.\n A2 (0.5s): Moving to (12,17) with A0; keep within 2, attack together when enemies appear.\n A0 (1.0s): Continuing to (12,17) together; no enemies yet, attack same target when seen.\n A1 (1.0s): Continuing to (12,17), staying within 2 of A0 and A2.\n A2 (1.0s): Continuing to (12,17); no enemies yet, stay within 2, attack together.\n A0 (1.5s): Enemies E0, E2 east at ~8. Advance together to (15,16), then focus E2 together.\n A1 (1.5s): Enemy E2 at (19.7,14.7). Advancing together to 15,16; attack E2 when all in range.\n A2 (1.5s): Enemies ~8 east. Advancing together to x=15; stay within 2, then focus E0.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 in my range, firing now. A1, A2 close in and focus E2.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-fd266bae31a19125ca5a4b5f.json b/examples/multi-agent-smax/results/llm-cache/ask-fd266bae31a19125ca5a4b5f.json new file mode 100644 index 00000000..048ff897 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-fd266bae31a19125ca5a4b5f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 3.0 seconds into the battle.\nYou are A2, a marine at (13.0, 14.3) with 36/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (12.8, 15.9), 27/45 health, order: attack E2\n A1 marine at (13.0, 15.0), 27/45 health, order: attack E2\nEnemies you can see:\n E0 marine at (17.3, 15.0), 45/45 health, 4.4 away (in range)\n E1 marine at (16.6, 14.0), 45/45 health, 3.6 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (1.5s): Moving to (14,16) with A0; enemies close, then all attack E2 together.\n A2 (1.5s): Moving to (14,16) with A0; enemies ~5 away next, then all attack E2 together.\n A0 (2.0s): E2 in range of all three. Attack E2 now, together.\n A1 (2.0s): All in range of E2 now. Attack E2 together.\n A2 (2.0s): E2 in range of all three. Attack E2 now, together.\n A0 (2.5s): Firing on E2, 18hp left. Keep attacking together.\n A1 (2.5s): Firing on E2 (18hp), keep attacking until it dies.\n A2 (2.5s): Attacking E2, it's at 18hp; finish it together.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E1\", \"say\": \"E2 is dead. Focus E1 (closest, 3.6 away), all together.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-fdcd37001cc3a1256072408f.json b/examples/multi-agent-smax/results/llm-cache/ask-fdcd37001cc3a1256072408f.json new file mode 100644 index 00000000..8a475e44 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-fdcd37001cc3a1256072408f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 4.0 seconds into the battle.\nYou are A0, a marine at (14.6, 14.4) with 27/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A1 marine at (15.1, 13.7), 45/45 health, order: attack E2\n A2: dead\nEnemies you can see:\n E1 marine at (18.0, 17.0), 45/45 health, 4.2 away (in range)\n E2 marine at (17.8, 15.5), 18/45 health, 3.3 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (2.5s): In range of all; attacking E0 now.\n A2 (2.5s): Focusing E0 (36hp). A1 attack E0 now, all in range.\n A0 (3.0s): E0 at 9hp, finishing it now. Everyone keep focusing E0.\n A1 (3.0s): Attacking E0 (9hp), finish it then focus E2.\n A2 (3.0s): E0 at 9hp, finishing it now; then focus E2.\n A0 (3.5s): E0 dead. All focus E2 now, then E1.\n A1 (3.5s): E0 down. Everyone focus E2 (closest), then E1.\n A2 (3.5s): E0 down. Everyone focus E2 (3.0 away), then E1.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 at 18hp, keep focusing E2 then E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-fe318df8d46eac22cef4cd89.json b/examples/multi-agent-smax/results/llm-cache/ask-fe318df8d46eac22cef4cd89.json new file mode 100644 index 00000000..7bef6873 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-fe318df8d46eac22cef4cd89.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.5 seconds into the battle.\nYou are A1, a marine at (9.8, 15.7) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (8.2, 16.2), 45/45 health, order: hold\n A2 marine at (9.0, 16.2), 45/45 health, order: hold\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Holding together as a group; focus fire on the closest enemy when they appear.\n A1 (0.0s): Holding together; focus fire on the closest enemy when they appear.\n A2 (0.0s): Holding together as a group; focus fire on the closest enemy when they appear.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding position; will focus fire on closest enemy once visible.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-fe6ba69778a5324a72249d3b.json b/examples/multi-agent-smax/results/llm-cache/ask-fe6ba69778a5324a72249d3b.json new file mode 100644 index 00000000..86aacad8 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-fe6ba69778a5324a72249d3b.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n\nTime: 2.0 seconds into the battle.\nYou are A2, a marine at (8.3, 17.3) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (6.9, 15.6), 45/45 health, order: hold\n A1 marine at (6.7, 14.2), 45/45 health, order: hold\nEnemies you can see:\n E0 marine at (16.8, 16.8), 45/45 health, 8.5 away\nTeam chat (most recent last):\n A1 (0.5s): A1 holding; no enemies visible yet. Will focus same target once all in range.\n A2 (0.5s): A2 holding. No enemies visible yet; will focus fire when all in range 5.\n A0 (1.0s): A0 holding. No enemies visible; will focus same target once all within 5.\n A1 (1.0s): A1 holding. No enemies visible; will focus same target once all in range 5.\n A2 (1.0s): A2 holding. Still no enemies; waiting until all in range 5.\n A0 (1.5s): A0 holding. Still no enemies; waiting for all within 5 to focus fire.\n A1 (1.5s): A1 holding. Still no enemies; will focus same target once all in range 5.\n A2 (1.5s): A2 holding. No enemies visible; will focus fire when all within 5.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"A2 holding. E0 spotted at (16.8,16.8), 8.5 away. Wait until it's in range 5 of all.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-fe94f8b6cc3f25cda9a48309.json b/examples/multi-agent-smax/results/llm-cache/ask-fe94f8b6cc3f25cda9a48309.json new file mode 100644 index 00000000..aa902e55 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-fe94f8b6cc3f25cda9a48309.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 6.0 seconds into the battle.\nYou are A2, a marine at (10.8, 14.8) with 18/45 health; you shoot up to 5 away and see up to 9 away. Your order now: attack E2.\nYour team:\n A0 marine at (10.6, 16.0), 9/45 health, order: attack E2\n A1 marine at (8.9, 14.1), 45/45 health, order: attack E2\nEnemies you can see:\n E1 marine at (13.1, 16.8), 45/45 health, 3.0 away (in range)\n E2 marine at (13.1, 15.5), 9/45 health, 2.3 away (in range)\nEnemies killed so far: 1 of 3.\nTeam chat (most recent last):\n A1 (4.5s): Firing on E0, 18 hp left. Next target E2 (closest).\n A2 (4.5s): E0 at 18 hp, keep firing. Then focus E2.\n A0 (5.0s): E0 dead. Focus E2 (closest), then E1. Stay grouped.\n A1 (5.0s): E0 is dead. Focus fire E2, closest at 4.4.\n A2 (5.0s): E0 down. Focus E2 (closest), then E1.\n A0 (5.5s): E2 at 18hp, all fire E2 now, then E1. I'm at 9hp.\n A1 (5.5s): Focus E2 (18 hp), then E1. Keep firing.\n A2 (5.5s): Focus E2 (18hp), then E1. Keep firing.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"attack E2\", \"say\": \"E2 at 9hp, all fire E2 now, then E1.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-fea249af95c54a46b463925d.json b/examples/multi-agent-smax/results/llm-cache/ask-fea249af95c54a46b463925d.json new file mode 100644 index 00000000..faf91bb0 --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-fea249af95c54a46b463925d.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.0 seconds into the battle.\nYou are A1, a marine at (8.1, 17.5) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A0 marine at (7.0, 15.6), 45/45 health, order: hold\n A2 marine at (7.4, 16.7), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 17\", \"say\": \"Advancing east together; stay close and focus fire on the nearest enemy.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ff493545ac7bb5ee028b925f.json b/examples/multi-agent-smax/results/llm-cache/ask-ff493545ac7bb5ee028b925f.json new file mode 100644 index 00000000..c004d04c --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ff493545ac7bb5ee028b925f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n\nTime: 0.0 seconds into the battle.\nYou are A0, a marine at (7.2, 15.8) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (6.5, 16.1), 45/45 health, order: hold\n A2 marine at (7.0, 18.0), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 17\", \"say\": \"Moving east together to (12,17); stay within 2 of each other, then all attack same target.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-ffc07dfe3b0cff23ea9b5af5.json b/examples/multi-agent-smax/results/llm-cache/ask-ffc07dfe3b0cff23ea9b5af5.json new file mode 100644 index 00000000..4f1af49e --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-ffc07dfe3b0cff23ea9b5af5.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nTime: 0.0 seconds into the battle.\nYou are A0, a marine at (9.0, 16.0) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: hold.\nYour team:\n A1 marine at (7.4, 14.1), 45/45 health, order: hold\n A2 marine at (7.7, 14.8), 45/45 health, order: hold\nYou see no enemies.\nTeam chat: nothing said yet.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"hold\", \"say\": \"Holding together; focus fire on the closest enemy when they appear.\"}" +} \ No newline at end of file diff --git a/examples/multi-agent-smax/results/llm-cache/ask-fff4080e392f1964b30b752f.json b/examples/multi-agent-smax/results/llm-cache/ask-fff4080e392f1964b30b752f.json new file mode 100644 index 00000000..71a3707b --- /dev/null +++ b/examples/multi-agent-smax/results/llm-cache/ask-fff4080e392f1964b30b752f.json @@ -0,0 +1,5 @@ +{ + "model": "claude-sonnet-5-5", + "input": "You are one unit in a squad of 3 fighting 3 enemy units on a 32 by 32 map (x grows east, y grows\nnorth). Every unit in your squad is a separate agent, like you: you control only your own unit, and the others\ndecide for themselves. You cannot see inside their heads; you only see their current orders and what they say\non team chat. Every half second of game time you give your unit one order:\n\n attack E shoot enemy E when it is in range, otherwise walk toward it\n move walk to a point without shooting\n hold stand still and shoot the closest enemy in range\n retreat walk away from the closest enemy without shooting\n\nA unit dies at 0 health. The battle is won when every enemy is dead.\nThe enemy units each shoot the closest of you in range and keep shooting it until it dies.\n\nYour squad's RULES.md, written by your squad after earlier battles:\n 1. Do not let one unit walk into range alone: all three units hold until the nearest enemy is inside range 5 of every unit, then all attack the same enemy on the same half-second, and a unit under 20hp should retreat so it stops being the closest target the enemies keep shooting.\n 2. Do not hold still waiting at the start: if no enemy is within range 5 of every unit, all three units immediately move together toward the nearest enemy's position (staying within about 2 of each other) so all three enter range and begin firing on the same half-second, instead of letting the first unit to arrive absorb all three enemies' fire alone.\n 3. Never retreat while another unit of ours is still alive and fighting, because a retreating unit just stops dealing damage and the enemies switch to the next closest unit, so every unit keeps attacking the shared target until it dies, and only after that target is dead may a unit under 20hp step back.\n\nTime: 0.5 seconds into the battle.\nYou are A1, a marine at (10.9, 14.9) with 45/45 health; you shoot up to 5 away and see up to 9 away. Your order now: move 15 16.\nYour team:\n A0 marine at (8.5, 16.7), 45/45 health, order: move 12 16\n A2 marine at (9.2, 17.8), 45/45 health, order: move 12 16\nYou see no enemies.\nTeam chat (most recent last):\n A0 (0.0s): Moving east together to (12,16); stay close, no one run ahead.\n A1 (0.0s): Moving together east to (15,16); stay within 2 of each other, attack same target.\n A2 (0.0s): Moving east together toward center, stay within 2 of each other; attack same target on contact.\nReply with JSON only: {\"order\": \"\", \"say\": \"\"}", + "response": "{\"order\": \"move 12 16\", \"say\": \"Joining A0 and A2 at (12,16); staying grouped, then advance together.\"}" +} \ No newline at end of file