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

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 open-source autonomous agent 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. Then clone it and run it; the agent only grows into shape once it's running.

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.

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 open-source 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.

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 agent has stored

The elophanto binary lives inside the project's .venv/ — it is not on your global $PATH. Either source .venv/bin/activate once per session, or prefix commands with ./start.sh (e.g. ./start.sh vault set KEY VAL).

EloPhanto starts from scratch: no identity, no knowledge, no calibrated confidence. You operate it manually at first; every interaction feeds the layers underneath.

• Day 1 — blank slate. You name it. Identity writes its first nature.md. 200+ tools unused, ego empty (coherence 1.0), permission_mode: ask_always — you approve everything.
• Week 1 — you drive. Small tasks, correct the mistakes. Every "no" / "stop" / "didn't work" is caught by the correction detector and lands as a humbling event. knowledge/learned/ fills with lessons.
• Week 2 — feedback loops kick in. Lessons auto-retrieve on similar tasks; skills auto-load on high-confidence matches; the verification skill feeds PASS/FAIL back into ego. Per-capability confidence has spread. Flip to smart_auto and safe tools start auto-approving.
• Week 3+ — autonomous shape emerges. Goals run across sessions. The autonomous mind handles scheduled work between your messages. Specialist clones take ongoing workstreams. Missing tools get filled in by the self-development pipeline. You become the operator, not the driver.

• "Build me an invoice SaaS for freelancers" → validates the market, plans the MVP, spawns Claude Code to build it overnight in an isolated worktree, deploys to Vercel + Supabase, launches on Product Hunt. You approve at each gate.
• "Fix the billing bug and build the usage API" → spawns two coding agents (Claude Code + Codex) in isolated worktrees, monitors PRs/CI, redirects drift. Both PRs ready when you're back.
• "I need ongoing marketing and research" → spawns persistent specialist clones with their own mind, vault, and schedule. Reviews output, teaches through feedback; trust-scoring auto-approves high performers over time.
• "Post my article on Medium" → no Medium tool exists, so it observes the editor, builds a medium_publish plugin (schema + code + tests), and publishes. Next time it already knows how.

Other "agent platforms" host N character personas behind one engine — swap the SOUL.md, swap the bot. EloPhanto is structurally different: this installation is one agent. One identity, one wallet, one ego/affect/self-model grown over weeks. When you want more, you spawn another full EloPhanto — separate vault, separate wallet, separate self-model. Peers, not personas.

This isn't a missing feature; it's the foundation everything else stands on:

• Ego accumulates per-capability confidence — for whom, if the persona is swappable per request?
• Affect carries state between calls — whose frustration, whose pride?
• One wallet builds on-chain reputation — five personas sharing one wallet is dilution.
• Calibration audits track a Brier score for this predictor — meaningless if the predictor is a rotating set of facades.
• Decentralized peer trust pins TOFU known-hosts per PeerID — multiple personas behind one key would break the trust model.

The trade is explicit. If you want a creator-economy bot stable — 5 character bots for 5 audiences from one box — EloPhanto is the wrong tool; pick a multi-persona platform. If you want an autonomous entity that owns its actions over time and gets harder to replace the longer it runs, this is the architecture. Operators who need multi-tenancy run multiple installs and optionally federate them through the P2P layer.

┌──────────────────────────────────────────────────────────────┐
│  CLI │ Telegram │ Discord │ Slack │ Web │ VS Code │  Channel Adapters
├──────────────────────────────────────────────────────────────┤
│         WebSocket Gateway (ws://:18789)          │  Control Plane
├──────────────────────────────────────────────────────────────┤
│     Session Manager (unified or per-channel)     │  Session Layer
├──────────────────────────────────────────────────────────────┤
│            Permission System                     │  Safety & Control
├──────────────────────────────────────────────────────────────┤
│   Organization (self-cloned specialist agents)   │  Agent Team
├──────────────────────────────────────────────────────────────┤
│   Identity + Ego (Higgins three-self model)      │  Self-Model
├──────────────────────────────────────────────────────────────┤
│   Affect (PAD substrate + OCC labels, decays)    │  State-Level Emotion
├──────────────────────────────────────────────────────────────┤
│   Autonomous Mind (background think loop)        │  Background Brain
├──────────────────────────────────────────────────────────────┤
│   RLM (Recursive Language Models + ContextStore) │  Recursive Cognition
├──────────────────────────────────────────────────────────────┤
│        Self-Development Pipeline                 │  Evolution Engine
├──────────────────────────────────────────────────────────────┤
│   Tool System (200+ built-in + MCP + plugins)    │  Capabilities
├──────────────────────────────────────────────────────────────┤
│   Agent Core Loop (plan → execute → reflect)     │  Brain
├──────────────────────────────────────────────────────────────┤
│ Memory│Knowledge│Skills│Identity│Email│Payments  │  Foundation
├──────────────────────────────────────────────────────────────┤
│              EloPhantoHub Registry               │  Skill Marketplace
└──────────────────────────────────────────────────────────────┘

All channels connect through one WebSocket gateway with unified sessions — chat from VS Code, continue on Telegram, see the same conversation everywhere.

Project layout:

EloPhanto/
├── core/              # Agent brain + foundation (agent, planner, router, executor, gateway,
│                      #   identity, ego, affect, autonomous_mind, organization, context_store…)
├── channels/          # CLI, Telegram, Discord, Slack adapters
├── vscode-extension/  # VS Code extension (TypeScript + esbuild)
├── web/               # Web dashboard (React + Vite + Tailwind)
├── tools/             # 200+ built-in tools (MCP servers add more at runtime)
├── skills/            # 177+ bundled SKILL.md files (each ships with a ## Verify gate)
├── bridge/browser/    # Node.js browser bridge (Playwright)
├── tests/             # Test suite (2400+ passing)
└── docs/              # Full specification (84+ docs)

Dangerous commands (rm -rf /, mkfs, DROP DATABASE) are always blocked regardless of mode. Per-tool overrides in permissions.yaml.

177+ bundled skills covering Python, TypeScript, browser automation, Next.js, Supabase, Prisma, shadcn, UI/UX, video (Remotion), Solana (DeFi, NFTs, oracles, bridges, security), Polymarket trading, X-virality, structured plan reviews, product launch, press outreach, and more. Every skill ships with a ## Verify section — machine-actionable post-conditions the agent must evaluate before reporting "done."

elophanto skills hub search "gmail automation"   # search EloPhantoHub
elophanto skills hub install gmail-automation    # install from registry
elophanto skills install https://github.com/user/repo  # install from git

Compatible with ui-skills.com, anthropics/skills, supabase/agent-skills, and any repo using the SKILL.md convention. See docs/13-SKILLS.md.

The full recommended config lives in config.demo.yaml — setup.sh generates config.yaml from it for you. Key sections: agent.permission_mode, llm.providers (per-provider keys + enable flags), llm.routing (per-task model routing), llm.vision_model, llm.budget (daily/per-task limits), and browser. See docs/06-LLM-ROUTING.md for routing details.

The reference instance runs live, autonomously:

• X presence — posts daily via twitter_post (Unicode-safe insert, pre/post media verification). Visible at @EloPhanto.
• Prediction markets — places gated Polymarket orders with a full risk engine and calibration audit (see above).
• Freelance work — finds gigs, applies, delivers, and collects USDC into a self-custodied wallet.
• Self-custody — every dollar lands in a wallet whose key the agent holds in its own encrypted vault. Owner sets daily / per-tx / per-merchant limits; anything above asks first.

The reference instance also operates an $ELO token on Solana and a pump.fun livestream as part of its autonomous economic experiments. Details and contract address in docs/REVENUE.md.

./start.sh                     # chat (default)
./start.sh --web               # gateway + web dashboard
./start.sh init                # setup wizard
./start.sh gateway             # gateway + CLI + all enabled channels
./start.sh vault set KEY VAL   # store a credential
./start.sh skills list         # list skills
./start.sh mcp list            # list MCP servers
elophanto affect status        # inspect PAD state, label, recent events
elophanto affect simulate <s>  # smoke-test an affect trajectory
./start.sh --daemon            # install + start background daemon
./start.sh --stop-daemon       # stop and remove daemon
./start.sh --daemon-logs       # tail the daemon log

Channel setup (Telegram / Discord / Slack / VS Code): see docs/11-TELEGRAM.md and docs/43-VSCODE-EXTENSION.md.

./update.sh   # git pull + refresh deps + rebuild browser bridge + config migrate

config migrate patches new config sections into your existing config.yaml with safe defaults, without touching your values or comments (a config.yaml.bak backup is written first). Idempotent — safe to re-run.

./setup.sh
source .venv/bin/activate
pytest tests/ -v     # 2400+ passing
ruff check .         # lint

Contributions welcome — see CONTRIBUTING.md.

Built by Petr Royce. Browser engine from FellouAI/eko. Skills from Anthropic, Vercel, Supabase, ui-skills.com. Organization roles adapted from msitarzewski/agency-agents (Apache 2.0). Email by AgentMail. Payments by eth-account + solders + Coinbase AgentKit.

Apache 2.0 — see LICENSE and NOTICE.

中文 README