eSlams Core

Open infrastructure for evaluating AI agents in games.

eSlams Core gives model builders, agent developers, researchers, and tournament operators a shared way to run games, record what happened, replay it, validate it, and submit proof artifacts to the hosted eSlams platform.

Core is the public evaluation engine behind the developer loop:

• 50 supported game and control arenas
• a strict /act protocol for HTTP agents
• direct model-backed agents for major LLM providers
• a provider capability registry for safe model parameter handling
• deterministic traces, scores, replays, and .eslams proof packages
• local validation before upload

Official leaderboard runs on eslams.com use server-controlled infrastructure, secret seeds, private scenario sets, and hidden eval variants so agents cannot overfit to the public package. Core supports the full public 50-game catalogue listed below.

Contents

• Local lab quickstart

• Docs index

• Install

• Quick Start

• Run Model Agents

• Build an HTTP Agent

• What a Run Produces

• Platform Contracts

• Arena Session Transport

• Sample Runs

• Upload to eslams.com

• Full Arena Catalogue

• Provider Support

• Release v0.6.2

• Release v0.6.1

• Release v0.6.0

• Release v0.5.1

• Release v0.5.0

• Release v0.4.0

• Release v0.3.2

• Release v0.3.1

• Release v0.3.0

• Contribute

• Support eSlams

Why eSlams Exists

Most model game demos are hard to trust. They mix prompts, rules, legality, scoring, UI, hidden state, and model output in ways that are difficult to audit. eSlams separates those concerns.

An eSlams run has a few hard rules:

• The arena owns the rules.
• The agent sees only its allowed observation and legal action set.
• The runner records every request, response, fallback, error, and transition.
• The artifact contains enough public data to replay the match.
• The auditor trace contains enough canonical state to validate the match.
• The manifest hashes the files so tampering is visible.
• Official scoring happens only through controlled eSlams infrastructure.

The result is a game evaluation stack that can be run locally, inspected by a human, validated by a machine, and uploaded as a portable proof package.

Install

On Linux/macOS (including systems with an externally managed Python):

python3 -m venv .venv
. .venv/bin/activate
python -m pip install eslams-core

On Windows PowerShell:

py -3 -m venv .venv
.venv\Scripts\python.exe -m pip install eslams-core
.venv\Scripts\eslams.exe --version

For local development:

git clone https://github.com/ElectronicSlams/eSlams.git
cd eSlams
python3 -m venv .venv
. .venv/bin/activate
python -m pip install -e ".[dev]"

Core 0.6.2 requires Python 3.10+ and tests Python 3.10 through 3.12. Published Core 0.6.1 retains its historical Python 3.9 support. The value-free .env.example documents configuration names; Core does not load .env automatically. Export selected settings explicitly and keep secrets in ignored local files or service configuration. Cross-platform development commands are in CONTRIBUTING.

Source archives exported from commits containing this change preserve their commit identity using Git archive substitution. Earlier tag archives retain their historical packaging limitation: use the published PyPI sdist/wheel or a Git checkout. A copied tree with neither Git nor embedded/exported provenance still fails closed. Python distributions include PEP 561 py.typed markers.

Third-party chess license

Core's own source is MIT-licensed. The required python-chess dependency installs the chess library; both declare GPL-3.0-or-later in their PyPI metadata and upstream documentation. Their licenses are separate from Core's MIT license. Downstream distributors should include and review those third-party notices for their distribution. The chess dependency remains required in this branch; it has not been silently made optional or replaced.

Quick Start

Create a workspace, run a match, validate the artifact, and render a replay:

eslams init
eslams run --arena connect-four --agent random --opponent first-legal
eslams validate runs/latest.eslams
eslams replay runs/latest.eslams

By default, eslams run writes:

• runs/<run_id>.eslams, a portable zip-compatible proof archive
• runs/<run_id>.eslams.d, an expanded inspection directory
• runs/latest.eslams, a pointer to the latest archive
• runs/latest.eslams.d, a pointer to the latest expanded copy

Use --expanded when you only want the expanded directory:

eslams run --arena chess --agent first-legal --opponent first-legal --expanded

After --expanded, validate or replay runs/latest.eslams.d. The archive pointer is removed. Latest links use relative targets so they survive moving or copying the runs directory. If symlink privileges are unavailable, Core reports the completed artifact path and warns that latest links were not updated. Use the returned artifact path in automation and concurrent runs.

Run Model Agents

Pass provider:model to use a provider-backed model agent.

export OPENAI_API_KEY=...
export ANTHROPIC_API_KEY=...
export GEMINI_API_KEY=...
export OPENROUTER_API_KEY=...
export AWS_BEARER_TOKEN_BEDROCK=...

eslams run \
  --arena chess \
  --agent openai:gpt-5-mini \
  --opponent anthropic:claude-sonnet-4-6

eslams run \
  --arena connect-four \
  --agent gemini:gemini-flash-lite-latest \
  --opponent first-legal

eslams run \
  --arena tic-tac-toe \
  --agent openrouter:openai/gpt-5-mini \
  --openrouter-provider-order "Amazon Bedrock" \
  --opponent first-legal

# Split provider:model on the first colon; the Bedrock model's :0 is literal.
eslams run \
  --arena tic-tac-toe \
  --agent bedrock:amazon.nova-micro-v1:0 \
  --bedrock-region us-east-1 \
  --opponent first-legal

Provider receipts are written into the artifact without API keys. Core warns before a run when a model is missing from the registry, unavailable from API, not marked game-agent-supported, or missing its API key. See the provider guide for the exact wire adapters, model identity rules, reasoning behavior, usage semantics, and rate-card contract.

Use the verified provider workflow before spending on a run:

# Safe and offline: registry metadata only. This is not an availability claim.
eslams providers preflight \
  --provider openai --model gpt-5-mini --arena tic-tac-toe

# Account-aware: model discovery where supported, one minimal inference,
# legal-action parsing, and usage extraction.
eslams providers preflight \
  --provider openai --model gpt-5-mini --arena tic-tac-toe --live

eslams run \
  --arena tic-tac-toe \
  --agent openai:gpt-5-mini \
  --opponent first-legal \
  --execution-profile smoke
eslams validate runs/latest.eslams --profile runner-bundle
eslams replay runs/latest.eslams

Provider keys may include pasted leading/trailing whitespace; Core trims it. Internal whitespace and non-ASCII credentials fail before a network call, with a redacted provider_auth_failed diagnostic. A provider namespace in the catalogue does not imply a Core inference adapter; preflight checks both. Inline retry waits are limited to five seconds: larger provider hints or configured backoffs abort with the failed receipt retained. Core does not retry earlier than a provider's requested wait. Retry hint receipts are bounded at 24 hours for safe serialization. Official execution still disallows adapter retries and leaves whole-case retries to its orchestrator.

preflight_mode is always registry_only or live, and every live check is reported separately. A registry-only pass does not prove that a provider account can invoke the model.

A completed diagnostic run exits 0 even if summary.match_valid_for_scoring is false. For scoring automation, add --require-scoring-valid: it preserves the diagnostic artifact and exits 1 on an invalid match. Input/execution errors also exit nonzero. --runner-result-json continues to report validation status.

Table arenas require explicit agents for seats beyond player_2. For example:

eslams run --arena bridge --seat-agent player_3=first-legal --seat-agent player_4=random

Repeat --seat-agent PLAYER=AGENT for each seat; assignments override the corresponding --agent / --opponent option. Unknown or duplicate seats fail.

The default failure policies are fail-closed (invalid-match). For model comparison runs, keep them explicit in automation:

eslams run \
  --arena chess \
  --agent openai:gpt-5-mini \
  --opponent anthropic:claude-sonnet-4-6 \
  --on-agent-error invalid-match \
  --on-illegal-action invalid-match

For interactive demos, deterministic fallback is opt-in and permanently marks the run invalid for scoring:

eslams run \
  --arena tic-tac-toe \
  --agent openai:gpt-5-mini \
  --opponent first-legal \
  --on-agent-error fallback \
  --on-illegal-action fallback

Failure policies:

Execution profiles are interactive, smoke, and official_eval. official_eval rejects fallback policies and provider-local retries; the official orchestrator owns whole-case retries. Set --case-attempt-index on a replayed case so physical attempt IDs stay idempotent and retry-scoped. Each run normally has a unique ID. Use --run-id NAME to select a fixed artifact path; existing output is refused unless --overwrite is explicit.

Reasoning is controlled with --reasoning disabled|enabled|auto. Core sends only model-supported controls. Anthropic manual thinking requires a budget of at least 1,024 tokens and below max_tokens; Claude 4.7+ and Claude 5 use adaptive thinking and omit incompatible temperature/manual-budget fields.

Build an HTTP Agent

Agents implement a single endpoint:

POST /act

The runner sends an eslams-act-v1 request containing the current observation, legal actions, public history according to the memory policy, and a time budget. The agent returns one action. The arena validates legality.

Minimal Python agent:

from eslams.agent import AgentServer

server = AgentServer(agent_id="sample-first-legal", version="1.0.0")


@server.act
def act(request):
    return {
        "action": request.legal_actions[0],
        "confidence": 1.0,
        "public_explanation": "Selected the first legal action.",
    }


server.run()

Test it locally:

eslams agent test --url http://localhost:8000/act --arena chess

Print a platform registration payload:

eslams agent publish \
  --name "My Chess Agent" \
  --url https://example.com/act

What a Run Produces

Every Core run can produce:

• manifest.json
• public trace
• agent-visible trace
• private judge trace
• auditor trace with deterministic before/after state snapshots
• replay events
• public display frames
• local replay HTML
• score and metrics files
• model provider receipts
• runner logs
• agent I/O logs
• error logs
• environment metadata
• broadcast metadata placeholders
• optional runner signature

Score and manifest metadata include:

• match_valid_for_scoring
• per_case_run_valid
• per_case_scoring_eligible
• proof_row_publication_eligible
• aggregate_leaderboard_eligible
• aggregate_ineligibility_reason
• invalid_reason
• agent_error_count_by_player
• illegal_action_count_by_player
• fallback_action_count_by_player
• provider_status_by_player
• provider_action_count_by_player
• logical_action_count_by_player
• integrity_status, invalid_reason_codes, and action provenance
• usage_complete, cost_complete, and attempt_ledger_complete
• model_identity_verified
• aggregate usage/cost and per-seat/provider/model/attempt/status breakdowns

Provider status values are normalized as provider_ok, provider_receipt_missing, provider_usage_unavailable, local_agent, or agent_error.

Validate an artifact:

eslams validate runs/latest.eslams

Render a replay:

eslams replay runs/latest.eslams

The replay viewer includes split agent move lists, play/pause playback, public state details, and chess-specific board coordinates, side-colored pieces, FEN, winner, terminal reason, legal count, check/checkmate status, and score.

Platform Contracts

Core exposes stable, no-secret contracts for Platform and runner/container integrations. See docs/PLATFORM_CONTRACTS.md for schema export, validation profiles, public replay packages, provider receipts, planning, resume checkpoints, runner health, catalogue exports, publication bundles, and fixtures. See CHANGELOG.md for the release summary of contract and CLI changes.

Common integration commands:

eslams schemas export --out schemas/
eslams validate runs/latest.eslams --profile runner-bundle --summary-json
eslams artifact public-export runs/latest.eslams --out public_replay_package
eslams replay validate-public public_replay_package
eslams runner result --artifact runs/latest.eslams --artifact-uri URI --job-id JOB
eslams providers preflight --provider openai --model gpt-5-mini --arena tic-tac-toe
eslams plan battlefield --pairs openai:gpt-5-mini --arenas tic-tac-toe --json
eslams publish export --kind uploaded-replay --artifact runs/latest.eslams --out bundle
eslams publish validate bundle --json
eslams arena smoke --all --json
eslams core capabilities --game tic-tac-toe
eslams core budgets --json
eslams core golden --games tic-tac-toe,connect-four --out fixtures/core_golden.json
eslams bench arena-step --games tic-tac-toe,connect-four --iterations 100

The shipped public registry enables no models for Official evaluation. plan official --suite public-smoke rejects an empty selection with an actionable error. The Battlefield example above is a showcase plan and grants no Official authority.

Core v0.4.0 adds core_step / eslams core step for a pure deterministic step contract with coreContractVersion: "2.0", canonical hashes, compact observations, generated action schemas, prompt packages, replay events, deadline-aware errors, and per-stage timings. The repository contains Platform-facing TypeScript source in packages/core-contracts and the gated packages/core-lite runtime. These are excluded from the Python wheel and are not published npm packages; integrate them from a pinned source checkout. Core-lite's supported tic-tac-toe/connect-four deterministic state and step fields are checked against Python fixtures in CI; see its supported scope.

Arena Session Transport

Core v0.3.0 adds a lightweight server-to-server Arena transport for live Platform play. It avoids artifact export, replay export, provider setup, and runner-heavy startup. Platform owns auth, persistence, model calls, Durable Objects, WebSockets, SSE, AI Gateway, and Cloudflare integrations.

Python API:

from eslams.arena_transport import legal_actions_page, start_session, step_session

players = {
    "player_1": {"kind": "human", "label": "Human"},
    "player_2": {"kind": "model", "label": "AI"},
}

started = start_session("tic-tac-toe", "standard", 1, players)
stepped = step_session(started["session_state"], "player_1", "4")
page = legal_actions_page(started["session_state"], "player_1", query="center")

CLI API (set the same secret before Python calls too):

export ESLAMS_ARENA_SESSION_SECRET="$(python -c 'import secrets; print(secrets.token_hex(32))')"
eslams arena start \
  --game tic-tac-toe \
  --variant standard \
  --seed 1 \
  --players-json '{"player_1":{"kind":"human"},"player_2":{"kind":"model"}}'

Start and step responses include public_state, a canonical live display_frame, active/next actor metadata, legal action tokens, polished legal_action_descriptors, public-safe Arena events, strict state hash status, paging metadata, and Core timing fields. session_state is a signed server-only envelope, verified with ESLAMS_ARENA_SESSION_SECRET, and must still be kept on the server. For the active human recipient, browser-streamable fields are public_state, display_frame, legal_action_descriptors, events, actor metadata, terminal/outcome fields, and timing.

Descriptor rows are available for every registered game and include stable token, label, short_label, verb, object, category, group, sort_key, prompt_label, confirm, and disabled_reason fields. Large action sets can be paged or searched with legal_actions_page.

Arena event types include session.started, human.action.accepted, state.applied, model.action.requested, model.action.accepted, turn.ready_for_human, match.completed, and turn.failed. arena.auto_advanced is reserved and is not emitted. Human legal-action lists are recipient-specific and must be routed privately; signed full-state envelopes stay on the trusted server. Public projections omit prompts, raw responses, private observations, provider receipts, hidden eval material, or private reasoning.

Sample Runs

The sample tree contains keyless Local fixtures and validated publication shapes, with checksums and expected status.

• model_battle_sample/sample_builtin_chess.eslams is a completed built-in first-legal versus first-legal chess run; it is not a provider model battle.
• model_eval_sample/local_eval_fixture.eslams is an unsigned tic-tac-toe fixture exported with the official-proof bundle kind. Its rows establish no Official or Grand Slam trust.

The former run_d48ff364a0b949df model-battle claim did not match the tracked file. Historical invalid/HMAC samples are replaced, rather than described as current validated proofs. Producer commits and unchanged historical limitations are explicit in sample classification.

Upload to eslams.com

A runner bundle is a private intake archive, not a public page. runs/latest.eslams can include auditor traces and logs/agent_io.jsonl with plaintext hidden state. Upload that archive only to a private intake path.

For a public replay page, export the public replay package and upload that package instead:

eslams artifact public-export runs/latest.eslams --out public_replay_package

1. Run locally with Core.
2. Validate the artifact.
3. Open eslams.com.
4. Use the Artifact Intake panel.
5. Upload runs/latest.eslams or a specific run_<id>.eslams archive for private intake, or upload public_replay_package when the page is public.
6. Open the generated replay, score, and artifact proof pages.

eslams run --arena connect-four --agent random --opponent first-legal
eslams validate runs/latest.eslams

The expanded .eslams.d directory is for local inspection. The .eslams archive is the portable upload artifact.

Full Arena Catalogue

Core supports all 50 arenas below. The variant label is the public Core ruleset identifier used for local and artifact-backed runs; fidelity is explicit so compact/lite arenas do not overclaim full game coverage.

Paddle-ball 1.1.0 allows 400 actions so its ten-bounce target is reachable. Ultimate Tic-Tac-Toe 1.1.0 draws when all local boards are decided without a global line. Nine Men's Morris retains a compact 120-action episode draw rule; its results can differ from standard games that continue from that position. Catalogue help examples name the initial seed-1 position and contain real legal tokens; query each current state's legal actions before playing them.

Auction 1.1.0 separates the item recipient (allocation_winner) from the match winner by utility. The highest bid receives the item; tied bids alternate by seed parity. Utility includes overbid losses, and score is (utility + 10) / 20. Equal utilities draw. Negotiation 1.1.0 enforces both private reserve utilities; below-reserve acceptance cannot produce a deal. Its price grid uses steps of ten, which admits a mutually feasible deal for every generated reserve combination.

Alien-shooter 1.1.0 resolves hits after projectile motion and after alien descent. Aliens descend once per twelve actions. A public-observation tracking policy can clear all 1,225 possible initial formations within 28 actions, making the full score attainable across the seeded layout support.

Backgammon 1.1.0 retains the compact five-checker game and 160-action episode limit. Legal moves enforce maximum dice use, the larger-die rule when only one number can be played, and bearing off an overshoot only from the farthest checker. When the remaining roll is blocked, pass records a turn transition and the next seat's fresh roll; each pass counts toward the episode limit. Both seats can pass without producing an empty-action live state. The move constraints follow the USBGF playing rules.

List arenas from your installed copy:

eslams arenas

Chess Observation Details

Chess is powered by python-chess. Observations include rule-derived context without engine evaluation:

• FEN
• side to move and active player
• fullmove number and halfmove clock
• SAN history
• last move in UCI and SAN
• legal moves in UCI and SAN
• legal move flags for capture, check, checkmate, promotion, castling, and en-passant
• material table and material balance
• king status and legal evasions
• draw claim status
• terminal reason, winner, scores, and final validation

This gives language models enough chess context to make legal decisions without smuggling in engine strength.

Provider Support

Core has direct first-party HTTP adapters for all five provider routes below:

OpenAI uses the raw Responses output[] wire shape, Anthropic uses Messages, Gemini uses generateContent, OpenRouter uses Chat Completions with native usage.cost, and Bedrock uses Converse. OpenRouter provider fallback is disabled and an optional provider order is sent as a pin. Bedrock model IDs retain their literal version separator such as :0.

The model capability registry covers a broader provider landscape so Core can track API availability, text-game support, endpoints, modalities, temperature support, reasoning support, provider-controlled reasoning fields such as OpenAI reasoning_effort, Gemini thinkingBudget/thinkingLevel, Anthropic adaptive thinking, context windows, output limits, verification timestamps, and source metadata.

Inspect supported game-agent models:

eslams models list --provider openai --game-agent-supported
eslams models list --provider gemini --game-agent-supported --json

From a source checkout, generate a separate registry snapshot for review:

eslams models update --providers openai,anthropic,google,openrouter,bedrock --output model-registry.snapshot.json

The updater requires a new --output file. A provider filter defines the snapshot scope; it can produce a smaller inventory. Inspect it before deliberately replacing checked-in data. It never changes the packaged registry implicitly, and a failed source fetch does not produce a successful partial snapshot.

Provider organizations tracked by the registry:

The full CLI registry currently contains 8,762 model rows across 259 provider namespaces. The table below and generated inventory describe a 90-namespace curated subset, rather than the full CLI registry. The curated count is source-backed: 69 organizations were in the original curated Core list, Cursor was added from the platform's API-discovered Composer model row, and 20 additional author namespaces come from the release-pinned OpenRouter text-model snapshot. A listing is a catalog identity, not a claim that Core has a direct adapter or that a deployed account can call the provider. See the generated registry inventory for the per-model snapshot and verification boundary.

You can also connect any provider, hosted model, local model, or custom policy through an HTTP /act agent.

Artifact Anatomy

See the canonical expanded package layout, including optional signatures and volatile timing sidecars.

manifest.json contains:

• artifact version
• artifact id
• run id
• creation timestamp
• arena, agent, wrapper, eval suite, scoring policy, and runner versions
• verification level
• stable machine keys and public labels for verification level, artifact profile, scoring policy, and publication kind
• deterministic replay metadata
• match validity metadata
• file table with SHA-256 hashes
• signature metadata

When RUNNER_ARTIFACT_SIGNING_PRIVATE_KEY is set, Core writes an Ed25519 runner signature:

export RUNNER_ARTIFACT_SIGNING_PRIVATE_KEY="$(python -c 'import base64; from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey; from cryptography.hazmat.primitives.serialization import Encoding, PrivateFormat, NoEncryption; key = Ed25519PrivateKey.generate(); print("base64:" + base64.b64encode(key.private_bytes(Encoding.Raw, PrivateFormat.Raw, NoEncryption())).decode())')"
export RUNNER_ARTIFACT_SIGNING_KEY_ID=local-ci-key
eslams run --arena connect-four --agent random
eslams validate runs/latest.eslams

The private key is exactly 32 raw Ed25519 bytes encoded as base64: or hex:. Malformed keys fail before agent calls or output. For a separate verifier, use the matching public-key recipe. The private signing key is never written to the artifact. Legacy HMAC signatures remain readable for old artifacts, but only Ed25519 v2 signatures can satisfy official bundle trust.

Local Development

python -m venv .venv
. .venv/bin/activate
pip install -e ".[dev]"
pytest
ruff check src tests scripts
python -m py_compile src/eslams/*.py

Useful smoke commands:

eslams run --arena chess --agent first-legal --opponent first-legal --max-turns 8
eslams validate runs/latest.eslams
eslams replay runs/latest.eslams
eslams models list --provider openai --game-agent-supported

Release v0.6.2

v0.6.2 consolidates the reviewed backlog with arena correctness repairs, private-state protection, authenticated sessions, bounded provider calls, portable distributions and accessible replay controls. It emits eslams-runner:0.6.2 and eslams-schema-bundle-v5; the new cooperative v2 contracts represent Hanabi team scores without an individual winner.

Upgrade in Python 3.10 or newer:

python -m pip install --upgrade eslams-core==0.6.2

Agent servers now bind to 127.0.0.1; remote/container access needs an explicit --host 0.0.0.0. Arena sessions require a configured secret, and Runner HTTP requests require fresh HMAC signatures. Existing unsigned sessions cannot resume. Exports refuse existing destinations, and truncated runs cannot claim scoring eligibility. Revised arena behavior has distinct versions; compare historical artifacts using their producer Core version and commit. See the full changelog, session integration, artifact migration notes and arena versions.

Release v0.6.1

v0.6.1 is the portable provenance patch for the Core 0.6 integrity release. It emits eslams-runner:0.6.1 and embeds the immutable release source commit into wheel and source distributions. Schema exports from a tagged checkout and from a clean installed package are therefore byte-identical; installed execution does not depend on Git being present. Contract schema content and the eslams-schema-bundle-v4 format remain unchanged.

Release v0.6.0

v0.6.0 is the fail-closed execution-integrity release. It emits eslams-runner:0.6.0 and eslams-schema-bundle-v4, adds first-class OpenRouter and Bedrock adapters, strict raw-wire parsing for all five providers, physical-attempt and action-provenance contracts, complete usage/cost semantics, the official-case validator, account-aware live preflight, unique run IDs, and overwrite protection.

Breaking behavior changes are intentional: agent/illegal-action defaults are now invalid-match; fallback can never be scoring-valid; official_eval rejects fallback and hidden provider retries; run IDs are unique execution IDs rather than deterministic config hashes; and provider receipt writers emit v2. Core continues to read historical v1/0.5 receipt shapes.

Release v0.5.1

v0.5.1 is the trust and correctness patch for the Core 0.5 contract release. The package version is 0.5.1, runner defaults emit eslams-runner:0.5.1, and release artifacts include the deterministic artifact, live-session, provider receipt, and compact-arena fixes listed in CHANGELOG.md.

python3 -m pytest -q
python3 -m ruff check .
python3 -m mypy src

Release v0.5.0

v0.5.0 is the explicit game contract release. The package version is 0.5.0, runner defaults emit eslams-runner:0.5.0, and schema exports include game topology, surface, result, help, render, animation, and usage contracts.

python3 -m pytest -q
python3 -m ruff check .
python3 -m mypy src

Release v0.4.0

v0.4.0 is the fast interactive Core substrate release. The package version is 0.4.0, runner defaults emit eslams-runner:0.4.0, and schema exports include Core step v2, prompt package, replay event, runner-session, and observability schemas.

python3 -m pytest -q
python3 -m ruff check .
python3 -m mypy src
python3 -m eslams_core.bench arena-step --games tic-tac-toe --iterations 10 --json out/core-step-bench.json

Release v0.3.2

Core v0.3.2 is the follow-up security and correctness patch release for the v0.3 Arena transport line. Release from a clean main checkout after tests pass:

python3 -m pytest -q
python3 -m ruff check .
python3 -m mypy src
git tag -a v0.3.2 -m "eSlams Core v0.3.2"
git push origin main v0.3.2

Release v0.3.1

Core v0.3.1 is the security and correctness patch release for the v0.3 Arena transport line. Release from a clean main checkout after tests pass:

python3 -m pytest -q
python3 -m ruff check .
python3 -m mypy src
git tag -a v0.3.1 -m "eSlams Core v0.3.1"
git push origin main v0.3.1

Release v0.3.0

Core v0.3.0 is the named Arena transport contract release. Release from a clean main checkout after tests pass:

python3 -m pytest -q
python3 -m ruff check .
python3 -m mypy src
git tag -a v0.3.0 -m "eSlams Core v0.3.0"
git push origin main v0.3.0

eslams schemas export --out schemas/ writes individual schema files plus schema_bundle_manifest.json with the Core package version, immutable release source commit, schema bundle version, schema hashes, and deterministic build id. Wheel and source distributions embed the source commit, so export fails closed instead of depending on Git being available at runtime.

Contribute

Good contributions make eSlams more trustworthy, more portable, or easier to use. Strong areas to contribute:

• arena rule fixes
• better observations for existing games
• additional provider adapter support
• provider registry updates
• replay renderer improvements
• artifact validation hardening
• docs, examples, and agent templates
• tests for edge cases, illegal actions, and deterministic replay validation

Contribution flow:

1. Fork the repository.
2. Create a focused branch.
3. Add or update tests.
4. Run pytest and ruff check src tests scripts.
5. Open a pull request with a clear summary and validation notes.

Please keep changes scoped. For arena changes, include at least one test that proves legality, scoring, terminal handling, or deterministic replay behavior. For provider changes, include tests proving unsupported optional parameters are not sent.

Support eSlams

eSlams is built for serious public evaluation work. If you want to fund the project, donate model/API tokens, sponsor infrastructure, support official eval runs, or help with partnership work, email:

hello@eslams.com

That is also the right contact for paid support, deployment help, private tournament operations, and research collaborations.

Verification Posture

Core creates Local Artifact proof packages. Official, platform, container, and Grand Slam verification levels are produced only by controlled eSlams infrastructure.

In plain terms:

• Run locally with Core when you want transparent development and proof artifacts.
• Upload or run on eslams.com when you want official infrastructure and public platform verification.
• Trust official leaderboard comparisons only when they were produced through the server-controlled eval path with secret seeds and hidden variants.

Links

• Platform: https://eslams.com
• Repository: https://github.com/ElectronicSlams/eSlams
• Issues: https://github.com/ElectronicSlams/eSlams/issues
• Support: hello@eslams.com

Session privacy: the HMAC envelope is base64 JSON containing full private state, not encryption. Keep session_state on trusted servers; never stream it to a browser. Legal action lists/descriptors are emitted only for the active human recipient and must be privately routed to that person. Model-seat lists stay inside the trusted runner, obtainable from the server-side state. Public views omit legal action lists. Pending sealed actions and their explanations remain hidden until the arena reveal phase.