Your AI sees every context switch, every wasted minute, every workflow that fights you — then rewrites it.
The Flywheel • Real Result • Quickstart • How It Works • Architecture • Roadmap
Three open-source systems. One closed loop. Each spin makes the next one faster.
┌─────────────────────────┐
│ SCREENPIPE │
│ (Capture Everything) │
│ │
│ OCR · audio · app logs │
│ local-first · MIT │
└────────────┬────────────┘
│
▼
┌─────────────────────────┐
│ WORKFLOWX │
│ (Understand + Replace) │
│ │
│ intent inference │
│ friction diagnosis │
│ replacement proposals │
│ ROI measurement │
└────────────┬────────────┘
│
▼
┌─────────────────────────┐
│ AGENTICOM │
│ (Execute Workflows) │
│ │
│ multi-agent YAML │
│ tool orchestration │
│ autonomous execution │
└────────────┬────────────┘
│
▼
┌─────────────┐
│ REAL WORK │
│ GETS DONE │
└──────┬──────┘
│
───────────┘
│
▼
┌──── feedback loop ────┐
│ │
│ freed time creates │
│ new captured data │
│ → better inference │
│ → smarter proposals │
│ → measured ROI │
│ │
└───────────────────────┘
Screenpipe records everything you do — OCR, audio, app switches — locally, privately, continuously. It captures everything but understands nothing.
WorkflowX reads Screenpipe's raw stream and asks the question no other tool asks: what were you trying to accomplish, and why did it take so long? It infers intent, scores friction, proposes replacement workflows, and measures whether the replacement actually saved time.
Agenticom takes WorkflowX's machine-readable YAML proposals and executes them — multi-agent orchestration that actually does the work, not just describes it.
The flywheel compounds:
- Spin 1: Screenpipe captures your day. WorkflowX finds you spent 52 minutes on competitive research with 23 app switches. It proposes an Agenticom workflow that does it in 3 minutes.
- Spin 2: You adopt the replacement. WorkflowX measures the actual before/after. The 49 minutes you saved generate new captured data — higher-value work that Screenpipe records, WorkflowX analyzes, and the cycle repeats.
- Spin N: Your validated replacements become a library. Patterns emerge across days and weeks. The system stops proposing — it starts predicting which workflow will fight you next.
Every productivity tool on the market is a speedometer. This flywheel is a GPS that rebuilds the road.
This is not a demo. This is what WorkflowX found on a real machine, running right now:
Session: 20:07–20:08 | Duration: 1 min | Apps: VS Code, Microsoft Teams, Chrome
Context switches: 10 | Friction: CRITICAL | Confidence: 76%
Intent: "Multitasking during Physical AI Team Sync meeting — editing a LinkedIn
article draft in VS Code while monitoring 3 Chrome windows (logo design,
test scenarios, OmegaPath dashboard)."
Friction: 10 context switches in under 60 seconds across 4 apps simultaneously.
Competing cognitive demands degrading both the meeting and the article.
Proposed replacement (82% confidence):
Async-first meeting intelligence layer. AI agent monitors the Teams call
in real-time, surfaces browser context on-demand via hotkey, queues
article edits as inline VS Code comments — so you never multitask during
the call. Post-meeting: a focused 15-min sprint with pre-populated notes.
Agenticom YAML: generated. Tools needed: Recall.ai, VS Code MCP webhook,
Agenticom multi-agent orchestrator.
That session cost real time. WorkflowX found it, named it, and proposed a replacement — automatically.
You know that feeling? You sat at your desk for 8 hours. You were busy. But what actually got done?
You switched between 14 apps. You copy-pasted the same data three times. You spent 40 minutes on a task that should have taken 5 — because the tool fought you. And you have no idea which 2 hours actually moved the needle.
Every productivity tool on the market shows you a time pie chart and says "good luck."
WorkflowX does something different. It doesn't just watch. It understands what you're trying to do, finds where you're bleeding time, and proposes workflows that achieve the same goal in a fraction of the time — not by speeding you up, but by reimagining the path.
| What WorkflowX finds | What it costs you |
|---|---|
| 10 context switches in 1 minute during a meeting | $1.25 in lost focus time, compounded daily |
| 52 minutes of competitive research that could be 3 minutes | $60/week at $75/hr |
| Recurring friction pattern (same workflow, 3× per week) | Hours/month, hundreds of dollars/quarter |
| Multitasking during a team sync | Degraded output on two tasks simultaneously |
ROI is measured, not estimated. WorkflowX tracks actual before/after time for every adopted replacement. If the replacement doesn't save time, you'll know within a week.
| What Exists Today | What It Does | What It Can't Do |
|---|---|---|
| RescueTime, Toggl | Counts time per app | Doesn't know why you used the app |
| Hubstaff, ActivTrak | Screenshots your screen | Surveillance, not intelligence |
| Celonis | Mines ERP system logs | Can't see what humans actually do |
| Screenpipe alone | Records everything locally | Captures everything, understands nothing |
WorkflowX completes the flywheel. Screenpipe captures. WorkflowX understands and replaces. Agenticom executes. No single tool in this table closes the loop from observation to autonomous execution to measured ROI.
Close your eyes. Think about the last time you did "competitive research." You probably opened a dozen tabs, skimmed articles, copied quotes into a doc, forgot which tab had the good stat, went back, re-read, pasted, reformatted. An hour gone.
WorkflowX sees that trail of events and says:
"You spent 52 minutes across Chrome and Notion doing what looks like competitive research (confidence: 0.85). You switched apps 23 times. Estimated cost: $65.
Proposed replacement: An Agenticom workflow that monitors these 12 competitor URLs, extracts pricing and feature changes daily, and delivers a structured brief to your Notion. Estimated time: 3 minutes/week. Savings: 49 minutes/week."
The full flywheel — nobody else closes it:
SCREENPIPE WORKFLOWX AGENTICOM
capture ──→ infer intent ──→ diagnose friction ──→ guardrails ──→ propose ──→ execute
↑ (4 gates) │
└──────────────────────── measure ROI ← freed time creates new data ─────────────┘
Activity trackers stop at capture. Process mining stops at diagnosis. RPA copies the old workflow. The flywheel reimagines the workflow from the goal backward — then proves it worked.
- Python 3.10+
- Screenpipe running locally (for live capture)
ANTHROPIC_API_KEYset in your environment
git clone https://github.com/wjlgatech/workflowx.git
cd workflowx
python3 -m venv .venv && source .venv/bin/activate
pip install -e ".[all]"# Install ffmpeg with x265 support (required by Screenpipe's video pipeline)
brew install ffmpeg@7
mkdir -p ~/.local/bin
ln -sf /opt/homebrew/opt/ffmpeg@7/bin/ffmpeg ~/.local/bin/ffmpeg
# Start Screenpipe
npx screenpipe@latest record# Start the background daemon — runs everything on a smart schedule
workflowx daemon start
# Check what's running and when it will fire next
workflowx daemon status
# Open the live dashboard (updates on demand)
workflowx serve
# Stop the daemon
workflowx daemon stopThe daemon runs silently. You get macOS notifications when:
- Screenpipe goes offline or drops frames
- Classification questions need your input
- A CRITICAL/HIGH-friction session needs a replacement proposal
- The morning brief fires at 8:30am with yesterday's summary
# Read today's events from Screenpipe
workflowx capture
# Cluster into sessions, infer intent with Claude
workflowx analyze
# Validate ambiguous sessions (interactive)
workflowx validate
# Generate daily report
workflowx report
# Generate replacement proposals with Agenticom YAML
workflowx propose
# Track a replacement and measure actual ROI
workflowx adopt "competitive research" --before-minutes 50
workflowx measure --days 7
# Static HTML dashboard (snapshot)
workflowx dashboard -o roi.html
# Live dashboard server with Update button
workflowx serve
# MCP server for Claude/Cursor integration
workflowx mcpWorkflowX exposes 18 MCP tools across the full flywheel — including 4 new Meeting Intelligence tools. Add it to Claude Desktop or Cursor and talk to your workflow data:
"Show me my highest-friction sessions this week"
"What patterns keep repeating?"
"Propose a replacement for that competitive research workflow"
"Adopt it — my baseline was 50 minutes"
"Measure ROI after a week"
# Meeting Intelligence Stack
"Debrief my client call — here are my notes: ..."
"Build me a pre-brief for tomorrow's 2pm with Acme Corp"
"Can the sidebar run on my 3pm team standup?"
# One-command setup for Claude Desktop
./setup-mcp.sh┌─────────────────────────────────────────────────────────────────────────────┐
│ Workflow Sessions │
├─────────────┬──────────┬──────────────────────┬──────────┬──────────────────┤
│ Time │ Duration │ Apps │ Switches │ Friction │
├─────────────┼──────────┼──────────────────────┼──────────┼──────────────────┤
│ 09:15-10:00 │ 45 min │ VS Code, Chrome │ 4 │ low │
│ 10:05-11:07 │ 62 min │ Chrome, Notion │ 23 │ CRITICAL !! │
│ 11:30-12:00 │ 28 min │ Slack, Zoom │ 8 │ medium │
│ 13:00-13:55 │ 55 min │ VS Code, Terminal │ 3 │ low │
│ 14:10-15:00 │ 48 min │ Chrome, Sheets │ 19 │ high │
└─────────────┴──────────┴──────────────────────┴──────────┴──────────────────┘
Total tracked: 238 min | High-friction: 2 sessions (110 min) ← replacement candidates
Not ambient AI. Bookend intelligence that compounds.
Ambient AI in meetings hits three hard walls: latency (Claude takes 2–5s; real-time needs <300ms), law (12 states require all-party consent), and cost ($1–3/hr sustained). The Meeting Intelligence Stack bypasses all three by working at the edges of meetings — before and after — where intelligence actually accumulates.
Phase 1 — Post-Meeting Debrief (workflowx_meeting_debrief)
Drop raw notes in. Get back:
- What was discussed (3–5 bullets, factual)
- Commitments — yours vs. theirs, separated
- Action items table with owners and deadlines
- Follow-up email draft → pushed to Gmail Drafts
- Wu's action items → appended to TASKS.md automatically
# MCP call — works from Claude Desktop or any MCP client
workflowx_meeting_debrief(
raw_notes="John confirmed deployment by EOM. I said I'd send API docs by Wed...",
attendees="John Smith (Acme Corp)",
)
# → structured debrief + gmail_draft payload + tasks_appended: 2Cost: ~$0.02/meeting. Time saved: 25–30 min.
Phase 2 — Pre-Meeting Brief (workflowx_prebrief + workflowx_generate_brief)
Nightly scan of tomorrow's calendar. For each external meeting:
- Gmail thread history with attendees
- Relevant Drive documents
- Web research (company news, attendee profiles)
- 1-page cheat sheet saved to
workflowx/briefs/YYYY-MM-DD-[client].md
Ready at 6 AM. Compounds over time: every debrief becomes context for the next brief.
Phase 3 — Real-Time Sidebar (workflowx_sidebar_check + SidebarAgent)
For internal meetings only. 30-second refresh: last 90s of transcript + one suggested question. Screenpipe (local audio) + Whisper (local transcription) — no cloud, no consent issue.
consent_guard.py enforces the rule in code: external attendees → blocked. Internal only → approved. Add "AI may assist" to calendar description → unlocked for external with disclosure.
Debrief (Phase 1) → action items in TASKS.md
→ email history for next Pre-Brief (Phase 2)
→ patterns in workflowx_patterns
→ sidebar gets smarter on this client (Phase 3)
After 30 meetings, the system knows your clients better than most CRMs.
src/workflowx/meeting/
├── __init__.py
├── prompt_templates.py # Haiku prompts for all 3 phases
├── debrief_agent.py # Phase 1: structured debrief + Gmail + TASKS
├── gmail_push.py # Gmail Drafts formatter
├── tasks_updater.py # TASKS.md appender
├── prebrief/
│ ├── brief_agent.py # Phase 2: orchestrator + brief generator
│ └── context_gatherer.py # Gmail/Drive/web query builder
└── sidebar/
├── consent_guard.py # Legal compliance — blocks external meetings
└── sidebar_agent.py # Phase 3: 30s refresh loop (Screenpipe + Whisper)
tests/test_meeting_intelligence.py # 23 tests, 0 API calls
src/workflowx/
├── models.py # 11 Pydantic domain models — the contract everything flows through
├── config.py # Config from env vars / .env
├── storage.py # Local JSON storage (file-per-day, privacy-first)
├── export.py # JSON/CSV export for external analysis
├── measurement.py # Before/after ROI tracking
├── dashboard.py # HTML ROI dashboard (static snapshot + live server mode)
├── server.py # Live dashboard HTTP server — GET / and GET /api/data
├── daemon.py # Background scheduler: all pipeline stages, smart cadences
├── notifications.py # macOS native notifications via osascript
├── mcp_server.py # 18 MCP tools — the agentic interface to the flywheel
├── capture/ # SCREENPIPE layer — don't rebuild capture, use it
│ ├── screenpipe.py # Reads Screenpipe's SQLite DB directly
│ └── activitywatch.py # Reads ActivityWatch REST API
├── inference/ # WORKFLOWX intelligence layer ← this is our value
│ ├── clusterer.py # Raw events → workflow sessions (deterministic IDs)
│ ├── intent.py # LLM intent inference + classification questions
│ ├── reporter.py # Daily/weekly report generation
│ └── patterns.py # Cross-day pattern detection + friction trends
├── replacement/ # AGENTICOM integration layer
│ └── engine.py # LLM-powered proposals + 4-gate guardrail pipeline
├── guardrails/ # TRUST LAYER — blocks garbage before it reaches users
│ ├── mechanism_validator.py # Rejects vague proposals ("leverage AI")
│ ├── savings_validator.py # Caps outlier savings estimates (3× observed max)
│ ├── confidence_gate.py # Suppresses proposals below confidence floor
│ └── yaml_validator.py # Pydantic schema validation for Agenticom YAML
├── eval/ # EVAL SYSTEM — proves the flywheel turns with numbers
│ ├── datasets/ # 20 gold-annotated sessions for CI gating
│ ├── graders/ # IntentGrader (F1), FrictionGrader, ROIGrader (MAPE)
│ └── runner.py # EvalRunner with CI gate thresholds
├── memory/ # PROPOSAL MEMORY — stops the rejected-proposal loop
│ └── proposal_history.py # Local similarity search + rejection tracking
├── reasoning/ # MODEL ROUTING — right model for right task
│ ├── model_selector.py # DecisionType → Haiku/Sonnet/Opus routing
│ └── cost_logger.py # Per-call cost tracking with session summaries
├── api/ # FastAPI endpoints (future)
├── meeting/ # MEETING INTELLIGENCE STACK — Phase 5
│ ├── debrief_agent.py # Post-meeting: notes → structured output + Gmail + TASKS
│ ├── gmail_push.py # Gmail Drafts formatter
│ ├── tasks_updater.py # TASKS.md appender (Wu's action items only)
│ ├── prompt_templates.py # Haiku prompts for all 3 phases
│ ├── prebrief/ # Pre-meeting: calendar → Gmail/Drive/web → 1-page brief
│ │ ├── brief_agent.py
│ │ └── context_gatherer.py
│ └── sidebar/ # Real-time: 30s refresh, internal-only, Screenpipe + Whisper
│ ├── consent_guard.py # Legal compliance enforced in code
│ └── sidebar_agent.py
└── cli/ # Click CLI — 16 commands
└── main.py
Design principles:
- Don't rebuild capture. Screenpipe is MIT, 12.6k stars, cross-platform. We read its SQLite DB — we don't reinvent screen recording.
- Local-first. All data stays on your device. No cloud. No telemetry. No surveillance.
- Models are the contract. Every piece of the system speaks
models.py. Add a new data source? Map it toRawEvent. Add a new output? Build onWorkflowSession. - LLM calls are isolated. Only
inference/intent.pyandreplacement/engine.pycall LLMs. Everything else — clustering, scoring, storage, reporting, scheduling — is deterministic and fully testable. - Daemon logic is pure. Scheduling decisions (
next_fire_time,should_measure,should_propose) are plain functions with no I/O — 61 tests cover every edge case without asyncio. - Measure everything. A workflow intelligence tool that can't prove ROI is just an advice column.
measurement.pycloses the loop.
Most tools solve one piece: capture, or analysis, or automation. WorkflowX is the intelligence layer that connects Screenpipe (capture) to Agenticom (execution) into a self-improving loop. Each adopted replacement generates measured ROI data that feeds back into better proposals. The system gets smarter with every spin.
Most productivity tools count time. WorkflowX asks why. Given a sequence of (app_name, window_title, OCR_text, timestamp) tuples, Claude infers the user's actual goal — not "used Chrome for 52 minutes" but "doing competitive research to inform a pricing decision." This is the difference between a speedometer and a GPS.
Sessions are clustered by time-gap heuristic and given deterministic IDs (MD5(date + start_time)). Re-running capture on the same day updates existing sessions via upsert rather than creating duplicates. Intent, friction score, and user validation persist across runs.
When the LLM can't infer intent with >70% confidence, it generates a single multiple-choice question to ask the user. One question. Not a survey. The answer is stored and used to correct the inference. Over time, this creates a validated ground-truth dataset of your actual workflows.
Friction is computed as context_switches / max(duration_minutes, 0.1). Thresholds: >3/min = CRITICAL, >1.5 = HIGH, >0.5 = MEDIUM. Simple, fast, and validated: the sessions WorkflowX flags as CRITICAL are exactly the ones users identify as painful when asked.
Replacement proposals aren't just text. Each proposal includes a machine-readable Agenticom workflow YAML that can be executed directly — no manual translation from "here's what to do" to "here's how to automate it."
workflowx mcp starts an MCP server exposing 14 tools organized across the full flywheel: observe (status, capture, analyze, sessions), understand (friction, patterns, trends, diagnose, screenshot), replace (propose, adopt, reject), measure (measure, roi). Claude or Cursor becomes your dashboard — no custom UI needed.
Every replacement proposal passes through four validation gates before reaching the user. The confidence gate suppresses low-confidence proposals (< 0.55). The mechanism validator blocks vague hand-waving ("leverage AI to streamline") and requires at least one named tool. The savings validator caps outlier estimates at 3× observed session duration. The YAML validator enforces Pydantic schemas on Agenticom output — agents must exist, steps must reference valid agent IDs. Garbage proposals used to reach users unchecked. Now they don't.
workflowx eval runs three graders against a gold dataset of 20 annotated sessions: IntentGrader (soft F1 with 0.60 similarity threshold), FrictionGrader (exact + adjacent accuracy), and ROIGrader (MAPE on estimate vs. actual savings). CI blocks merges if intent F1 < 0.80. Prompt changes that silently degrade quality now fail loudly before they ship.
Users reject a proposal. A week later, the same proposal appears. That loop kills trust. Proposal memory stores rejection reasons (enum + free-text notes) and runs local similarity search before generating new proposals. Three rejections on the same intent triggers "stuck intent" detection — which escalates to a stronger model and builds a context string from rejection history, so the next proposal addresses why the previous ones failed.
Not every LLM call needs the same model. Intent inference (fast, high-volume) routes to Haiku. Replacement proposals (nuanced, medium-stakes) route to Sonnet. Stuck intents and complex reasoning route to Opus. Per-call cost tracking logs model, tokens, cost, and decision type — so you can see exactly where your API budget goes. Configurable via WORKFLOWX_MODEL_OVERRIDE env var.
workflowx daemon start installs a macOS launchd agent that runs the full pipeline automatically — invisible until it needs you.
health: every 5 min — Screenpipe liveness; notifies if frames drop
capture: 12:55·17:55·22:55 — rolls up last 4h of Screenpipe events (every day)
analyze: 13:00·18:00·23:00 — LLM inference; event-triggers propose on HIGH/CRITICAL
measure: 07:00 daily — adaptive ROI: weekly for 30 days, monthly after
brief: 08:30 weekdays — morning notification: friction summary + pending actions
The propose step is event-driven, not time-driven: it only fires when a new HIGH or CRITICAL session is found and hasn't already triggered a notification. No spam, no redundancy.
Ambient AI in meetings fails on three axes: latency (2–5s vs. <300ms required), law (12 states require all-party consent), and cost ($1–3/hr sustained). The Meeting Intelligence Stack sidesteps all three. Phase 1 (debrief) converts raw notes to structured output + Gmail draft + TASKS entries via a single MCP call ($0.02/meeting). Phase 2 (pre-brief) scans the calendar nightly, pulls Gmail/Drive/web context, and generates a 1-page cheat sheet per external meeting. Phase 3 (sidebar) uses Screenpipe + local Whisper for a 30-second refresh during internal meetings only. consent_guard.py enforces the legal boundary in code — not policy. The flywheel: each debrief becomes context for the next pre-brief, which becomes input for the next pattern detection cycle. After 30 meetings, the system holds better institutional memory than most CRMs.
workflowx serve opens a local HTTP server at localhost:7788. The dashboard fetches fresh data from /api/data on load and whenever you click ↻ Update — no file regeneration, no page reload. Zero new dependencies (Python stdlib http.server).
- 11 Pydantic domain models
- Screenpipe + ActivityWatch capture adapters
- Session clustering with deterministic IDs
- LLM intent inference (Anthropic claude-sonnet-4-6 / OpenAI / Ollama)
- Classification questions (user validation loop)
- Daily + weekly workflow reports
- Replacement engine with Agenticom YAML
- Full CLI:
capture,analyze,validate,report,propose,status - Local JSON storage (privacy-first, file-per-day)
- 63 tests, CI pipeline
- Pattern detection (recurring high-friction workflows across days)
- Weekly friction trends (is friction improving?)
- Workflow diagnosis engine (cost attribution, automation scoring)
- Export to JSON / CSV
- MCP server (Claude/Cursor integration)
- CLI:
patterns,trends,export,mcp
- LLM-powered replacement proposal engine
- Agenticom workflow YAML generation
- Before/after ROI measurement — the flywheel's feedback signal
- Self-contained HTML ROI dashboard (Chart.js)
- Live dashboard server with Update button (
workflowx serve) - Adoption tracking with cumulative savings
- Background daemon — full pipeline on smart schedule (
workflowx daemon) - macOS native notifications (health alerts, friction detection, morning brief)
- 12-tool MCP server — agentic interface to the full flywheel
- CLI:
adopt,measure,dashboard,serve,daemon start/stop/status,mcp - 134 tests, CI pipeline
- 4-gate guardrail pipeline (confidence, mechanism, savings, YAML validation)
- Eval system with gold dataset (20 annotated sessions) + 3 graders + CI gates
- Agenticom YAML validator (Pydantic schema enforcement)
- Proposal memory with rejection tracking + stuck intent detection
- Anthropic-native model routing (Haiku/Sonnet/Opus by decision type)
- Per-call cost tracking with session summaries
-
workflowx_rejectMCP tool — 14 tools total - 225 tests, CI pipeline
- PRD: Tech Stack Upgrade | Deep Dive
- Post-Meeting Debrief — raw notes → structured output + Gmail draft + TASKS.md (
workflowx_meeting_debrief) - Pre-Meeting Brief — calendar scan → Gmail/Drive/web context → 1-page cheat sheet (
workflowx_prebrief,workflowx_generate_brief) - Real-Time Sidebar skeleton — 30s refresh loop, Screenpipe + Whisper, Phase 3 scaffold (
sidebar_agent.py) - Consent Guard — enforces two-party consent laws in code, blocks external meetings automatically
- 4 new MCP tools (18 total), 23 new tests — all zero API cost
- Flywheel integration — debriefs feed pre-briefs feed patterns, compounds across meetings
- Multi-user workflow graph
- Team bottleneck detection
- Shared replacement library
- Privacy-preserving aggregate views
- FastAPI dashboard
- More capture adapters: WakaTime, browser extension, calendar APIs
- Workflow marketplace (share/discover replacements)
- Real-time friction alerts
- Self-improving inference (learn from user corrections)
- Agenticom deep integration (execute proposals directly from WorkflowX)
- Shadow mode: proposals run silently alongside manual work, accuracy measured before going live
Workflow data is the most intimate data you have after your health records. Who you talk to, what you work on, how long things take, what you struggle with — it's all in here. If your workflow intelligence tool isn't open source and local-first, you shouldn't trust it.
WorkflowX will always be:
- MIT licensed — use it however you want, build on it, fork it
- Local-first — your data never leaves your device, ever
- Fully auditable — every line that touches your data is on GitHub
| Feature | WorkflowX | RescueTime | Screenpipe | Celonis | ActivTrak |
|---|---|---|---|---|---|
| Privacy (local-first) | Yes | No | Yes | No | No |
| Intent inference | Yes | No | No | No | No |
| User validation loop | Yes | No | No | No | No |
| Workflow replacement | Yes | No | No | No | No |
| Guardrails on proposals | Yes | N/A | N/A | No | N/A |
| Eval system + CI gates | Yes | No | No | Partial | No |
| Proposal memory | Yes | N/A | N/A | No | N/A |
| Model routing (cost-aware) | Yes | No | No | No | No |
| Agenticom integration | Yes | No | No | No | No |
| MCP server (14 tools) | Yes | No | Partial | No | No |
| ROI measurement | Yes | No | No | Partial | Partial |
| Closed-loop flywheel | Yes | No | No | No | No |
| Open source | MIT | No | MIT | No | No |
| Price | Free | $12/mo | Free | $$$$$ | $10–19/mo |
We're building this in public and we want contributors who care about:
- Privacy-first workflow intelligence — not surveillance
- AI that replaces work, not just reports on it
- Clean, tested, composable code
git clone https://github.com/wjlgatech/workflowx.git
cd workflowx
python3 -m venv .venv && source .venv/bin/activate
make install-dev
make test # 225 tests — all green before you PRSee CONTRIBUTING.md for details.
Good first issues:
- Add WakaTime capture adapter
- Add browser extension for richer URL/tab data
- Improve friction heuristics with real user data validation
- Add OpenClaw integration (trigger replacements from Slack/WhatsApp)
- Build the Phase 4 team workflow graph
If this solves a real problem for you, star the repo. It helps others find it — and this is the kind of tool that gets better when more people contribute real workflow patterns.
Built by @wjlgatech
Screenpipe captures. WorkflowX understands. Agenticom executes. The flywheel spins.