Hermes Agent Cursor: Import Your Cursor Setup In 6 Steps (2026)

Hermes Agent Cursor support means one command, hermes import-agent cursor, pulls your Cursor rules, MCP servers and skills into Hermes.

It ships in the official agent-importers plugin from Nous Research, and the v0.22.4 release notes (21 October 2026) list it as "now with Cursor".

This is the exact order I would run it in: version check, plugin, dry run, real import, cleanup, then a daily sync.

If you want my team to look at which jobs your agents should own first, book a free SEO strategy session.

What the Cursor importer reads from ~/.cursor

The importer looks in ~/.cursor by default and maps four things into your active Hermes profile.

In Cursor	Lands in Hermes
`AGENTS.md`	Memory entries in `~/.hermes/memories/MEMORY.md`
`rules/` files ending `.md` or `.mdc` (User Rules)	Memory entries in the same `MEMORY.md`
`mcp.json` → `mcpServers`	`mcp_servers` in `config.yaml`
`skills/**/<name>/` (folders holding `SKILL.md`)	`~/.hermes/skills/cursor-imports/<name>/`

That table comes straight from the Hermes import guide.

Notice what is missing: there is no permissions row for Cursor, so no command allowlist gets built from it.

You set Hermes approvals yourself after the import.

Before you start, open ~/.cursor and look at what is actually in there.

Count your rule files, note which ones are .mdc with globs, and list the MCP servers in mcp.json that need keys.

Five minutes of looking now makes the dry run much faster to read.

Step 1: get Hermes onto v0.22.4 or newer

Cursor arrived in the plugin version of the importer, so an old install is the first thing that trips people up.

The plugin README says that on a Hermes build that still has import-agent built in, the plugin stays inert and the built-in command runs instead.

That older built-in command is the one without Cursor.

Update first, before you go any further.

hermes update

There is a nice side effect if you already sync another agent.

Profiles with a registered sync source get the plugin installed automatically by hermes update, or on the first start after updating.

That honours security.allow_lazy_installs, and if you remove the plugin later it stays removed.

Everyone else sees the install line the first time they run hermes import-agent without it.

Step 2: install agent-importers once per profile

The command lives in the plugin catalog, so install it by name or straight from the repo.

hermes plugins install agent-importers
# or
hermes plugins install NousResearch/hermes-official-plugins#agent-importers

On a fresh machine you can skip this step.

hermes setup checks for ~/.cursor before anything else, asks whether to import, installs the plugin for you and runs the same preview.

If it also finds other agent folders, you get a checklist with everything ticked, so untick what you do not want.

The plugin is MIT-licensed and used to live in Hermes core as hermes_cli/agent_import.py, so the flags and the sync manifest did not change in the move.

Step 3: dry-run the Cursor import before anything is written

hermes import-agent cursor --dry-run

A dry run prints the per-item plan and never touches disk.

Read every line of it.

You are looking for three things: rules you forgot existed, MCP servers you no longer use, and skills flagged as conflicts.

If your Cursor folder lives somewhere else, point at it with --source /path/to/.cursor.

Got Claude Code or Codex on the same machine as well?

Plain hermes import-agent with no name auto-detects ~/.claude, ~/.codex and ~/.cursor, so name cursor explicitly when you only want that one.

🔥 Want the Hermes setup I run day to day, already wired? Inside the AI Profit Boardroom you get step-by-step video trainings, the installable Agent OS, four coaching calls a week and 3,400+ members moving their agents over. → Join the AI Profit Boardroom

Step 4: run the import and keep the report open

hermes import-agent cursor

You get the same plan again and a confirmation prompt.

Say yes, and the importer backs up your current MEMORY.md as MEMORY.md.bak.<timestamp> before merging anything.

Memory entries are deduplicated against what you already have, so re-running does not stack copies.

A broken mcp.json becomes a per-item error in the report while the rest still imports.

Running it from a script with no TTY? It stops at the preview unless you add --yes.

The report is the most useful output of the whole run, so do not close the terminal on it.

It splits into what was imported, what was skipped as a conflict, what errored and what was stripped.

Copy the stripped list into a note, because that is your to-do list for Step 5.

Copy the conflict list too, because those are skills or MCP servers Hermes already had and kept.

Errors point at a specific file, usually a malformed mcp.json, so fix that file in Cursor and run again.

Anything not listed came across cleanly.

Keep that terminal open while you work through the next three sections.

Everything below refers back to the lists it just printed.

How .mdc rules come across, and the scoping you lose

Cursor .mdc files carry frontmatter: description, globs and alwaysApply.

The importer strips that block because it is routing metadata for Cursor's rule engine, and keeps only the rule body.

So a rule that only fired on certain file patterns in Cursor becomes a plain memory entry in Hermes with no file filter.

My fix is simple: open MEMORY.md after the import and add one line to each scoped rule saying where it applies.

The plugin README lists rules/**/*.md and rules/**/*.mdc, so rules in nested folders count too.

If your team shares one Cursor rules folder, agree who owns each rule before the import, so the review in Hermes has one name against every entry.

Skill folders: why two "deploy" skills clash

Cursor lets you group skills into category folders, and the importer allows that.

A skill is the folder that holds SKILL.md, so skills/shipping/land-it/ arrives as cursor-imports/land-it/.

The category folder disappears in the move.

That means two skills with the same name in different categories collide, and the report lists them as a conflict.

Rename one in Cursor, then run the import again.

Skills that already exist in Hermes are skipped by default; --overwrite replaces them.

Step 5: put your MCP keys back by hand

Credential files are never read, and that includes ~/.cursor/cli-config.json.

MCP environment variables or headers with secret-looking names, such as *_TOKEN, *_API_KEY or Authorization, are stripped and listed in the report.

Your MCP servers arrive, but any server that needs a key will fail until you add it.

Put those values in the profile's .env, or run hermes setup for model providers.

Then test each server one at a time.

Only after every keyed server answers would I move on to scheduling.

Step 6: keep Cursor and Hermes in step with a daily sync

Every successful import registers its source in ~/.hermes/import-sync.json.

When you add a rule or skill in Cursor later, one command pulls the change across:

hermes import-agent --sync --dry-run   # see what changed
hermes import-agent --sync             # apply it

Sync is prompt-free and skips any source whose files have not changed, so the docs call it safe to run on a schedule.

I would hand it to a Hermes cron job once a day:

hermes cron create "every 1d at 09:00" "Run hermes import-agent --sync and tell me what changed"

If you edit an imported skill inside Hermes, sync leaves your copy alone and treats it as a conflict.

📞 Moving your team's agents and not sure what to automate first? Book a free SEO strategy session and my team will map which SEO and content jobs to give Hermes. → Book your free call

Re-running the import without making a mess

You will run this more than once, so it helps to know what a second pass does.

Memory merges stay deduplicated, so rules you already have are not added twice.

Skills and MCP servers that already exist are skipped as conflicts unless you choose otherwise.

When you do want Cursor to win, combine the flags:

hermes import-agent cursor --overwrite --yes

Do a dry run before that line every time, because --overwrite replaces what Hermes had.

For routine updates, --sync is the better tool, since it only touches files that changed.

Importing into another profile or from a custom path

The import always writes into the active profile.

To keep a Cursor import separate from your main agent, target a profile directly:

hermes -p client-site import-agent cursor --dry-run
hermes -p client-site import-agent cursor

Cloning a profile? The profiles docs cover hermes profile create <name> --clone --sync-imports, which carries the sync manifest into the new profile.

A quick test after the import tells you whether it worked: ask Hermes to list the rules it now has in memory and the MCP servers it can see.

If both lists match what you counted in ~/.cursor at the start, the move is done.

If a server is missing, check the conflicts list; if a server is there but failing, check the stripped list.

Gotchas I would check before trusting the import

No Cursor in the help output means you are still on the built-in command, so update Hermes.
A config.yaml Hermes cannot parse is never rewritten; the import logs an error and leaves it byte-identical.
Your comments in config.yaml survive the write.
Imported MCP servers with stripped keys fail quietly until you re-add them.
Glob-scoped rules lose their scope, so review them in MEMORY.md.

One more: a run with errors keeps the old sync digest, so the next --sync retries the same files.

That is good news, but it means a broken file keeps showing up until you fix it at the source.

Cursor import vs the Claude Code import

I covered the Claude Code and Codex routes in my Hermes import agent walkthrough.

The Cursor route is narrower.

Claude Code brings permission allowlists and deny rules; Cursor brings none, because its table has no permissions row.

Cursor brings rule files from a rules/ folder instead, which Claude Code does not have.

Both share the same safety model: preview first, credentials left behind, conflicts skipped.

Use the Claude Code guide if you run both tools, then come back here for the Cursor-only steps: rules, scoping and skill folders.

Your first hour on Hermes after the import

Run hermes setup and pick a model provider, since no keys came across.
Re-add the MCP secrets listed in the report.
Add scope notes to any glob rules in MEMORY.md.
Fix skill name clashes and re-run the import.
Schedule the daily --sync job.
Give Hermes one real task you used to run in Cursor and compare the result.

If you want those steps on video with the Agent OS ready to install, join the AI Profit Boardroom.

Also On Our Network

FAQ: Hermes Agent Cursor

What command imports Cursor into Hermes?

Run hermes import-agent cursor after installing the agent-importers plugin. Add --dry-run first to preview the plan without writing anything.

Why does Hermes not show a Cursor option?

Your install is still using the older built-in import-agent, which keeps the plugin inert. Update Hermes to v0.22.4 or newer and run the command again.

Do my .mdc rule globs still work in Hermes?

No. The frontmatter, including globs and alwaysApply, is stripped and only the rule body becomes a memory entry, so add scope notes by hand.

Why do my imported MCP servers fail?

Secret-looking env vars and headers are stripped on import and listed in the report. Add those keys to the profile .env and test each server.

Can I import Cursor into a separate Hermes profile?

Yes. Run hermes -p <name> import-agent cursor and the import writes into that profile instead of the active one.

📺 Video notes + links to the tools 👉

🎥 Learn how I make these videos 👉

🆓 Get a FREE AI Course + Community + 1,000 AI Agents 👉

About Julian

I'm Julian Goldie, an SEO entrepreneur, author and founder of the AI Profit Boardroom, which has 3,400+ members.

I help business owners scale with AI agents, automation and SEO.

I've built a 7-figure SEO and link building agency, Goldie Agency, with a team of 70+ SEO experts.
I've grown a YouTube channel to 400,000+ subscribers.
I wrote "Link Building Mastery".
My Udemy courses have taught over 29,000 students.

→ Get my best AI training inside the AI Profit Boardroom

Update Hermes, dry-run the import, schedule the sync, and if you want help picking the first jobs, book a free SEO strategy session or get the Agent OS inside the AI Profit Boardroom before you run Hermes Agent Cursor.