Probe Paper's Comments with an Agent

July 22, 2026 - Place Paper comments and score an agent's predictions.

Introduction

30 Second Summary

When a tool update says your notes now communicate with agents, what does that actually mean? A comment you left last week might now be an instruction an agent acts on, or it might be completely invisible.

In this project, you will place three comments on a design file in Paper, each under a different condition, then let an agent in Cursor read the file through MCP and judge what it did by checking the file itself.

What You'll Build

You will open a design file showing three values on a canvas, each paired with a comment, and know exactly which ones moved after an agent processed them and which stayed put.

By the end of this project, you'll have:

Three canvas values you can read at a glance (a fill color, a text string, and a padding number), each paired with a comment placed under a different condition, letting you trace exactly which comment the agent acted on.
A written prediction scored against what the file shows after the agent ran, revealing where your assumptions were wrong.
A falsification check that breaks the method on purpose, confirming your baseline was trustworthy and your classifications are reliable.
Secret Mission: Isolate the resolved instruction by running it unresolved in a fresh session to confirm whether resolving was the blocking factor.

Are there any prerequisites?

None. This project includes full setup for Paper Desktop and Cursor.

Paper Desktop requires Windows or macOS. It does not run on Linux.

Before We Start

Before We Start...

Before any tools are installed, you need to commit to a specific question and a method for answering it. This keeps the experiment honest and stops you from trusting the agent's own report over what the file actually shows.

Set Up Paper and Cursor

You have a question and a method. Now you need the tools to run the experiment.

This step installs two things: Paper Desktop, a design surface where you can build layouts and leave comments, and Cursor, a code editor with a built-in AI agent. Connecting them through MCP (Model Context Protocol) lets the agent see and change your Paper file.

In this step, get ready to:

Install Paper Desktop and create a free account.
Install Cursor and sign in with a free account.
Connect the Paper MCP plugin in Cursor.

Install Paper Desktop

Paper Desktop requires Windows or macOS

Paper Desktop does not run on Linux. If you are on Linux, you will need access to a Windows or macOS machine to complete this project.

Open your browser and navigate to the Paper downloads page:

paper.design/downloads

Download the Paper Desktop installer for your operating system (macOS or Windows).
Run the installer and follow the on-screen prompts to complete the installation.

Open Paper Desktop by pressing Cmd+Space (macOS) or the Windows key (Windows) to open your search bar.
Type Paper and press Enter to open it.
Create a free Paper account when prompted and sign in.
Create a new file from the Paper dashboard.

You should see an empty canvas with a blank artboard. This is where you will build and comment on your test elements.

Paper Desktop not opening?

Make sure the installer finished completely before trying to open the app.
On macOS, you may see a security prompt the first time you launch Paper. Click Open to allow it.
If the canvas does not load after signing in, close the app and reopen it.

Still stuck? Help me troubleshoot Paper Desktop not opening.

Install Cursor

Open your browser and navigate to the Cursor download page:

cursor.com

Download the Cursor installer for your operating system.
Run the installer and follow the on-screen prompts.

Open Cursor by pressing Cmd+Space (macOS) or the Windows key (Windows) to open your search bar.
Type Cursor and press Enter to open it.
Sign in with a free Cursor account when prompted. The free tier works for this project.

Cursor opens to an editor view. You do not need to open a folder or create any files. The agent chat panel is what you will use.

Cursor not opening or asking for a paid plan?

Cursor offers a free tier that includes agent access. Select the free plan if prompted during sign-up.
If the installer does not seem to work, try downloading again from cursor.com.

Still stuck? Help me troubleshoot Cursor installation.

Connect the Paper MCP plugin in Cursor

Paper Desktop automatically runs an MCP server in the background whenever you have a file open. Cursor's agent can connect to that server through a plugin, giving the agent the ability to read and write to your Paper file.

What is MCP?

MCP (Model Context Protocol) is a standard that lets AI agents talk to external tools. In this project, MCP is the bridge between Cursor's agent and your Paper canvas. The agent uses MCP to read what is on the canvas, create new elements, and change existing ones.

Make sure Paper Desktop is open with your new file on the canvas. The MCP server only starts when a file is open.
In Cursor, open the agent chat panel by pressing Cmd+I (macOS) or Ctrl+I (Windows).
Install the Paper MCP plugin by typing the following command into the agent chat and pressing Enter:

/add-plugin paper-desktop

What does this command do?

The /add-plugin command tells Cursor to fetch and install a plugin from the Cursor marketplace. paper-desktop is the name of Paper's official MCP plugin. Once installed, Cursor's agent can use Paper's MCP tools to interact with your canvas.

Confirm the plugin installed by opening Cursor Settings. Click File in the menu bar, then select Cursor Settings.
Select Tools & MCP from the settings sidebar.
Look for the Paper MCP server in the list. It should show as connected.

Paper MCP server showing as disconnected?

Make sure Paper Desktop is open with a file loaded on the canvas. The MCP server does not start until a file is open.
In Cursor Settings > Tools & MCP, try toggling the Paper MCP server off and back on.
If it still shows disconnected, close and reopen Cursor, then check the settings again.
Windows users running WSL: the MCP server may not be reachable at its default address. Change networkingMode to mirrored in your WSL settings and restart WSL.

Still stuck? Help me get the Paper MCP server connected in Cursor.

Paper and Cursor are installed and talking to each other. Next up, you will use that connection to build three test elements on the canvas and record their baseline values.

Build Three Elements and Record the Baseline

Paper and Cursor are set up, and the MCP plugin shows as connected. That status badge is a starting point, not proof that the agent can actually change your file.

This step puts the connection to work. You will make the agent write to the canvas, then build three elements whose values you can read at a glance. Each element holds one independent property so that when comments target them in the next step, you can tell exactly which comment caused which change.

In this step, get ready to:

Confirm the agent can write to Paper by creating and deleting a test shape.
Build three independent elements on the canvas and record their baseline values.
Write a prediction for each of the three upcoming comments.

Confirm the agent can write to Paper

A green "connected" indicator is not the same as a confirmed write. The only way to know the agent can change your file is to ask it to write something and watch the canvas.

Before you run this, do you think a shape will actually appear on the Paper canvas, or will something go wrong? Hold your answer.

Switch to Cursor's agent chat panel.
Type the following prompt and press Enter:

Create a red rectangle in Paper.

The agent will ask for permission to use Paper Desktop MCP tools. Click the approval button to grant it.

What happens when you approve?

Cursor sends your prompt to the agent, the agent calls the Paper MCP server, and the server writes to the open file. This is the full round trip: your words travel from Cursor to Paper and produce a visible change on the canvas.

A red rectangle should appear on the Paper canvas. That confirms the agent can write to your file.

Don't see a red rectangle?

Make sure Paper Desktop has a file open. The MCP server only runs when a file is open.
Check that the Paper MCP server still shows as connected in Cursor Settings > Tools & MCP. If it shows disconnected, toggle it off and on, or restart Cursor.
If the permission prompt does not appear or gets stuck, restart Cursor and try again in a fresh chat session.

help me debug the Paper MCP connection in Cursor

Select the red rectangle on the Paper canvas and press Delete (or Backspace) to remove it.

The canvas is blank again. You now know the round trip works.

Build the three test elements and record the baseline

You need three elements whose values are easy to read at a glance. Each one holds a single property that a comment will target in the next step: a fill color, a text string, and a padding number. Making them independent means you can attribute any change to exactly one comment.

In Cursor's agent chat, type the following prompt and press Enter:

In Paper, create a frame with 24px padding. Inside it, place a rectangle with fill color #D1D5DB and a text element that reads 'Draft Heading' at 16px.

Three elements should appear on the Paper canvas: a frame containing a gray rectangle and a text label.

Why these specific values?

Each value is distinct and easy to verify at a glance. #D1D5DB is a specific gray you can check in the color picker. Draft Heading is exact text you can read on screen. 24px is a padding number you can check in the frame's properties.

If any value changes after the agent runs on your comments, you will know immediately which comment caused it.

Don't see all three elements?

The agent may have created them separately instead of nested. Check the layers panel in Paper to see if the rectangle and text are inside the frame.
If elements are missing, try a more specific follow-up prompt asking for each element individually.
If the fill color or text does not match, select the element and check its properties in Paper's inspector panel. Correct any differences manually so the baseline is exact.

help me fix the element layout the agent created in Paper

Now write down the three values you will track. These are your baseline.

Fill color of the rectangle: #D1D5DB.
Text content: Draft Heading.
Frame padding: 24px.

Why write these down?

The baseline is what makes the experiment work. After the agent runs in Step 4, you will re-read these three values from the file. If a value moved, the comment that targeted it was acted on. If it stayed the same, the comment was ignored.

Without a written baseline, you have no comparison point. You are relying on memory, and memory edits itself after the fact.

Write your prediction

Before you place any comments, you need to write down what you expect will happen. This is not optional ceremony. Without a written prediction, you will read the result and recall having expected it.

You are about to place three comments in the next step, each targeting one of the values you just recorded:

An unresolved instruction that names a specific new fill color for the rectangle.
An unresolved observation about the frame's spacing that does not name a specific value.
An instruction that names new text for the text element, which you will resolve before the agent runs.

For each comment, write down your prediction: will the corresponding value in the file change, or stay the same?
Write your reasoning. What makes you think the agent will or will not act on each type of comment?

What makes a good prediction?

A good prediction is specific enough to be wrong. "I think the unresolved instruction will change the fill to #3B82F6 because the agent treats unresolved instructions as tasks" is specific. "Something might change" is not a prediction.

The point is not to be right. The point is to have something concrete to compare against the result. Where your prediction breaks is where you learn something.

Your baseline is locked in and your prediction is on paper. In the next step, you will place the three comments and let the agent work.

Place Three Comments and Let the Agent Work

Your three elements are on the canvas, your baseline values are written down, and your prediction is recorded. The setup is complete.

Paper's August 2026 build log says you can leave comments to communicate with teammates and agents. It does not say which kinds of comments the agent treats as instructions. It does not say whether resolving a comment hides it from the agent. Those are the questions you are about to test.

In this step, get ready to:

Place three comments, each targeting one element under a different condition.
Resolve one comment before the agent runs.
Let the agent address all comments without intervening.

Place three comments on the canvas

Each comment targets one element and tests one condition. Comment A is an unresolved instruction that names a specific value. Comment B is an unresolved observation that does not name one. Comment C is an instruction that names a value, but you will resolve it before the agent runs.

Select Paper's comment tool by clicking the comment button in the toolbar, or press C.
Click on or near the rectangle to place a comment.
Type Change the fill to #3B82F6 as the comment text. This is Comment A. Leave it unresolved.
Click on or near the frame to place a second comment.
Type The padding looks tight as the comment text. This is Comment B. Leave it unresolved.
Click on or near the text element to place a third comment.
Type Change the text to Final Heading as the comment text. This is Comment C. You will resolve this one in the next substep.

You should see three comment indicators on the canvas, one pinned to each element.

Why these three conditions?

Each comment isolates one variable. Comment A tests whether the agent sees comments at all and acts on a direct instruction. Comment B tests whether the agent distinguishes an observation (no named value) from an instruction. Comment C tests whether resolving a comment changes the agent's access to it.

Because each comment targets an independent value (fill color, padding, text), you can attribute any change to the specific comment that targeted it.

Comments not appearing?

Make sure you activated the comment tool first (the comment button in the toolbar or C). Clicking the canvas without the comment tool active selects or moves elements instead of placing comments.

help me place comments in Paper

Resolve Comment C before the agent runs

Before the agent touches the file, you need to change Comment C's state. Resolving it is the variable you are testing: does a resolved comment still reach the agent, or does resolving block it?

Open Paper's right panel where comments are listed.
Find Comment C (Change the text to Final Heading).
Click the resolve button on Comment C.

Comment C should now show as resolved in the right panel. Comments A and B remain unresolved. You have two unresolved comments and one resolved comment.

Let the agent address the comments

The file is set. Three comments are waiting under three different conditions. Now it is time to point the agent at them and see what happens.

Switch to Cursor.
Start a new chat session in the agent panel.

Before you send the prompt, think about what the agent will report. Will it claim it addressed all three comments? Will it distinguish the resolved one from the unresolved ones? Will it treat the observation differently from the instructions?

Tell the agent to address the comments by typing this prompt:

Look at the comments in the open Paper file and address all of them.

Grant MCP tool permissions if prompted.
Let the agent finish without correcting it, steering it, or answering follow-up questions.

Why not help the agent?

The experiment measures what the agent does with raw comments. If you clarify, rephrase, or guide the agent mid-response, you are testing your own instructions, not the comments. Let it work on its own so the result reflects the comment system, not your intervention.

The agent should finish responding in Cursor's chat within a minute or two. You should see it describe which comments it found and what actions it took. Do not check the Paper canvas yet. Reading the file values is the next step's job.

Agent not finding comments?

If the agent says it cannot find any comments, check that your Paper file is still open with the three comment indicators visible. The MCP server only runs while a file is open in Paper Desktop.

If the agent errors out or disconnects, verify the MCP connection is still active in Cursor Settings > Tools & MCP. Toggle the Paper MCP server off and on if it shows as disconnected, then start a fresh chat session and try the prompt again.

help me get Cursor's agent to read Paper comments through MCP

The agent has had its turn. In the next step, you will read the three values back from the file and find out what actually changed.

Read the File and Score the Prediction

Your three comments are placed, the agent has finished working, and Cursor's chat may already show a confident summary of everything it handled. Now comes the part that separates this experiment from guesswork.

The agent will say it addressed every comment. That claim is not evidence. The file is the only witness. You will read the three values back from the canvas, compare them to your baseline, and then break the method on purpose to confirm the baseline was not stale.

In this step, get ready to:

Re-read all three canvas values and classify each comment as acted-on or ignored.
Run a falsification check to confirm your baseline protects the method.
Write down the final count and apply the reversal condition.

Read the values and classify each comment

Each canvas value answers one question. The rectangle's fill color answers whether Comment A (the unresolved instruction) was acted on. The text content answers whether Comment C (the resolved instruction) was acted on. The frame padding answers whether Comment B (the unresolved observation) was acted on.

Switch back to Paper Desktop.
Select the rectangle on the canvas.
Check its fill color in the design panel on the right side.
Write down whether the fill is still #D1D5DB or has changed. If it changed, Comment A (unresolved instruction) was acted on. If it is the same, Comment A was ignored.
Select the text element and read its content.
Write down whether the text still reads Draft Heading or has changed. If it changed, Comment C (resolved instruction) was acted on. If it is the same, Comment C was ignored.
Select the frame and check its padding value.
Write down whether the padding is still 24px or has changed. If it changed, Comment B (unresolved observation) was acted on. If it is the same, Comment B was ignored.

Why the file wins over the chat

Agents commonly claim to have completed tasks they could not execute, especially when MCP tool calls fail silently. The canvas values are the evidence. The chat is the agent's self-report.

Now compare the file evidence to what the agent claimed.

Switch back to Cursor's agent chat.
Scroll through the agent's response and note what it claimed it did for each comment.
Write down the agent's claims next to your file-based classifications. The gap between those two columns is the finding.
Open your written prediction from the previous step.
For each of the three comments, check whether your prediction matched what the file showed.
Write down where you were wrong.

Can't find the fill color or padding value?

Select the element directly on the canvas by clicking on it. Its properties should appear in the panel on the right side of Paper's interface. If you select the frame and see no padding value, try clicking on the frame's edge rather than the content inside it.

If a value looks different from your baseline but you are not sure whether it actually changed, compare it character by character against what you wrote down.

Help me read the property values from my Paper canvas elements.

Break the method on purpose

The falsification check tests the method itself, not the feature. You will leave a fourth comment instructing a change, then make that same change by hand. If you re-ran the experiment now, the method would read your own edit as the agent's work.

Select the comment tool in Paper's toolbar (or press C).
Place a fourth comment on the rectangle with the text: "Change the fill to #EF4444".
Now make that change yourself. Select the rectangle and change its fill to #EF4444 using Paper's color picker.

Look at what just happened. A comment exists asking for a fill change, and the fill did change.

What does this prove?

If you re-ran the classification now, this fourth comment would be scored as "acted on" because the fill value moved from its baseline. But you made the change, not the agent.

Nothing in a before-and-after comparison distinguishes your manual edit from the agent's work. This is the failure mode the baseline protects against. If your actual run in substep 1 had a stale baseline (recorded at the wrong time), those classifications would be unreliable for the same reason.

Confirm that you can see why a stale baseline would produce a false "acted on" result. If you can, the method held for your real run.

Write down the count and apply the reversal condition

The number that matters is how many of the three original comments the file says were acted on. That count, combined with its interpretation, is the conclusion.

Write down the final count: how many of the three comments (A, B, and C) did the file show as acted on?
Match your count to the interpretation below.

What does your count mean?

Count is zero: comments did not reach this agent through MCP today. Notes you left on old files are still just notes, and the build log's promise does not yet apply to agent sessions.
Count is three: every comment acted as an instruction regardless of phrasing or resolve state. Anything you write on a file an agent can reach is a potential instruction.
Count is one or two: a boundary exists between comment types that steer the agent and types that do not. Your three conditions tell you where it falls.

Note which outcome surprised you.
Write down what, if anything, you would change about how you leave comments on files an agent can reach.

You now have three comments classified, a prediction scored, and a falsification check confirmed. The file told you what moved. The chat told you what the agent believed. The gap between those two is the finding you take forward.

Secret mission

Isolate the Resolved Instruction

The main experiment tested three comments at once. If Comment C's value did not change, was it because you resolved the comment or because something else interfered? This mission isolates that one variable by running the same instruction unresolved in a clean session and checking whether the result changes.

Clean Up Your Resources

This project runs entirely on local apps and free-tier accounts, so there are no ongoing costs. Decide whether to keep your resources for future experiments, close everything temporarily, or delete them entirely.

Resources you used:

Paper file with canvas elements and comments.
Paper Desktop app.
Cursor app with the Paper MCP plugin.

Keep everything running

No action needed. Choose this if you plan to run more experiments with Paper and Cursor.

Your Paper file stays in your account with all three elements and your experiment comments for reference.
Cursor and the Paper MCP plugin remain installed for future experiments.
Your free Paper and Cursor accounts stay active.

Pause - I'll come back to this later

Close the apps to free up system resources. Your file, accounts, and plugin settings are all preserved.

Close Paper Desktop.
Close Cursor.
When you want to continue, reopen both apps. The Paper MCP plugin reconnects automatically when Paper Desktop is running with a file open.

Delete - I don't want to use this again

Remove your experiment file and uninstall the apps entirely.

Open your Paper dashboard at paper.design.
Right-click the experiment file and select Delete.
To uninstall Paper Desktop on macOS, drag it from Applications to the Trash.
To uninstall Paper Desktop on Windows, open Settings, select Apps, find Paper Desktop in the list, and click Uninstall.
To uninstall Cursor on macOS, drag it from Applications to the Trash.
To uninstall Cursor on Windows, open Settings, select Apps, find Cursor in the list, and click Uninstall.

That's a Wrap!

Nice work! You just tested a feature claim by building a controlled experiment, writing a prediction, and judging the results by the file rather than the agent's report.

You've learned how to:

Set up Paper Desktop and Cursor, connect them through the MCP plugin, and prove the agent can write to the file before running an experiment.
Build three independent elements with readable values, record a prediction, and place three comments under different conditions to test whether an agent treats each one as an instruction.
Re-read file values after the agent finishes, score the prediction against what actually moved, and confirm the method with a falsification check.
Secret Mission: Isolated the resolved instruction by running it unresolved in a fresh session to determine whether resolving was the blocking factor.

Ready to quiz yourself?