On your machine
Free and open source
Run npx notato next to your app. Notes, the board and your agent's tools stay on your computer. No account to make and no server to look after.
For coding agents Figma-style comments for the web and mobile apps you're building
Click anything in your running app, in a browser or on a phone, and say what's wrong. Notato hands the note to your coding agent with a screenshot, the component, and the file and line it was written at. The agent makes the change, commits it, and the pin turns green. Or a developer picks it up from the board. Start locally for free, or run the full server for shared workspaces, tool connections and background workflows.
npm i -D notato @notato/react
Nothing to sign up for: Notato works fully on your machine, and it is all open source. Or try it on this page.
Works with Claude Code Codex Cursor Gemini CLI Copilot any MCP client
Runs in React Angular any web page SwiftUI Jetpack Compose .NET MAUI React Native Flutter
section#loop
Every note is an annotation: an element, what you said about it, and screenshots. Nothing is recorded between notes, so there's no analytics and no session replay to worry about.
Press Alt Shift A and click an element. You can also select text, drag over an area, or Ctrl-click several things at once.
Write the note. Say if it's a fix, a change, a question, an approval or a request for variants, and how much it matters.
The note reaches your coding agent over MCP with the screenshots, the component path, and the file, line and column.
The agent acknowledges it, makes the smallest change, commits it on its own and resolves it. One commit per note keeps every undo clean.
3 Cyan means you picked a variant and the agent is tidying up. A struck-through pin was dismissed.
section#run
The same toolbar, board and agent tools everywhere. What changes is where Notato runs and who looks after it.
Free and open source
Run npx notato next to your app. Notes, the board and your agent's tools stay on your computer. No account to make and no server to look after.
Free and open source · Docker Compose
Run the full server where other people can reach it: accounts and invitations, shared workspaces, pull request reviews and tool connections. It uses your own Postgres, storage and email, and one command brings it all up.
Self-hosting guideOnly need testers to send you notes, without accounts? npx notato serve is a smaller shared server that uses project tokens. See Testers and servers.
| On your machine | For a team or testers | |
|---|---|---|
| Best for | Building and checking your own app | Several people, or testers outside your team |
| Who can use it | Just you | People you invite, in shared workspaces |
| Sign-in | None | Email and password, with optional two-factor |
| Where your notes live | A folder on your computer | Your own Postgres and storage bucket |
| What you run | npx notato | One Docker Compose file |
| Capture, board and agent tools | Included | Included |
| Webhooks to Slack, Discord, Teams or your own service | Yes, set up with npx notato config webhook | Yes, set up from the board |
| Connections to GitHub, GitLab, Azure DevOps, Linear, Slack and Teams | Not available | Yes, with your own credentials |
| Pull request reviews | Not available | Yes |
Every part is MIT licensed: the SDKs, the command line, the servers and the board. Nothing here needs an account with us or a subscription.
section#self-host
The full server is the same open source project: a shared home for the feedback loop that you run yourself. Start it with one command, then swap any part for something you already have.
Accounts, workspaces and invitations, with project history everyone on the team can see. Registration is invitation-only by default, and two-factor sign-in is optional.
Feedback you capture while building stays personal to your checkout and agent. Feedback from testers lands in a shared inbox and is assigned before an agent acts on it.
Open a review for a pull request and its running preview. Feedback is tied to the exact commit, and a summary goes back to GitHub only after you have previewed and confirmed it.
Docker Compose brings up Postgres, private screenshot storage and a test inbox. Use your own Postgres, an S3, R2 or B2 bucket, and your own email provider instead, behind Caddy, nginx or a Cloudflare Tunnel.
Tool connections use your own provider credentials. Check each one against the real service before you rely on it.
section#start
This is the whole local setup. It needs no account, no subscription and no network service of ours.
npm i -D notato @notato/reactInstall the CLI and the React SDK.
npx notato initAdds <Notato /> behind a dev-only guard, then sets up your agents: the MCP server and the skills, for Claude Code, Codex, Cursor, Gemini CLI or Copilot. --revert takes it all back out.
npm run devStart your app as usual.
npx notato doctorChecks the whole loop, including that a page is connected.
Building a phone app? Run npx notato, then add the SwiftUI, Android or .NET MAUI SDK with one line at start-up.
Setup guides
“watch Notato and fix what comes in”
section#showcase
Each of these is the real behaviour, acted out with the real markup and data shapes. Click around.
Every note can carry an intent, and the agent acts on it. A question gets an answer and no edit.
AlexThe total doesn't change when I remove an item
ClauderemoveItem never recalculated the total. Fixed in Basket.tsx:44, committed 9e1c0d2 on its own, resolved.
Ask for variants and the agent writes each one into your code. Switch between them in the running page, then keep one.
Any note can be written out as Markdown at four levels, for an agent, an issue or a pull request. This is the real renderer's output for the note in the demo above.
Pause freezes CSS and Web Animations mid-flight, so you can annotate a frame that only exists for 200ms. The note records how far through each one was.
Animations: running
Ask the agent to undo a change. It knows which files and which commit, because it recorded them when it resolved the note.
Made the pay button green and renamed it.
Every reply reaches the agent, even on a note that's already done, with nothing to tag. Send a reply as an aside, or mark a whole note People only, and it stays between people.
Passwords are always masked in screenshots. In test and agent mode every input is. Mark anything else private and its pixels and text stay out.
data-notato-maskThe notato-critique skill has the agent open your app in a browser it can drive, use it like a careful reviewer, and file the things that matter most as notes. Then it works through them.
Same-origin iframes, open shadow roots and portals all work. The note says how to get there.
iframe#preview >>> my-widget >>> button.pay
section#apps
SDKs for SwiftUI, Jetpack Compose and Views, .NET MAUI, React Native and Flutter put the same toolbar in your iOS and Android apps. Tap an element, write a note, and your agent gets the screenshot and the file and line it was written at, just as it does on the web. Same server, same board, same agent loop.
.notato("ProductRow") marks where a view is written. The compiler fills in the file and line, so there is nothing to keep in stepNotato.start out of a build and it ships nothingimport Notato
@main
struct ShopApp: App {
init() {
#if DEBUG
Notato.start(NotatoConfiguration(project: "spudshop-ios"))
#endif
}
var body: some Scene { WindowGroup { RootView() } }
}
dependencies {
debugImplementation("dev.notato:notato-compose:0.3.0")
}
class ShopApp : Application() {
override fun onCreate() {
super.onCreate()
Notato.start(this, NotatoConfig(project = "spudshop-android"))
}
}
appsettings.jsonusing Notato.Maui;
var builder = MauiApp.CreateBuilder();
builder.UseMauiApp<App>();
#if DEBUG
builder.UseNotato(options => options.Project = "spudshop-app");
#endif
<NotatoMask> keeps a view's pixels and text out of notes. In a release build <Notato> is your app and nothing elseimport { Notato } from "@notato/react-native"
import { expoStorage } from "@notato/react-native/expo"
export default function App() {
return (
<Notato project="spudshop-rn" storage={expoStorage}>
<Navigation />
</Notato>
)
}
NotatoMask keeps a widget's pixels and text out of notes. In a release build Notato is your app and nothing elseimport 'package:notato/notato.dart';
void main() {
runApp(const Notato(project: 'spudshop-flutter', child: ShopApp()));
}
What your agent gets
npx notato --tunnel puts the server on your machine behind a dev tunnel that only answers with the device's token. The simulator and emulator use localhost.
A note made while the server can't be reached is kept on the device and sent as soon as it can be.
Recent Logger and os_log messages, logcat warnings, the MAUI app's log, or React Native's and Flutter's warnings and errors come with every note.
Password fields are always covered. .notatoMask(), Modifier.notatoMask(), Feedback.Mask and NotatoMask hide anything else, pixels and text.
In test mode notes stay on the phone, then go out as a zip through the share sheet, ready for your agent to import.
Drag the bar anywhere, fold it into the potato, or hide it from its menu. Turn Notato on and off from your own settings screen.
Pick things inside modal pages, sheets, full-screen dialogs and lazy lists. The note says which screen it was on.
#if DEBUG, a debugImplementation dependency or a Debug-only package ships none of it, and in React Native and Flutter a release build draws only your app.
section#everywhere
React and Angular apps get an SDK, and any other app can start the toolbar itself. A page you didn't build gets a bookmark or the Chrome extension, with nothing to install in it. The same server and MCP tools are behind all of them, and behind the phone apps above.
init edits Vite and Next.js apps for you, in your project's own code styleimport { Notato } from "@notato/react"
{import.meta.env.DEV && (
<Notato mode="dev" project="spudshop" server="http://localhost:4747" />
)}
provideNotato() in the app config. It starts only in development builds, and production never loads the toolbarimport { provideNotato } from "@notato/angular"
export const appConfig: ApplicationConfig = {
providers: [provideNotato({ project: "spudshop" })],
}
npx notato
npx notato inject # prints the bookmark page, a console line and a script tag
bun run build:extension
# chrome://extensions › Developer mode › Load unpacked › packages/extension/dist
section#modes
The same toolbar runs in three modes. What changes is who is annotating and where the notes go.
dev You, while you buildNotes go live to a local server on your machine. Your agent reads them over MCP and works through them as they come in.
<Notato mode="dev" project="spudshop" />
test Testers, anywhereTesters annotate, then choose Download zip in the toolbar's Export menu. They get a zip with every note in order and its screenshots. Hand it to your agent, or post it to a shared server.
<Notato mode="test" project="spudshop" />
agent An AI driving the browserPlaywright, Chrome DevTools or an agent's own browser call the page API. The agent's notes go through the same pipeline as yours, with the steps it took.
await window.__notato.annotate({ target: "#pay", comment: "No loading state" })
section#board
The server has its own board, for the developers. One server holds many projects: an inbox for each, a timeline of what was said, and an overview of what's left. Agents and people work the same notes, and it updates as things happen.
Webhooks send each change to Slack, Discord, a Teams workflow, or your own service as signed JSON. Set them up and test them from the board, with a preview of exactly what will be sent.
section#agents
Notato is an MCP server and two Agent Skills, so it works with any coding agent that speaks MCP. npx notato init finds the ones you use and sets up each one. Notato never edits your code: the agent does the work.
claude mcp add notato -- npx notato dev.claude/skills/codex mcp add notato -- npx notato dev.agents/skills/.cursor/mcp.json.agents/skills/.gemini/settings.json.agents/skills/.vscode/mcp.json.github/skills/npx notato dev as a stdio server.agents/skills/notatoPick them yourself with npx notato init --agent codex,cursor, or --agent all. Replies are signed with the agent's own name, and the toolbar says who it is asking: Ask Codex to revert. No agent at all? Notes still land on the board, and webhooks tell your team.
notatoThe loop: make the smallest change, commit each fix on its own with only its own files, resolve with the files and the commit, answer questions without editing, and undo a change when asked.
notato-critiqueThe agent reviews the running app itself, files the five to eight things that matter most, then works through them.
Call them by name (/notato in Claude Code, $notato in Codex) or just ask: "watch Notato and fix what comes in". A second agent session attaches to the first one's server, and takes over if it goes away.
section#try
This button loads the real Notato toolbar onto this page. It runs in test mode with no server, so your notes stay in this browser. Open Export and choose Download zip for the zip a tester would send.
Agents, replies, variants and reverts need a server on the other end. On your own machine that's npx notato.
section#faq
No. The toolbar, the SDKs, your agent's tools and the board all work on your machine. A server is for sharing with testers and teammates.
Yes. The SDKs, the command line, both servers and the board are MIT licensed, and the source is on GitHub.
Not at the moment. You run Notato yourself, locally or on a server, and your notes stay with you.
On your machine, or on your server: notes in a local database or your Postgres, screenshots in files or your own S3-compatible bucket. Notato sends nothing anywhere else unless you configure an integration.
Yes. The Docker Compose setup runs all three for you, and each can be replaced by what you already run. The self-hosting guide has the settings and examples.
Both use the same toolbar and the same agent tools. Pick where Notato runs.