Friday — A 24/7 AI Assistant Built Entirely on Claude Code

An always-on personal AI system using only Claude Code CLI ($100/month) and Telegram — no custom AI, no cloud VMs, no fine-tuning.

Live page: missingus3r.github.io/friday-showcase

What Is This?

A self-evolving AI assistant that runs 24/7 on a standard Windows, Linux, or macOS machine. It talks over Telegram, runs scheduled tasks, manages files and projects, and keeps persistent memory across sessions — and it learns from its own behavior: acquiring skills, reflecting nightly, inferring preferences from repeated corrections, and proposing its own improvements. All powered by Claude Code (Anthropic's CLI agent) on the $100/month Max Plan — no custom AI backend, no fine-tuned models, no orchestration framework. The only custom code is a lightweight Flask server for memory and the self-evolving subsystems.

How It Works

Claude Code sits at the center, reaching external services through MCP (Model Context Protocol) plugins and shell tools. A CLAUDE.md file is the system prompt — behavior, tools, and cron schedules. Self-evolving subsystems (skills, reflection, preference learning, world modeling, proposals) run as scheduled jobs on the same memory server, feeding insights back into behavior with no fine-tuning.

User (Telegram) ---> Claude Code (with MCP plugins)
    |
    |--> Memory API        ---> SQLite (conversations, memories, embeddings)
    |--> Self-Evolving     ---> Skills, reflections, preferences, world model, proposals
    |--> Knowledge Base    ---> Notes, wiki, structured data (Notion MCP)
    |--> GitHub            ---> Repos (push, commit, PR)
    |--> Voice API         ---> Text-to-speech / Speech-to-text (ElevenLabs)
    |--> Email (REST API)  ---> Send, receive, forward (AgentMail)
    |--> Web Search/Fetch  ---> News, research, data
    |--> Cron system       ---> Recurring autonomous jobs
    |--> Local tools       ---> Shell, scripts, system utilities

Why Not Use an Agent Framework?

Agent frameworks (OpenClaw, NemoClaw, and others) are impressive but add layers: custom runtimes, orchestration code, deployment pipelines, often their own API costs.

Claude Code already is the runtime — native tool use, MCP plugins, cron scheduling, sub-agent spawning, file I/O, git, and shell, all built in. No glue code between the LLM and the tools.

One plan, one CLI, one model: stay within a single subscription, respect the provider's ToS, and let the model do what it was designed to do.

Star History

The Stack

Screenshots

Telegram Examples

How Friday looks in everyday use — the same Telegram chat, across different tasks.

Memory Graph

D3.js force-directed view of conversations, memories, and entities. Drag, zoom, and click to explore.

Architecture Diagram

Map of all components and their connections. Nodes are draggable; positions persist server-side.

The memory server renders all logs, memories, and entities as interactive graph nodes. This implementation is called Friday, but the name is just a variable in the CLAUDE.md configuration.

Capabilities

• Scheduled briefings — weather (Open-Meteo), forex/crypto (DolarAPI, ExchangeRate), AI news (WebSearch), movies (YTS)
• Autonomous monitoring — scans 60+ HuggingFace orgs, blogs, and aggregators for new AI model releases
• Notes & knowledge — saves links, text, and structured data to Notion (MCP) and local markdown
• Voice messages — transcribes audio in (ElevenLabs Scribe STT), replies with synthesized speech (ElevenLabs TTS)
• Video analysis — downloads, transcribes (YouTube subs / ElevenLabs), and reports via LLM (Groq / OpenRouter)
• Email — check, draft, send, forward (AgentMail REST API)
• Git — commit, push, PRs, repo management (GitHub API + git CLI)
• Web research — search, fetch, summarize, report back (WebSearch + WebFetch)
• Self-healing crons — monitors its own jobs and recreates any that expire
• Proactive messaging — reaches out first: check-ins, reminders, follow-ups based on memory and context. An optional rule-based outbox paces them like a person would: non-urgent items wait for a good moment (not while you sleep, work, commute or sit in a meeting) and go out together in one short message instead of on the clock
• Skill acquisition — extracts reusable patterns from solved tasks, stored with trigger patterns
• Daily self-reflection — nightly review of logs for mistakes, wins, and patterns → insights
• Preference learning — infers rules from repeated corrections and applies them automatically
• World modeling — a behavioral model of the user (activity, topics, correlations) with confidence + expiry
• Self-improvement proposals — formal proposals with diffs; never applied without approval
• Memory API health — periodic checks with auto-restart and failure notification
• Live camera & object detection (optional extra) — turns a security camera (IP, USB, etc.) into a local detector: YOLOv8n (Ultralytics + OpenCV) detects people on-device, captures a snapshot with a bounding box + a ~10s clip, and alerts via Telegram — nothing leaves the machine. Enabled by the --with-camera flag in the setup prompt

Scheduled Jobs

A handful of autonomous cron jobs keep the system alive and learning. Over time the assistant consolidated its own schedule — collapsing 25 sprawling jobs into 7 grouped ones (25 → 8 → 7, retiring jobs whose purpose expired). Exact times are arbitrary, so adapt them to your routine; what matters is the split between the essential jobs (the framework itself) and the project-specific ones you swap for your own.

Essential — the framework:

Project-specific (examples — swap for your own): AI-model release monitor, dataset scrapers, monthly usage reports. These aren't part of the core framework — they're whatever you want running 24/7.

The heartbeat and briefing crons act as watchdogs — they verify every job is active, recreate missing ones, and refresh them before the 7-day lifetime expires. The dashboard's Crons tab shows a two-column diff: runtime jobs with live countdowns vs disk-persisted prompts with sync badges.

Disaster recovery

/backup/export and /backup/import move a whole-DB snapshot over HTTP. Schedule a nightly off-site rsync of the export; if the machine dies, import the snapshot into a fresh install, restart, and Friday picks up where it stopped. A 💾 Backup button on the dashboard does the same from the browser.

Memory Server

Reference snapshot: github.com/missingus3r/memory-graph. ⚠️ Not a template to clone — that code is generated autonomously by Claude Code following the SETUP.md in this repo, so every user's version differs. The repo is committed only as the source for the screenshots and a reference of what the output looks like.

Claude Code generates a single Flask + SQLite server handling conversation logging, long-term memory, entity tracking, key-value storage, and RAG with vector embeddings. No external vector DB — embeddings live as BLOBs in the same SQLite file.

Core features:

• Conversation logging — every message with timestamp, role, channel, and auto-classified importance (0.0-1.0)
• Importance scoring — auto-classified at insert via dynamic keyword-score pairs in the DB (not hardcoded), editable through GET/POST /keywords with hit counts tracked; the preference cron tunes scores over time
• Semantic search — cosine similarity over 3072-dim embeddings
• Hybrid search — FTS5 + semantic via Reciprocal Rank Fusion, weighted by importance
• Weekly summarization — compresses old logs into summaries (originals preserved)
• Entity tracking — people, companies, tools, concepts
• Key-value store — server-side UI state

Web visualization — a single-page app at /graph with four tabs:

• Graph — D3.js force-directed nodes for conversations, memories, and entities
• Logs — chronological view with collapsible date groups and search
• Architecture — system diagram with draggable, server-persisted nodes
• RAG — semantic-search dashboard with hybrid search and embedding stats

The whole memory layer is one Python file. No vector DB, no Redis, no Elasticsearch — just Flask + SQLite + embeddings in the same file.

Self-Evolving Harness

The assistant doesn't just follow instructions — it learns from its own behavior and improves over time. On top of the base assistant sits a thin, entirely additive cognition harness that turns Friday from "an LLM with tools" into a system that sets goals, plans, verifies, experiments, and measures whether it's actually improving. (In the spirit of When AI builds itself — Anthropic.)

Five subsystems do the learning:

• Skill Acquisition — extracts the pattern from a solved task and saves it as a reusable skill with trigger patterns and steps; usage is tracked.
• Daily Self-Reflection — a nightly cron reviews the day's logs (what went well, what went wrong, what patterns emerge) and stores conclusions that feed future behavior.
• Preference Learning — periodically analyzes all past feedback; repeated corrections become rules applied automatically.
• World Model — builds a model of the user over time (active hours, recurring topics, correlations) with confidence scores and expiration dates.
• Self-Improvement Proposals — proposes better keyword lists, cron schedules, or scoring functions as formal diffs; never applied without Telegram approval.

It all runs on the same memory server, visible in the Memory Graph's Brain tab — skills, preferences, reflections, world-model insights, and pending proposals.

Brain Dashboard

The Brain tab: skills, preferences, reflections, world-model insights, and pending proposals — all on the same memory server.

What the harness adds: 13 SQLite tables, dozens of endpoints (including /backup/* for disaster recovery and /harness/health for loop monitoring), the harness cron passes, and operational rules in CLAUDE.md. Nothing was removed — new columns are ALTER TABLE … IF NOT EXISTS, so old DBs upgrade in place. Later passes closed the loops end-to-end: auto-calibration, self-applying proposals with rollback, sandbox auto-promotion, and hybrid recall.

8 subsystems:

Consolidated Brain dashboard — eight sections (Overview, Goals, Memory, World, Self, Safety, Learning, Metrics) behind a sticky sub-nav. Crons dashboard — runtime snapshot with live countdowns + disk-persisted prompts with sync badges.

The system gets better every day not because the model changes, but because it builds a growing library of skills, preferences, and patterns on top of it. The model stays the same; the assistant evolves.

Golden rule (in CLAUDE.md): no unrecorded autonomy. Every goal, plan node, sandboxed action, resolved prediction, and promoted skill leaves a row — the dashboards are where a human audits whether the system is earning its autonomy.

How Friday Compares

The same table as the live page, against four open agents in the same space: Clawdbot (renamed OpenClaw in January 2026, by Peter Steinberger — repo), Hermes Agent (Nous Research — repo), Khoj and Leon. All are good projects. The difference is architectural: they ship a runtime you install and maintain; Friday uses Claude Code as the runtime and spends its complexity budget on cognition instead.

✓ yes · ~ partial / unconfirmed · — no. Compiled from public docs, August 2026. The marketplace row is theirs, fairly — Friday builds its skill library from its own solved tasks instead of a community catalog.

The $100 Question

The whole system runs on a single $100/month Anthropic Max Plan. No cloud inference VMs, no LangChain/AutoGPT/agent framework — just Claude Code on a machine with MCP plugins.

Claude Code isn't only a coding assistant — it's a general-purpose autonomous agent runtime. Give it tools, instructions, and a schedule and it becomes a full 24/7 assistant. One $100 plan buys (almost) unlimited access to a top model with native tool use and long context. That's enough.

Known Issue: Lost Telegram Messages (and the fix)

The Bot API plugin can occasionally drop incoming messages without any error — photo albums are the most common casualty. The setup guide includes an optional Telethon ledger: a passive listener on your own account that records the full chat to a local file, so the assistant detects gaps and auto-recovers the lost messages instead of asking you to resend. See "Optional: Telethon Message Ledger" in SETUP.md.

Safety Net: the Guardian

Friday runs unattended with --dangerously-skip-permissions, so a poisoned email or web page — or a plain hallucination — could tell it to delete things. The guardian is a PreToolUse hook that sees every command before it runs and blocks the destructive ones: recursive deletes outside temp folders, deleting or moving data off the media disk, sudo/dd/mkfs, git reset --hard/git clean/git push --force, recursive chmod/chown, and writes to credentials or to its own config.

When it blocks something, you get a Telegram message explaining what the command would do (which folder, how many files, how many GB, whether it can be undone) plus the full command. Reply ok <code> and that exact command runs once. The approval is verified against your own account's chat ledger, so the assistant can't approve itself — not even to edit the guardian. Everyday work (normal pushes, temp cleanup, downloads) is untouched. Details and install: guardian/README.md.

Set It Up Yourself

Download SETUP.md and hand it to a fresh Claude Code session — it walks through every step autonomously (Telegram config, memory server, API keys, CLAUDE.md). You just approve as it goes.

Open Claude Code and type:

Read the file ~/Downloads/SETUP.md and follow every step in it to set up a 24/7 AI assistant on this machine. Ask me for confirmation before each major step.

Once set up, start it with:

claude --channels plugin:telegram@claude-plugins-official --dangerously-skip-permissions

Claude Code reads your CLAUDE.md, connects to Telegram, creates the cron jobs, and runs autonomously.

Named after the last A.I. assistant Tony Stark built before hanging up the suit. This one doesn't have a suit either — just a terminal.

GitHub: missingus3r | X: missingus3r