Friday

Your real-life F.R.I.D.A.Y. — an autonomous AI operating system for solo founders.

Voice-controlled. Self-improving. ADHD-native. Device-aware. Budget-tracked.
One founder + Friday = a full engineering team.

"Will that be all, sir?" — No. Friday does more. Friday is what comes after Jarvis.

In the MCU, Tony Stark replaced J.A.R.V.I.S. with F.R.I.D.A.Y. — an AI that didn't just answer questions, but ran the suit, managed the lab, and made the calls when Tony couldn't. This project is the real-world version: an always-on AI chief of staff that perceives your workflow, remembers everything, writes production code, controls your devices, manages your budget, and gets smarter every week — autonomously.

Friday is not a chatbot with a microphone. It's an operating system that wraps around your entire workflow — perceiving what you're doing via screen awareness, remembering everything across projects in a battle-tested dual-SQLite memory system, generating production-quality code through an OpenCode factory with writer≠reviewer enforcement, controlling your PC and server by voice, dictating text hands-free, analyzing your screen with vision models, setting timers and reminders, delivering morning briefings, monitoring server health around the clock, decomposing complex requests into multi-step background tasks, tracking your spend per AI provider, shadow-testing new models before promoting them, and getting measurably better every Saturday — without you lifting a finger.

The thesis: most of what slows a solo founder down isn't coding ability — it's context-switching overhead, decision fatigue, forgotten context, and the constant tax of re-explaining what you're working on. Friday eliminates all of it.

You: "Friday, build the entire payment module for ACFO"
       ↓ intent classified (COMPLEX) → memory retrieved (project facts, architecture decisions)
       ↓ brain decomposes into 5-step plan → TaskManager executes in background
       ↓ Step 1: research existing payment patterns → Step 2: generate models
       ↓ Step 3: generate API endpoints → Step 4: write tests → Step 5: review
       ↓ progress streamed to dashboard + voice notification on completion
Friday: "Payment module complete. 5 steps, 12 files modified. Tests pass. Cost: $0.23."

You: "Open YouTube" → 0 tokens. Pattern-matched, browser opens instantly.
You: "Set a timer for 25 minutes" → 0 tokens. Timer set, TTS confirmation.
You: "How's the server?" → 0 tokens. Health report via TTS.
You: "What's on my screen?" → Screenshot → vision model → spoken description.
You: "Dictate" → Continuous speech-to-text typed at your cursor. Zero brain tokens.

Why Friday Exists

Problem	How Friday solves it
"What was I working on?"	Dual-SQLite memory (FACTS + WARM) + morning briefings reconstruct your full context
Context-switching kills momentum	ADHD-native focus tracking detects drift, parks side-quests, nudges you back
AI coding tools produce inconsistent output	OpenCode factory: spec → generate → review (writer≠reviewer) → validate → deliver
Every AI tool starts from zero	Friday remembers architecture decisions, coding patterns, and past mistakes permanently
Token costs spiral with dumb context injection	60-70% of commands use zero tokens (pattern-matched). Complexity classification + budget tracking for the rest
AI assistants require constant hand-holding	Screen awareness + full device control + dictation + proactive timers/reminders
No way to know if a cheaper model would work	Shadow validation A/B tests new models silently, promotes when statistically proven
Complex tasks need babysitting	TaskManager decomposes into steps, executes in background, retries failures, reports when done
Server goes down at 3 AM	System monitor checks CPU/memory/disk/services every 60s, auto-restarts, sends alerts

Architecture

┌───────────────────────────────────────────────────────────────────────┐
│                         YOUR MACHINE (Client)                          │
│  ┌────────────┐  ┌─────────────┐  ┌───────────────────────────────┐  │
│  │ Wake Word  │  │   Screen    │  │  Full PC Device Controller    │  │
│  │ (Porcupine)│  │  Awareness  │  │  Windows / Linux / macOS      │  │
│  └─────┬──────┘  └──────┬──────┘  │  50+ actions: apps, windows,  │  │
│        │  Mic capture    │ Window  │  media, clipboard, files,     │  │
│        ▼    + VAD        ▼ track   │  system, network, brightness  │  │
│  ┌─────────────────────────────────┴──────────────────────────────┐  │
│  │   WebSocket Client (WSS + Auth) + Dictation Mode              │  │
│  │   Voice stream │ Dictation stream │ Device results              │  │
│  └──────────────────────┬─────────────────────────────────────────┘  │
└─────────────────────────┼────────────────────────────────────────────┘
                          │  Persistent connection (JWT / shared secret)
┌─────────────────────────┼────────────────────────────────────────────┐
│  SERVER                 ▼                                             │
│  ┌────────────────────────────────────────────────────────────────┐  │
│  │              Category-Based Orchestrator                        │  │
│  │  1. Transcribe → 2. Classify intent (10 categories)            │  │
│  │  3. Route: builtin│device│server│proactive│mode│screen│        │  │
│  │           memory│adhd│briefing│brain  → 4. Respond + TTS       │  │
│  │  5. Log outcome (model=pattern_match, cost=$0 for 60-70%)      │  │
│  └───┬──────────┬──────────┬──────────┬─────────┬──────────────┘  │
│      │          │          │          │         │                   │
│  ┌───▼───┐  ┌──▼───┐  ┌──▼──────┐  ┌▼──────┐ ┌▼───────────────┐ │
│  │Memory │  │Brain │  │OpenCode │  │Task   │ │Device Control  │ │
│  │FACTS  │  │Router│  │Bridge   │  │Manager│ │PC (50+ cmds)   │ │
│  │WARM   │  │GPT/  │  │build,   │  │multi- │ │Server (svc,    │ │
│  │runs   │  │Claude│  │critic,  │  │step   │ │docker, deploy, │ │
│  │routing│  │Ollama│  │research │  │plans  │ │git, security)  │ │
│  └───────┘  └──────┘  └─────────┘  └───────┘ └────────────────┘ │
│                                                                    │
│  ┌────────┐ ┌────────────┐ ┌────────┐ ┌──────────────────────┐   │
│  │ Budget │ │   Shadow   │ │  ADHD  │ │  Self-Improve        │   │
│  │Tracker │ │ Validator  │ │Tracker │ │ Saturday Review       │   │
│  │per-prov│ │ A/B test   │ │focus,  │ │ Night Shift          │   │
│  │caps    │ │ promote/   │ │drift,  │ │ Morning Briefing     │   │
│  │runway  │ │ reject     │ │nudge   │ │ Consolidation        │   │
│  └────────┘ └────────────┘ └────────┘ └──────────────────────┘   │
│                                                                    │
│  ┌────────────┐ ┌──────────────┐ ┌────────────────────────────┐  │
│  │ Proactive  │ │   System     │ │  Screen Reader             │  │
│  │ Engine     │ │  Monitor     │ │  Vision model analysis     │  │
│  │ timers,    │ │  CPU/mem/    │ │  OCR, summarize, explain   │  │
│  │ reminders, │ │  disk/svc    │ │  error, evaluate design    │  │
│  │ pomodoro,  │ │  alerts,     │ │                            │  │
│  │ breaks     │ │  auto-restart│ │                            │  │
│  └────────────┘ └──────────────┘ └────────────────────────────┘  │
│                                                                    │
│  ┌─────────────────────────────────────────────────────────────┐  │
│  │  Dashboard (React SPA) — dark-mode mission control          │  │
│  │  Memory · War Room · Tasks · Routing · Focus · Chat         │  │
│  │  Monitor · Timers · Reminders · Screen · Dictation          │  │
│  └─────────────────────────────────────────────────────────────┘  │
└────────────────────────────────────────────────────────────────────┘

Features

Zero-Token Intent Classification

The biggest cost optimization: 60-70% of voice commands never touch an LLM. A comprehensive regex-based classifier handles 10 intent categories with extracted parameters:

Command	Category	Tokens used
"Open YouTube"	`device/open_url`	0
"Set a timer for 25 minutes"	`proactive/timer`	0
"Restart nginx"	`server/service_restart`	0
"What's on my screen?"	`screen/analyze`	0 (classification)
"Remember that ACFO launches June 15"	`memory/store`	0
"I'm working on the payment module"	`adhd/set_focus`	0
"Morning briefing"	`briefing/deliver`	0
"Dictate"	`mode/dictation_start`	0
"What time is it?"	`builtin/time`	0
"Build me a payment module"	`brain/think`	Context-budgeted

Always-On Perception

Wake word detection via Porcupine — say "Friday" and talk naturally
Screen awareness — tracks your active window, detects which project you're in, captures context every 5 seconds
Voice Activity Detection — knows when you've stopped speaking, handles interruptions
< 2 second end-to-end voice response latency for simple commands

Full PC & Server Control

50+ device actions by voice or dashboard — never touch a terminal:

PC actions (cross-platform: Windows, Linux, macOS):

Window management — open, close, minimize, maximize, snap left/right, focus, list, kill process
Apps & browser — open any app, open known sites (YouTube, GitHub, Gmail, etc.), Google search, new tab, close tab
Media — play/pause, next/previous track, volume control, mute
Typing & clipboard — type text, press keys, copy, paste, select all, undo, redo, save
Files — create folders, delete files, find files, list directories, zip/unzip, disk usage
System — lock screen, sleep, shutdown, restart, brightness, DND, system info, Wi-Fi status, Bluetooth

Server actions (direct shell on remote server):

Service management — restart/start/stop nginx, postgres, redis, docker, pm2
Monitoring — server health, disk space, CPU/memory, active sessions, service logs
DevOps — deploy projects, rollback, git status/log/pull, Docker container listing
Database — list tables, check sizes, run queries
Security — firewall status, SSL cert expiry, open ports

Dictation Mode

Say "Friday, dictate" and everything you say is transcribed and typed at your cursor in real time. Zero brain tokens — pure STT passthrough. Say "Friday, stop dictating" to end.

Screen Understanding

Vision-powered screen analysis via multimodal models:

"What's on my screen?" — general description of visible content
"Read this to me" — OCR-style text extraction
"Summarize this page" — condensed summary of what you're looking at
"What does this error mean?" — error explanation and suggested fixes
"Rate this design" — UI/UX evaluation and feedback

Proactive Engine

Timers, reminders, and productivity tools — all by voice:

Timers — "Set a timer for 25 minutes", "Cancel the timer", "Show my timers"
Reminders — "Remind me to call the dentist in 30 minutes", persistent across restarts
Pomodoro — "Start a pomodoro" → 25-minute focus timer with break prompt
Break nudges — configurable reminders to stand up and stretch
Deadline alerts — warns when stored deadlines are approaching
Budget anomaly detection — alerts when daily spend spikes above normal

System Monitoring

Always-on server health checks running every 60 seconds:

CPU, memory, and disk usage tracking with configurable thresholds
Watched service health (nginx, postgres, redis, etc.)
Alert cooldown to prevent notification spam
Auto-restart for crashed services
Critical alerts delivered via TTS to voice client
Dashboard endpoint for real-time health snapshots

Morning Briefing

Delivered automatically on your first interaction of the day (after 5 AM):

Yesterday's work summary from WARM memory
Server health status
Pending decisions awaiting review
Budget alerts and runway status
Monday includes Saturday Review highlights
Focus suggestions for the day

Battle-Tested Memory System

Two SQLite databases, zero vector DB dependency for core operations:

memory.db — FACTS (permanent knowledge), WARM (session context with TTL), pending decisions, people, projects
runs.db — every brain call, OpenCode invocation, and device command logged with model/tokens/cost/latency/success
Routing table view — aggregated success rates per agent × model × task type, auto-generated from runs_log
Token-budgeted retrieval — trivial tasks get zero context, complex tasks get full memory
Contradiction detection — new facts automatically supersede old ones
Weekly consolidation — deduplicates, archives stale entries, cleans expired WARM

OpenCode Factory

Not a single LLM call — a full production pipeline with writer≠reviewer:

Task routed to OpenCode @build agent (Claude/GPT via Fireworks)
Code generated → @critic agent reviews (different model family)
If critic score < 7/10, flagged for retry with diagnosis
Compliance audit for sensitive files (payments, auth, PII)
Every invocation logged: agent, model, tokens, cost, success/fail
Max 2 retry cycles — fail with diagnosis, never silently ship broken code

Complex Task Orchestration

For requests that need more than one step:

Brain decomposes into a TaskPlan (2–8 atomic steps)
TaskManager executes steps sequentially: code_gen, device, research, shell, brain_only
Progress streamed to dashboard + voice client via WebSocket
Failed steps retry with escalation (up to 2 retries)
Completed tasks store learnings in memory for future reference

Budget Tracking & Shadow Validation

Per-provider budgets with hard caps that cannot be bypassed
Runway projection — alerts when any provider projected to exhaust within 60 days
Shadow validation — register a cheaper model as shadow, run both in parallel silently, promote when statistically proven (≥95% success rate over 50+ runs)
All recommendations stored as pending decisions for your review

ADHD Operating System

Built for brains that context-switch:

Focus stack — ordered list of what you're working on, always visible
Drift detection — notices when you're bouncing between projects, nudges you back
Scope parking — "park that" saves your current task and asks what's next
Session tracking — "how long have I been working?" gives elapsed time
Daily progress — "am I on track?" gives you a focus context summary
Calibration — adjusts thresholds weekly based on your actual behavior

Self-Improvement Engine

Friday gets better every week without you doing anything:

Saturday Review — 7 automated jobs: routing optimization, memory consolidation, prompt refinement, self-correction mining, ADHD calibration, shadow evaluation, budget projection
Night Shift — runs test suites, server health checks (disk/memory/CPU), pre-research pending topics, generates morning briefing data
Morning briefing — overnight events, budget status, pending decisions count, shadow validation progress, suggested focus for today
Report as fact — every weekly report stored in memory.db for longitudinal analysis

Dashboard (React SPA)

Dark-mode mission control — not AI slop:

Home — key metrics, 14-day spend chart, budget alerts, quick command input
Memory — browse/search/edit FACTS, WARM entries, and pending decisions
War Room — project status, commitments, deadlines, priority triage
Tasks — run history, success rates, create multi-step tasks
Routing — provider budgets, spend charts, routing stats, active shadows
Focus — current task, context switches, focus history
Chat — text-based conversational interface with Friday
Settings — server config, budget caps, agent management
Monitor — real-time server health (CPU, memory, disk, services)
Timers & Reminders — set/cancel/list via dashboard API
Screen Analysis — trigger screenshot + vision analysis from dashboard
Dictation Control — start/stop dictation from dashboard

Built with React 18, TypeScript, Vite, Tailwind CSS, Recharts. DM Sans/DM Mono typography.

Security

WebSocket auth — JWT tokens or shared secret, validated on every connection
Dashboard API auth — Bearer token middleware on all /api/ endpoints (health exempt)
Shell whitelist — only approved command prefixes can execute
Destructive command approval — rm -rf, kill -9, chmod 777 require explicit user approval
Budget hard caps — enforced at the provider level, cannot be bypassed by any code path

Performance

Request timing middleware — Server-Timing and X-Response-Time-Ms headers on every response
Slow request logging — warns on any request > 2 seconds
Brain retry with backoff — 429 rate limits retry 3x with exponential delays (2s, 5s, 15s)
DB locked retry — SQLite lock contention handled with 4-step exponential backoff
OpenCode crash recovery — subprocess crashes caught, logged, returned as graceful errors

Quick Start

Prerequisites

Python 3.11+
Node.js 18+ (for dashboard build)
A brain provider API key (OpenAI, Anthropic, or local Ollama)

Install

git clone https://github.com/user/friday.git
cd friday
python -m venv .venv && source .venv/bin/activate  # or .venv\Scripts\activate on Windows
pip install -e ".[dev]"

# Build the dashboard
cd dashboard && npm install && npm run build && cd ..

Configure

cp .env.example .env
# Edit .env — at minimum set:
#   BRAIN_PROVIDER=openai
#   BRAIN_API_KEY=sk-...
#   BRAIN_MODEL_NAME=gpt-4o-mini

Run

# Terminal 1 — Server (serves API + dashboard at http://localhost:8765)
make run-server

# Terminal 2 — Client (requires mic + speakers)
make run-client

# Say "Friday, hello" and start talking
# Or open http://localhost:8765 for the dashboard

Run Tests

make test          # 632 tests
make lint          # ruff check

Project Structure

friday/
├── client/                    # Local PC daemon
│   ├── audio/                 # Wake word, mic capture, VAD, TTS playback, dictation mode
│   ├── screen/                # Window tracking, focus stack, project detection
│   ├── connection/            # WebSocket client with auto-reconnect + dictation stream
│   ├── device/                # Platform-agnostic device controller
│   │   ├── platform_base.py   # Abstract base: 35+ async methods
│   │   ├── linux.py           # Linux: wmctrl, xdotool, amixer, playerctl, nmcli
│   │   ├── windows.py         # Windows: pywin32, PowerShell, pynput, psutil
│   │   ├── mac.py             # macOS: osascript, AppleScript, open, pmset
│   │   └── controller.py      # Unified dispatch with clipboard history
│   └── main.py
├── server/                    # Remote server (FastAPI)
│   ├── api/                   # WebSocket, dashboard REST API (45+ endpoints), auth, health
│   ├── pipeline/              # Category-based orchestrator, intent classifier (10 categories),
│   │                          # STT (Sarvam/Whisper), TTS (Sarvam/Piper)
│   ├── brain/                 # Multi-provider LLM router with 429 retry + vision support
│   ├── memory/                # Dual-SQLite store, retrieval, writer, consolidation
│   ├── actions/               # Shell, filesystem, OpenCode bridge, device controller,
│   │                          # screen reader (vision analysis)
│   ├── tasks/                 # TaskManager for multi-step background execution
│   ├── budget/                # Per-provider budget tracking with hard caps
│   ├── adhd/                  # Focus tracker, interventions, weekly calibration
│   ├── proactive/             # Timers, reminders, pomodoro, break nudges, deadline alerts,
│   │                          # morning briefing, budget anomaly detection
│   ├── monitoring/            # Always-on system monitor (CPU/mem/disk/services), auto-restart
│   ├── code_factory/          # Legacy pipeline (spec → decompose → validate)
│   ├── frontend/              # Design system, component gen, visual QA
│   ├── improvement/           # Saturday review, night shift, shadow validation, reports
│   ├── war_room/              # Persistent operational state document
│   └── main.py                # FastAPI app with timing + auth middleware
├── shared/                    # Protocol (WebSocket messages), models, constants
├── dashboard/                 # React SPA (Vite + TypeScript + Tailwind + Recharts)
│   ├── src/
│   │   ├── components/        # Sidebar, Header, Toasts, Card primitives
│   │   ├── pages/             # Home, Memory, WarRoom, Tasks, Routing, Focus, Chat, Settings
│   │   ├── hooks/             # useFetch, usePolling, useToast
│   │   └── lib/               # API client for all 45+ dashboard endpoints
│   └── dist/                  # Build output served by FastAPI
├── deploy/                    # Systemd service files
├── scripts/                   # Setup, seeding
├── data/                      # Runtime data (gitignored)
│   ├── memory.db              # Facts, warm context, decisions, projects, people
│   ├── runs.db                # All run logs, routing table, spend views
│   └── deploy_config.json     # Deploy/rollback scripts per project
└── tests/                     # 632 tests (unit, integration, end-to-end)

Configuration Reference

All configuration via environment variables (loaded by Pydantic Settings):

Variable	Default	Description
`BRAIN_PROVIDER`	`openai`	LLM backend: `openai`, `anthropic`, `local` (Ollama)
`BRAIN_API_KEY`	—	API key for the configured brain provider
`BRAIN_MODEL_NAME`	`gpt-4o-mini`	Model name passed to the provider
`OPENAI_API_KEY`	—	OpenAI key (also used for Codex tool routing)
`ANTHROPIC_API_KEY`	—	Anthropic key for Claude models
`SARVAM_API_KEY`	—	Sarvam AI key for STT/TTS
`PORCUPINE_ACCESS_KEY`	—	Picovoice key for wake word detection
`OPENCODE_PATH`	`opencode`	Path to the OpenCode CLI binary
`OPENCODE_WORKING_DIR`	`.`	Default working directory for OpenCode
`FRIDAY_DATA_DIR`	`./data`	Root directory for SQLite databases and logs
`FRIDAY_TOKEN_BUDGET_DAILY`	`500000`	Hard daily token cap
`FRIDAY_IMPROVEMENT_BUDGET_WEEKLY`	`100000`	Token budget for Saturday Review
`FRIDAY_NIGHT_SHIFT_ENABLED`	`true`	Enable overnight automation tasks
`FRIDAY_MORNING_BRIEFING_ENABLED`	`true`	Enable morning briefing
`FRIDAY_SATURDAY_REVIEW_DAY`	`5`	Day of week for Saturday Review (0=Mon, 5=Sat)
`FRIDAY_SATURDAY_REVIEW_HOUR`	`3`	UTC hour to run the Saturday Review
`FRIDAY_LOG_LEVEL`	`INFO`	Log level (`DEBUG`, `INFO`, `WARNING`)
`FRIDAY_WS_SHARED_SECRET`	—	WebSocket auth token (simple mode)
`FRIDAY_WS_JWT_SECRET`	—	JWT signing key (enables JWT auth mode)
`FRIDAY_VISION_MODEL`	`accounts/fireworks/models/qwen3-30b-a3b`	Vision model for screen analysis
`FRIDAY_MONITOR_INTERVAL`	`60`	System monitor check interval (seconds)
`FRIDAY_MONITOR_CPU_THRESHOLD`	`90`	CPU usage alert threshold (%)
`FRIDAY_MONITOR_MEMORY_THRESHOLD`	`85`	Memory usage alert threshold (%)
`FRIDAY_MONITOR_DISK_THRESHOLD`	`90`	Disk usage alert threshold (%)
`FRIDAY_BREAK_INTERVAL_MINUTES`	`90`	Minutes between break nudges

See .env.example for the complete list with all tuning options.

How It Works

The Category-Based Pipeline

Every interaction flows through the same pipeline, whether from voice or dashboard:

Transcribe — Audio → text via Sarvam AI (primary) or local Whisper (fallback)
Classify — Pattern-match against 80+ regex rules across 10 categories. 60-70% of commands resolve here at zero token cost. Unmatched commands get heuristic complexity scoring.
Route — Dispatch to the matching category handler:

Category	Handler	Examples
`builtin`	Instant response	time, date, stop, status, verbosity
`device`	PC DeviceController	open apps, volume, screenshot, clipboard
`server`	Server DeviceController	restart nginx, deploy, git status, logs
`proactive`	ProactiveEngine	timers, reminders, pomodoro
`mode`	Client command	dictation start/stop
`screen`	ScreenReader + vision model	analyze, OCR, summarize, explain error
`memory`	MemoryStore	store, recall, archive, pending decisions
`adhd`	FocusTracker	set focus, park task, session duration
`briefing`	MorningBriefing	daily brief, EOD summary, weekly review
`brain`	Full LLM pipeline	complex reasoning, code generation, planning

Respond — Text response + TTS audio to voice client + dashboard broadcast
Log — Every interaction → runs_log (model, tokens, cost, latency, success) for routing optimization

Token Frugality

Not every request needs GPT-4. Friday classifies complexity before any model call:

Complexity	Context Budget	Example
TRIVIAL	0 tokens	"open youtube", "volume 50", "what time is it"
SIMPLE	1,000 tokens	"what's this function do?", "explain this error"
MEDIUM	2,000 tokens	"build a login page", "refactor this module"
COMPLEX	3,500 tokens	"redesign the auth system", "build the entire payment module"

60-70% of daily interactions are pattern-matched at zero cost. The remaining 30-40% use token-budgeted context retrieval.

Memory Architecture

 ┌──────────────────┐     ┌──────────────────┐
 │    memory.db      │     │     runs.db       │
 │                   │     │                   │
 │  facts            │     │  runs_log         │
 │  warm_context     │     │  (auto-populated) │
 │  pending_decisions│     │                   │
 │  people           │     │  VIEWS:           │
 │  projects         │     │  routing_table    │
 │  kv_store         │     │  daily_spend      │
 │  outcome_index    │     │  monthly_spend    │
 │                   │     │  provider_runway  │
 └────────┬──────────┘     └────────┬──────────┘
          │                         │
   ┌──────▼─────────────────────────▼──────┐
   │         Context Retriever              │
   │  • Token budgeting per complexity      │
   │  • Project facts + identity facts      │
   │  • Recent WARM context                 │
   │  • Pending decisions                   │
   │  • Exchange history                    │
   └────────────────────────────────────────┘

Voice Commands Reference

Click to expand full command list

Device (PC)

Command	Action
"Open YouTube / GitHub / Slack / ..."	Opens known site in browser
"Open terminal / VS Code / ..."	Launches application
"Close / quit Chrome"	Closes window
"Switch to / focus on Chrome"	Brings window to front
"Minimize / maximize Slack"	Window management
"Kill Chrome"	Force-kills process
"What's open?"	Lists open windows
"Search for react hooks tutorial"	Google search
"Volume 50" / "Mute"	Audio control
"Play" / "Pause" / "Next track" / "Skip"	Media control
"Type hello world"	Types text at cursor
"Press ctrl+c" / "Copy" / "Paste" / "Undo"	Keyboard shortcuts
"Take a screenshot"	Screen capture
"Lock screen" / "Sleep" / "Shut down"	System power
"Brightness 80"	Display brightness
"Do not disturb"	Toggle DND
"System info" / "What's my IP" / "CPU"	System information
"Wi-Fi status" / "Bluetooth"	Network toggles
"Create folder called X" / "Delete file X"	File operations
"Zip / unzip X"	Archive management

Server

Command	Action
"Restart / start / stop nginx"	Service management
"Server status" / "How's the server"	Health check
"Logs for nginx"	Tail service logs
"Deploy acfo" / "Rollback acfo"	Deployment
"Git status friday" / "Git pull friday"	Git operations
"List containers" / "Docker ps"	Docker management
"Who's logged in"	Active sessions

Productivity

Command	Action
"Set a timer for 25 minutes"	Timer
"Remind me to call the dentist in 30 minutes"	Reminder
"Start a pomodoro"	25-min focus session
"Cancel the timer"	Cancel timer
"Show my timers / reminders"	List active
"I'm working on the payment module"	Set focus
"What am I working on?"	Current focus
"Park that"	Save current task for later
"What's parked?"	List parked tasks
"How long have I been working?"	Session duration
"Morning briefing"	Daily briefing
"End of day"	EOD summary

Screen & Dictation

Command	Action
"What's on my screen?"	Vision analysis
"Read this to me"	OCR text extraction
"Summarize this page"	Page summary
"What does this error mean?"	Error explanation
"Rate this design"	UI evaluation
"Dictate" / "Start dictating"	Begin dictation mode
"Stop dictating"	End dictation mode

Memory

Command	Action
"Remember that ACFO launches June 15"	Store fact
"What do you know about ACFO?"	Recall facts
"Forget about the old API key"	Archive fact
"What are my pending decisions?"	List decisions

Builtins (zero tokens)

Command	Action
"What time is it?"	Current time
"What's the date?"	Current date
"Stop" / "Cancel" / "Never mind"	Cancel current task
"Status"	System status
"Be brief" / "Be detailed"	Change verbosity

Deployment

Linux Server (systemd)

sudo cp deploy/friday-server.service /etc/systemd/system/
sudo systemctl daemon-reload
sudo systemctl enable --now friday-server

Client (User Session)

cp deploy/friday-client.service ~/.config/systemd/user/
systemctl --user enable --now friday-client

See deploy/README.md for full instructions.

Roadmap

Multi-device sync (phone + desktop)
Plugin system for custom tools
Real-time pair programming mode with screen sharing
Native mobile companion app
Calendar integration for proactive scheduling
Slack/Discord bot mode
MCP server for tool integrations
Spotify/YouTube Music deep integration
Multi-language voice support

Contributing

Contributions welcome. Please:

Fork the repo and create a feature branch
Write tests for new functionality
Run make test && make lint before submitting
Keep PRs focused — one feature per PR

License

MIT — see LICENSE for details.

Friday — Jarvis was the butler. Friday is the chief of staff.

Name		Name	Last commit message	Last commit date
Latest commit History 5 Commits
client		client
dashboard		dashboard
deploy		deploy
docs		docs
scripts		scripts
server		server
shared		shared
tests		tests
.cursorrules		.cursorrules
.env.example		.env.example
.gitattributes		.gitattributes
.gitignore		.gitignore
LICENSE		LICENSE
Makefile		Makefile
README.md		README.md
pyproject.toml		pyproject.toml

Folders and files

Latest commit

History

Repository files navigation

Friday

Why Friday Exists

Architecture

Features

Zero-Token Intent Classification

Always-On Perception

Full PC & Server Control

Dictation Mode

Screen Understanding

Proactive Engine

System Monitoring

Morning Briefing

Battle-Tested Memory System

OpenCode Factory

Complex Task Orchestration

Budget Tracking & Shadow Validation

ADHD Operating System

Self-Improvement Engine

Dashboard (React SPA)

Security

Performance

Quick Start

Prerequisites

Install

Configure

Run

Run Tests

Project Structure

Configuration Reference

How It Works

The Category-Based Pipeline

Token Frugality

Memory Architecture

Voice Commands Reference

Device (PC)

Server

Productivity

Screen & Dictation

Memory

Builtins (zero tokens)

Deployment

Linux Server (systemd)

Client (User Session)

Roadmap

Contributing

License

About

Topics

Resources

License

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Uh oh!

Contributors

Uh oh!

Languages

Packages