Cursor cloud agents still don't read ~/.cursor/rules

Where does the bug appear (feature/product)?

Background Agent (GitHub, Slack, Web, Linear)

Describe the Bug

Cursor cloud agents still don’t read the ~/.cursor/rules. In my project, I set up a Dockerfile for the cloud environment where I install my global cursor files into ~/.cursor. The cloud agent does see the ~/.cursor/skills but it does NOT see or apply the ~/.cursor/rules files. I had to tell it to read those files manually in my workspace rules, otherwise the cloud agent would never see them.

Steps to Reproduce

Set up a Dockerfile for your cloud environment and in that Dockerfile clone or set up some global rules into ~/.cursor/rules. Note that in my case ~/.cursor/rules is a symlink to ~/.agentfiles where I cloned my own repo.

Expected Behavior

Locally this is fully supported and the local Cursor agent gets the full ~/.cursor/rules in addition to the workspace ./.cursor/rules files. I expect the same from the cloud environment.

Screenshots / Screen Recordings

Operating System

Linux

Version Information

Version: 3.9.8
VS Code Extension API: 1.105.1
Commit: 4aa8ff1b7877ed7bd01bcba308698f71a6735380
Date: 2026-06-25T01:39:30.490Z (2 days ago)
Layout: glass
Build Type: Stable
Release Track: Default
Electron: 40.10.3
Chromium: 144.0.7559.236
Node.js: 24.15.0
V8: 14.4.258.32-electron.0
xterm.js: 6.1.0-beta.256
OS: Darwin arm64 25.5.0

Note that I got this from my local Cursor app, BUT this bug report is about cloud agents.

For AI issues: which model did you use?

Composer 2.5 Fast

Does this stop you from using Cursor

No - Cursor works, but with this issue

Related similar issues I found, but in none of them I see a fix or resolution:

For verification, I asked a local and a cloud agent over the same repository to output what global user rules it gets injected at the start of a new chat. Locally it sees my rule files from ~/.cursor/rules, but in the cloud it does not. See the screenshots below.

Local:

Cloud:

In the cloud there’s no mention of ~/.cursor/rules/local-env.mdc or example.

Hey @martindzejky!

Thanks for raising this. The home directory of a Cloud Agent is /home/ubuntu, while checked-out code lives at /workspace. Rule resolution currently walks upward from the workspace, so it never reaches /home/ubuntu/.cursor/rules.

We explicitly search the home directory for other configuration, such as skills, but don’t currently do so for rules.

I’ll look into this! In the meantime, (I haven’t tested it myself) I wonder if you could do something like this in your Dockerfile:

USER root
RUN mkdir -p /.cursor \
  && ln -s /home/ubuntu/.cursor/rules /.cursor/rules
USER ubuntu

Hey @Colin .

Thank you for your response. I tested your proposed solution and unfortunately it does not work. I updated my Dockerfile to symlink the root /.cursor → to my agent files at the ubuntu home /home/ubuntu/.cursor like this:

RUN ln -s /home/ubuntu/.cursor /.cursor

This still does not make the cloud agent see and apply my rules. I started a new cloud agent to verify this and it did not see the global rules. Note that I have instructions in the workspace (the project repository) rules to read the global user rules manually, but here I asked the agent to not read any files yet and tell me what it sees.

Here’s the conversation for reference:


I just pushed a workaround for you not reading my global rule files. Now, WITHOUT READING ANY FILES YET, tell me, what files do you already see included in your system instructions (above this first message)? Can you already see my global agent files? Or do you ONLY see the workspace/project’s agent files?

Without reading any files, here’s exactly what I see in my system instructions above:

Fully included rule files (always applied)

Workspace rules (/workspace/.cursor/rules/):

  • /workspace/.cursor/rules/agent.mdc — “Agent instructions”
  • /workspace/.cursor/rules/cloud.mdc — cloud environment rules

Cursor plugin rules (NOT your globals — these come from the public plugin cache):

  • [...]

Referenced but not yet read (agent-requestable)

  • [...] (more plugin rule files)

Inline user_rules (no file path, just inline content)

Four blocks: [...]. These appear to be inline content, but no file path is attached to them, so I can’t tell which file they came from — if any.

What I do NOT see

I do not see any of your actual global rule files from ~/.cursor/rules/. Specifically, these are missing from my context:

  • ~/.cursor/rules/cloud-env.mdc
  • ~/.cursor/rules/local-env.mdc
  • any other ~/.cursor/rules/*.mdc files

The /home/cursor/.cursor/plugins/... paths are Cursor’s public plugin cache, not your personal global rules directory.

Honest answer to your question

I only see workspace/project agent files (/workspace/.cursor/rules/...) and Cursor plugin rules. I do not see your global rule files from ~/.cursor/rules/. There is inline user_rules content that may have been extracted from a global file, but its origin file is not named in my context — so I can’t confirm it’s your workaround working as intended.

If your workaround was supposed to inject the actual ~/.cursor/rules/*.mdc file paths into my context, it does not appear to have taken effect for the file-based rules — only the inline user_rules block came through (without a path).

Do you see anything from the root /.cursor/*?

No. I do not see anything from /.cursor/* (root level).

Every .cursor/... path in my context falls into one of two locations:

  1. Workspace level: /workspace/.cursor/...

    • /workspace/.cursor/rules/agent.mdc
    • /workspace/.cursor/rules/cloud.mdc
    • /workspace/.cursor/skills/[...]/SKILL.md (listing out skills)
  2. Cursor’s home dir (plugins cache only): /home/cursor/.cursor/plugins/cache/cursor-public/...

There is nothing rooted at /.cursor/* in my system instructions. If your workaround was meant to surface files from the root-level /.cursor/ directory, it did not produce any visible entries in my context.

Okay and can you confirm there are rule files under the root /.cursor folder?

Yes, confirmed. There are rule files under /.cursor/rules/ — but it’s a symlink to /home/ubuntu/.agentfiles/rules/.

/.cursor/ contents

.gitignore
agent-hooks/
agents       -> /home/ubuntu/.agentfiles/agents   (symlink)
bin/
commands     -> /home/ubuntu/.agentfiles/commands  (symlink)
plugins/
projects/
rules        -> /home/ubuntu/.agentfiles/rules     (symlink)
skills       -> /home/ubuntu/.agentfiles/skills    (symlink)

/.cursor/rules/ contents (8 files)

  • [...] (here it listed my rule files correctly)

These are exactly the global rule files I noted as missing from my system context — including cloud-env.mdc and local-env.mdc (which both my workspace cloud.mdc and the inline ENVIRONMENT user_rule tell me to read first).

So: the files exist at /.cursor/rules/, but none of them are being surfaced into my system instructions. Your workaround (placing them under /.cursor/) is on disk, but Cursor is not injecting them into my context as it does for /workspace/.cursor/rules/agent.mdc and /workspace/.cursor/rules/cloud.mdc.

Related UX on the skills side (same Cloud / Agents Window):

Staff confirmed home skills are searched (~/.cursor/skills), and that works for us — we install a public skills package there and agents can run them when asked in prose.

What still fails: invoking user skills via /<skill-name> in the slash menu. / doesn’t list those skills on Cloud Agent follow-ups (known Agents Window bug class), so “skills on disk” ≠ “slash-accessible.”

Separate from ~/.cursor/rules not auto-applying (still true for us too) — just flagging that user-skill slash invoke is still broken even when the files are correctly under /home/ubuntu/.cursor/skills.

@Colin any updates?