# autoMate: an MCP tool layer that gives every AI client the same notes, files and memory

> autoMate is a local FastAPI hub that exposes notes, a file vault, reminders, memory and 30-plus tool integrations over MCP or HTTP, so OpenClaw, Claude Desktop, Cursor and Cline can all read and write the same personal data store. The trade-off is that you now run a server, and the desktop tools need a real display.

**yuruotong1/autoMate** — Like Manus, Computer Use Agent(CUA) and Omniparser, we are computer-using agents.AI-driven local automation assistant that uses natural language to make computers work by themselves

- Repository: https://github.com/yuruotong1/autoMate
- Stars: 3,969 · Forks: 490
- Language: Python
- License: MIT
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/yuruotong1-automate

## The problem autoMate targets: AI clients that forget you between vendors

The README states the case plainly: most AI vendors can call tools, but "none of them remember anything across vendors, store your files, or ping your phone when something matters." That is the gap autoMate aims at. If you use Claude Desktop for serious work, Cursor for code and an IM client for chat, each one keeps its own history and its own tool list. Nothing carries over.

autoMate positions itself as "the layer behind the chat: a warehouse you own." You keep the client you like and point it at autoMate over MCP. The client then gains autoMate's tools, and the data those tools write lands in one place on your machine rather than in a vendor account. Tomorrow's client reads the same store back.

Who this is for: developers and technically comfortable users who already run at least one MCP-capable client and want a shared store they control. It is not aimed at someone who wants a single chat app with no moving parts. Running autoMate means running a local server, and the README is explicit that data lives in ~/.automate/ as SQLite plus Fernet encryption.

## How the MCP bridge and the agent loop fit together

The architecture in the README is a hub with several entry points. Clients arrive three ways: MCP, HTTP, or a bridge. The repository layout shows server/mcp_bridge.py handling "FastMCP exposure, mounted at /mcp/", while server/ holds the FastAPI app serving REST, WebSocket and MCP-over-HTTP. So the same backend answers all of them.

On the data side, the README lists notes.* as markdown documents with tags, search and pinning; files.* as a content-addressed blob vault with deduplication and a configurable storage path; search.find as hybrid retrieval using SQLite FTS5 BM25 across notes and files in one call; reminders.* as a scheduler thread that fires Web Push to the PWA; and memory.* as long-term key-value facts any AI can read or write.

Execution is split into layers. shell.*, script.* (Python, Bash, Node) and desktop.* (pyautogui) run locally. browser.* uses Playwright in a fresh Chromium tab. bx.* drives your real browser through the Chrome extension. Beyond that sit 31 SaaS connectors, from GitHub and Notion to Stripe and Shopify.

The two usage modes matter for how the loop runs. In client mode, your chat client is the brain and autoMate is a tool source. In standalone mode, autoMate's own agent loop in agent/ turns natural language into tool calls. The README notes the client also receives "a top-level automate tool that runs autoMate's own agent loop on demand," so both paths coexist.

## Installing autoMate and connecting your first AI client

The README lists four install paths. With Python available, the package is automate-hub. The Dockerfile shows a container build and run. Standalone binaries for Windows, macOS and Linux are attached to the latest release. The browser extension lives in extension/, and the PWA is installed by opening the hub URL in mobile Chrome or Safari and choosing Add to Home Screen.

For the Python path, install the published package with the extras you need:

```bash
pip install 'automate-hub[full]'
```

That pulls core plus the optional groups. The requirements.txt comments explain the same split for a source checkout, where pip install -e . gives core only and pip install -e '.[full]' adds mcp, browser and desktop.

Start the server with the console script:

```bash
automate
```

According to the README, the browser opens to http://127.0.0.1:8765 and a wizard walks you through picking a model, pasting a key, and optionally wiring up an AI client.

The container path is documented in the Dockerfile header:

```bash
docker run --rm -p 8765:8765 -v automate-data:/data automate-hub
```

Inside the container AUTOMATE_HOME is set to /data and AUTOMATE_HOST to 0.0.0.0, which is why the volume mount matters if you want the store to survive the container. Desktop tools are skipped there because there is no display; browser tools still work because Chromium is preinstalled.

Connecting a client is the part worth reading carefully. After install, the README says to open Settings, then "Connect to AI clients", then click "Copy install text". You get a markdown blob with the URL and token already filled in, split into sections for OpenClaw, Claude Desktop, Cursor, Cline, generic MCP and non-MCP gateways. You can edit your client's config by hand, or paste the blob into another AI and ask it to do the setup. For OpenClaw specifically, the text goes into the OpenClaw config under bundle-mcp. Once the client reloads the server, it should list autoMate's tools such as search.find, notes.read, files.list and audio.transcribe.

## Where autoMate gets awkward: display requirements, Pro gating and IM channels

Three constraints stand out.

First, desktop.* depends on pyautogui and a graphical session. The Dockerfile states plainly that desktop tools are skipped in the container. So a headless box or NAS gives you notes, files, search, reminders, memory, shell, script and browser tools, but not screenshot-and-click automation. If desktop control is the reason you came, the container is the wrong deployment.

Second, audio.transcribe is described in the README as voice to text via Tencent ASR or OpenAI Whisper "with custom vocabulary mined from your notes (Pro tier)". The auth.py comment in the layout mentions an "autoMate Cloud session (Pro tier hook)". The README does not spell out what the Pro tier costs, what it unlocks beyond transcription, or what happens to that feature without a cloud session. Treat transcription as a feature to verify before you rely on it.

Third, IM channels are deliberately not bundled. The README says "We don't ship per-platform bots ourselves" and instead directs you to run OpenClaw alongside autoMate, install a WeChat plugin, drop a generated bundle-mcp snippet into ~/.openclaw/openclaw.json5, set channel config with openclaw config set channels.wechat.*, and start the gateway with openclaw gateway start. The legacy adapters in automate/bots/ for Telegram, WeChat OA and WeCom still exist but are filed under "Direct platform webhooks (advanced / legacy)". If you wanted a one-command WhatsApp bot, this is not it.

One more thing the README does not document: rollback. There is no stated procedure for downgrading between the v4.5.x and v4.6.0 releases or for migrating the SQLite store backwards.

## autoMate compared with wiring tools directly into one client

The obvious alternative is not another product but the default: let each AI client own its own tools and storage. Claude Desktop has its own MCP servers, Cursor has its own, and you configure each one separately. That approach has real advantages. No extra process, no port 8765, no shared token to manage, and no single point of failure for your notes and files.

The difference in approach is where the data lives and who can read it. With per-client setup, a note written through Claude Desktop is invisible to Cursor unless you also configure the same server there. autoMate inverts that: one backend, one store under ~/.automate/, and every connected client sees the same notes, files, memory and reminders. The README frames it as a warehouse you own rather than a per-vendor silo.

That inversion is also the cost. You are now responsible for a long-running local service, for its token, and for the machine it runs on. If your needs are narrow, for example a single client that reads a single repository, the per-client route is less machinery for the same outcome. autoMate earns its place when you genuinely want cross-client continuity or when you want the SaaS connectors and local executors in one tool list.

## Maintenance, licensing and what upgrades cost you

The repository is not archived and the last push was on 2026-08-25, which is recent. Releases are frequent rather than rare: v4.5.9, v4.5.10 and v4.6.0 all landed on 2026-04-28, and the pyproject.toml carries version 4.6.0. That pattern suggests active iteration, but it also means the surface you integrate against can move.

The dependency choices reduce one kind of upgrade pain. The core dependency list in pyproject.toml is deliberately short: fastapi, uvicorn, pydantic, cryptography, python-multipart, pywebpush, and mcp[cli]. The comment above the MCP entry explains that it was promoted from optional to required in v4.5.7 so the /mcp endpoint always works without an extras install. Everything heavier, including litellm, playwright and pyautogui, sits in optional groups. The litellm pin is capped at >=1.65,<1.85, so that particular upgrade is bounded by the project rather than by you.

Licensing is MIT, declared both in the repository metadata and in pyproject.toml as license = {text = "MIT"}. That is permissive and places few obligations on how you use or redistribute it, but the project also references an autoMate Cloud session and a Pro tier for transcription. Whether that cloud component carries separate terms is not stated in the README, and the README does not document a data-retention or export path for the local store. If your use is commercial or regulated, read the cloud/ directory and the auth.py hook yourself before assuming the MIT grant covers every path. This is a description of what the files say, not legal advice.

## Conclusion

Adopt autoMate if you already use one or more MCP-capable clients and want a single owned store for notes, files, memory and reminders instead of per-vendor silos. Skip it if you only need one client's built-in tools, or if your machine has no display and you were counting on desktop.* automation. Before committing, verify three things yourself: that your chosen client actually picks up the /mcp endpoint after you paste the install text, that the storage path you configure for files.* points where you intend, and whether the Pro-gated audio.transcribe path is one you need, since the README marks it as Pro tier.

## FAQ

### What is autoMate and what does it do?

autoMate is a local hub that exposes notes, files, reminders, memory, search and more than 30 tool integrations to AI clients over MCP or HTTP. The README describes it as "a smart NAS for AI" that acts as the layer behind your chat client, storing data you own in ~/.automate/ as SQLite plus Fernet encryption.

### How do I install autoMate?

The README lists four paths: pip install automate-hub for Python users, a standalone binary for Windows, macOS and Linux from the releases page, a Docker image at ghcr.io/yuruotong1/automate:latest, and a browser extension in the extension/ directory. After install, running the automate command opens the hub at http://127.0.0.1:8765.

### How do I connect autoMate to Claude Desktop or Cursor?

After install, open Settings, then "Connect to AI clients", and click "Copy install text". The README says you get a markdown blob with the URL and token pre-filled, with separate sections for OpenClaw, Claude Desktop, Cursor, Cline, generic MCP and non-MCP gateways, which you can either paste into the client's config yourself or hand to another AI to apply.

### Can autoMate run in Docker on a NAS or headless server?

Yes. The Dockerfile documents building and running the container with a port mapping to 8765 and a volume mounted at /data. It also notes that desktop tools are skipped because the container has no display, while browser tools work since Chromium is preinstalled.

### Does autoMate send messages on WhatsApp or WeChat by itself?

No. The README states that autoMate does not ship per-platform bots and directs you to run OpenClaw alongside it, install the relevant plugin, drop the generated bundle-mcp snippet into ~/.openclaw/openclaw.json5, configure the channel, and start the OpenClaw gateway. Legacy direct-webhook adapters exist in automate/bots/ but are marked advanced and legacy.

## Sources

- [Issues](https://github.com/yuruotong1/autoMate/issues)
- [License: MIT](https://github.com/yuruotong1/autoMate/blob/master/LICENSE)
- [README](https://github.com/yuruotong1/autoMate/blob/master/README.md)
- [Releases](https://github.com/yuruotong1/autoMate/releases)
- [yuruotong1/autoMate on GitHub](https://github.com/yuruotong1/autoMate)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/yuruotong1-automate