Comparison
Frontman vs Cursor
Browser-Based vs IDE-Based AI Coding
Frontman is an open-source AI coding agent that lives in your browser. It integrates with your framework (Next.js, Astro, or Vite) as a plugin that serves an overlay UI at /frontman. A browser-side MCP server handles DOM inspection, screenshots, computed CSS, and element selection, while an Elixir/Phoenix backend orchestrates the AI agent and LLM calls. You click elements in your running app, describe changes in plain English, and Frontman edits the actual source files — with hot reload showing results instantly.
Cursor is a commercial AI-powered IDE based on VS Code. It offers tab completion, an agentic coding mode, multi-file refactoring, and a built-in terminal. It works primarily from file context — it doesn't natively see what your app renders in the browser, though it can connect to browser tools via MCP servers.
The core difference: Cursor is an AI-enhanced IDE that edits files. Frontman is a browser-based agent that edits files informed by what it sees rendered. They approach development from opposite directions — and many teams use both.
Feature Comparison
| Feature | Frontman | Cursor |
|---|---|---|
| Sees live DOM & styles | Browser-side MCP server inspects the live page | File-only context by default |
| Sees computed CSS | Runtime values, not class names | Reads source files; can extend via MCP |
| Click-to-select elements | Visual component selection | Must describe or find in file tree |
| Hot reload feedback loop | Instant in browser | Can trigger builds via agent, doesn't see browser result |
| File-based editing | Edits source files | Full file system access |
| Autocomplete | | Tab completion, inline suggestions |
| Multi-file refactoring | Can edit multiple files, but not its primary workflow | Cross-file edits, Composer, agent mode |
| Terminal integration | | Built-in terminal, agent mode, cloud agents |
| Backend coding | Can read/write any project file, but frontend-focused | Any language, any framework |
| Framework-aware | Deep plugin integration with Next.js, Astro, Vite | MCP servers, .cursorrules, project context |
| Designer/PM friendly | No IDE needed | Requires IDE proficiency |
| Open source | Apache 2.0 / AGPL-3.0 | Proprietary |
| BYOK (bring your own key) | OpenRouter, Anthropic, OpenAI | API key mode, bring your own models |
| Self-hostable | | |
| Works in the browser | No IDE required | VS Code fork |
Sees live DOM & styles
Sees computed CSS
Click-to-select elements
Hot reload feedback loop
File-based editing
Autocomplete
Multi-file refactoring
Terminal integration
Backend coding
Framework-aware
Designer/PM friendly
Open source
BYOK (bring your own key)
Self-hostable
Works in the browser
What Cursor Does Well
Cursor is a genuine productivity multiplier for developers who live in an IDE. It deserves its popularity.
Autocomplete is best-in-class. Tab completion understands your codebase, predicts multi-line edits, and learns from your patterns. For raw typing speed, nothing in this comparison comes close.
Agent mode is powerful. Cursor's agent can plan multi-step changes, run terminal commands, interpret output, and iterate on errors — all within the IDE. Cloud agents and background agents let work continue asynchronously. Frontman's AI agent is focused on browser-visible changes, not general-purpose coding workflows.
Multi-file refactoring works. Cursor's Composer and agent mode can rename a prop across 15 files, update imports, and fix type errors in one pass. Frontman can edit multiple files, but it's not its primary workflow.
Backend and general-purpose coding. Cursor handles Python, Go, Rust, SQL, infrastructure-as-code — any language, any project. Frontman is frontend-focused. It can read and write any project file, but its strengths are in visual editing where browser context matters.
Terminal integration. Cursor's terminal agent can run commands, read output, and fix errors automatically. Frontman has no terminal — it captures console logs and build errors from the dev server, but cannot run arbitrary commands.
Extensibility via MCP. Cursor supports MCP servers, allowing it to connect to external tools, databases, APIs, and even browser automation. Combined with .cursorrules for project-specific context, this makes Cursor highly customizable.
Large community and ecosystem. Cursor has millions of users, extensive documentation, and a mature extension ecosystem inherited from VS Code.
Where Frontman Is Different
Frontman exists because of a specific problem: AI coding tools don't natively see the browser. Cursor reads your JSX files, but by default it has never seen what they render. It doesn't know that your hero section overflows at 768px, that the computed font size is 18px not 16px, or that a sibling component's margin is pushing your layout. Cursor can connect to browser tools via MCP servers, but that requires setup and isn't the default workflow.
Three-part architecture. Frontman integrates with your framework (Next.js, Astro, or Vite) as a plugin that serves an overlay UI at /frontman and relays file operations to the dev server. A browser-side MCP server handles DOM inspection, screenshots, computed CSS, element selection, and device emulation. The AI agent runs on a separate Elixir/Phoenix server, orchestrating tool calls and LLM interactions. When you click a button in your running app, Frontman resolves the source location via source maps and knows exactly which file, component, and line rendered it.
Click-to-edit workflow. Instead of describing which file to open, you click the element you want to change. The AI already knows the component, its source location, its styles, and its context in the rendered page. "Make this card's shadow more subtle" works because Frontman can see the card.
Hot reload closes the feedback loop. Frontman edits actual source files, and the framework's built-in HMR handles live reloading automatically. Edit → see result → edit again happens in the browser without switching windows. No alt-tab, no manual refresh, no guessing whether the change worked.
More than just frontend. While Frontman is optimized for visual frontend editing, it can read, write, search, and grep any file in your project. It captures console logs, build errors, and can run Lighthouse audits. It's frontend-focused, not frontend-only.
Open source and BYOK. Frontman's client libraries are Apache 2.0. The server is AGPL-3.0. There are no prompt limits, no subscription fees, and no usage-based pricing. You bring your own API keys to Anthropic, OpenAI, or OpenRouter — or sign in with your Claude or ChatGPT subscription via OAuth.
Accessible to non-developers. Designers and PMs can click elements and describe changes in plain English. Changes produce real source code edits for developer review. The browser is a familiar environment — no IDE required.
Who Should Use Cursor
Cursor is the better choice when you need a full-featured IDE with AI capabilities. Specifically:
- Backend developers working in Python, Go, Rust, or any non-frontend language
- Large codebase refactoring — renaming across dozens of files, updating APIs, migrating patterns
- Agentic coding workflows — if you want the AI to plan, execute, and iterate across files and terminal
- Autocomplete-dependent workflows — if inline suggestions are core to how you code
- Full-stack work where you move between frontend and backend in the same session
- Teams standardized on VS Code — Cursor inherits the entire VS Code extension ecosystem
Who Should Use Frontman
Frontman is the better choice when browser context matters more than IDE features. Specifically:
- Frontend developers frustrated by AI breaking CSS and layout — Frontman sees computed styles, rendered output, and viewport behavior, not just class names in source files
- Teams where designers or PMs need to make UI changes — click elements, describe changes in plain English, review real code diffs
- Projects using Next.js, Astro, or Vite where deep framework plugin integration provides better context than generic file reading
- Developers who want open-source with no vendor lock-in — Apache 2.0 client libs, AGPL-3.0 server, BYOK, self-hostable
- Visual editing workflows where seeing the live result matters more than typing speed
Many developers use both. Cursor for backend, refactoring, and general-purpose coding. Frontman for visual frontend changes where the AI needs to see what's actually rendered in the browser.
For a deeper technical comparison including Claude Code, read our full comparison of Frontman, Cursor, and Claude Code. Also see: Frontman vs Stagewise for a comparison with another browser-based tool.
Pricing Comparison
Frontman
Open source, BYOK
- Always free to self-host
- Bring your own API keys (OpenRouter, Anthropic, OpenAI)
- Or sign in with Claude/ChatGPT subscription via OAuth
- Apache 2.0 (client) / AGPL-3.0 (server)
- You pay your LLM provider directly
Cursor
Freemium, proprietary
- Hobby: Free — limited agent + tab completions
- Pro: $20/mo — extended agent, unlimited tabs
- Pro+: $60/mo — 3x usage on all models
- Ultra: $200/mo — 20x usage, priority access
- Teams: $40/user/mo — shared usage, SSO
- API key mode available (full BYOK)
Frequently Asked Questions
Is Frontman an open-source alternative to Cursor?
Yes, but they work differently. Cursor is an AI-powered IDE with agent mode, autocomplete, and terminal integration. Frontman is a browser-based AI agent that integrates with your framework as a plugin and uses a browser-side MCP server to inspect the live DOM, computed CSS, and rendered output. For frontend visual editing where browser context matters, Frontman is a free open-source alternative. For general-purpose coding, backend work, or agentic IDE workflows, Cursor is the more complete tool.
Can Frontman replace Cursor?
For frontend visual editing — clicking elements, adjusting layout, fixing CSS — yes. For agentic coding workflows, autocomplete, terminal integration, or large codebase refactoring, no. Frontman can read, write, and search any file in your project, but its strengths are in browser-informed editing. Many developers use both: Cursor for backend and broad refactoring, Frontman for visual frontend changes where browser context matters.
Does Frontman work with Cursor?
Yes. You can use Cursor as your IDE for backend and general coding, and Frontman in the browser for visual frontend editing. They edit the same source files. Changes from either tool are reflected in the other through normal file watching and hot reload.
What does Frontman see that Cursor doesn't?
Frontman integrates with your framework (Next.js, Astro, or Vite) as a plugin and runs a browser-side MCP server that inspects the live DOM tree, computed CSS styles (not just class names), viewport layout and spacing, and can take screenshots and emulate different devices. The framework plugin captures console logs, build errors, and resolves source locations via source maps. Cursor reads your source files and doesn't natively see what they render — though it can connect to browser tools via MCP servers, that requires additional setup.
Is Frontman really free?
Yes — self-hosting is free forever. The client libraries are Apache 2.0 and the server is AGPL-3.0. You bring your own API keys to Anthropic, OpenAI, or OpenRouter and pay those providers directly for LLM usage. You can also sign in with your Claude or ChatGPT subscription via OAuth. Paid tiers with hosted features are coming, but the open-source core will always remain free.
Try Frontman
One command. No account. No credit card.
$ npx @frontman-ai/nextjs install Next.js $ npx @frontman-ai/vite install Vite (React, Vue, Svelte, SolidJS) $ astro add @frontman-ai/astro Astro