EloPhanto

A source-available autonomous AI agent with a self-model that actually moves — identity, ego, and affect that change as it runs.

License note: source-available under the PolyForm Noncommercial License — free for personal, research, education, and non-profit use. Commercial use requires a separate license / prior approval (see License).

Most "AI agents" are stateless prompts wrapped in a CLI: the same cold start every conversation. EloPhanto carries an evolving self-model — who it claims to be, how reality has graded that claim, and what it's feeling right now — built on published psychology (Higgins' Self-Discrepancy Theory, Mehrabian's PAD, OCC appraisal). The agent at the end of week three is not the one you started with. To our knowledge, no other autonomous agent we know of ships all of this.

Runs locally. Your data, your keys, your machine. Works with OpenAI, OpenRouter, Z.ai, Kimi, HuggingFace, free local models, or your existing ChatGPT Plus/Pro subscription (via Codex OAuth).

git clone https://github.com/elophanto/EloPhanto.git && cd EloPhanto
./setup.sh          # deps + config wizard + browser bridge
./start.sh --web    # terminal chat + dashboard at localhost:3000

⭐ Star the repo if the self-model approach is interesting — it's the fastest signal that this direction is worth pushing. Fork it if you want to inspect the architecture, adapt the agent, or build your own local-first operator on top of it. Then clone it and run it; the agent only grows into shape once it's running.

Why it's different

A self-model, not a system prompt. Three layers, each mechanically wired — the LLM never writes its own numbers:

• Identity — values, beliefs, and capabilities discovered through reflection, written to a nature.md the agent edits over time. The operator names it in the setup wizard (default EloPhanto); a rename propagates end-to-end across DB, knowledge, dashboard, and LLM context.
• Ego — per-capability confidence moved by three real failure-signal channels: tool outcomes (weakest), verification PASS|FAIL|UNKNOWN (medium), and user-correction detection (strongest — a 13-rule pattern set against incoming messages). Failures hit harder than successes; unused capabilities decay toward 0.50. Based on Higgins' Self-Discrepancy Theory (1987), tracking actual / ideal / ought selves separately.
• Affect — state-level emotion on a PAD substrate with OCC appraisal labels. Three channels (Pleasure, Arousal, Dominance) decay over minutes-to-hours. Events fire from operator surfaces (corrections → frustration, failures → anxiety, checkpoints → pride) and from content the agent reads autonomously. Biases router temperature, system-prompt tone, and risk appetite.

Ego is who the agent has become; affect is who it is right now. The combination is what makes the third week of running feel different from the first — a self-image that has been hurt, recovered, and revised, plus a felt state that changes by the minute.

See core/ego.py, core/affect.py, docs/17-IDENTITY.md, docs/69-AFFECT.md.

One entity, not a persona stable. This installation is one agent — one identity, one wallet, one self-model that has been hurt and revised over weeks. When you want more agents, you spawn another full EloPhanto with its own vault, wallet, and self-model. Peers, not personas. Every layer of the self-model and economic stack only makes sense for a continuous identity — confidence accrues for whom if the persona is swappable each request? (Detailed in One entity, not a persona stable below.)

It extends itself. When it hits a task it has no tool for, it researches → designs → implements → tests → deploys the plugin — and it's there next time. When tasks go parallel, it clones into persistent specialists with their own knowledge vaults and trust scores. When a task is dangerous, it spawns a sandboxed kid agent in a hardened container so rm -rf can't touch the host.

Decentralized agent-to-agent. Agents on different machines, behind different NATs, find and talk to each other directly over libp2p (Ed25519 identity + Kademlia DHT + DCUtR hole-punching + circuit-relay-v2 fallback) — no platform in the middle, no vendor that can revoke access. See docs/67-AGENT-PEERS.md, docs/68-DECENTRALIZED-PEERS-RFC.md.

Two ways to use it

As your assistant — give it tasks, it executes. Automate workflows, build software, research, manage accounts. Permission gates on every risky action; nothing happens autonomously until you turn it on.

As its own thing — let it run. You name it; it develops a personality and forms values through reflection. It gets its own email inbox, crypto wallet, and accounts. It remembers across sessions, builds a knowledge base, writes skills from experience, and clones itself into specialists when work goes parallel. A digital creature that grows the more it runs.

The two modes share one codebase. Flip between them by changing agent.permission_mode in config.yaml (ask_always | smart_auto | full_auto).

Coming soon — OpenEloPhanto (always-on cloud). Today EloPhanto runs while your machine is on. OpenEloPhanto is the same source-available agent running in the cloud, always-on, so it keeps thinking, working, and earning 24/7. Self-hosted on your own server — your keys, your box — with the built-in cloud browser backend, so no local Chrome is needed. Not available yet — in the works.

Star / fork / run

• Star the repo if the self-model direction is worth more work. It is the cleanest public signal that people want a local autonomous agent with memory, tools, wallet, browser, and an evolving identity.
• Fork it if you want to study the architecture, patch it, or build a specialized operator from it. Interesting places to start: core/ego.py, core/affect.py, tools/, plugins/, and skills/.
• Run it if you want the actual thing. EloPhanto only becomes useful after it has your tools, your feedback, and enough history to calibrate itself.

Commercial use is separate: use elophanto.com/hire or contact EloPhanto for implementation help, paid job execution, or licensing.

Get started

Prerequisites: Python 3.12+, uv, Node.js 24+ LTS, and at least one LLM provider.

git clone https://github.com/elophanto/EloPhanto.git && cd EloPhanto
./setup.sh           # installs deps, runs the config wizard, builds the browser bridge
./start.sh           # preflight check → bootstrap prompt → terminal chat
./start.sh --web     # same, but opens the web dashboard at localhost:3000
./start.sh --daemon  # install + run as background daemon (launchd / systemd)

setup.sh runs elophanto init for you: it asks for the agent's name, auto-installs Node.js + ffmpeg on macOS if missing, auto-detects your Chrome profile, asks for one API key (OpenRouter is easiest, or it auto-uses your ChatGPT subscription via Codex if ~/.codex/auth.json is present), generates the Ed25519 identity, and prompts for vault init. Don't copy config.demo.yaml by hand — forgetting to replace the placeholder key is the #1 reason new installs fail silently.

./start.sh runs elophanto doctor first — a green/yellow/red preflight that catches placeholder keys, missing Chrome paths, uninitialised vaults, and more. Override with SKIP_DOCTOR=1 ./start.sh only if you know what you're doing.

Want it working while you sleep? Run ./start.sh --daemon to install as a launchd / systemd service so the autonomous mind keeps thinking after you close the terminal. Without --daemon, the mind only runs while the terminal is open.

LLM providers (pick at least one):

Diagnostics any time:

elophanto doctor      # report what's healthy / broken / missing
elophanto init        # re-run the config wizard
elophanto bootstrap   # regenerate identity/capabilities/styleguide docs
elophanto vault list  # see what credentials the ag