Remix

Make your own version of Offline Text World Agent

Edit the prompt below and generate a customized version in seconds.

Original by Naresh R

Describe your app

You are an expert AI software architect and full-stack Python developer.
Build a complete hackathon-ready AI-powered Text World Agent web app.

Tech Stack:
- Frontend: HTML, CSS, JS (Bootstrap optional, local assets only — no CDN, must run offline)
- Backend: Flask (Python)
- AI: Ollama (Llama 3.2 3B)
- Data Structure: Linked List
- No database.

Project Goal:
Build a REUSABLE, event-driven text-adventure agent framework. The default
instance is a 10-room world with a multi-step objective, but world data
(rooms, items, locks, goal) must be swappable via config, not hardcoded into
the engine. The agent must explore, keep a continuously updating world model,
reason with minimal token overhead, respond fast, navigate efficiently, and
self-correct when its beliefs are contradicted. Runs fully offline after
initial Ollama setup.

Requirements:

1. World Data as Config (reusable framework)
   Rooms/items/goal live in world_data.py or world.json, loaded at startup
   by world_model.py. Core engine (linked_list.py, agent.py, updater.py,
   game.py) has ZERO hardcoded room names — must work unmodified with a
   different map/goal/item set.

Default world — 10 rooms:
   Hall(start,-) Kitchen(Key) Bedroom(Map) Garden(Apple) Hallway(connector,-)
   Attic(Lantern) Study(Book) Library(LOCKED needs Book; Scroll)
   Bathroom(Soap, decoy) Cellar(LOCKED needs Lantern,-)
   Treasure Room(LOCKED needs Key+Lantern; Treasure)

Map:
   Hall: N-Bedroom, E-Kitchen, W-Garden, S-Hallway
   Hallway: N-Hall, S-Bathroom, E-Study, W-Bedroom
   Bedroom: S-Hall, E-Hallway | Bathroom: N-Hallway
   Attic: S-Study | Study: N-Attic, W-Hallway, E-Library
   Library: W-Study (locked, needs Book) | Garden: E-Hall
   Kitchen: W-Hall, N-Cellar (locked, needs Lantern)
   Cellar: S-Kitchen, N-Treasure Room
   Treasure Room: S-Cellar (locked, needs Key AND Lantern)

Three lock/key dependencies force genuine multi-step planning.

2. Linked List World Model — Dynamic & Continuously Updating
   RoomNode: room_name, description, objects, visited, north, south, east,
   west, next (visualization pointer), locked, required_item(s).
   `next` is a SEPARATE insertion-order chain for visualization only — never
   conflate with the navigable directional graph. World model is the single
   source of truth: every mutation (move/take/unlock) happens only in
   updater.py and is immediately visible to the agent's next query, /api/state,
   and the UI — no caching, no stale copies, no rebuild step.

3. Event-Driven Modular Architecture
   Lightweight pub-sub in world_model.py: on(event, callback) / emit(event, data).
   Emits: room_entered, item_taken, room_unlocked, correction_issued,
   goal_completed. game.py, the reasoning logger, and the API layer subscribe
   instead of polling. A state change fires once and every subscribed module
   reacts immediately — this is how game/world model/agent/objects/events
   stay in sync.

4. Inventory Linked List
   ItemNode: item_name, next pointer. Emits item_added / item_removed events.

5. Query Layer — Token-Efficient by Design
   Extract only: current room, its objects, known exits, inventory, goal,
   visited-room names. Never send the full world model.
   - Full description only on FIRST visit; repeat visits send name only.
   - Compact key:value formatting, not full sentences.
   - Visited list = names only, no descriptions.
   - Every Ollama call is a fresh, stateless single-turn call from the
     current slice — no conversation history replay, so prompts never grow.

6. Improved AI Navigation
   Add a lightweight "frontier": exits from the current room leading to
   unvisited rooms, computed cheaply from the linked list, marked in the
   prompt to reduce backtracking. Loop protection: small ring buffer of the
   last N actions in world_model; if the same failed action repeats twice,
   inject a hint ("Repeated action failed twice — try something different")
   into the next prompt so Auto-Play doesn't stall.

7. Self-Correction
   Wrong-belief actions (no such exit, missing required item) return a clear
   correction message, fire correction_issued, and flow into the next prompt
   so the agent visibly adjusts. Log corrections distinctly in AI Reasoning.

8. Fast, Low-Overhead Ollama Calls
   Use ollama.generate (single-turn, not chat history). Low num_predict
   (~15-20 tokens, action is one short line). Low temperature (0.2-0.3) for
   consistent choices. Request timeout + safe "look" fallback so one slow
   or malformed call never stalls the loop.

9. Flask routes:
   / start page | /game dashboard
   /api/action — player action OR one AI step
   /api/state — full current world model, always live, never cached
   /api/reset — fresh in-memory session

10. UI dashboard must show: Current Room, Description, Objects, Exits,
    Inventory, AI Reasoning (correction/navigation hints called out), Goal,
    AI Play controls (Step Once + Auto-Play with a safety step limit ~40),
    and Manual Controls.

11. Visualize Room Linked List (insertion order, all 10 rooms):
    Head
      ↓
    Hall→Kitchen→Bedroom→Garden→Hallway→Attic→Study→Library→Bathroom→Cellar→Treasure Room
    Highlight current, visited, and locked rooms distinctly; wraps/scrolls on mobile.

12. Visualize Inventory Linked List:
    Head
      ↓
    Key→Lantern→Book→Apple→Map

13. Ollama prompt, built ONLY from the token-reduced slice:
    Goal: {goal}
    Room: {room}{" - "+description if first visit else ""}
    Objects: {objects}
    Inventory: {inventory}
    Exits: {exits} (frontier/unvisited marked, e.g. "north*")
    {optional loop-protection hint}
    Return ONLY one action. No explanations.
    Examples: go north | go south | go east | go west | take key | open chest | look
    Fallback parser: if output isn't a clean recognized action, extract the
    first matching line or default to "look".

14. Agent Loop:
    Read live world model -> Query Layer builds token-minimal slice
    (+frontier +loop hint) -> build compact prompt -> call Ollama (single-turn,
    low tokens, low temp, timeout) -> parse action -> execute via Updater ->
    Updater self-corrects if needed + fires events -> world model updates in
    place -> subscribed modules react to events -> repeat until goal or step limit.

15. Log AI reasoning per step, e.g.:
    "Need Lantern before Cellar. Attic unvisited (frontier). Moving to Attic."
    "Tried Treasure Room with only Key — corrected: still need Lantern."
    "Repeated 'go north' failed twice — trying 'go east' instead."

16. Modular structure:
    project/
      app.py, game.py, world_model.py (generic engine, no hardcoded rooms),
      world_data.py (swappable config), linked_list.py, inventory.py,
      agent.py, updater.py, events.py (shared pub-sub)
      templates/index.html, game.html
      static/css/style.css, static/js/script.js

17. Clean, commented code — comments explain WHY (separate next pointer,
    event decoupling, stateless prompts, frontier navigation), not just what.

18. requirements.txt included.

19. README.md: setup (install Ollama, pull llama3.2:3b, run app), confirms
    offline operation after setup, and a short "swap in a new world" guide
    proving the framework is reusable beyond the default map.

20. Modern UI: cards, responsive layout, subtle animations that serve
    clarity, not decoration.

Must clearly demonstrate to judges: (1) a live, event-driven linked-list
world model, (2) a token-minimal query layer for fast/cheap AI calls,
(3) improved navigation via frontier-awareness and loop protection,
(4) autonomous self-correction, and (5) a genuinely reusable framework —
not just one hardcoded game.

Free to use. No credit card required.