Skip to content

By Automation

By MCP covers handing your assistant a file in the moment — a lab panel, an old spreadsheet, one conversation, one import. This page covers the other shape: a scheduled agent that keeps pulling from some other app on its own, on a cadence, and keeps writing the result into Cohearence — no conversation required after you set it up.

This is the write direction of a scheduled agent — data flowing into Cohearence. For the read direction, where an agent reads what's already there and reports back to you on a cadence, see Scheduled Check-Ins.

This isn't a Cohearence feature you turn on. It's a recipe: you point a scheduled agent (a Claude Routine, a Cursor Cloud Agent, or anything else that can run unattended on a timer) at a data source and at Cohearence's MCP server, and let it do the rest. Cohearence's side of this — the write tools, the dedup, the caps — already exists and is documented in By MCP; this page is about the piece that's new, the recurring pull from somewhere else.

Choosing what to automate

Not every app is a good fit, and it's worth checking before you spend time on it. Ask one question: does the source have programmatic access?:

  • It has its own MCP server — best case, skip ahead to MCP-to-MCP below. Your agent already knows how to call another MCP server; there's no API key to manage and no request shapes to get right, because the source already describes its own tools.
  • It has a read API, no MCP — still a clear yes, build the recipe below. A read API with a key you can generate yourself is the strongest signal an app was built to be automated against.
  • No API, but it has a manual export — don't automate it. A "click a button, get a CSV" export exists for a human, not a script. Instead, export it by hand when you want fresh data and hand the file to your assistant — see By MCP.
  • No API, no export at all — leave it out, or log the parts you care about by voice instead.

Cohearence itself clears the bar both ways: the MCP server is the programmatic access, and it's the strongest kind — the same bar you're applying to everything else, an interface meant to be called by software, not just clicked by a person.

MCP-to-MCP: when the source speaks MCP too

Some apps ship their own MCP server instead of, or alongside, a plain REST API — Strava's official connector is a current example. When that's true, the recipe below collapses: no API key to generate or store, no request shape to get right, no bespoke fetch logic. You connect two MCP servers — the source's and Cohearence's — to the same agent, and let it read from one and write to the other.

That composition works in either shape:

  • Ad-hoc, in a single conversation. Connect both servers to Claude Desktop, Cursor, or Claude Code, and just ask: "pull my last two weeks of rides from Strava and log them in Cohearence." See By MCP for the write side of that conversation.
  • Scheduled, unattended. Same idea, running on a timer — give a Claude Routine or Cursor Cloud Agent both connections (the source's MCP credentials, plus a Cohearence Personal Access Token) and instructions like step 4 below, minus the API-key step.

How it works

Four pieces, all living on your side, not Cohearence's:

  1. A credential for the source — an API key or token from the app you're pulling from. Store it wherever your agent keeps secrets (a Claude Routine's configured environment, a Cursor Cloud Agent's variables, whatever your runner supports). Cohearence never sees it — it's not ours to hold.
  2. A connection to Cohearence — the same MCP setup any other client uses; see Setting up MCP. Which kind depends on where the agent runs. A Claude Routine uses the Cohearence connector on your Claude account, so you sign in once and it keeps working unattended. A runner where you configure the MCP connection yourself, and where nothing can open a browser to sign in, needs a Personal Access Token instead.
  3. A schedule — however your agent runner supports recurring runs (a Routine's cadence setting, a cron-triggered Cloud Agent, a scheduled task). Daily or weekly both work; match it to how often the source actually has new data.
  4. Instructions — tell the agent what to pull (which metrics, how far back on the first run), and to write it in using the normal MCP write flow: check catalog first so it reuses your existing metrics instead of creating near-duplicates, then stage_writes for the batch. Cohearence de-dupes by metric + timestamp, so a daily run that re-fetches the last few days of data on top of what it already wrote won't create doubles.

Approval when nobody's watching

By MCP describes a propose → review → commit handshake so nothing writes without your say-so. On an interactive client, that's a dialog you click. On a scheduled run, there's no one there to click it — the agent stages the batch, gets back a preview, and confirms it itself, the same way it would if you'd said "yes, go ahead" in a chat.

That's expected, not a gap: the approval that matters for an unattended recipe happens when you write the instructions and turn the schedule on, not on every individual run after that — the same trust you'd extend to any other script you've configured to run on its own. The caps documented in By MCP (proposals expire after 30 minutes, and are size- and rate-limited) bound how much damage a misbehaving run could do, and the measurement history is always queryable and editable afterward — by you, the app, or your assistant — so a bad batch is a cleanup conversation, not a permanent one. If you want an extra check anyway, have the agent post its staged preview somewhere you'll see it (a Slack message, an email) before it confirms, rather than committing silently.

A worked shape

This is the plain-API recipe — for a source with its own MCP server, use MCP-to-MCP above instead. Concretely, for a fitness or activity app with a read API (Withings is one example — mentioned as an example of the pattern, not an official partnership):

  1. Generate an API key or OAuth token from the source app's developer settings.
  2. Connect Cohearence to the runner (see Setting up MCP) — a Personal Access Token if it can't sign in interactively.
  3. Set up a Claude Routine or Cursor Cloud Agent with both credentials, connected to Cohearence over MCP, scheduled to run daily.
  4. Give it a short prompt: fetch anything new since the last run, check catalog for matching metric names, stage and commit the batch.

That's the whole thing. Nothing here is Cohearence-specific beyond step 2 and 4 — the same recipe works for any source that clears the "programmatic access" bar in the section above.

Have a source you wish this were easier for? Email us at [email protected] and tell us what you're using — see By Integration for the sources Cohearence connects to directly.