Hermes is the kind of agent you want on a CRM backlog. It is persistent, it carries 40-plus tools, it spawns subagents for the long jobs, it schedules its own cron runs, and it keeps the skill it builds so the second pass starts warmer than the first. If you run Hermes, pointing it at HubSpot is the obvious next thought.
The part to price in before you wire anything: Hermes' approval gate watches dangerous shell commands. It exists to protect your machine, not your database. A PATCH to a contact record is not on its pattern list, so an agent with a live line to HubSpot writes at machine speed with no one reading first, onto the CRM your pipeline reports and your forecast run on. The fix is not less Hermes. It is changing what Hermes touches: files on your laptop instead of live records, with the write-back pulled out into a review step. Here are the ways to wire it, held to one question: what does Hermes touch, and who reads the changes before HubSpot does?
Your options
A HubSpot MCP server
Hermes loads MCP tools dynamically, so wiring a HubSpot MCP in takes minutes, and for asking questions of your CRM it is genuinely good. Which deals have no next step? Which companies have no owner? The shape breaks when the job is bulk. Every read is a metered API page, so seeing 20,000 contacts once costs 200 paginated calls before the agent has formed a single opinion, and every question it wants to ask of the dataset is another pass through the meter. Writes are worse than slow: each one lands on the live CRM the moment the tool call returns, with no diff, no queue, and no gate between the agent's judgment and your production data.
Scripts against the CRM API
Hermes has a terminal and writes good scripts, so the tinkerer's path is a private app token in the environment and a batch update against the CRM API. It works, and it is faster than the MCP because a well-built script batches what an agent would do call by call. You have just handed a live credential to the agent's shell, though, and the supervision gap stays open: Hermes' approval prompt fires on dangerous shell commands, and a curl to the CRM API does not read as dangerous to a pattern list built around protecting your filesystem. When a run goes wrong, HubSpot's restore tool does not list API changes among the sources it can roll back. The token also outlives the session, sitting wherever the script left it.
Browser automation on the HubSpot UI
Hermes ships real browser tools, so it can drive HubSpot the way you do: open the record, click into the field, type the fix. For a handful of records it is a neat trick and the closest thing to supervision the live paths offer, since you can watch it work. As a bulk method it is the slowest option on the page, every save still lands live, and a UI change breaks the run halfway through the object. Nobody cleans 20,000 records through a browser.
CSV export and re-import
The instinct is right: get the records into files, because files are where an agent like Hermes does its best work. Export the object, hand Hermes the spreadsheet, and it will sort, dedupe, and rewrite with real judgment, one different value per row. The write-back is what stays blind. HubSpot's import screen validates your file, not your CRM: no screen puts the current value next to the incoming one, every populated cell overwrites silently, and the restore tool reaches back 14 days, needs a Super Admin, and cannot restore selected properties from an import. Files were the right idea. The re-import throws away the review the files made possible.
Scratch
Scratch is the files idea with the write-back done right. It pulls your HubSpot CRM into a folder on your laptop, one JSON file per record, a folder per object, with a schema for every table. It also writes an AGENTS.md into the workspace describing the layout and which fields are off-limits, and Hermes reads context files from the working directory automatically at session start, so it orients itself before your first prompt. Hermes gets full read and write on the copy: grep the whole book of business in seconds, script the mechanical bulk, spend judgment on the strange remainder, and none of it costs an API call or touches HubSpot. Every changed field comes back in Scratch as a word-level diff against the value currently in the CRM. You approve what writes back, Scratch sends only the approved changes through the CRM API, and every written record can be reverted afterwards, per record. Hermes never sees a HubSpot token at any point in the loop.
| Option | Where Hermes works | Preview before the CRM changes | Undo after the run |
|---|---|---|---|
| HubSpot MCP server | Live records | No | Not covered by restore |
| API scripts | Live records | No | Not covered by restore |
| Browser automation | Live UI | Only as fast as you watch | By hand |
| CSV re-import | A spreadsheet | File checks only | Restore window, not per property |
| Scratch | Local files | Every field, as a diff | Per record, even after publish |
How the loop works
- Scratch pulls your HubSpot into files. Contacts, companies, deals, tickets, quotes, line items, products, notes, tasks, calls, meetings, leads, and your custom objects come down as one JSON file per record, named so you can read the folder: contacts by email, companies by name, deals by deal name. Calls, meetings, and emails come along too, so the agent reads the whole account before it decides anything. Each table gets a schema that marks HubSpot's calculated and system fields read-only, and the workspace gets an
AGENTS.mdexplaining all of it. - Start Hermes in the folder.
cdinto the Scratch workspace and runhermes. It loads theAGENTS.mdon startup the way it loads any project context file, so it already knows the layout and the hands-off fields when the prompt appears. You bring your own model the way you already run Hermes, through Nous Portal, OpenRouter, or any OpenAI-compatible endpoint. Scratch holds no model credentials, and Hermes holds no HubSpot credentials. - Give it the pass. Standardize every company description to two sentences in our house style, tighten the deal notes from last quarter, and fill missing industries from what is already on the record. Touch nothing else. Hermes greps the files to size the job, scripts the mechanical bulk, reads the long tail itself, and can fan the work out to subagents when the object is large. When it finishes, it can save the whole pass as a skill.
- You review every diff and publish. Scratch shows each record's changes field by field, word by word, next to the value currently in HubSpot. Approve what holds up, and Scratch writes only those records, and only the changed fields on them, back through the HubSpot CRM API. Every written record can be reverted from Scratch afterwards, one at a time.
The second run is the point
Most agents start every session cold, and you pay the orientation tax every time: re-explain the folder, the field names, the tone rules. Hermes is built to stop paying it. The skill it saves after the first pass records your catalog structure, your conventions, and the decisions it made, and the next session starts from that skill instead of from zero.
That is what makes the recurring version of this job real. Hermes schedules its own runs with hermes cron, and a scheduled run starts a fresh session, which is exactly where a saved skill earns its keep: the Tuesday-morning hygiene pass loads the skill, works the freshly pulled files, and has the diffs waiting in Scratch before you sit down. The preparation happens on a schedule. Publishing still waits for you, because the review step lives in Scratch, not in the agent, and nothing writes back until you approve it.
What people run with it
- Standardize company descriptions across every account so the firmographics read one way.
- Tighten and normalize deal notes after a quarter of drift, before the forecast review.
- Collapse every spelling of the same industry or title into one taxonomy.
- Fill empty fields from what is already on the record instead of paying to enrich data you already have.
- Fix the associations that drifted, contacts pointing at the wrong company, deals orphaned from both.
Run the first pass on a few hundred records to feel the loop and let Hermes build the skill. Then point it at the whole object, and after that, at the calendar.
Questions people ask
Does Hermes get write access to my live CRM?
No. Hermes reads and writes JSON files in a folder on your laptop, and there is no HubSpot token in its environment to find. The only write path to HubSpot belongs to Scratch, opens after your approval, and carries only the records and fields you approved.
Why not just give Hermes the HubSpot MCP?
For asking questions of your CRM, do. For a bulk pass, the MCP is the wrong shape twice over: reading the whole object costs hundreds of metered calls before the agent has seen the data once, and every write lands live with no review. Hermes' own approval gate does not close the gap, because it watches dangerous shell commands, and a CRM write is just another tool call.
Does Hermes' approval mode protect my HubSpot data?
Not on its own. The approval prompt checks shell commands against a pattern list built to protect your machine, and API writes to a CRM are not what it is scanning for. That is not a flaw in Hermes; it is a reason to keep the CRM out of reach. On a Scratch folder, the blast radius of any Hermes action is a local file that has to survive your diff review before it can touch HubSpot.
Which HubSpot objects can it edit?
Contacts, companies, deals, tickets, quotes, line items, products, notes, tasks, calls, meetings, leads, and your custom objects, plus the associations between the standard objects, so a contact pointing at the wrong company is an editable fact. Calls, meetings, and emails come down so the agent has full context on every account. Workflows, lists, sequences, and Marketing Hub assets are not part of the sync at all. The full picture lives on Scratch for HubSpot.
Will approved writes fire my workflows?
They can. Edits to the local files fire nothing. When you approve a record, Scratch writes it back like any CRM update, so a workflow watching that field can fire, the same as a hand edit would. The difference is that you choose which records write back, and when, instead of one bulk pass tripping every workflow at once.
Can I undo a pass after it publishes?
Yes, per record. The original value stays next to every written change in Scratch, and reverting a published record puts it back. HubSpot's own restore tool is not part of the story, which matters, because it reaches back 14 days, needs a Super Admin, and does not list API changes among the sources it can restore.
What does the skill actually change on the second run?
The first pass costs orientation: Hermes learning your folder layout, your naming conventions, and what the brief means against your data. The skill it saves records all of that. The second run loads the skill, skips the orientation, and goes straight to work, which is what makes a weekly scheduled pass with hermes cron cheap enough to be routine.
See it on your own CRM
The fastest way to trust the loop is to watch Hermes work your own records and read the first diffs yourself. Book a 30-minute demo on your HubSpot CRM →, or try Scratch free, pull one object this afternoon, and let Hermes build its first skill on it.