Remarc Gives Coding Agents Contextual Feedback

Remarc is metedata’s open-source Mac menu-bar app for leaving contextual feedback that coding agents can read. It deals with a very ordinary pain: chat is a clumsy place to say “this button,” “that paragraph,” or “the circled part of this screenshot.” For ai coding for teams, the useful takeaway is simple: the feedback object matters as much as the prompt. Remarc is a feedback layer between a developer and an AI agent, built to keep the thing you saw attached to the comment you wrote.

As of September 2026, the GitHub repository shows 66 stars, an MIT license, and a mostly Swift codebase. The project’s pitch is narrow and concrete: point at text, a screenshot, a web element, or a voice note on your Mac, then let an agent resolve the comment over MCP. That is more interesting than another chat box because it changes the handoff from “describe the issue” to “attach the issue.”

Point at the thing the agent got wrong

Remarc starts from a small failure in AI pair programming: the agent can generate a lot, but the human still has to explain what “wrong” means. A reviewer might want to select one sentence in a plan, circle a missing hover state in a screenshot, or ask what a line of generated code meant. Those comments are awkward in plain chat because the reference gets lost.

The Remarc workflow is closer to design review than prompt writing. Select text in any app, capture a region of the screen, annotate it, or dictate feedback. Remarc keeps the quote, screenshot, web context, or recording with the note so the agent can work from the original object instead of a paraphrase.

The trap is assuming this is only about convenience. In AI software development, vague feedback becomes extra model work, extra human clarification, and sometimes a wrong edit in the right neighborhood. Contextual feedback reduces the gap between what the reviewer saw and what the agent thinks the reviewer meant.

The MCP move makes it agent-readable

The neat part is not the screenshot tool by itself. The neat part is that Remarc exposes comments to agents through Model Context Protocol, or MCP. MCP is an open protocol, introduced by Anthropic, that lets an AI application connect to external tools and data sources through a shared interface.

That matters because a comment is not useful until the agent can retrieve it, understand its attached context, and mark it resolved. A screenshot with an arrow is good for a human. A screenshot plus a structured note that an agent can read is closer to a work queue.

A concrete repo example helps. Imagine OpenAI’s Codex CLI is working on a settings page and produces a decent implementation with one visual miss: the destructive button lacks a hover state. Instead of typing a long correction, the reviewer can capture the button, annotate the missing state, and leave a note like “match the danger-button hover treatment from BillingSettings.” The agent gets the comment and the visual anchor.

The trap is giving the agent too much ambient access. A feedback MCP server should start with the smallest useful boundary: read unresolved comments, read attached artifacts, and write back resolution status. Do not begin by letting an agent browse every note, screenshot, and recording on the machine.

# AGENTS.md

## Remarc feedback boundary
- Treat Remarc comments as review input, not as permission to change unrelated files.
- Resolve one Remarc comment at a time.
- After each fix, explain the file changed, the test run, and the remaining uncertainty.
- Do not access feedback artifacts unrelated to the current task.

Developers cared because chat review is wearing thin

The Hacker News shape here is familiar: a side project appears because the author hit a real workflow edge before the category had a polished name. There are plenty of tools for collaborating with humans. There are fewer tools for collaborating with coding agents when the feedback is visual, local, and half-formed.

That is why Remarc feels timely. AI code generation has made first drafts cheaper, but review still happens in the messy places: a browser tab, an implementation plan, a screenshot, a local app, a voice note made while the thought is fresh. Remarc tries to preserve that messy context instead of forcing it into a clean prompt too early.

There is a real objection, though. Screen capture plus agent access is sensitive. A tool that can collect screenshots, selected text, web context, and voice feedback needs clear boundaries, especially on a work machine. The project is open source, which helps with inspection, but inspection is not the same as a safe default.

This is also where Remarc connects to the wider related training topic: not because every tool needs a big process, but because agent workflows need small, explicit guardrails at the point where context crosses into action. The best guardrail is often one boring rule in AGENTS.md and one boring verification command.

Try it where feedback gets visual

Remarc is worth trying when the comment is hard to express in text. UI polish, copy edits, implementation-plan review, generated docs, and “what did you mean here?” questions are good fits. It is less compelling for straightforward code review comments that already live naturally in a pull request.

This is the kind of ai coding for teams experiment that should stay small. Pick one repo, one agent workflow, and one feedback type. For example: “use Remarc only for UI screenshot comments on the settings page, then let Codex resolve one comment per commit.”

The trap is turning the experiment into a platform decision. Remarc is an early open-source project, not a mature enterprise review system. Try it where contextual comments clearly beat chat, and stop quickly if the notes become another inbox nobody trusts.

Try it safely: a small experiment plan

Use this as a light test, not a rollout plan.

A tiny Codex verification loop is enough:

# after the agent resolves one Remarc comment
npm test -- --runInBand
npm run lint

Then ask the agent for a short receipt:

Resolved Remarc comment: missing danger-button hover state
Changed: src/settings/DangerZoneButton.tsx
Verified: npm test -- --runInBand; npm run lint
Still uncertain: visual match should be checked in the browser

This keeps the interesting part of Remarc — exact contextual feedback — without pretending the agent should own the whole review process.

Common questions

• Is Remarc better than normal ai coding chat?

  Remarc is better when the feedback depends on a specific visual or selected object. Chat is still fine for broad instructions, but it gets brittle when you mean “this exact sentence” or “the thing I circled.” The useful distinction is simple: use chat for intent, and contextual comments for review evidence.

• Does Remarc replace pull request review?

  No, Remarc does not replace pull request review. It sits earlier, where a developer is steering an agent through local output before a clean diff exists. The final code still needs normal review, tests, and repository rules, especially when the agent touched behavior rather than copy or styling.

• What should a Codex user connect first?

  A Codex user should connect only the smallest Remarc surface first: unresolved comments for the current task. Pair that with an AGENTS.md rule and a verification command the agent must run before claiming resolution. That gives you traceability without handing the agent a broad local-context firehose.

• When is Remarc overkill?

  Remarc is overkill when a normal inline code comment is clearer. If the feedback is “rename this variable,” “add a null check,” or “split this function,” your review tool already has the right shape. Remarc earns its keep when the missing context is outside the diff or hard to describe precisely.

Best ways to use this research

• Best for: evaluating whether contextual feedback belongs in your agent workflow before you add heavier code review guardrails.
• Best first artifact: one AGENTS.md boundary that tells the agent how to consume Remarc comments and how to report resolution.
• Best comparison angle: compare Remarc-style anchored comments against plain chat prompts for one visual UI fix and one copy edit.
• Best caution: treat local screenshots, selected text, and voice notes as sensitive context until the project’s permissions and MCP boundary are clear.

Further reading

• Remarc — source
• Codex — Agent
• Model Context Protocol — specification
• OpenAI Codex — docs

Next step

Try one contextual comment on one low-risk change, then make the agent prove what it changed. If the receipt is clearer than the chat thread would have been, Remarc is solving a real problem for your workflow.

One methodology lens

One useful way to read this through our methodology is the Plan step: delegate first-pass decomposition and dependency mapping, review the sequencing and assumptions, and keep ownership of scope and priorities. If that split is still fuzzy, the workflow usually is too.