---
language:
- en
- es
license: gpl-3.0
tags:
- cognitive-agent
- symbolic-ai
- memory
- cpu
- software
---
ECHO 5.8
Official release · 5.8.3
Learn from consequences. Carry memory forward.
Website · Download · GitHub
ECHO is a cognitive agent for local simulations and agent tooling. It observes
what happens, learns the consequences of actions and reuses that memory to guide
future decisions. Run it on CPU, explore its terminal and carry memory between
sessions in **WSP files**.
## What does this look like in practice?
Imagine an agent exploring a small simulated world. Some objects move on their
own; touching them can end the attempt. Experience with one world can help the
agent recognize that role in another, even when the object has a new identifier.
A **WSP file is like a memory card for a game**: save what the agent has learned,
then load it into another compatible ECHO agent so it can reuse that experience.
The file carries learned records; the receiving agent uses the same memory format
and role representation.
## See it work
### 1. Remember which objects are dangerous
In this recorded MiniGrid example, the agent without memory hits an obstacle at
step 2. With learned memory, it reaches the green goal at step 33. The red triangle
is the agent; the blue circles are moving obstacles. Left: empty memory. Right:
learned memory. This is one illustrative run with new object identifiers.
### 2. Reuse experience with a key and a door
Both agents finish this recorded task: **38 steps without memory, 27 with memory**.
The agent picks up a key, unlocks a door and collects the target object. Left:
empty memory. Right: learned memory. These clips show individual examples;
the evaluation totals below summarize many runs.
### 3. Save the memory and load it again
This is actual output from the installed release, paced for readability. The
small synthetic example records three observations, saves and reloads a WSP file,
and predicts `HURT` for a new object with the same role. `valid: true` confirms the
file passes the format and integrity checks. Try these commands in Getting started.
[Explore the interactive replay and controls](https://rxlabs.org/echo-en-accion).
## What you can build
- **Agents with persistent memory:** record consequences, recall learned roles
and save or reload the same memory.
- **Interactive simulations:** follow an agent's observations, map and actions
in the browser panel.
- **Connected tools:** use the terminal with local backends and an optional
language-model adviser.
One `echoai` installation brings the core, memory tools and terminal together.
The source includes the simulation and repository integrations.
## Getting started
Python **3.12+** and a Linux, macOS or WSL shell. Download and install the official
runtime package:
```bash
curl -fLO https://huggingface.co/RxLabs/echoai-5.8/resolve/main/echoai-5.8.3.tar.gz
curl -fLO https://huggingface.co/RxLabs/echoai-5.8/resolve/main/SHA256SUMS
if command -v sha256sum >/dev/null; then
sha256sum -c SHA256SUMS
else
shasum -a 256 -c SHA256SUMS
fi
tar -xzf echoai-5.8.3.tar.gz
cd echoai
bash install.sh
export PATH="$HOME/.local/bin:$PATH"
echoai info
echoai demo --memory echo-memory.wsp
echoai memory verify echo-memory.wsp
echoai tui
```
The installer creates a dedicated Python environment. The synthetic demo learns
three observations and reloads the resulting WSP memory. It predicts `HURT` for a
new object with the same role; verification prints `valid: true`. Use a new
filename to run the demo again. In the terminal, start with `/help` or `/demo`.
### Your memory, in Python
Use the environment created by the installer:
```python
from echoai.echo58.memx.memory import Memory
from echoai.echo58.wspfiles.memory import export_memory, load_memory
memory = Memory()
for _ in range(3):
memory.observe(7, 16, "ENTER", 0, "HURT")
export_memory(memory, "my-memory.wsp")
restored = load_memory("my-memory.wsp")
print(restored.recall(99, 16, "ENTER", 0)) # HURT
```
The package contains code, operational settings, a synthetic memory example and
licenses. [Full usage guide](https://github.com/navywakura/echoai/blob/main/docs/USAGE.md)
· [Simulation setup](https://github.com/navywakura/echoai/blob/main/simulation/README.md)
· [See ECHO in action](https://rxlabs.org/echo-en-accion).
## What the results mean
Completed evaluations in simulated worlds:
| What improved? | Measured result | In everyday terms |
|---|---|---|
| Remembering danger | Harmful endings **150.0 → 24.2** | Starting with learned memory reduced attempts that ended in hazards such as lava or contact with moving obstacles. |
| Choosing useful improvements | Unfinished tasks **94.3 → 13.8 out of 120**; harmful endings **58.6 → 0** | ECHO selected and combined five available policy improvements, completing more tasks safely. |
| Sharing experience | **160/160 worlds completed**, compared with **119/160** for isolated agents | Four agents used shared memory to help complete worlds, including tasks where agents cooperate on pressure plates. |
A **harmful ending** means a simulated attempt ended in a hazard. An **unfinished
task** means the goal was not reached, whether because of a hazard or because the
step budget ran out. Decimal counts are averages across repeated evaluations.
How these numbers were measured
- **MEMORIA-X:** mean harmful endings per evaluation run, pooled across held-out
world families in the A1 setting (fixed object identifiers), over 10 runs;
learned memory compared with empty memory.
- **ACUMULA-3:** means over 10 runs, each with a 120-task evaluation and five rounds
of selecting and chaining supplied policy pieces.
- **ENJAMBRE-1:** four agents per team, 20 teams and eight worlds per team;
includes pressure-plate tasks designed for cooperation.
These measurements describe those tasks. ECHO 5.8.3 packages the components
with common setup and memory commands.
## Built over time
ECHO 4/4.5 established the core and terminal; 5.0/5.1 added simulation,
composition and repository tools; 5.5 developed interactive-world tooling;
5.8 brings role memory, chained improvements and cooperation. The WSP persistence
work from 5.8.2 is included in this release.
RxLabs / Nav
rxlabs.org · Source code
GPL-3.0-or-later for the main source; component licenses are included.