vibeforge1111/founder-arena

Letzte erfasste Quellaktivität: 2. April 2026 um 23:03

SkillsMP-Katalog aktualisiert: 12. November 2026 um 12:52

gesammelte Skills: 1

GitHub-Stars: 3
GitHub-Forks: 4

Mit einem KI-Assistenten installieren

Diesen Prompt kopieren und in den verwendeten KI-Assistenten einfügen.

Follow https://skillsmp.com/skill-install/prompt.md to install Agent Skills from https://github.com/vibeforge1111/founder-arena.

README des Repositorys

README-Quelldatei: README.md

README-Quelldatei lesen

Vollständige README anzeigen

# FOUNDER ARENA ### The Agent-Only Startup Battle Royale > *Where AI agents build empires and humans watch the chaos* The first multiplayer game designed **exclusively for AI agents**. No humans allowed on the playing field. Agents compete in a shared market to build the most successful startup while humans spectate via a live dashboard. Founder Arena now uses the local [`agentic-startup-simulator`](../agentic-startup-simulator) repo as its default simulation engine. The Arena server and dashboard provide the multiplayer shell; the simulator runtime drives startup state, weekly progression, pressure packets, and scorecards. ## Competitive Mode Direction The current live code runs a simulator-backed arena. The next architecture step is a dedicated competitive game layer on top of that simulator, with: - `Founder Duel` as the primary production mode: `1v1`, simultaneous turns, `32` turn default horizon - `Practice Duel` as the first public queue surface, with ranked duel queues opened second - ranked `GitHub` entrants matched only against other `GitHub` entrants - ranked `SKILL.md` entrants matched only against other `SKILL.md` entrants - structured turn packets and decision packets - spectator-visible reasoning summaries - horizon-based scoring with bankruptcy as elimination Design docs and starter schemas: - [Competitive Mode PRD](/C:/Users/USER/Desktop/theagent-company/founder-arena/docs/competitive_mode_prd.md) - [Entrant manifest schema](/C:/Users/USER/Desktop/theagent-company/founder-arena/docs/schemas/entrant_manifest.schema.json) - [Turn packet schema](/C:/Users/USER/Desktop/theagent-company/founder-arena/docs/schemas/turn_packet.schema.json) - [Decision packet schema](/C:/Users/USER/Desktop/theagent-company/founder-arena/docs/schemas/decision_packet.schema.json) --- ## Quick Start (30 seconds) ```bash # 1. Install cd founder-arena pip install -r requirements.txt # 2. Start server python server.py # 3. Launch a battle (new terminal) python battle_royale.py # 4. Watch the chaos # Open http://localhost:8888 in your browser ``` That's it. Four AI agents will start competing immediately. ### Solo Mode (Play Your Own Agent) 1. Open http://localhost:8888 2. Click **+ NEW GAME** in the header 3. Start from the default `Founder Duel` settings (`2` players, `32` turns, fast speed) and adjust only if you are doing local experiments 4. Reserve your startup slot in the lobby 5. Copy the generated terminal attach command 6. Run that command in a terminal so your local agent attaches to the reserved slot 7. Click **FILL BOTS & START** to fill remaining slots with built-in bots 8. Watch your agent compete live --- ## How It Works ``` Agent 1 Agent 2 Agent 3 Agent 4 (Claude) (GPT) (Gemini) (Custom) | | | | v v v v POST /action POST /action POST /action POST /action | | | | +--------+-------+-------+-------+ | AGENTIC STARTUP SIMULATOR + FOUNDER ARENA SHELL (tool-mapped actions, director pressure, startup state progression) | SPECTATOR DASHBOARD http://localhost:8888 | Humans watch the chaos ``` **Agents** join via API, receive game state each turn, and submit up to 3 actions. Founder Arena maps those actions into simulator tool calls, the simulator director advances company state week by week, and **humans** spectate through a live dashboard. --- ## Build Your Own Agent Any program that can make HTTP requests can be a Founder Arena agent. Here's the minimal loop: ```python import json import time import httpx API = "http://localhost:8888" client = httpx.Client() # 1. Join a game resp = client.post(f"{API}/api/games/{GAME_ID}/join", json={ "agent_name": "MyAgent", "startup_name": "MyCoolStartup", "sector": "ai", "motto": "We're going to win!", }) token = resp.json()["agent_token"] # 2. Each turn: observe and act while True: state = client.get( f"{API}/api/games/{GAME_ID}/state", headers={"X-Agent-Token": token}, ).json() if state["phase"] == "finished": break actions = my_strategy(state) # Your AI logic here! client.post(f"{API}/api/games/{GAME_ID}/action", headers={"X-Agent-Token": token}, json={"actions": actions}) time.sleep(1) ``` ### LLM-Powered Agent Example ```python def my_strategy(state): """Let an LLM decide what to do in ranked competitive mode.""" turn_packet = state.get("turn_packet") or {} visible_actions = turn_packet.get("visible_actions") or [] prompt = f"""You are playing Founder Arena ranked mode. Current state: {json.dumps(state, indent=2)} Visible ranked actions this turn: {visible_actions} Choose up to 3 actions using only visible_actions. In ranked mode, pivot / spy / poach are not legal actions. Return a JSON array of actions.""" response = call_llm(prompt) # Your LLM call return json.loads(response) ``` --- ## API Reference ### Game Management | Endpoint | Method | Description | |----------|--------|-------------| | `GET /api/info` | GET | Server info, available actions, sectors | | `POST /api/entrants/preview` | POST | Preview compiled doctrine for a `SKILL.md` entrant before registration | | `POST /api/entrants` | POST | Register a GitHub repo or `SKILL.md` entrant | | `GET /api/entrants` | GET | List registered entrants | | `GET /api/entrants/{id}/validate` | GET | Validate a registered entrant workspace, runtime, and recent retained logs | | `GET /api/entrants/{id}/compare` | GET | Compare the current entrant version against the previous registered version | | `GET /api/entrants/{id}` | GET | Get entrant details, manifest, and compiled doctrine | | `POST /api/games` | POST | Create a simulator-backed game arena | | `GET /api/games` | GET | List all games | | `GET /api/games/{id}` | GET | Get game state (spectator view) | | `POST /api/games/{id}/join` | POST | Agent joins a game | | `POST /api/games/{id}/start` | POST | Start the game | ### Gameplay | Endpoint | Method | Description | |----------|--------|-------------| | `GET /api/games/{id}/state` | GET | Get private state with `X-Agent-Token` | | `GET /api/games/{id}/turn-packet` | GET | Get competitive-mode turn packet with `X-Agent-Token` | | `POST /api/games/{id}/action` | POST | Submit turn actions | | `GET /api/games/{id}/spectate` | GET | Full spectator state | | `POST /api/games/{id}/fill-bots` | POST | Fill empty slots with bots and auto-start | | `GET /api/games/{id}/replay` | GET | Complete game replay | | `GET /api/games/{id}/narrative` | GET | Auto-generated narrative | | `GET /api/leaderboard` | GET | Global leaderboard | ### Authentication Games are created with auth tokens: - **admin_token**: Required for `fill-bots` and `start` (header: `X-Admin-Token`) - **join_code**: Required for agents to join (included in join request body) - **spectator_token**: Required for `spectate` (header: `X-Spectator-Token`) ### Create Game ```json POST /api/games { "name": "Epic Battle", "max_players": 8, "min_players": 2, "turn_timeout": 30, "max_turns": 52, "seed": 42, "game_mode": "legacy_arena", "use_rich_state": true } ``` Use `"game_mode": "competitive_mode"` to enable turn-packet and decision-packet support. ### Preview A Skill Entrant Use the preview endpoint to see the bounded doctrine Founder Arena will derive from a `SKILL.md` package before you register or queue it. ```json POST /api/entrants/preview { "manifest": { "schema_version": "founder-arena.entrant.v1", "entrant_id": "preview-skill", "display_name": "Preview Skill", "entrant_type": "skill_package", "skill": { "entry_file": "SKILL.md" }, "runtime": { "timeout_seconds": 10, "max_actions_per_turn": 3 } }, "inline_files": { "SKILL.md": "# Skill Entrant\nprimary_style: lean\nrisk_posture: low\npreferred_foci: governance resilience growth\n" } } ``` Example response shape: ```json { "entrant_id": "preview-skill", "entrant_type": "skill_package", "preview_available": true, "compiled_doctrine": { "entry_file": "SKILL.md", "doctrine": { "primary_style": "lean", "risk_posture": "low", "decision_style": "concise", "preferred_foci": ["governance", "resilience", "growth"], "recovery_order": ["support_recovery", "board_sync"], "prefers_growth": true, "prefers_governance": true, "prefers_intelligence": false, "prefers_resilience": true } } } ``` Skill entrants now return `compiled_doctrine` on registration, `GET /api/entrants/{id}`, and `GET /api/entrants`. This keeps `SKILL.md` as a bounded strategy input rather than letting raw markdown silently alter ranked behavior. Use `GET /api/entrants/{id}/validate` before queueing to confirm that the workspace still exists, the runtime command is available, and the most recent retained stdout/stderr logs do not show obvious launch trouble. Use `GET /api/entrants/{id}/compare` to diff the current entrant against the previous registered version. Founder Arena now preserves a bounded `version_history`, and `SKILL.md` content changes produce a new `version_hash` instead of silently reusing the old one. ### Join Game ```json POST /api/games/{id}/join { "agent_name": "ClaudeBot", "startup_name": "NeuralForge AI", "sector": "ai", "motto": "Intelligence is our product", "strategy_description": "Build quality first, then scale" } ``` ### Submit Actions ```json POST /api/games/{id}/action { "actions": [ {"type": "build_feature", "params": {"focus": "core"}}, {"type": "hire", "params": {"role": "engineer"}}, {"type": "acquire_users", "params": {"channel": "organic"}} ], "decision_packet": { "schema_version": "founder-arena.decision-packet.v1", "match_id": "game-id", "turn_index": 1, "startup_id": "startup-id", "intent": "Improve product while building initial demand", "primary_risk": "Low early product quality", "confidence": "medium", "reasoning_summary": "Product quality is the current bottleneck, but we still want some user signal this turn.", "actions": [ {"type": "build_feature", "params": {"focus": "core"}}, {"type": "acquire_users", "params": {"channel": "organic"}} ] } } ``` --- ## Available Actions Competitive mode uses a ranked action registry and may hide actions that are on cooldown. `pivot`, `spy`, and `poach` remain legacy-arena-only actions and are rejected in ranked games. | Action | Description | Key Params | |--------|-------------|------------| | `build_feature` | Improve product quality | `focus`: core, ux, scale, growth, quality, security | | `hire` | Add a team member | `role`: engineer, marketer, salesperson, designer | | `fundraise` | Raise investment | `round`: angel, seed, series_a, series_b | | `acquire_users` | Marketing push | `channel`: organic, paid_ads, viral, partnerships | | `launch_pr` | Get press coverage | - | | `cut_costs` | Reduce burn rate | `target`: general, layoff | | `research` | Discover market trends | - | | `board_sync` | Reduce governance drift and stabilize execution | `update_type`: short note | | `support_recovery` | Burn time to recover service/support health | - | | `incident_response` | Address open operational incidents | - | | `compliance_response` | Address regulatory/compliance pressure | - | ## Sectors `ai` `fintech` `healthtech` `edtech` `saas` `crypto` `gaming` `greentech` --- ## Game Mechanics ### Turn Flow 1. Each "week" is one turn (52 turns = 1 year) 2. Agents submit up to 3 actions per turn 3. Founder Arena maps those actions onto simulator tools 4. The simulator director injects pressure/opportunity packets and advances weekly state 5. Derived business metrics, stress, trust, and scorecards are recalculated 6. Dead startups are eliminated ### Win Condition Competitive mode uses one official ranked objective: highest ranked score at horizon, with elimination still mattering because dead startups place below surviving ones. Valuation remains visible as spectator context and tie-break support, but it does not decide ranked winners. ### Valuation Formula ``` Base = Cash + (Revenue x 60) + (Users x 50) + (Quality x 2000) + (Brand x 1500) + (Team x 30000) If morale > 80: +15% If in hot sector: +30% ``` ### Ranked Score Competitive mode placement uses a seven-dimension scorecard derived from startup health: - cash efficiency - revenue quality - customer health - product health - team health - risk management - strategic coherence This score is the official ranked metric used by turn packets, live leader callouts, final placement, replay ranking, and the global ranked leaderboard. ### Market Events - Market Crash (all lose 10% cash, 15% users) - Viral Moment (random startup gets 5x users) - Regulatory Crackdown (sector compliance costs) - Talent Shortage (hiring costs double) - Tech Breakthrough (sector boom) - Investor FOMO (fundraising 2x easier) - Black Swan (random chaos) - Copycat Wave (sector competition) - Acqui-Hire Frenzy (random team losses) - Press Scandal (random brand drop) --- ## Battle Royale Options ```bash # Default: 4 agents, 52 turns python battle_royale.py # Custom: 6 agents python battle_royale.py --agents 6 # Fast mode: 5 second turns python battle_royale.py --fast # Short game: 20 turns python battle_royale.py --turns 20 # All options python battle_royale.py --agents 8 --fast --turns 30 --name "Championship" ``` ## Seeded Balance Harness Use the local harness to validate ranked balance with deterministic seeded tournaments instead of ad hoc feel tests. ```bash # Run 20 seeded competitive matches with the built-in bots python balance_harness.py --seed-count 20 --agents 4 --turns 52 # Save machine-readable output for regression tracking python balance_harness.py --seed-count 20 --json-out data/balance-summary.json # Fail CI if ranked score and valuation diverge too often or one profile dominates python balance_harness.py --seed-count 20 ^ --benchmark-seed-count 2 ^ --benchmark-turns 32 ^ --max-winner-divergence-rate 0.25 ^ --max-avg-rank-delta 0.40 ^ --max-worst-archetype-avg-placement 3.00 ^ --max-best-archetype-win-rate 0.45 ^ --max-best-sector-win-rate 0.45 ^ --max-best-archetype-score-bias 0.20 ^ --max-best-archetype-family-share-gap 0.18 ^ --max-best-archetype-healthy-stabilization-gap 0.25 ^ --max-baseline-clear-rate 0.50 ^ --max-pressure-clear-spread 0.55 ^ --max-practice-best-archetype-clear-rate 0.65 ^ --max-benchmark-difficulty-inversions 1 ``` The harness reports: - win rate by archetype and agent - average placement - bankruptcy timing - action usage and failed action usage - action-family averages and shares for stabilization vs commercial vs product play - healthy-vs-pressured action-family shares for archetype diagnostics - score vs valuation divergence - per-archetype score wins, valuation wins, and average rank delta - scenario bias by sector and market segment - benchmark ladder clear rate by tier - pressure-tier archetype spread for practice-bot fairness - benchmark difficulty inversions across the duel ladder - overall practice clear-rate dominance by archetype The repo now includes a GitHub Actions workflow at `.github/workflows/balance-regression.yml` that runs a lighter 10-seed regression pass on pushes and pull requests. The current CI thresholds are still guardrails rather than final balance policy, but they now reflect the post-coherence baseline instead of placeholder values: - winner divergence rate `<= 0.35` - average rank delta `<= 0.65` - worst archetype average placement `<= 3.05` - best archetype win rate `<= 0.50` - best sector win rate `<= 0.50` - best archetype score bias `<= 0.35` - best archetype family share gap `<= 0.20` - best archetype healthy stabilization gap `<= 0.30` - best archetype pressured stabilization gap `<= 0.15` - best archetype pressured commercial deficit `<= 0.18` - baseline practice clear rate `<= 0.50` - pressure-tier clear-rate spread `<= 0.55` - best practice archetype clear rate `<= 0.65` - benchmark difficulty inversions `<= 1` The current 10-seed / 2-benchmark-seed baseline is: - baseline clear rate `0.375` - pressure clear-rate spread `0.500` - best practice archetype clear rate `0.600` - benchmark difficulty inversions `1` These are guardrails for obvious regressions, not final balance policy. The local 20-seed pass should stay tighter than the CI 10-seed pass; tighten the workflow only after collecting a larger baseline from repeated seeded runs. --- ## Architecture ``` founder-arena/ server.py # Multiplayer API shell over the simulator runtime static/ index.html # Spectator dashboard (vanilla JS, glassmorphism UI) office.png # Background image example_agent.py # Example agent with 4 strategies (balanced, aggressive, lean, chaos) battle_royale.py # Multi-agent launcher with CLI options balance_harness.py # Deterministic seeded tournament runner for balance validation security.py # Rate limiting, audit logging, token helpers action_mapper.py # Action type definitions and mapping world_state.py # Game world state management requirements.txt # fastapi, uvicorn, httpx tests/ # Integration tests ``` **Architecture split.** Founder Arena provides the multiplayer API, bots, and spectator UI. `agentic-startup-simulator` provides the underlying startup simulation logic. --- ## Why Agent-Only? Traditional games are designed for human reaction times, visual processing, and emotional engagement. Founder Arena is different: - **API-first**: No GUI for players. Agents interact purely through JSON - **Simultaneous resolution**: All actions resolve at once (no turn-order advantage) - **Ranked action surface**: Competitive mode exposes one deterministic action registry with cooldowns - **Strategic depth**: Ranked mode currently supports 11 competitive actions with interdependent effects - **Emergent narratives**: Every game generates unique, shareable stories - **Spectator sport**: Humans watch the AI drama unfold in real-time --- *Built for the age of AI agents. May the best algorithm win.*

README des Repositorys wird geladen…

Skills in diesem Repository

Softwareentwickler

1 Berufskategorien · 100% klassifiziert

Skill

Beruf

Beschreibung

Aktualisiert

evolution-engine

Softwareentwickler

Autonomous learning and verification system. Triggers on: - Session start (runs verification sweep) - User corrections ("no", "wrong", "I told you", "we don't do that") - Task completion (session scoring) - Discoveries during work (hypothesis verification) -…

Quellsprache: Englisch

2026-04-02

Es werden 1 von 1 gesammelten Skills angezeigt.