10xProductivity — Personal AI Assistant for Work, Built on Coding Agents

A local-first stack for building a personal AI assistant for work inside real corporate constraints.

Use the coding agents, browser sessions, desktop apps, notifications, and tool access you already have. No new company-wide automation platform, no admin-approved Slack app, no webhooks, and no IT project required.

If this saves you time, consider giving it a star. It helps others discover the project.

Star History

The Idea

Most employees cannot install a new automation platform, register Slack or GitHub apps, add webhooks, or wait for IT approval every time they want an AI agent to help.

10xProductivity builds around the access you already have:

• your coding agent
• your browser and desktop apps
• your authenticated sessions
• your local machine
• your existing permissions
• your app notifications, messages, and calendar events

Coding agents are no longer just coding assistants. Cursor, Claude Code, Codex, Copilot, and similar tools can read files, run scripts, call APIs, use browsers, and work across your local environment. 10xProductivity turns that agent into a personal work assistant that can operate within normal workplace constraints.

The shift is not "let an AI run autonomously." The shift is human-AI interaction:

• You delegate work in natural language.
• The agent uses your connected tools to search, draft, triage, update, and automate.
• You supervise, correct, and coach when the work is new or important.
• Repeated patterns become reusable agent skills.
• Working sessions become persistent memory.
• Mistakes and tool use become better skills.
• Trusted skills become workflows you can launch from triggers, schedules, or your laptop.

Tool connections are still the foundation, but they are no longer the whole product. They are the first layer of a broader personal AI assistant for work stack.

Available Today / Coming Next

How It Works

Human
  ↓
Trigger or schedule          Laptop coding-agent session
  ↓                                   ↓
Runtime host                 Workflow / skill
  ↓                                   ↓
Workflow                     Tool connections
  ↓                                   ↓
Tool connections                     |
  ↓                                   ↓
Work done in Slack, Jira, GitHub, docs, calendar, CRM, internal portals, and more

1. Connect Your Tools

Your agent needs access to the same tools you already use: Slack, Jira, GitHub, Confluence, Google Drive, Outlook, Salesforce, internal portals, or anything else with an API, CLI, browser surface, or local files.

10xProductivity provides agent-readable setup guides in tool_connections/. The core principle is still zero new infrastructure: your local coding agent acts as you, using your existing access.

For the detailed connection philosophy, see tool_connections/README.md.

2. Coach Through Real Work

The assistant learns by doing real work with you.

When a workflow is new, you supervise from the laptop in Cursor, Claude Code, Codex, or another coding-agent session. You correct mistakes, explain judgment calls, and shape the process. That coaching becomes durable instructions.

3. Capture Reusable Agent Skills

A skill is more than an API recipe. It teaches the agent how to do a kind of work:

• Search across tools for context
• Triage a Jira sprint
• Summarize an incident
• Draft a PR description
• Prepare a customer call
• Write a standup update
• Review open follow-ups

Over time, your skill library becomes the operating manual for your personal AI assistant for work.

4. Run Trusted Workflows

Once a workflow has been coached and proven, you can run it with less supervision:

• From an event trigger, such as Slack self-DM polling or a desktop notification
• From a scheduled cron/launchd job
• From a repeatable workflow prompt
• From your laptop when you want richer interaction

Automation is reserved for workflows you trust. Everything else stays in the human-AI interaction loop.

The current runtime is intentionally thin and local. Triggers notice app and service events, runtime handles execution mechanics, workflows define the work, and tool connections fetch or update external systems.

5. Learn Continuously

The assistant should get better the more you use it.

One scheduled loop reviews recent work: what the agent tried, where it got stuck, which tools and skills it used, what the human corrected, and what patterns repeated. That loop turns working sessions into persistent memory and improves the skills that caused friction.

Another loop broadens capability. When the assistant needs to learn a new tool, workflow, domain, or work surface, it follows a guided, battle-tested learning skill with verifiable progress. Sometimes that learning is human-coached; sometimes the agent can learn independently through a structured skill, as long as it can test the result and produce evidence that the capability works. After enough evidence from real use, the new capability can be captured as a reusable skill and eventually become trusted.

This gives the system self-awareness: it should know what it can do reliably, what it has only tried a few times, what it can plausibly learn, and where it still needs human supervision. Capability is evidence-based, not aspirational.

Interaction Surfaces

Tool connections are the pull layer: the agent uses them to fetch context or take action in systems, tools, and apps when a workflow asks for it.

Triggers are the push layer: they listen for events from systems, tools, and apps, normalize them into workflow events, and wake up workflows or automations when something happens. The event may originate in a cloud service like GitHub, Slack, Outlook, PagerDuty, or Jira; the trigger may detect it through an available surface such as a desktop app, browser notification, macOS notification, authenticated session, email, or polling.

Triggers are deliberately separate from tool connections. A trigger notices that something happened; a tool connection fetches authoritative context or takes action afterward.

Laptop sessions are the coaching surface. This is where you supervise complex work, correct the agent, refine skills, and teach the assistant new workflows. On the laptop, you do not need a routing layer first; you can directly invoke the individual skill, workflow, or tool connection you want to work on.

Runtime is the local execution machinery. It handles polling cadence, jitter/backoff, scheduling, state, dedupe, reply logging, and invoking Cursor, Claude Code, or Codex. It should stay thin.

Workflows are the useful automations. Stand-up prep is the first scheduled workflow. Automatic PR review is a good future example: a GitHub/GHE review request may arrive via Outlook, Slack, Teams, or a macOS notification; the workflow then uses GitHub/GHE, Jira, Slack, and CI connections to review the PR and produce a summary or draft comment.

The product is designed around both: quick delegation when the workflow is familiar, active coaching when the workflow is still being learned.

What's In This Repo

tool_connections/        How agents access systems, tools, and apps
triggers/                Event listeners that wake up workflows and automations
runtime/                 Local execution machinery: scheduling, state, replies, agent clients
workflows/               Multi-tool workflows built on top of connections
tests/                   Regression tests for triggers, runtime, and workflows
.cursor/skills/          Cursor agent skills packaged with the repo
.claude/skills/          Claude Code agent skills packaged with the repo
staging/                 Community contributions under review
setup.md                 Main setup path for connecting tools
add-new-tool.md          Playbook for connecting tools not yet in the repo
setup-python.md          Python and Playwright setup helper

Private runtime state lives outside the public repo by default:

~/.10xProductivity/
  .env                    Tokens, cookies, and private config
  personal/               Your active private tool recipes and patched copies
  verified_connections.md Device-specific connection index
  tmp/                    Trigger state, runtime sessions, scheduler state, reply logs

Set TENX_PRIVATE_DIR if you want a different private directory. The repo keeps hooks and .gitignore as safety nets, but credentials and browser/session state should not live under the repo tree.

Migration note: older local instructions may point at /path/to/10xProductivity/.env, /path/to/10xProductivity/personal/, or /path/to/10xProductivity/verified_connections.md. Those now map to TENX_PRIVATE_DIR/.env, TENX_PRIVATE_DIR/personal/, and TENX_PRIVATE_DIR/verified_connections.md. The repo personal/ folder is only a placeholder with this reminder.

The current repo is strongest at the connection layer. The trigger, runtime, and workflow layers now exist, but are still early. The next product direction is to harden enterprise-friendly triggers, promote more workflows, and make runtime execution reliable without requiring enterprise app installs or new infrastructure.

Work Surfaces

This is not a connector-count competition. The point is to cover the surfaces where work actually happens, then teach your agent how to move across them.

Internal portals and custom company tools matter just as much as commercial SaaS. If a tool has an API, CLI, browser interface, or local files, use add-new-tool.md to teach your agent how to use it privately.

Agent Skills and Workflows

Agent skills sit above raw tool connections. They teach your coding agent how to do work, not just how to call an API.

Packaged skills currently cover tool setup, enterprise search, workflow creation, UI surface discovery, colleague distillation, and the assistant inbox/runtime.

Quick Start

1. Install a coding agent such as Cursor, Claude Code, Codex, or another agent you trust.

2. Clone and open this repo:

git clone https://github.com/ZhixiangLuo/10xProductivity.git
cd 10xProductivity

3. If needed, set up Python and Playwright:

Read setup-python.md and prepare this repo.

4. Install the local runtime:

python3 -m venv .venv
source .venv/bin/activate
pip install -e ".[dev]"

5. Ask your agent to set up your personal AI assistant for work. The first step is connecting your tools:

Read setup.md and set up my personal AI assistant for work.

6. Try a first workflow:

Read workflows/enterprise-search/enterprise-search.md and search across my connected tools for <topic>.

7. Try the trigger host after configuring a trigger:

10x-host --trigger slack-polling --workflow workflows/assistant/assistant.md --engine cursor

From there, coach the agent through work you actually do. When a pattern repeats, capture it as a skill or workflow.

Example Workflows and Prompts

Available today: enterprise search

Search for everything related to the decision to deprecate the v1 API.

The agent searches across connected tools, synthesizes the answer, and links back to source material.

Available today: real-time web research

Research the current state of WebAssembly support across major browsers
and summarize what changed in the last 6 months.

The agent queries Google AI Mode for AI-synthesized answers grounded in live web sources, with multi-turn follow-up for deeper investigation. No API key — sign in to Google once.

Coaching example: sprint triage

Review my Jira sprint, identify stale tickets, and draft follow-up comments.

The agent can learn this from connected Jira, docs, and PRs. Once the pattern is reliable, capture it as a workflow or skill.

Coaching example: morning brief

Summarize what changed since yesterday across Slack, Jira, GitHub, and my calendar.

Once trusted, this can become a scheduled workflow.

Early trigger example: Slack self-DM polling

10x-host --trigger slack-polling --workflow workflows/assistant/assistant.md --engine cursor

The trigger uses SLACK_XOXC and SLACK_D_COOKIE from TENX_PRIVATE_DIR/.env. It does not require a personal Slack app, Socket Mode, or webhook.

Early scheduled job example: stand-up prep

10x-standup-prep --meeting-context "Daily stand-up for <team/project>" --dry-run

Add --post only after reviewing the output and setting TENX_STANDUP_PREP_SLACK_CHANNEL.

Future workflow example: automatic PR review

A review-request notification arrives from Outlook, Slack, Teams, or GitHub Desktop.
The macOS notification trigger captures it.
The automatic PR review workflow fetches PR, ticket, and CI context through tool connections.
The agent returns a review summary or draft comment for approval.

Who This Is For

10xProductivity is for people who already use a coding agent and want it to become useful outside the code editor:

• Developers who want one agent to work across code, tickets, docs, and chat
• Engineering managers who want cross-tool status and follow-up automation
• Product managers, support engineers, analysts, sales teams, and operators who live across many tools
• Power users who want to coach their own personal AI assistant for work instead of waiting for a centralized platform rollout

The same stack works differently for each person because the tools, skills, and trusted workflows are personal.

Project Direction

10xProductivity started as the tool connection layer for coding agents. It is evolving into an open-source personal AI assistant for work stack:

1. Tool connections — let the agent use the tools you already use.
2. Triggers — detect incoming work through app and service events the user already receives.
3. Runtime — provide the local machinery for polling, scheduling, state, replies, and agent invocation.
4. Workflows — compose triggers, runtime, and connections into repeatable work.
5. Agent skills — teach the agent how you want work done.
6. Human-AI interaction — delegate through safe event triggers, coach from the laptop.
7. Learning and memory — turn sessions, corrections, tool use, and mistakes into persistent improvements.
8. Self-awareness — track capabilities and limitations based on evidence from real use.
9. Trusted automation — run proven workflows from triggers or schedules.

The goal is not to replace Cursor, Claude Code, Codex, or Copilot. The goal is to give those approved coding agents the missing layer: tool access, reusable skills, workflows, and a coaching loop that turns them into personal AI assistants for work.

Contributing

Contributions are welcome for:

• New tool connections
• New auth or deployment variants
• Fixes to existing setup guides
• Useful workflows built on connected tools
• Agent skills that teach repeatable work patterns

See contributing.md for the full process. The core rule for tool connections is: run before you write. Every snippet should be something you executed and saw succeed.

Legal

Some workflows in this repo automate actions on external platforms. Platform automation may violate Terms of Service. Read LEGAL_NOTICE.md before running automation scripts.

License

MIT