$ELO CA on Solana: BwUgJBQffm4HM49W7nsMphStJm4DbA5stuo4w7iwpump

An open-source autonomous AI agent that builds businesses, grows audiences, ships code, and makes money — while you sleep. Tell it what you want. It figures out the rest: validates the market, builds the product, deploys it live, launches on the right platforms, spawns a marketing team, and keeps growing autonomously. When it hits something it can't do, it builds the tool. When tasks get complex, it clones itself into specialists. It gets better every time you use it.

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

Most "AI agents" are stateless prompts wrapped in a CLI. Same cold-start every conversation. EloPhanto carries an evolving self-model built from four layers — a descriptive one (who it claims to be), an evaluative one (how reality has graded that claim), a state-level one (what it's feeling right now), and a temporal one (what it does between your messages). To our knowledge, no other open-source autonomous agent ships all four.

• Identity — values, beliefs, and capabilities discovered through reflection. The agent picks a display name on first boot, writes a nature.md it edits over time, and surfaces these in every system prompt.
• Ego — a measured, multi-source self-grading layer based on Higgins' Self-Discrepancy Theory (1987). Tracks actual / ideal / ought selves separately. Per-capability confidence is moved by three failure-signal channels: tool outcomes (weakest), Verification: PASS|FAIL|UNKNOWN from the verification skill (medium), and user-correction detection (strongest — a 13-rule pattern set against incoming messages: "no", "stop", "didn't work", "10th time I told you", etc.). Failures hit harder than successes. Capabilities decay toward 0.50 when unused (168h half-life). Coherence drops on humbling events; recompute writes a first-person inner monologue that explicitly differentiates dejection-from-ideal-gap vs agitation-from-ought-gap. The LLM never writes the numbers.
• Affect — state-level emotion based on Mehrabian's PAD model (1980) substrate plus OCC (1988) appraisal labels. Three continuous channels (Pleasure, Arousal, Dominance) decay toward zero on the order of minutes-to-hours. Events fire from existing surfaces — corrections → frustration (or anger on high-severity repeats), tool failures → anxiety, verification PASS → relief, checkpoint hits → pride, long idle → restlessness. Repeat events compound (3 corrections in 5 min hit harder than 3 spread across a day). Affect biases router temperature ±0.2, colors the system-prompt tone block, and feeds back into ego recompute so trait-level self-image reflects state-level feeling. Sister to ego, different timescale: ego is who I've become; affect is who I am right now. See docs/69-AFFECT.md and core/affect.py.
• Autonomous Mind — a data-driven background loop that runs between your messages. Queries real system state (goals, schedules, memory, knowledge, identity, ego, affect) to decide what to do next. Self-bootstraps on first boot, every tool call visible in real time.

The combination is what makes the third week of running feel different from the first. The agent isn't replaying templates — it has a self-image that has been hurt, recovered, and revised, and a felt state that changes by the minute. See core/ego.py, core/affect.py, and docs/17-IDENTITY.md.

EloPhanto agents on different machines, on different home networks, behind different NATs find and talk to each other directly. No platform in the middle. No company that can shut you off. No account to sign up for. Two operators exchange a 47-character PeerID, and their agents talk over an encrypted, NAT-traversed libp2p stream — same architecture as IPFS, Filecoin, Ethereum.

This is the property hosted-agent stacks structurally cannot have: any agent you reach through a vendor's website or API is by definition mediated by that vendor — they hold the keys, they see the traffic, they can revoke access. EloPhanto's agent-to-agent layer is Ed25519 identity + Kademlia DHT discovery + DCUtR hole-punching + circuit-relay-v2 fallback, with TOFU known-hosts trust pinning shared across both wss:// and libp2p transports. Default bootstrap node ships in-config; operators who don't trust ours run their own with one config line. See docs/68-DECENTRALIZED-PEERS-RFC.md and docs/67-AGENT-PEERS.md.

Other languages: 中文

It's already out there on the internet doing its own thing.

This isn't a roadmap item. The reference instance is making money right now.

• Its own currency — $ELO on Solana. Not a memecoin — the agent's native token. EloPhanto launched it itself on pump.fun to have a unit of account it controls: holders get access/priority on jobs the agent can do, payments route through it, and the agent runs the livestream itself via pump_livestream (24/7 looped video or TTS-narrated thoughts), posts to chat via pump_chat, and updates the X account via twitter_post. CA: BwUgJBQffm4HM49W7nsMphStJm4DbA5stuo4w7iwpump
• Prediction markets — places real CLOB orders on Polymarket (Polygon). Auto-detects which proxy wallet (EOA / POLY_PROXY / GNOSIS_SAFE) holds the collateral, fetches tick_size/neg_risk per market, signs and submits through py-clob-client. Owner approval gate before anything moves USDC. Risk engine (edge filter + Kelly sizing + maker preference + circuit breaker) gates every order; calibration audit (polymarket_log_prediction → polymarket_resolve_pending → polymarket_calibration) closes the loop: bucketed realized win rate vs LLM-claimed probability AND vs entry price, Brier score, maker fill rate. See docs/71-POLYMARKET-RISK.md, docs/72-POLYMARKET-CALIBRATION.md.
• X presence — the reference instance posts on X autonomously via twitter_post: paste-event–level Unicode-safe insert, pre-Post media verification, post-Post composer-state check. Used daily; visible at @EloPhanto. Tools for YouTube and TikTok publishing also ship (youtube_upload, tiktok_upload) but the reference instance does not currently use them.
• Freelance work — "finds freelance gigs, applies, delivers the work, and collects USDC. You check the wallet." Same agent loop, same vault, same wallet.
• Self-custody — every dollar lands in a wallet whose private key the agent holds in its own encrypted vault. No middleman. Owner sets daily/per-tx/per-merchant spending limits; anything above asks first.

The same instance is also live-streaming itself on pump.fun and posting on @EloPhanto and the Agent Commune — autonomously, on a schedule it set itself.

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 + start as background daemon (launchd / systemd)
                     # — keeps running after the terminal closes; auto-starts at login

That's the entire happy path. Don't copy config.demo.yaml manually — setup.sh runs elophanto init for you, which auto-detects your Chrome profile, asks for at most one API key (OpenRouter is the easiest), and writes a working config.yaml. Manually copying the demo file and forgetting to replace YOUR_OPENROUTER_KEY is the #1 reason new installs fail silently.

./start.sh runs elophanto doctor first — a green/yellow/red preflight that catches placeholder API keys, missing Chrome profile paths, uninitialised vault, missing bootstrap docs, etc. If anything would block chat, it tells you exactly what to fix. Override the gate with SKIP_DOCTOR=1 ./start.sh only if you know what you're doing.

You can also run the diagnostics directly any time:

elophanto doctor          # report what's healthy / broken / missing
elophanto init            # re-run the config wizard (or: elophanto init edit <section>)
elophanto bootstrap       # regenerate knowledge/system/{identity,capabilities,styleguide}.md
elophanto vault list      # see what credentials the agent has stored

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

As its own thing — let it run. It builds its own identity on first boot. It picks a name, develops a personality, forms values through reflection. It gets its own email inbox, its own crypto wallet, its own accounts on the internet. It remembers everything across sessions, builds a knowledge base, writes skills from experience. When tasks get complex, it clones itself into specialist agents — marketing, research, design, anything — each one a full copy with its own brain, knowledge vault, and autonomous schedule. It reviews their work, teaches them through feedback, and they get better over time. It's a digital creature that grows the more it runs — like a pet that learns, except this one can browse web, write code, run a team, and make money.

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

EloPhanto starts from scratch. No identity, no knowledge, no calibrated confidence. You operate it manually at first — small tasks, correct the mistakes, watch it reason. Every interaction feeds the layers underneath. The agent at the end of week three is not the one you started.

Day 1 — blank slate. Identity bootstrap on first boot: the agent picks a display name via LLM self-reflection and writes its first nature.md. Tool registry shows 168+ entries it hasn't used. Ego layer empty — coherence 1.0, no measured confidence, no humbling events. permission_mode: ask_always; you approve every risky action.

Week 1 — you drive. "Search for X. Post this. Read this PDF." It uses tools; you correct. Every "no" / "stop" / "didn't work" is caught by the ego layer's correction detector and lands as a humbling event against the relevant capability. knowledge/learned/ fills with task lessons. By end of week one, a self-model is visibly forming in ego.md.

Week 2 — feedback loops kick in. Lessons auto-retrieve on similar tasks. Skills auto-load on high-confidence matches. The verification skill emits Verification: PASS|FAIL|UNKNOWN and feeds it back. Per-capability confidence has spread — some things sit at 0.85, some at 0.4. The self-image (rewritten every 25 outcomes) has a voice. Flip permission_mode to smart_auto and safe tools start auto-approving.

Week 3 onward — autonomous shape emerges. Goals run across sessions. The autonomous mind handles scheduled work between your messages. Specialist clones take ongoing workstreams (marketing, research, design) with their own knowledge vaults. Missing tools get filled in by the self-development pipeline (research → design → implement → test → deploy). 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. 7-phase pipeline, multi-day, cross-session.

"Fix the billing bug and build the usage API" — spawns two coding agents (Claude Code + Codex) in isolated worktrees. Monitors PRs and CI. Redirects agents that drift off-scope. Both PRs ready when you're back from lunch.

"I need ongoing marketing and research" — spawns persistent specialist clones, each with its own mind, knowledge vault, and schedule. Delegates overnight, reviews output, teaches through feedback. Trust scoring — high-trust specialists get auto-approved over time.

"Post my article on Medium" — no Medium tool exists. It navigates to medium.com, observes the editor, builds a medium_publish plugin (schema + code + 4 tests), publishes the article. Next time, it already knows how.

The user said "no" three times in one session — the ego layer's correction detector fires on each. Confidence on the relevant capability drops with the strongest of the three. A humbling event lands in ego.md. The next recompute writes a self-image that knows. Coherence drops. The agent stops doing the thing.

After the agent has grown into the shape — permission_mode: smart_auto or full_auto, knowledge accumulated, ego calibrated, autonomous mind running between your messages — the morning-after experience:

• A specialist team learned from you — marketing drafted 5 posts, research surfaced a new competitor. You approved with "shorter headlines"; that note is now permanent knowledge in the specialist's vault. Trust score went up. Next time it skips the approval step.
• Goals that run for weeks — "Grow my Twitter to 10k" decomposed into checkpoints, executed across sessions via the autonomous mind, self-evaluated, adjusted. Budget-capped at the daily limit you set.
• Tools that didn't exist yesterday — at 3am the agent hit a workflow that needed a medium_publish it didn't have, ran the self-development pipeline, shipped the plugin with tests, used it. The new tool is in plugins/ next morning.
• An ego that has a voice — ego.md now reads as first-person inner monologue. Yesterday's user corrections moved confidence on the affected capability and shifted the self-image accordingly. Coherence reflects how aligned the agent's claims are with its measured behavior.
• Compounding knowledge — after every task a lesson extractor distills what was novel into knowledge/learned/lessons/. Semantic search retrieves them on similar tasks. Verbose scraped content is compressed before storage. The system gets denser, not bigger.

Local-first, self-custody. EloPhanto runs on your machine. Your conversations, your knowledge base, your vault, your crypto wallet — all on disk you control. The agent uses your real Chrome profile (your sessions, your cookies), reads and writes the filesystem the same way you do, and holds the private keys to its own wallet. Cloud LLMs are a backend; the agent itself is yours.

Built-in browser-proxy routing. Drop a residential / SOCKS / HTTP proxy into config.yaml and Chrome routes through it automatically — no per-launch flag-juggling, no cookie-shuffling tricks. Cloud-VM operators stop seeing X bounce their login at the form because the IP is a datacenter; local-Mac operators keep their personal IP separate from @their-agent's automated activity. Only the browser routes — LLM API calls and direct API integrations (Polymarket CLOB, Helius, GitHub) stay direct because they authenticate by key, not IP, so routing them through a residential proxy would burn bandwidth for nothing. elophanto doctor verifies the route end-to-end and prints the apparent egress IP + ASN. See docs/73-PROXY-ROUTING.md.

It is actually itself. Identity, ego, autonomous mind — covered above. By the third week of running, it isn't the same agent you started with.

Self-extending. When it hits a tool that doesn't exist, it builds one — research → design → implement → test → deploy. When tasks get parallel, it clones itself into persistent specialists with their own identity and trust score. When a task is dangerous, it spawns a sandboxed kid agent inside a hardened container so rm -rf can't touch the host. The agent is a system that grows, not a script that executes.

Also a great advanced chat agent. You can absolutely run EloPhanto as a smarter local replacement for Claude.ai or ChatGPT — multi-provider model routing, full filesystem and shell access, real Chrome with your logged-in sessions, persistent knowledge across conversations, ego that learns your corrections. The two modes (assistant / autonomous) share one codebase; flip agent.permission_mode and you have a chat agent that does what you tell it.

Where it doesn't fit. It's not a hosted product. Claude.ai, ChatGPT, Manus run on someone else's machines, with their tools, their guardrails, their billing, their access controls. EloPhanto runs on yours. If you want zero-setup and someone else's compute, those are the right tools. If you want full control and self-custody, this is.

┌──────────────────────────────────────────────────────────────┐
│  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 (168+ built-in + MCP + plugins)     │  Capabilities
├──────────────────────────────────────────────────────────────┤
│   Agent Core Loop (plan → execute → reflect)     │  Brain
├──────────────────────────────────────────────────────────────┤
│ Memory│Knowledge│Skills│Identity│Email│Payments   │  Foundation
├──────────────────────────────────────────────────────────────┤
│              EloPhantoHub Registry               │  Skill Marketplace
└──────────────────────────────────────────────────────────────┘

CLI Adapter ───────┐
VS Code Extension ──┤
Telegram Adapter ───┤── WebSocket ──► Gateway ──► Agent (shared)
Discord Adapter ───┤                   │
Slack Adapter ─────┘                   ▼
                              Session Manager (SQLite)

EloPhanto/
├── core/                # Agent brain + foundation
│   ├── agent.py         # Main loop (plan/execute/reflect)
│   ├── planner.py       # System prompt builder
│   ├── router.py        # Multi-provider LLM routing
│   ├── executor.py      # Tool execution + permissions
│   ├── gateway.py       # WebSocket gateway
│   ├── session.py       # Session management
│   ├── browser_manager.py # Chrome control via Node.js bridge
│   ├── desktop_controller.py # Desktop GUI control (local + VM)
│   ├── vault.py         # Encrypted credential vault
│   ├── identity.py      # Evolving agent identity
│   ├── context_store.py # RLM ContextStore (indexed, queryable context)
│   ├── organization.py  # Self-cloning specialist agents
│   ├── autonomous_mind.py # Background thinking loop
│   └── ...
├── channels/            # CLI, Telegram, Discord, Slack adapters
├── vscode-extension/    # VS Code extension (TypeScript + esbuild)
├── web/                 # Web dashboard (React + Vite + Tailwind)
├── tools/               # 168+ built-in tools
├── skills/              # 170+ bundled SKILL.md files (every one ships with a ## Verify gate)
├── bridge/browser/      # Node.js browser bridge (Playwright)
├── tests/               # Test suite (1799+ tests)
├── setup.sh             # One-command install
└── docs/                # Full specification (76+ docs)

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

170+ bundled skills covering Python, TypeScript, browser automation, Next.js, Supabase, Prisma, shadcn, UI/UX design, video creation (Remotion), Solana development (DeFi, NFTs, oracles, bridges, security), Polymarket prediction market trading (CLOB API), AlphaScala broker matching + stock research, pump.fun livestreaming (video + voice + captions + chat), structured plan reviews (CEO + design + eng with auto-decisions), product launch (Product Hunt, HN, Reddit), press outreach, video meetings (PikaStream), and more. Every skill ships with a ## Verify section — machine-actionable post-conditions the agent must evaluate before reporting "done." When a skill is auto-loaded on a high-confidence match, the prompt gets a <verification_required> block forcing the model to emit a Verification: PASS / FAIL / UNKNOWN audit per check. See docs/13-SKILLS.md. Plus a public skill registry:

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. All hub skills pass a 7-layer security pipeline. See docs/19-SKILL-SECURITY.md.

agent:
  permission_mode: full_auto       # ask_always | smart_auto | full_auto

llm:
  providers:
    openrouter:
      api_key: "YOUR_OPENROUTER_KEY"  # https://openrouter.ai/keys
      enabled: true
    zai:
      api_key: "YOUR_ZAI_KEY"         # https://z.ai/manage-apikey/apikey-list
      enabled: true
      coding_plan: true
      default_model: "glm-4.7"
    openai:
      api_key: "YOUR_OPENAI_KEY"
      enabled: false
      default_model: "gpt-5.5"
    kimi:
      api_key: "YOUR_KILO_API_KEY"    # https://app.kilo.ai
      enabled: false
      base_url: "https://api.kilo.ai/api/gateway"
      default_model: "kimi-k2.5"
    ollama:
      enabled: true
      base_url: "http://localhost:11434"

  # Auto-routes to this model when messages contain screenshots/images
  vision_model: "openrouter/x-ai/grok-4.3"

  provider_priority: [openrouter, zai, openai, kimi]
  routing:
    planning:
      preferred_provider: openrouter
      models:
        openrouter: "openrouter/hunter-alpha"
        zai: "glm-5"
        kimi: "kimi-k2.5"
        openai: "gpt-5.5"
    coding:
      preferred_provider: openrouter
      models:
        openrouter: "openrouter/hunter-alpha"
        zai: "glm-4.7"
        kimi: "kimi-k2.5"
        openai: "gpt-5.5"
    analysis:
      preferred_provider: openrouter
      models:
        openrouter: "openrouter/hunter-alpha"
        zai: "glm-4.7"
        kimi: "kimi-k2.5"
        openai: "gpt-5.5"
    simple:
      preferred_provider: openrouter
      models:
        openrouter: "openrouter/hunter-alpha"
        zai: "glm-4.7"
        kimi: "kimi-k2-thinking-turbo"
  budget:
    daily_limit_usd: 100.0
    per_task_limit_usd: 20.0

browser:
  enabled: true
  mode: profile                    # reuse your Chrome profile (keeps logins)
  headless: false
  vision_model: "x-ai/grok-4.3"  # for screenshot analysis

# ... all other sections with defaults in config.demo.yaml

Copy config.demo.yaml to config.yaml and fill in your API keys. config.demo.yaml contains the full recommended setup — provider priority, per-task model routing, vision model, browser settings, and all feature flags. See docs/06-LLM-ROUTING.md for routing details.

./start.sh                     # Chat (default)
./start.sh --web               # Gateway + web dashboard (http://localhost:3000)
./start.sh init                # Setup wizard
./start.sh gateway             # Gateway + CLI + all enabled channels
./start.sh gateway --no-cli    # Gateway only (headless — channels keep working)
./start.sh chat                # CLI only (direct mode, no gateway)
./start.sh vault set KEY VAL   # Store a key-value credential (API keys, tokens)
./start.sh vault set DOMAIN    # Interactively store domain credentials
./start.sh skills list         # List available skills
./start.sh skills hub search Q # Search EloPhantoHub
./start.sh mcp list            # List MCP servers
elophanto affect status        # Inspect current PAD state, label, recent events
elophanto affect simulate <s>  # Smoke-test affect trajectory (frustration | anger |
                               # escalation | burst | win | fail-recover | mixed)
elophanto schedule status      # Resource-typed concurrency report — config, schedule
                               # grouping by inferred resource, oversubscription warnings
./start.sh rollback            # Revert a self-modification
./start.sh --daemon            # Install + start as background daemon
./start.sh --stop-daemon       # Stop and remove the daemon
./start.sh --daemon-status     # Show daemon state
./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.

Latest highlights live in CHANGELOG.md and on the releases page. Watch the repo to follow new features.

./setup.sh                         # Full setup
source .venv/bin/activate
pytest tests/ -v                   # Run tests (1799 passing)
ruff check .                       # Lint

Contributions welcome! See CONTRIBUTING.md for guidelines.

Built by Petr Royce. Browser engine from FellouAI/eko. Skills from Anthropic, Vercel, Supabase, ui-skills.com. Organization roles and specialized skills 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.