Alice Project中文

V0.01 Development Log — Farmer Louise Prototype

Overview

V0.01 was not yet the world-scale simulation that ALICE would later become. It was an earlier single-agent prototype built around a much simpler question:

Can an NPC with almost no initial knowledge gradually learn a concrete skill through natural-language dialogue with a human?

The character chosen for this experiment was a farmer named Louise. At the beginning, Louise does not even understand what "move" means. Through repeated dialogue with the player, she gradually learns the idea of movement, then directions, then distance. Looking back, this prototype was the conceptual embryo of ALICE: it was the first time the chain of language instruction -> action execution -> state change was tied together in one playable loop.

Development Period: January 17-18, 2025 (estimated from the visible commit history of the public repository)

Code Repository: github.com/jeffliulab/WorkWithFarmerLouise

What This Prototype Explored

The central idea of this project was to treat "teaching an agent to do something" as a form of language-driven skill learning.

  • Instead of hardcoding a full behavior script from the start
  • The system gives the NPC only a few primitive actions
  • The human then teaches concepts like "move," "go right," or "walk five steps" through dialogue
  • The system translates that evolving language understanding into visible in-game behavior

So V0.01 was not mainly about a rich world or a social simulation. It was about a more fundamental question:

If an LLM can understand language, can it use language to learn actions?

That question later fed directly into ALICE's deeper concerns:

  • Can language serve as the interface for agent learning?
  • Should memory live in prompts, databases, or in the model itself?
  • When does an NPC that can talk actually count as having "learned" something?

Prototype Mechanics

Technically, the repository is a lightweight but revealing experiment:

  • A small Pygame scene provides a 2D space with Louise, a chat box, and a minimal environment
  • The OpenAI API generates Louise's in-character responses
  • An appended conversation history acts as Louise's running experience
  • The system prompt defines learning stages, from not understanding movement at all to understanding direction and distance
  • When the LLM emits structured markers such as [stage=4], [move=right,5], or [moves=down,2|right,5], the game parses them into an actual movement queue

The important point is not simply that "the NPC can walk." It is that Louise's actions are mediated by language understanding first, then converted into executable behavior.

This makes V0.01 an early and very direct attempt at grounding language in embodied action.

The screenshot below shows the demo in practice: the player keeps refining Louise's understanding of boundary, one-step distance, and moving right, while Louise gradually turns those language instructions into executable movement.

Farmer Louise Demo

Why It Mattered

Even though V0.01 was tiny in scope, it surfaced several ideas that would remain central to ALICE.

First, it suggested that dialogue does not have to end as text. It can become a control interface for embodied behavior.

Second, it revealed how easily "learning" can be simulated. Louise appears to grow because the prompt state and conversation history evolve over time. But that growth happens mostly in prompt engineering and external state, not in the model weights themselves.

Third, it planted the earliest ALICE intuition: if an NPC can learn a basic action through interaction, could a richer agent also learn rules, relationships, values, and eventually participate in a more complex society?

Limitations

The value of V0.01 is also in how clearly its limits appeared.

  • The learning was externally scaffolded rather than intrinsic: growth depended on prompt updates and appended dialogue history, not on parameter updates inside the model
  • The world was tiny: a very small 2D scene, not a real world model
  • There was only one agent: no social propagation, collective behavior, or emergence
  • The skill domain was narrow: the main experiment focused on movement, not open-ended task composition
  • Memory was fragile: "remembering" was mostly continuity in text context

Because of these limits, the prototype made one thing clear:

Prompt accumulation alone would never be enough to build the kind of agent ALICE was really aiming for.

Relationship to Later Versions

If V0.01 asked:

"Can an NPC learn a single action through conversation?"

Then V0.1 pushed the question further:

"If we scale this idea into a larger world, can LLM-driven characters actually grow?"

That transition from V0.01 to V0.1 is where the core ALICE agenda began to sharpen:

  • not just a character that can chat
  • but an agent that can live in a world, accumulate memory, learn, and change

So while V0.01 was only a small classroom-style prototype, it was genuinely the starting point of the ALICE line of thought.