Runable is a general-purpose AI agent for turning a plain-language brief into websites, slides, reports, media, spreadsheets, and other deliverables. Its separate Agent, Chat, and Plan modes help match execution, analysis, or approval-first planning to the job.
Used this tool? Rate it
Used this tool? Rate it
Runable is a general-purpose AI agent for moving from a plain-language outcome to finished work. It is not only a question-and-answer interface: the product positions its Agent Mode as the place where an agent can create artifacts, write code, work with files, and carry a job through several steps. The current product surface covers websites, presentations, reports, images, videos, spreadsheets and related visual or document work.
That breadth is useful only when the interface makes a hard job easier rather than merely bundling many generators. Runable's central design choice is to separate the kind of request before it starts: Agent Mode is for making or executing, Chat Mode is for text conversation and analysis, and Plan Mode is for research and a reviewed plan before execution. The distinction is important. A request for a production website with payments needs a different degree of review than a request to explain a document.
For a prospective user, the most useful way to think about Runable is as a task workspace with an agent at the center. You describe a result, provide context or files, choose a mode, review what the agent shows, and keep refining. It is not a promise that every output is production-ready; it is a framework for making the building and review loop more explicit.
The official guide names websites, slides, images, videos, reports, and spreadsheets as commonly used outputs. That makes the best-fit task one with a concrete artifact at the end, not a vague request to "do AI."
Runable does not remove the need for a human owner. You still need to supply the purpose, check factual material, decide whether an output is acceptable, and approve a plan or a deployment when the work has real consequences. This page therefore treats it as an assisted work system, not an autonomous substitute for subject-matter review.
Runable separates Agent Mode, Chat Mode, and Plan Mode rather than treating every prompt as the same kind of job. Choose the mode that fits the level of review and the kind of result you need, and confirm the current product documentation before relying on a particular action or limit.
This is the mode to select when the result must become an artifact: a landing page, a deck, an analysis report, a spreadsheet model, an image set, or a video draft. The sensible first prompt defines the output, audience, key constraints and source material. A request such as “make a website” gives the agent too much latitude; a request that specifies the users, pages, data needed, visual constraints and success condition gives you something reviewable.
Chat Mode is intended for questions and analysis. If you only need an explanation or a document review, keep the scope narrow and confirm the current mode behaviour in the product before starting work.
Plan Mode is designed for planning before a more consequential piece of work. Treat the plan as a review artifact: use it to surface assumptions, scope and verification expectations before you rely on a result.
Runable says Plan Mode researches the request, asks clarifying questions, writes a detailed plan, and waits for user approval before it starts executing. That documented sequence is useful when the project owner needs a review point before a consequential build begins.
For a project with authentication, payments, a database, multiple integrations, or a consequential public launch, this is the mode worth choosing. The review point lets you correct assumptions before code, assets, or configurations are made. It does not make a plan automatically correct, but it gives the project owner a clear moment to decide whether scope, order and verification are appropriate.
Runable says every Agent Mode conversation runs in a private sandbox: an isolated environment where the agent can write code, run commands, install packages, and build projects without affecting the user's computer or another person's work. Keep the conversation focused on one reviewable goal so that the work remains easier to inspect.
That persistence helps with iterative work. A website can move from scaffold to preview to revision without asking you to upload the project each time. It also explains why a chat should have a coherent goal: mixing unrelated experiments into one conversation makes its working context harder to review.
Runable says an inactive sandbox pauses after 45 minutes and resumes where it left off when the next message arrives. It also says that when you roll back to a previous message, the sandbox is restored from that message's saved snapshot. Keep important decisions, source material and review checkpoints visible in the conversation before relying on a resumed task.
Do not interpret a workspace label as a blanket data-handling promise. Before providing confidential material, review the current privacy policy, data classification rules and applicable contractual requirements.
For a website project, define the intended pages, data boundaries, release owner and acceptance checks before beginning. Runable's AI Websites documentation says every website includes a database, file storage, payment processing, custom-domain support, and analytics. Those components still need project-specific configuration and review.
This workflow is attractive for prototypes, internal tools, landing pages and small customer-facing applications because it keeps design discussion and implementation in one conversation. But it should not be confused with a hands-off production engineering process. Review authentication, payment behavior, legal copy, data retention, environment variables and domain configuration before clicking Deploy.
Runable documents a workflow that scaffolds a React plus Vite project, writes frontend and backend code, sets up the database, and starts a live preview. The site goes live only when the user clicks Deploy. Website capabilities must still be configured and tested for the particular project; do not treat a generated site as secure or compliant by default.
Runable documents an option to export generated website code to a GitHub repository. If a team moves generated work into its own development process, review the resulting files, secret handling, deployment configuration and destination before treating it as a contribution. The same review standard should apply to any externally generated code.
For slides, the documented choices are HTML or Image, Professional or Visual, a 4–24-slide range, and PDF or PPTX export. Select a format based on the editing and presentation needs of the team, then verify the current editing behaviour in the product before committing to a delivery.
That constraint suggests a simple decision rule. Choose HTML when a team expects to fine-tune layout and wording in the deck. Choose Image when visual treatment matters more than direct object-level editing. For either route, write down the audience, takeaway, tone, required evidence and slide count before generating. A deck with a clear decision to support is easier to evaluate than a generic “presentation about” topic.
Runable documents that the chosen HTML or Image format cannot be switched after generation, and that animations, transitions, speaker notes, and drag-to-reorder are unavailable. If any of those are essential, validate the current product behaviour early and plan a second editing tool if needed.
Reports and other structured materials are useful starting points for analysis and communication, but their citations, numbers and conclusions still require subject-matter verification. Before a financial, operational, or public decision relies on a draft, compare its substantive statements with the source material and the team's own acceptance criteria.
Visual material is most useful when it serves a larger deliverable, such as a product page, slide deck, campaign brief, or report, rather than becoming an isolated prompt result.
For a marketing task, a disciplined flow is to agree the message first, use Agent or Plan Mode to collect context, create a small number of visual directions, review them for brand and rights issues, and only then use the selected direction in a larger artifact. This reduces the common failure mode where a polished image arrives before anyone has decided what the page or campaign needs to say.
Visual material can look finished while still being unsuitable for publication. Check claims, logos, people, source rights, regional requirements, and any altered or synthetic depiction before release. A draft or supplied asset is not automatically cleared for every context.
State the intended user, artifact, decision or action it should support, and what inputs are authoritative. “Draft a six-slide internal launch update from these notes” is more controllable than “make an update.” For a website, include pages, call to action, content source, data fields and constraints.
Use Chat Mode for an answer or analysis only. Use Agent Mode for an artifact or a multi-step build. Use Plan Mode when wrong assumptions would be expensive, especially around authentication, payments, databases, or a public launch. The distinction helps the team establish the right review point before proceeding.
Make the first upload set coherent: source copy, a brand guide, an approved example, and a data file are more useful than a folder of unrelated references. Confirm current upload limits and supported material types in the product documentation, then prioritise the authoritative version rather than uploading duplicates.
For a plan, check scope, unaddressed risks, what must be manually verified and recovery expectations. For media or slides, check audience, factual claims, visual consistency, accessibility and delivery requirements. For code, inspect dependencies, secrets and the project’s own review requirements.
Use the existing artifact as the reference and change one meaningful dimension at a time: audience, evidence, structure, visual treatment, interaction, or deployment configuration. A vague “make it better” request makes it hard to know what changed or why.
Preview a website before Deploy, open exported slides before presenting, inspect supplied data and written conclusions, and review content before publishing. The product can accelerate construction, but the ownership of a public, financial, legal, or customer-facing result remains with the person or team that releases it.
Runable documents a limit of 10 files per chat message and 25 MB per file. It says Agent Mode accepts all file types, while Chat Mode accepts PNG, JPG, JPEG images and PDFs only. Keep the upload set coherent and do not treat a conversation as a bulk archive.
These limits have workflow consequences. Break a large project into intentional stages rather than using the chat as a bulk archive. Label versions clearly, remove confidential data that is not necessary for the task, and do not assume a large language or media model can infer which of several near-identical files is authoritative.
The pricing page currently lists Free at $0, Pro at $20 per month, and Max at $100 per month. The page also displays different credit allowances for each tier, including daily credits on Free and higher monthly allowances on paid tiers. Pricing and credits are product details that can change, so consult the live pricing page before a purchase rather than relying on this summary.
Runable's FAQ says daily free credits reset, unused daily credits do not carry over, paid users can buy one-time top-ups or enable auto-refill, and subscriptions renew unless cancelled. The practical implication is that a casual test can use the free tier, but a production schedule should track usage, renewal and refill settings deliberately. Do not enable auto-refill on a shared account without agreeing a spending owner and limit.
Runable's homepage advertises availability on iPhone, Android, and Mac. Availability alone does not establish feature parity between devices; for a complex build or a file-heavy review, verify the current client support and use the surface that gives the project owner the clearest view of the output and controls.
Before including company data in a task, check the current privacy policy, the organisation's data classification rules, retention requirements, and contractual terms. A workspace label or a claimed isolation boundary is not a substitute for that review.
Runable's privacy policy says integration data may be sent to its subprocessors, including infrastructure and AI service providers, to generate the response or deliverable requested by the user. The same policy says each Workspace service is optional, enabled individually and requested incrementally at a read-only or full access level. Review the permission scope before connecting a service.
Use the minimum data necessary for the task and review the handling of sensitive customer, health, employment, and financial information before providing it. Do not put such data into a creative prompt merely because a tool can process it.
Before you distribute a site, slide deck, report, image or video, confirm that you have permission for source material, that generated claims were reviewed, that third-party brand or person references are appropriate, and that the target channel permits the chosen media. These are release responsibilities, not product features.
The clearest constraints are those Runable publishes, but mode behaviour and presentation features should be checked in the current product documentation for the task at hand. A workspace can help make work more controlled; it does not guarantee that a result is correct.
More generally, AI-generated artifacts are drafts until validated. A plan can miss a business requirement, a web result can need security review, a report can misread a source, and a presentation can need editorial work. Use the different modes to improve control, but do not turn mode selection into a claim of guaranteed correctness.
Compare Runable with a single-purpose website builder when your output is primarily an application; compare it with a presentation tool when slides are the only deliverable; and compare it with an AI chat product when you need analysis without an artifact. The strongest reason to choose Runable is not that it replaces every specialist. It is that a broader task can keep research, planning, construction and iteration in one agent-centered workspace.
When evaluating alternatives, test the same brief with the same source material. Compare: whether a plan is reviewable before execution; the quality of the editable artifact; file and connected-service controls; export or ownership path; pricing under real usage; and the effort required to make a result safe to release. Avoid comparing only a polished demo image or a vendor claim.
It includes Chat Mode, but its official positioning is broader: the product separates Agent, Chat and Plan modes. Use the mode that matches the task and confirm the current behaviour before relying on a particular action.
Use it for multi-part work where an early mistake is costly: projects with authentication, payments, databases, integrations, or a public launch. Review the plan, source material and release criteria before relying on any resulting work.
Yes. Runable says every Agent Mode conversation has a private, isolated sandbox for writing code, running commands, installing packages, and building projects. It says inactive sandboxes pause after 45 minutes, resume with the next message, and save a snapshot after every assistant message for rollback.
Yes. Runable documents a React plus Vite website workflow with a live preview; its AI Websites documentation says database, file storage, payment processing, custom-domain support, and analytics are built in. The site goes live when the user clicks Deploy. Before any release, review the project’s code, data handling and release settings.
Runable documents HTML and Image slide formats plus PDF and PPTX export. Choose a format after validating its current editing and presentation behaviour against the needs of the project.
Runable documents a maximum of 10 files per chat message and 25 MB per file. It says Agent Mode accepts all file types, while Chat Mode accepts PNG, JPG, JPEG images and PDFs only. Keep uploads relevant and remove data you do not need to share.
The current pricing page lists Free at $0, Pro at $20 per month and Max at $100 per month. Credit allowance and plan details can change, so confirm the live pricing page before paying or enabling auto-refill.
Runable says integration data may be sent to its subprocessors, including infrastructure and AI service providers, to generate the requested response or deliverable. It says each Workspace service is optional, enabled individually, requested incrementally, and can have read-only or full access. Review the current privacy policy and your organisation's data rules before sharing data for a requested deliverable.
