Lattice

Lattice is an agentic isometric game kit built for coding agents. It bundles 12 agent skills over 9 zero-dependency TypeScript packages, so a tool like Claude Code, Codex or Grok can generate a complete, playable isometric game from a one-sentence idea. Everything renders onto a plain 2D canvas, and the core rule is full determinism: the same input always produces the same game, with no sprite sheets or royalty-free asset hunting required.

Key Features

• One-sentence game generation: Install the agent plugin, then run a command like /lattice build a farm sim and the agent assembles the game.
• Zero-dependency TypeScript core: A single 80kb gzipped package handles rendering, with no framework lock-in.
• Deterministic by rule: Seeded randomness and deterministic math guarantee the same game output for the same prompt, which makes agent-produced games stable and testable.
• No external assets: Sprites and audio can be synthesized on the fly with companion packages such as @latticekit/audio, so there is no hunt for royalty-free art.
• Agent-agnostic plugins: Ready-to-go instructions exist for Claude Code, Codex and Grok, and the kit can be extended to other agents.

Use Cases

Who Should Use This Tool?

• Agent-first developers: Teams that already build with Claude Code or Codex and want a packaged skill set for game projects.
• Game jam builders: Prototyping an isometric game idea in an afternoon instead of setting up engines, assets and pipelines.
• Prompt engineers: Testing how far a coding agent can take a structured, deterministic generation task.
• Educators: Teaching game development or agentic coding with a reproducible, self-contained example.

Problems It Solves

1. Asset friction: Synthesized sprites and audio remove the biggest time sink in small game projects.
2. Non-deterministic agent output: The hard determinism rule makes generated games reproducible instead of unpredictable.
3. Setup overhead: Nine small packages and one plugin replace a full game engine setup for isometric prototypes.

Pricing

Lattice is open source under the MIT license, and the core packages are free to use on npm (@latticekit/core and related packages). You pay only for the coding agent subscription or tokens you already use to generate the games.

Advantages & Unique Selling Points

1. Agent-native design: Unlike generic game engines, Lattice is packaged as skills and plugins that coding agents already understand.
2. Determinism as a hard rule: Most AI-generated code is fragile; Lattice guarantees the same prompt maps to the same game.
3. Zero dependency core: An 80kb TypeScript package renders the whole game, which keeps builds small and predictable.

What Makes It Stand Out: Lattice treats the agent as the primary developer. Instead of asking you to learn an engine, it teaches your coding agent a complete, deterministic workflow for isometric games.

Getting Started

Quick Start Guide

1. Install the plugin: Follow the agent-specific instructions on the Lattice website for Claude Code, Codex or Grok.
2. Describe the game: Run the /lattice <my game idea> command with a one-sentence description.
3. Play and iterate: The agent produces a playable game in a browser canvas; ask for changes in plain language.
4. Extend: Add music with @latticekit/audio or other companion packages as the project grows.

Frequently Asked Questions

Do I need to know game development?

No. The kit encodes the workflow as agent skills, so describing what you want in one sentence is the main input.

What kind of games can it make?

Isometric games rendered on a 2D canvas, including simulations, puzzles and small RPG-style scenes. The demos on the Lattice website show a range of 18 worlds built by different agents.

Is the output deterministic in practice?

Yes. Determinism is enforced as a hard rule of the core package, using seeded randomness and consistent math, so regenerating the same prompt reproduces the same game.

Alternatives

If Lattice is not the right fit, consider these alternatives:

• OpenCode: Open-source coding agent CLI you can use to run Lattice skills.
• Claude Code: Anthropic's coding agent with official support for installing Lattice skills.
• Devin: Autonomous coding agent useful when you want a project handled end to end.

Tips & Best Practices

1. Start with a concrete sentence: The more specific the description, the more consistent the generated game.
2. Iterate in small asks: Change one mechanic at a time so the deterministic output stays predictable.
3. Reuse worlds as tests: Because output is deterministic, you can treat each prompt as a reproducible fixture for evaluation.

Conclusion

Lattice is a fast, reproducible way to generate isometric games with coding agents. Its zero-dependency core, hard determinism rule and agent-native skills remove the asset and setup friction that usually stalls AI-built games. If you already work with Claude Code, Codex or Grok, it is a great playground for what agentic game development can do.