Open Questions — Layered
Status: OPEN (seed document)
Created: 2026-05-11
Wiki depot: /workcell/llm-wiki/wiki/architecture/
Repo: langgraph-game-surface
Layer 1: Pi — Hardware, Runtime, Agent Harnesses
The infrastructure layer. What the game runs ON.
Q-PI-01: LangGraph Compile Time on Pi 4
At what map size does LangGraph compile time become a practical blocker on Pi 4 hardware? 10x10 hex? 50x50? 100x100? - Source: [[langgraph-hex-node-mapping]] - Depends on: actual benchmarking
Q-PI-02: Bun→Python Subprocess Overhead
How much does invoking a Pi agent (Bun/JS) from within a LangGraph node (Python) cost per turn on a Pi 4 — subprocess spawn vs HTTP vs IPC? - Source: [[langgraph-tool-execution-tradeoffs]] - Depends on: benchmarking subprocess vs HTTP latency
Q-PI-03: Optimum Agent Harness Per Node Role
Which agent harness (Pi, Hermes, OpenCode, raw LangChain) is optimal for each node type (research, design, development, review) given Pi 4 constraints? Does the answer change per-unit vs per-node? - Source: [[langgraph-tool-execution-tradeoffs]] - Depends on: Q-PI-02, testing each harness on each node type
Q-PI-04: Docker Container Shape for Game Runtime
Does the game backend (LangGraph + renderer + agents) run in the existing d3-tui-pi-teams-proto container, a new container, or directly on the Pi host? What bind mounts, ports, and resource limits?
- Source: [[langgraph-game-surface]]
- Depends on: Q-PI-01, Q-PI-02
Q-PI-05: Checkpointer Backend on Pi
Which LangGraph checkpointer (MemorySaver, SqliteSaver, PostgresSaver) is appropriate for game state persistence on Pi 4? MemorySaver loses state on restart; SqliteSaver may have concurrency issues with multiple console clients. - Source: [[langgraph-game-surface]] - Depends on: concurrent access patterns
Q-PI-06: Multiple Console Clients → Pi Concurrency
Can a single Pi 4 serve LangGraph state to three simultaneous console clients (RG40XXV + Wii + PS2)? What are the concurrency limits on checkpointer reads/writes? - Source: [[langgraph-game-surface]] - Depends on: Q-PI-05
Q-PI-07: Model Key Routing for Multi-Unit Sessions
When multiple units run simultaneously (harvesters + active units), how are API keys routed per-unit/per-model without collision? Can the existing secrets/model.env pattern handle per-unit model switching?
- Source: [[langgraph-unit-node-interaction-model]]
- Depends on: Q-PI-03
Layer 2: Game — Assets, UX/UI, Engine
The player-facing layer. What the game IS.
Q-G-01: Turn Cycle Granularity
Is the turn cycle structure (Planning → Execution → Resolution → End-of-Turn) the right granularity, or should moves be real-time-with-pause? What does the "feel" need to be? - Source: [[langgraph-gameplay-modes]] - Depends on: prototype feel testing
Q-G-02: Lane vs Unit Toggle Hierarchy
Should per-lane toggles override per-unit toggles, or the reverse? If a lane says auto-run but a unit says manual, who wins? Should hero units override lane toggles? - Source: [[langgraph-gameplay-modes]] - Depends on: UX design, gameplay balance
Q-G-03: AI Decision — LLM vs Heuristic
Do the AI decision nodes call an LLM for tactical reasoning, or run a deterministic heuristic? LLM gives adaptivity but costs latency and tokens. Heuristic is fast but predictable. What's the MVP choice? - Source: [[langgraph-gameplay-modes]] - Depends on: Q-PI-02 (latency budget)
Q-G-04: Renderer / Graph Separation
Does the rendering layer need its own terrain representation separate from the LangGraph state, or can it read directly from state keys? If hexes are nodes, does the renderer understand the graph topology? - Source: [[langgraph-hex-node-mapping]] - Depends on: Q-G-06 (renderer choice)
Q-G-05: Dynamic Node Generation for Procedural Maps
Are there LangGraph patterns for generating nodes at runtime (procedural maps), or must all nodes be defined at compile time? If so, does this limit map variety? - Source: [[langgraph-hex-node-mapping]] - Depends on: LangGraph API capabilities
Q-G-06: Rendering Engine Choice
Which rendering engine (pygame, Arcade, Pyglet, OpenRTS template, HTML5 Canvas for Wii, native for PS2) should be used for the first prototype? Is a unified renderer possible across all three console targets? - Source: [[langgraph-game-surface]] - Depends on: target console priority
Q-G-07: Console Priority Order
Which console first for the prototype — RG40XXV (easiest, native Python), Wii (HTML5 Canvas, novel), or PS2 (hardest, native C homebrew)? - Source: [[langgraph-game-surface]] - Depends on: MjF preference, available dev time
Q-G-08: Spectator Mode
Should the game surface support a read-only spectator mode (view auto-run without interaction)? Is this a separate LangGraph thread or a read-only state view? - Source: [[langgraph-gameplay-modes]] - Depends on: Q-G-01 (turn cycle design)
Q-G-09: Intel Suggestion UI During Node Activation
How does the rendering surface present intel suggestions (from harvesters) during node activation? Is it an interrupt() modal, a sidebar, or a notification queue? - Source: [[langgraph-unit-node-interaction-model]] - Depends on: Q-G-06 (renderer capabilities)
Q-G-10: Output Locale Presentation
When a node produces output (wiki page, Forgejo issue), how does the player view it? In-game overlay? Browser launch? Terminal link? - Source: [[langgraph-unit-node-interaction-model]] - Depends on: target console UX
Layer 3: Membrane — Wiring Between Pi and Game
The interoperability layer. What makes the two sides talk without breaking.
Q-M-01: Tool Visibility Boundary
Is the LangChain tool visibility trade-off real in practice for a game surface, or does the Hybrid pattern (LangGraph routes + agent decides + reports high-level outcomes) cover enough ground? - Source: [[langgraph-tool-execution-tradeoffs]] - Depends on: prototyping the Hybrid pattern
Q-M-02: Mid-Tool-Execution Interrupts
If the game surface needs interrupts mid-tool-execution (e.g., "scout found something — stop and let human decide"), does this force a move toward LangChain ToolNode (Pattern B), or can the external harness pattern be extended? - Source: [[langgraph-tool-execution-tradeoffs]] - Depends on: Q-M-01, gameplay needs
Q-M-03: Pi Agent Internal Event Streaming
Could Pi agents be configured to expose their internal tool calls as streamed events that LangGraph could optionally subscribe to, without making them mandatory state keys? Is this worth the complexity? - Source: [[langgraph-tool-execution-tradeoffs]] - Depends on: Q-M-01, Pi agent capabilities
Q-M-04: Access List Hierarchy
Should access lists be hierarchical? Unit-level default + node-level overrides that merge (additive) or replace (exclusive)? What's the least confusing model for the player? - Source: [[langgraph-unit-node-interaction-model]] - Depends on: UX testing
Q-M-05: Forward Intel Flagging
Can a harvester flag intel for nodes that haven't been created yet? (Pre-positioned context for future work that hasn't been staged.) Does this require a different intel routing mechanism? - Source: [[langgraph-unit-node-interaction-model]] - Depends on: graph topology design
Q-M-06: Cross-Unit Access Collisions
What happens when Unit A's access block conflicts with Unit B's access grant for the same node? Which unit's access policy wins? Or does each unit maintain its own view of the same node? - Source: [[langgraph-unit-node-interaction-model]] - Depends on: access model design
Q-M-07: Intel Item Expiry / Staleness
Should intel items have an expiry or staleness mechanism? How does the system know when intel is outdated and should no longer be suggested? - Source: [[langgraph-unit-node-interaction-model]] - Depends on: wiki maintenance patterns
Q-M-08: LangGraph Internal Limits
Would a hexagonal grid of 100+ nodes hit any internal LangGraph limits on graph size or edge count? What are the documented ceilings? - Source: [[langgraph-hex-node-mapping]] - Depends on: LangGraph docs / testing
Q-M-09: State Serialization With Complex Objects
When units carry complex configs, agent handles, or non-serializable objects, does the checkpointer handle them? What objects survive serialization and what breaks? - Source: [[langgraph-node-anatomy]] - Depends on: checkpointer backend choice (Q-PI-05)
Q-M-10: Game State vs Agent State Separation
Should the "game" state (positions, health, terrain) and the "agent" state (configs, access lists, intel items) share the same LangGraph state schema or be separated into subgraphs? Does separation help or hurt the membrane? - Source: [[langgraph-unit-node-interaction-model]] - Depends on: schema design, performance
Count
- Pi layer: 7 questions
- Game layer: 10 questions
- Membrane layer: 10 questions
- Total: 27 open questions
Next
- Each question should become its own Forgejo issue in this repo
- Questions with dependencies should be linked
- Answers should be written back to the wiki depot as they resolve