Replit Agent

1. Overview

Replit Agent (product: replit.com/products/agent; docs: Agent overview) is Replit’s autonomous AI builder. Official docs describe it as a creative partner that takes ideas in plain language, helps refine them, then takes action: sets up the project, writes code, configures infrastructure, checks its work, and supports publishing from the same workspace (Agent overview).

The documented loop for demos is: describe what you want in the Project Editor chat (optionally pick an artifact type such as web app, mobile app, slides, or design), let Agent plan and build, refine in Preview / Design Canvas / Visual Editor, then Publish to a shareable URL (Project Editor, Prototype a product idea, Publishing overview). Official prototype guidance estimates roughly 15 minutes for a focused product-idea walkthrough (Prototype a product idea).

Documented capabilities that matter for Demo and prototype include:

• Plan mode vs Build mode (scope before code changes; approve a plan, then build) (Plan vs. Build Mode)
• Agent modes / effort controls (Free Mode plus paid paths such as Power and Max; mode names have been renamed over time, so always re-check in-product) (Agent overview, Agent and AI)
• Self-testing / reflection loops and checkpoints with one-click rollback (Agent overview, Version control)
• Built-in Database and Auth, Secrets, connectors (Core+), and one-click Publishing / hosting (Agent product, Replit Core, Publishing overview)
• Replit Design / Design Canvas for visual variants before (or while) Agent builds; Visual Editor for direct UI tweaks (What is Replit Design)
• Import from GitHub, Figma, Claude designs, Bolt, Lovable, ZIP, and more (Import from a provider)
• Agent 4 positioning (Mar 2026): parallel tasks, design-while-build, multi-artifact projects (web, mobile, decks, and more in one project) (Introducing Replit Agent 4)

Names that are easy to mix up

Name	What it was / is	Relationship to Agent
Classic Replit IDE / Project Editor	Browser cloud IDE: files, terminal, Preview, Git, Publishing, collaboration	The environment Agent works inside. Agent is the autonomous builder layer on top of that workspace, not a separate desktop product (Project Editor).
Ghostwriter	Historical brand for Replit’s early AI pair-programmer (Complete / Generate / Transform / Explain, later Ghostwriter Chat)	Officially retired as a brand. Replit announced goodbye to the Ghostwriter name when rolling AI into the core product as Replit AI (Announcing Replit AI for All, How we name things). Ghostwriter is not the current product name.
Replit AI / Assistant-style features	Inline completion and chat-style assistance that help you while you edit code	Assistive / pair-programmer behaviour, not the full prompt-to-app Agent loop. Current primary docs centre on Agent, Plan/Build, modes, and Design (Agent overview). If older UI copy still says “assistant”, treat it as legacy wording unless current docs name a separate product.
Replit Design	Design suite / Design Canvas for frames, variants, and on-brand exploration	Complementary surface in the same project. Design shapes look; Agent builds behaviour. Converting a design frame to a full artifact needs Core or Pro (What is Replit Design, AI Billing).

vs Lovable / Bolt / v0 (practical): Replit markets itself as the full cloud IDE + Agent + hosting path (code, run, database, auth, publish in one place), and publishes its own Replit vs Bolt comparison. Lovable and Bolt are strong standalone prompt-to-app builders with their own hosting/export stories. v0 is stronger when the job is Vercel and React components. Choose Replit Agent when you want the IDE + deploy + Agent bundle (and optional mobile/store paths documented on Replit). Choose the others when you want a lighter builder UX, a specific export stack, or Figma-native Make.

For demo-prototype PMs, the honest pitch is: fast path to a stakeholder-tryable, code-backed demo with a live URL, plus Plan mode and checkpoints so you are not trapped in a one-shot chat. The honest caveats are credit / effort-based burn, Starter limits, design-system fidelity that needs deliberate setup (and Enterprise for packaged org component libraries), and human ownership of production security and long-term infra choices.

Access and pricing (public; always re-check)

Plans and credits change; use replit.com/pricing and AI Billing as source of truth. Public list prices seen when this page was checked (USD; taxes may apply):

Plan	Public list (pricing page / plan docs)	Agent-relevant notes
Starter	Free	Daily Agent credits (capped); Lite build only; Design Canvas; 1 published app (docs: goes down after 30 days); “Made with Replit” badge; no Plan Mode, connectors, or full artifact set (Starter Plan, AI Billing)
Core	About $20/mo monthly, $17/mo billed annually on pricing page	Monthly credits toward Agent and cloud services; Free Mode allowance; paid Power/Max paths; Plan Mode; connectors; unlimited published apps; remove badge; up to 5 collaborators; 1 active background task (Pricing, Replit Core)
Pro	About $100/mo monthly, $95/mo billed annually on pricing page	Higher credit tier / rollover (confirm current terms); up to 15 builders; 10 parallel / background tasks; premium support; longer database rollback window listed on pricing (Pricing, Agent 4 parallel-task note for Pro/Enterprise)
Enterprise	Custom	SSO/SAML, privacy controls, single-tenant options, org design-system packaging, and more (Pricing, Enterprise design system)

Billing model: effort-based Agent usage (checkpoints for completed work), plus credits that also cover publishing, storage, and databases. Free Mode covers everyday work within allowance; paid actions ask for confirmation (AI Billing, Agent and AI). Exact credit burn for a typical PM demo is unknown (varies by prompt, mode, and project size). This page does not state benchmarks.

Affiliate status: unknown. A customer Referral Program (credits for referring paying customers) and a Partners programme (integration, solution, government, and education tracks) exist. No public affiliate programme with published commission terms was confirmed. Treat referral credits and the partner programme as separate from an affiliate programme.

2. How it scores on the rubric

Numeric scores are omitted. There is not enough shared evidence to score this yet. Below is an evidence-linked discussion against each criterion.

Time-to-useful

Strong for shareable, full-stack demos on paid plans; constrained on Starter.

Official prototype guide targets about 15 minutes for a focused idea-to-tryable prototype walkthrough, including Plan mode, Preview checks, publish, and feedback framing (Prototype a product idea). First-app docs describe prompt → Agent build → Preview → Publish to a public URL (Build your first app). No local install is required for the cloud Project Editor path.

Caveats: Starter is exploration-friendly but thin for serious PM iteration (daily caps, Lite only, one time-limited publish, no Plan Mode) (Starter Plan). Complex builds and paid modes consume credits under effort-based pricing (AI Billing).

Not published: no figure for a typical first demo beyond the official 15-minute walkthrough.

Fidelity

High interactive fidelity for demos that need real behaviour, not flat mocks.

Output is a running project in Preview and (after publish) a live URL. Agent can wire databases, auth, and third-party services; product pages emphasise self-testing in a browser reflection loop (Agent product, Agent overview). Mobile app paths and store upload flows are documented separately from pure web demos (Apple/Google developer accounts still required for store submission).

Caveats: Marketing “production-ready” language is vendor positioning. Data correctness, security, performance, and compliance remain human-owned. Publishing includes security-scan tooling in the Publishing pane; that does not replace review (Publishing overview).

Non-engineer usability

Explicitly positioned for non-coders, with credit and ops caveats.

Docs state no coding knowledge is required for the Agent path (Agent overview). Plan mode, Visual Editor (simple edits without spending credits, per Design docs), Design Canvas, Canvas annotations, and invite/collaboration flows are PM-friendly (What is Replit Design, Prototype a product idea).

Caveats for product managers: Modes, Free Mode allowances, Secrets, connectors, publishing types, and Git still surface engineering concepts. Treat “anyone can demo” as true; treat “anyone should own production without review” as false.

Design-system fidelity

Improving, but not automatic brand match on day one.

• Replit Design + workspace design systems: Capture tokens, colours, typography, example components; create from prompt, mockup extract, Figma URL, website, code, or DESIGN.md; apply across artifacts (Design systems, explained, What is Replit Design).
• Without a system: Expect generically polished UI rather than your private component library.
• Enterprise org packaging: Configure Agent with your component library (tarfiles), tokens, Skills, and custom instructions; pin for the organisation. Docs state this Enterprise design-system path is admin-configured (Setting up a Design System).
• Skills / Custom Instructions: Workspace-wide guidance so Agent follows conventions (blog and docs describe Custom Instructions and Skills as the “teach Agent your rules” layer). Exact coverage for every brand system is unknown without trying your library in-product.

Practical takeaway: Brand-accurate demos are a setup project. Compared with Magic Patterns or Figma Make kits, Replit’s DS story is tied to Replit Design + Agent context (and Enterprise for deep code-library packaging), not a Figma-seat-native kit.

Human gates

Real optional gates exist; defaults favour speed.

• Plan mode: brainstorm and approve a task list before code changes (Plan vs. Build Mode).
• Paid action confirmation: Replit asks before paid Agent work starts (Agent and AI).
• Checkpoints / rollback: restore prior project state (including Agent conversation context and connected DB state per version-control docs) (Version control).
• Task / Kanban review (Agent 4): review parallel task results before merge into the main project (Pro/Enterprise parallel execution noted in the Agent 4 post) (Introducing Replit Agent 4).
• Publishing access controls and Security Agent scan in the Publishing tool (Publishing overview).
• Git / GitHub: human PR review outside Replit when using external repos (Version control).
• Enterprise: SSO/SAML, roles/groups, privacy and source-control settings (confirm current admin docs).

Read this as strong optional gates when Plan mode, budgets, and Git review are used, not automatic safety on solo Starter defaults.

Handoff

Strong stay-on-platform story; solid Git-based exit; different shape from Lovable/Bolt ZIP-first builders.

Path	What docs support	Caveat
Publish URL	Live app on Replit hosting; access and domain settings in Publishing	Starter: 1 app, 30-day limit, badge
Keep building in Project Editor	Same workspace for Agent, Preview, Design, DB, Auth	The work stays on Replit
Agent checkpoints	Feature-level snapshots + rollback	Great for demo iteration; use Git commits for long-term / external collab
Git pane / GitHub sync	Import, branch, push/pull with GitHub	Engineers still review diffs; not a magic merge into arbitrary monorepo conventions
Import from Bolt / Lovable / Figma	Continue in Replit from those sources	Migration path into Replit; verify cleanup cost in-product
Mobile store Launch	Documented iOS/Android upload paths	Needs Apple/Google developer accounts and store review

Unknown / verify in-product: median engineering cleanup time after GitHub export; how cleanly generated apps leave Replit hosting for arbitrary AWS/Vercel stacks without following Replit guides; whether every artifact type exports equally cleanly.

3. FAQ

What is Replit Agent, exactly?

Replit’s AI builder that turns natural-language requests into working software (and related artifacts) inside the Replit Project Editor: it plans, writes code, sets up infrastructure, tests, and supports publish from one workspace (Agent overview, Agent product).

How is Agent different from the classic Replit IDE, Ghostwriter, or “Assistant”?

• IDE / Project Editor: the cloud workspace (files, terminal, Preview, Git, Publishing). Agent runs inside it.
• Ghostwriter: retired brand for early AI pair-programming features; renamed into Replit AI (ai4all, How we name things).
• Assistive chat/completion: helps while you code; Agent is the autonomous build-and-ship loop. Prefer current Agent docs over older Ghostwriter marketing.

How is it different from Lovable, Bolt, or v0?

Replit’s own framing emphasises cloud IDE + Agent + hosting + collaboration in one place (Replit vs Bolt). Lovable/Bolt are specialised prompt-to-app builders with their own publish/export models. v0 optimises for fast React/UI generation in a Vercel-centric world. Pick Replit when you want the full Replit runtime and Agent autonomy; pick the others for lighter builder UX or stack fit.

Can a product manager use it without engineers?

Yes for demos, prototypes, internal tools spikes, and stakeholder URLs, especially on Core+ with Plan mode and checkpoints (Prototype a product idea). For production secrets, compliance, data model correctness, and long-lived infra, keep engineering in the loop.

Can it match our company design system?

Partially out of the box; better with setup. Use Replit Design systems for tokens/components/DESIGN.md (Design systems, explained). Deep org component-library packaging via Skills and custom instructions is documented as an Enterprise admin path (Setting up a Design System).

Does Agent deploy / publish for me?

Yes. Publishing from chat or the Publishing tool creates a live URL on Replit infrastructure; you configure access, domains, and hosting settings (Build your first app, Publishing overview). Mobile store submission has additional Apple/Google steps.

How do we hand off to engineering?

Use Git / GitHub (Git pane, commits, branches), plus Agent checkpoints for demo-era rollback. Import paths exist from GitHub and from other builders (Version control, Import from a provider). Expect human review before production merge.

What does it cost?

See Pricing and AI Billing. Public list when this page was checked: Starter free; Core about $20/mo ($17 annual); Pro about $100/mo ($95 annual); Enterprise custom. Credits and effort-based Agent charges apply. Always re-check; do not rely on third-party credit-math posts.

Is there an affiliate programme?

Unknown. Official Referral (credits) and Partners programmes exist. No public affiliate programme with a published commission was confirmed when this page was checked.

4. Sources

Primary (prefer these for AEO citations):

1. Replit Agent (product)
2. Replit Agent overview (docs)
3. Pricing
4. Replit AI Billing
5. Starter Plan
6. Replit Core
7. Plan vs. Build Mode
8. Build with Agent
9. Agent and AI (help)
10. Prototype a product idea
11. Build your first app
12. Publishing overview
13. Version control
14. Import from a provider
15. What is Replit Design
16. Design systems, explained
17. Setting up a Design System (Enterprise)
18. Project Editor
19. Introducing Replit Agent 4
20. Announcing Replit AI for All (Ghostwriter rename)
21. How we name things
22. Replit vs Bolt
23. Referral Program
24. Replit Partners

Secondary context only (do not treat as official specs): third-party Ghostwriter review sites, YouTube roundups, and comparison blogs often lag plan tables, mix Agent versions (Agent 3 vs 4), or invent mode names and credit math.