Your complete AI companion.

Identity + Memory + Tools + Workflows + Guardrails + Skills + Evaluation — setup, deploy, run anywhere.

18+ releases across 5 packages. From a CLI tool to a deployable, browser-accessible, multi-agent AI companion ecosystem.

One Command

npx @aman_asmuei/aman

Sets up your complete AI ecosystem:

◆ aman — your complete AI companion

✔ Identity:   created ~/.acore/core.md
✔ Memory:     run npx @aman_asmuei/amem to enable
✔ Tools:      run npx @aman_asmuei/akit add github
✔ Workflows:  run npx @aman_asmuei/aflow init
✔ Guardrails: run npx @aman_asmuei/arules init
✔ Evaluation: run npx @aman_asmuei/aeval init

  ✔ Your AI companion is ready.

The Ecosystem

aman
├── acore       →  identity     →  who your AI IS
├── amem        →  memory       →  what your AI KNOWS
├── akit        →  tools        →  what your AI CAN DO
├── aflow       →  workflows    →  HOW your AI works
├── arules      →  guardrails   →  what your AI WON'T do
├── askill      →  skills       →  what your AI MASTERS
├── aeval       →  evaluation   →  how GOOD your AI is
├── achannel    →  channels     →  WHERE your AI lives
└── aman-agent  →  runtime      →  the engine that runs it all

| Layer | Package | What it does | |:------|:--------|:-------------| | Identity | acore | Personality, values, appearance, relationship memory | | Memory | amem | Automated knowledge storage with semantic search (MCP) | | Tools | akit | 15 portable AI tools (MCP + manual fallback) | | Workflows | aflow | Reusable AI workflows (code review, bug fix, etc.) | | Guardrails | arules | Safety boundaries and permissions | | Skills | askill | Domain expertise with leveling (testing, security, etc.) | | Evaluation | aeval | Relationship tracking and session logging | | Channels | achannel | Telegram, Discord, webhook server | | Runtime | aman-agent | Standalone AI companion CLI | | Unified | aman | Setup + Deploy — one command for everything |

Each package works independently. aman is the front door.

Commands

| Command | What it does | |:--------|:------------| | aman | First run: setup. After that: show status | | aman setup | Set up the full ecosystem | | aman status | View ecosystem status (all layers) | | aman here | Write a project context card (.acore/context.md) for the current directory | | aman deploy | Deploy your AI anywhere (Docker, Ollama, systemd) |

aman here — project context cards

Run aman here in any repo to create a .acore/context.md with the detected stack and today's date. The file is read by aman-claude-code on every session start and embedded into aman-copilot's copilot-instructions.md at init time — so both surfaces know which project you're in. Use --force to overwrite an existing card non-interactively.

After setup, use the individual CLIs for detailed management:

acore customize         # change AI personality
acore doctor            # health check identity
akit add github         # add tools
akit search database    # find tools
aflow init              # set up AI workflows
aflow list              # view workflows
arules init             # set up guardrails
arules add Coding       # add a coding rule
aeval log               # log a session
aeval report            # view relationship report

Ecosystem Status

$ aman status

◆ aman — ecosystem status

✔ Identity:   Companion + Aman
✔ Memory:     amem connected (automated)
✔ Tools:      3 installed
✔ Workflows:  4 defined
✔ Guardrails: 24 rules
✔ Evaluation: 12 sessions tracked
✔ Platform:   Claude Code (auto-save + MCP)

  Ecosystem: Complete ecosystem (6/6 layers active)

Deploy Anywhere

Make your AI companion always-on — accessible from terminal, browser, Telegram, or Discord.

npx @aman_asmuei/aman deploy

Interactive wizard with 4 deployment methods:

Docker Compose (VPS / Home Server)

aman deploy          # select "Docker Compose", enter API key
docker compose up -d # → running on port 3000

Packages the full ecosystem in one container: aman-agent + achannel (Telegram/Discord/webhook) + aman-mcp + amem.

Docker + Ollama (Fully Local)

aman deploy          # select "Docker + Ollama"
docker compose up -d # → aman + Ollama, zero cloud dependency

No API key needed. Runs on Raspberry Pi 4/5 (ARM64), any Linux, macOS.

Systemd Service (Bare Metal / Raspberry Pi)

aman deploy          # select "Systemd service"
# Shows step-by-step install for bare metal Linux

What's in the Docker Image

| Component | What it does | |:---|:---| | aman-agent | Interactive CLI companion | | achannel | Telegram, Discord, webhook server | | aman-mcp | MCP bridge for all ecosystem layers | | amem | Persistent memory with SQLite |

Environment Variables

| Variable | Description | |:---|:---| | ANTHROPIC_API_KEY | Anthropic API key | | OPENAI_API_KEY | OpenAI API key (alternative) | | AMAN_AI_NAME | Your AI's name (default: Aman) | | AMAN_MODEL | LLM model (default: claude-sonnet-4-6) | | TELEGRAM_BOT_TOKEN | Optional — Telegram bot | | DISCORD_BOT_TOKEN | Optional — Discord bot |

All data persists in Docker volumes (identity, memory, config, rules, workflows, skills, eval).

How It All Connects

Every layer is a markdown file. acore auto-injects all of them into your AI's system prompt:

CLAUDE.md / .cursorrules / .windsurfrules
  ├── core.md    (identity — acore)
  ├── context.md (project — acore)
  ├── kit.md     (tools — akit)
  ├── flow.md    (workflows — aflow)
  └── rules.md   (guardrails — arules)

Your AI reads these files and behaves accordingly. Switch platforms? Bring your files.

Not a Developer?

Generate your AI identity from a browser — no terminal needed:

https://amanasmuei.github.io/acore/

Works With

ChatGPT, Claude, Claude Code, Cursor, Windsurf, Gemini, Ollama, and any AI that accepts a system prompt.

Full install (all surfaces)

The one-command setup creates your global ecosystem. To light up every surface:

# 1. Ecosystem (identity + rules + eval)
npx @aman_asmuei/aman@latest

# 2. Persistent memory (MCP) — required for cross-surface memory sync
npx @aman_asmuei/amem

# 3a. Claude Code — plugin + live MCP tools
claude plugin marketplace add amanasmuei/aman-claude-code
claude plugin install aman-claude-code@aman
# Plugin auto-installs the MCP tools on first session start. To install manually:
# node ~/.claude/plugins/cache/aman/aman-claude-code/*/bin/install-mcp.mjs

# 3b. VS Code Copilot Chat — per project
cd /path/to/your/project
npx @aman_asmuei/aman-copilot init
npx @aman_asmuei/aman-copilot install-mcp --all
# Then: reload VS Code window, switch Copilot Chat to Agent mode

# 4. Per-project context card (optional, per repo)
cd /path/to/your/project
npx @aman_asmuei/aman here

Every step is idempotent — safe to re-run. The plugin + copilot auto-load identity/rules/memory from the global ecosystem; you only need to personalise once.

Uninstall / reset

Soft reset — keep packages, wipe content, re-run setup

rm -rf ~/.acore ~/.arules ~/.aeval
npx @aman_asmuei/aman@latest

Useful when your identity drifts and you want a clean slate without fully uninstalling.

Full uninstall — nothing aman-related on disk

# 1. Global ecosystem data
rm -rf ~/.acore ~/.arules ~/.aeval ~/.aflow ~/.akit ~/.askill ~/.amem

# 2. Claude Code plugin + MCP entry
claude plugin uninstall aman-claude-code@aman
claude plugin marketplace remove aman
claude mcp remove aman 2>/dev/null || true

# 3. VS Code + Copilot CLI MCP entries
npx @aman_asmuei/aman-copilot uninstall-mcp --all

# 4. Per-project files — find every .acore folder you opted in to
find ~ -maxdepth 4 -type d -name .acore 2>/dev/null
# Review the list, then delete by hand or:
# find ~/Projects -maxdepth 4 -type d -name .acore -exec rm -rf {} +

Per-project only — remove aman from one repo

# From the project root
rm -rf .acore .github/copilot-instructions.md
rm -f .github/prompts/{identity,rules,eval,remember,session-narrative}.prompt.md

The package npx binaries (aman, amem, aman-copilot, etc.) live in npm's cache — npm cache clean --force if you want those gone too, but they're tiny and usually not worth the trouble.

License

MIT

Setup. Deploy. Run anywhere. Your AI companion.