Background intelligence that evolves with you.
Autonomous agent on GitHub Actions, powered by Claude Code. 68 skills across research, dev tooling, crypto monitoring, and productivity — all off by default, enable what you need.

OpenClaw is great if you need real-time responses and have infra to run it on. Aeon is for everything else:

• Cheaper — runs on GitHub Actions, free for public repos, ~$2/mo otherwise. No server.
• Built for background tasks — digests, monitoring, research, writing. You don't need sub-second latency for any of that.
• Doesn't break — no daemon to crash, no process to restart. If GitHub Actions is up, Aeon is up. Failed skill? Next cron tick retries it.
• 5-minute setup — fork, add secrets, flip skills on. No Docker, no self-hosting, no config files beyond one YAML.

git clone https://github.com/aaronjmars/aeon
cd aeon && ./aeon

Click on http://localhost:5555 to open the dashboard in your browser. From there:

1. Authenticate — add your Claude API key or OAuth token
2. Add a channel — set up Telegram, Discord, or Slack so Aeon can talk to you (and you can talk back)
3. Pick skills — toggle on what you want, set a schedule, and optionally set a var to focus each skill
4. Push — one click commits and pushes your config to GitHub, Actions takes it from there

You can also schedule and trigger skills by messaging Aeon directly on Telegram — just tell it what you want.

Set one of these — not both:

Getting an OAuth token:

claude setup-token   # opens browser → prints sk-ant-oat01-... (valid 1 year)

Route all Claude Code requests through Bankr LLM Gateway for multi-model access and cost optimization. Bankr routes Claude through Vertex AI (~67% cheaper for Opus) and adds access to Gemini, GPT, Kimi, and Qwen models through a single API.

Setup:

1. Get an API key at bankr.bot/api
2. Top up credits at bankr.bot/llm?tab=credits (USDC, ETH, or BNKR on Base)
3. Add BANKR_LLM_KEY as a repo secret (value: bk_your_key)
4. Set the gateway provider in aeon.yml:

gateway:
  provider: bankr

Key Permissions: Your API key must have LLM Gateway enabled at bankr.bot/api. The Read Only toggle only affects the Agent API — LLM Gateway access is always available when enabled. A key used only for LLM Gateway doesn't need Agent API enabled. See Access Control for full details.

Available models (via Bankr):

Non-Claude models are available in the workflow dispatch dropdown and per-skill model overrides when gateway is set to bankr. Set provider: direct (the default) to use the standard Anthropic API.

Aeon's skills are available as tools in Claude Desktop and Claude Code via the MCP server bundled in mcp-server/.

./add-mcp

That's it. Every Aeon skill appears as an aeon-<name> tool in your Claude interface — no GitHub Actions required. Skills run locally via claude -p -, identical to how they run in Actions.

Example usage in Claude:

Use the aeon-hacker-news-digest tool to get today's top HN stories

Run aeon-deep-research with var="AI agent frameworks" and write a summary

Use aeon-token-movers to get today's top crypto movers

Options:

Skills that need API keys (CoinGecko, Alchemy, etc.) read from the same environment variables they use in Actions — set them in your shell or a .env file in the repo root. Notification channels (Telegram, Discord, Slack) are optional; if not set, output is returned directly to Claude.

Aeon publishes articles to a browsable gallery via GitHub Pages. After merging, enable it in Settings → Pages → source Deploy from a branch, branch main, folder /docs.

The gallery will be live at https://<username>.github.io/aeon.

The site includes three sections:

• Articles — published content from content-generating skills
• Activity (/activity/) — daily log of everything Aeon does: skills run, files created, notifications sent
• Memory (/memory/) — current goals, active topics, and topic deep-dives synced from memory/

The update-gallery skill syncs articles/*.md → docs/_posts/ with proper Jekyll frontmatter on a weekly schedule. Site data (logs, memory, topics) is synced via scripts/sync-site-data.sh. Enable update-gallery in aeon.yml to keep the gallery up to date automatically.

Subscribe to Aeon's article output via Atom feed:

https://raw.githubusercontent.com/<owner>/<repo>/main/articles/feed.xml

Add this URL to any RSS reader (Feedly, Miniflux, NetNewsWire, etc.) to get new articles as they're published. The feed is regenerated daily or after each content-generating skill runs.

The only skill enabled by default. Runs every 3 hours as a fallback catch-all.

Every run: reads recent memory and logs, checks for stalled PRs (>24h), flagged memory items, urgent issues, and skills that haven't run on schedule. Deduplicates against the last 48h of logs — it won't re-notify you about something it already flagged.

Nothing to report → logs HEARTBEAT_OK, exits, no commit. Something needs attention → sends a concise notification.

Heartbeat is listed last in aeon.yml so it only runs when no other skill claims the slot.

All scheduling lives in aeon.yml:

skills:
  article:
    enabled: true               # flip to activate
    schedule: "0 8 * * *"       # daily at 8am UTC
  digest:
    enabled: true
    schedule: "0 14 * * *"
    var: "solana"               # topic for this skill

Standard cron format. All times UTC. Supports *, */N, exact values, comma lists.

Order matters — the scheduler picks the first matching skill. Put day-specific skills (e.g. Monday-only) before daily ones. Heartbeat goes last.

Every skill accepts a single var — a universal input that each skill interprets in its own way:

If var is empty, each skill falls back to its default behavior (scan everything, auto-pick topics, etc.). Set it from the dashboard or pass it when triggering manually.

The default model for all skills is set in aeon.yml:

model: claude-opus-4-6

You can change it from the dashboard header dropdown. Options: claude-opus-4-6, claude-sonnet-4-6, claude-haiku-4-5-20251001. Per-run overrides are also available via workflow dispatch.

Skills can be chained together so outputs flow between them. Chains run as separate GitHub Actions workflow steps via chain-runner.yml.

chains:
  morning-pipeline:
    schedule: "0 7 * * *"
    on_error: fail-fast       # or: continue
    steps:
      - parallel: [token-movers, hn-digest]    # run concurrently
      - skill: morning-brief                   # runs after parallel group
        consume: [token-movers, hn-digest]     # gets their outputs injected

How it works:

1. Each step runs as a separate workflow dispatch
2. After each skill completes, its output is saved to .outputs/{skill}.md
3. Downstream steps with consume: get prior outputs injected into context
4. Steps can run in parallel or sequentially
5. on_error: fail-fast aborts the chain on any failure; continue keeps going

Define chains in aeon.yml alongside your skills. The scheduler dispatches them on their own cron schedule.

Aeon can spawn and manage copies of itself. Use this to run specialized instances — one for crypto monitoring, another for research, etc.

Spawning a new instance:

var: "crypto-tracker: monitor DeFi protocols and token movements"

The skill forks the repo, selects relevant skills based on the purpose, writes a SETUP.md with activation instructions, and registers it in memory/instances.json. The new instance is inert until the owner adds their own API keys — no secrets are propagated.

Fleet control runs twice daily by default (9am, 3pm UTC). It checks each instance's health, flags stale or degraded instances, and can dispatch skills remotely:

var: "dispatch crypto-tracker token-movers"
var: "status"

Edit .github/workflows/messages.yml:

schedule:
  - cron: '*/5 * * * *'    # every 5 min (default)
  - cron: '*/15 * * * *'   # every 15 min (saves Actions minutes)
  - cron: '0 * * * *'      # hourly (most conservative)

Claude only installs and runs when a skill actually matches.

To reduce usage: switch to */15 or hourly cron, disable unused skills, keep the repo public.

Set the secret → channel activates. No code changes needed.

Telegram: Create a bot with @BotFather → get token + chat ID.
Discord: Outbound: Channel → Integrations → Webhooks → Create. Inbound: discord.com/developers → bot → add channels:history scope → copy token + channel ID.
Slack: api.slack.com → Create App → Incoming Webhooks → install → copy URL. Inbound: add channels:history, reactions:write scopes → copy bot token + channel ID.
Email: sendgrid.com/settings/api_keys → Create API Key (Mail Send permission) → add as SENDGRID_API_KEY. Set NOTIFY_EMAIL_TO to your recipient address. Optional: set repository variable NOTIFY_EMAIL_FROM (default: aeon@notifications.aeon.bot) and NOTIFY_EMAIL_SUBJECT_PREFIX (default: [Aeon]).

Default polling has up to 5-min delay. Deploy this ~20-line Cloudflare Worker for ~1s response:

export default {
  async fetch(request, env) {
    const { message } = await request.json();
    if (!message?.text || String(message.chat.id) !== env.TELEGRAM_CHAT_ID)
      return new Response("ignored");

    // Advance offset so polling doesn't reprocess
    await fetch(`https://api.telegram.org/bot${env.TELEGRAM_BOT_TOKEN}/getUpdates?offset=${message.update_id + 1}`);

    // Trigger GitHub Actions immediately
    await fetch(`https://api.github.com/repos/${env.GITHUB_REPO}/dispatches`, {
      method: "POST",
      headers: { Authorization: `token ${env.GITHUB_TOKEN}`, Accept: "application/vnd.github.v3+json" },
      body: JSON.stringify({ event_type: "telegram-message", client_payload: { message: message.text } }),
    });

    return new Response("ok");
  },
};

Set env vars (TELEGRAM_BOT_TOKEN, TELEGRAM_CHAT_ID, GITHUB_REPO, GITHUB_TOKEN) in Cloudflare dashboard, then point your bot's webhook at the worker URL.

The built-in GITHUB_TOKEN is scoped to this repo only. For github-monitor, pr-review, issue-triage, and feature to work on your other repos, add a GH_GLOBAL personal access token.

Setup: github.com/settings/tokens → Fine-grained → set repo access → grant Contents, Pull requests, Issues (all read/write) → add as GH_GLOBAL secret.

Skills use GH_GLOBAL when available, fall back to GITHUB_TOKEN automatically.

./add-skill BankrBot/skills --list          # browse a repo's skills
./add-skill BankrBot/skills bankr hydrex   # install specific skills
./add-skill BankrBot/skills --all           # install everything

Or discover programmatically:

npx skills find "crypto trading"

Installed skills land in skills/ and are added to aeon.yml disabled. Flip enabled: true to activate.

Every skill in this repo is independently installable. Browse the full catalog in skills.json or use the CLI:

# Install a single skill
./add-skill aaronjmars/aeon token-alert

# Install multiple skills
./add-skill aaronjmars/aeon token-alert polymarket hn-digest

# Install everything
./add-skill aaronjmars/aeon --all

# Browse available skills
./add-skill aaronjmars/aeon --list

Package any skill as a standalone directory (with a generated README) for sharing:

./export-skill token-alert              # exports to ./exports/token-alert/
./export-skill token-alert --tar        # also creates a .tar.gz archive
./export-skill --list                   # list all exportable skills

Label any GitHub issue ai-build → workflow fires → Claude reads the issue, implements it, opens a PR.

Don't need the full agent? Grab individual workflow templates and drop them into any repo. These work with GitHub Agentic Workflows — plain Markdown files in .github/workflows/ that run with any supported agent engine.

# Copy a template into your repo
curl -O https://raw.githubusercontent.com/aaronjmars/aeon/main/workflows/pr-review.md
mv pr-review.md .github/workflows/
git add .github/workflows/pr-review.md && git commit -m "Add PR review workflow"

Each template is self-contained Markdown — edit the trigger, criteria, or format to fit your project. See workflows/README.md for details.

By default Aeon has no personality. To make it write and respond like you, add a soul:

1. Fork soul.md and fill in your files:
   • SOUL.md — identity, worldview, opinions, interests
   • STYLE.md — voice, sentence patterns, vocabulary, tone
   • examples/good-outputs.md — 10–20 calibration samples
2. Copy into your Aeon repo under soul/
3. Add to the top of CLAUDE.md:

## Identity

Read and internalize before every task:
- `soul/SOUL.md` — identity and worldview
- `soul/STYLE.md` — voice and communication patterns
- `soul/examples.md` — calibration examples

Embody this identity in all output. Never hedge with "as an AI."

Every skill reads CLAUDE.md, so identity propagates automatically.

Quality check: soul files work when they're specific enough to be wrong. "I think most AI safety discourse is galaxy-brained cope" is useful. "I have nuanced views on AI safety" is not.

CLAUDE.md                ← agent identity (auto-loaded by Claude Code)
aeon.yml                 ← skill schedules, chains, and enabled flags
skills.json              ← machine-readable skill catalog (68 skills)
./notify                 ← multi-channel notifications
./add-skill              ← import skills from GitHub repos
./export-skill           ← package skills for standalone distribution
./generate-skills-json   ← regenerate skills.json from SKILL.md files
docs/                    ← GitHub Pages site (articles, activity log, memory)
soul/                    ← optional identity files
skills/                  ← each skill is SKILL.md (Agent Skills format)
  article/
  digest/
  heartbeat/
  ...                    ← 68 skills total
workflows/               ← GitHub Agentic Workflow templates (.md)
memory/
  MEMORY.md              ← goals, active topics, pointers
  instances.json         ← fleet registry (managed Aeon instances)
  topics/                ← detailed notes by topic
  logs/                  ← daily activity logs (YYYY-MM-DD.md)
.outputs/                ← skill chain outputs (passed between chained steps)
dashboard/               ← local web UI (modular components)
scripts/
  sync-site-data.sh      ← sync memory/logs to docs site data
.github/workflows/
  aeon.yml               ← skill runner (workflow_dispatch, issues)
  chain-runner.yml       ← skill chain executor
  scheduler.yml          ← cron-based chain scheduler
  messages.yml           ← message polling + scheduler (cron)

This repo is a public template. Run your own instance as a private fork so memory, articles, and API keys stay private.

# Pull template updates into your private fork
git remote add upstream https://github.com/aaronjmars/aeon.git
git fetch upstream
git merge upstream/main --no-edit

Your memory/, articles/, and personal config won't conflict — they're in files that don't exist in the template.

Messages not being picked up?

GitHub has two requirements for scheduled workflows:

1. The workflow file must be on the default branch — crons on feature branches don't fire.
2. The repo must have recent activity — GitHub disables crons on repos with no commits in 60 days. New template forks need one manual trigger to activate.

Fix: Actions → Messages → Run workflow (manual trigger). After that, the cron activates automatically.

Support the project : 0xbf8e8f0e8866a7052f948c16508644347c57aba3