Grok Build 2026: Free Access, Devices, Memory and Limits

Grok Build is available on every Grok plan on the web, iOS, and Android, according to xAI’s August 19, 2026 announcement. The September 16 memory release adds project notes that can carry conventions and decisions into later sessions. That answers where to start, but not how much usage a plan includes, whether every control is identical on every device, or whether a generated app is ready for production.

This guide checks the current official Grok Build announcement, memory announcement, changelog, pricing page, connector documentation, API pricing, and open-source note as of September 17, 2026. It separates the consumer web/mobile builder from the terminal coding agent, distinguishes subscription pricing from API billing, and gives a cautious first-build workflow. It does not report a hands-on build, performance benchmark, account entitlement, or production test.

Short answer: access widened, but quotas remain a separate question

• Where it runs: the official announcement says Grok Build is on every plan and can be used on the web, iOS, and Android. You describe an app, game, website, or dashboard and Grok creates a working version in the chat.
• What changed: publishing and sharing, X timeline rendering, custom domains, Remix, GitHub export, third-party secret storage, connectors, and per-app access to SpaceXAI APIs are listed as additions since the Early Beta.
• What memory does: the September 16 announcement says Grok Build records conventions, decisions, and project facts in background notes and reads them in later sessions. It applies to new sessions; notes begin after the first completed turn.
• What “free” means: the current pricing page lists a Free plan at $0/month and includes Grok Build in its feature comparison. It does not publish a simple Build quota by device or project, so free access should not be read as unlimited use.
• What is still unknown: exact rate limits, feature flags, country-specific controls, connector permissions, memory retention and governance, export fidelity, deployment requirements, and the usage cost of a particular project need to be checked in the account or current documentation.

Grok Build timeline: the dates that matter

The first-party wording is unusually useful here: the August page says “every plan” and names three surfaces, while the September page explains the memory behavior and its new-session boundary. Those statements are stronger than a search snippet, but they are still product documentation rather than an account-level test.

Device availability: web, iOS, and Android are the entry points

xAI says a Build request can be made on the web, iOS, or Android, with the result appearing live in the chat. In practical terms, that is mobile access to the builder and its conversation workflow. It is not the same thing as a promise that Grok will package a native iOS or Android binary, publish to an app store, or expose identical editing controls on each surface. The official page describes apps, games, websites, and dashboards; it does not claim native mobile compilation.

• Use the web surface when you need deeper inspection: a larger screen makes it easier to review generated files, permissions, links, and an export before sharing.
• Use mobile for ideation and review: the official availability statement supports mobile use, but do not infer that a mobile session has the same connector catalog, preview, or file-management controls as the web.
• Check the account, not just the app download: “available on every plan” establishes the product rollout. It does not state your remaining usage, response speed, rate-limit behavior, or eligibility for an individual model.

Pricing: keep subscription access and API usage in separate ledgers

The current official pricing page displays individual plans in US dollars: Free at $0/month, SuperGrok at $30/month, and SuperGrok Plus at $100/month. The page says Plus includes significantly higher usage across Chat, Imagine, Voice, and Build. It does not show a Build-specific quota in the visible plan copy. Taxes, currency conversion, promotions, and region-specific checkout terms can change what a particular account sees.

If your decision is “can I try it?”, start with the Free plan and a disposable prototype. If your decision is “what will a production dashboard cost?”, price the external APIs, storage, hosting, connector calls, and human review separately. The public pages do not provide enough information to promise a total cost from a subscription alone.

Memory in Grok Build: helpful continuity, not a source of truth

The September 16 announcement says Grok Build keeps notes about conventions, decisions, and project facts, writes them in the background, and reads them before related work in a later session. xAI’s example shows a testing convention being recalled, but that example is a vendor illustration rather than a test conducted for this article. The official availability section says memory applies to new sessions: run /new or start a fresh grok, then notes begin after the first completed turn.

• Good use: record stable project conventions, naming rules, a short data model, and the approved way to run a test suite.
• Review before relying: ask Grok to show which note it used and compare it with the repository or current brief. A remembered decision can be obsolete after a product, policy, or schema change.
• Do not treat memory as audit evidence: the feature is a convenience layer. Keep the authoritative requirement, credentials policy, release checklist, and approval record in the system your team already controls.
• Mind the boundary: xAI says notes are project-scoped, with a global preference scope, and describes task state, tentative conclusions, secrets, and information already covered elsewhere as excluded. That description is not a substitute for checking your own retention and privacy requirements.

Publishing, sharing, and GitHub export are different handoff levels

Every published app gets a grok.me address. The August announcement says the creator can make it private, link-only, or available to the whole internet, and can point a custom domain at it. Remix lets another person fork a published app. An X share can render an inline banner and, for games, a play affordance. These are distribution controls, not proof that the generated code has production monitoring, accessibility coverage, authentication hardening, or a rollback plan.

GitHub export is a portability step: xAI says the whole project can be pushed to a repository for continued work in an editor or in terminal Grok Build. Before sharing that repository, inspect the commit, generated configuration, dependency versions, environment references, and any sample data. A repository export is not the same as a deployed service, and a custom domain is not the same as a security review.

Connectors and API access create a data boundary

The Build announcement says Connectors can bring business data into live, filterable dashboards. xAI’s connector documentation says connectors let Grok access external tools and data in a conversation, with built-in services authenticated through OAuth. Its current list includes Gmail and Google Calendar, Google Drive, OneDrive, Outlook, Microsoft Teams, SharePoint, Salesforce, and a catalog that includes GitHub, Linear, Notion, Box, Canva, Vercel, and other services. Business and Enterprise administrators must provision a connector before members can use it.

The connector announcement also describes write-capable actions for some services, such as creating or updating documents, calendar invites, email, and Salesforce records. That makes a connector a permission boundary, not just a search shortcut. Start with a read-only or sample-data path where possible, inspect the OAuth scopes, and keep a human approval step before an app writes to a production system. Custom MCP connectors can expose an internal API or database, but the documentation says the server must be reachable over the public internet; that is a deployment and security decision, not a harmless local toggle.

• Connect only the service needed for the first prototype.
• Use a test workspace or redacted dataset before a customer, employee, financial, or health dataset.
• Confirm whether the connector can read, create, edit, or delete before writing a prompt that asks it to act.
• Revoke the connection and rotate third-party credentials if the scope, owner, or prototype changes.

A safe first-build workflow, using plan mode

xAI’s code-planning use case describes a plan mode that explores a repository, presents a file-level plan, accepts questions or changes, and only then implements. It also describes parallel subagents for implementation, tests, and review. That is the vendor’s documented workflow, not a performance claim. You can use the same separation of decisions for a small app prototype:

1. Define the smallest reader or user job. Name the input, the output, the user, and what is deliberately out of scope. “Build a dashboard” is not enough; specify the fields, filters, and sample dataset.
2. Ask for a plan first. Request the proposed files, data flow, assumptions, failure states, accessibility considerations, and a manual test checklist. Say clearly: “Do not publish, connect external services, or use secrets.”
3. Review the plan before code. Remove unnecessary dependencies, reject unsupported capabilities, and decide whether a browser app is enough or a native application and separate engineering handoff are required.
4. Use synthetic data. Keep production credentials, customer records, and private repositories out of the first pass. If a connector is essential, connect a test account with the narrowest available permission.
5. Inspect and test the working version. Check keyboard use, mobile layout, error states, empty states, data boundaries, and links. Do not describe the result as tested unless someone actually ran those checks.
6. Choose a handoff deliberately. Keep the project unpublished while reviewing it. Export to GitHub for code ownership, publish a restricted grok.me link for a bounded demo, or use a custom domain only after the owner accepts the operational responsibility.

Build a private dashboard prototype from the attached sample CSV.
First show a plan with files, assumptions, schema, empty/error states, and a manual test checklist.
Use synthetic data only. Do not connect services, add secrets, publish, or export.
Wait for approval before writing code.

This prompt is a reusable safety pattern, not a claim that the workflow was run here. If the generated plan asks for a connector, a secret, public sharing, or a destructive action before the prototype is understood, stop and narrow the brief.

How Grok Build fits the current app-builder search

Current search results place Grok Build in the same broad discovery set as Lovable, Bolt, v0, and Replit, but those products do not necessarily own the same job. Some emphasize UI generation, some browser development, some hosting, and some a local or full engineering environment. The useful comparison is not a generic “best AI builder” score; it is whether the tool gives you the device access, preview, data boundary, code handoff, and operating control your project needs.

Community discussions are a useful warning signal about that distinction. For example, one August Reddit thread reports a personal usage and pricing experience, while another asks about monthly versus weekly limits. They are dated, account-specific observations; they do not establish a current quota, a universal speed result, or a production-quality comparison. Use the account’s current usage panel and official documentation for a purchasing decision.

What existing DMT coverage does and does not answer

This page has a distinct job: explain Grok Build access, devices, memory, publishing, connectors, export, and cost boundaries. For adjacent questions, use the existing guides on Grok Bot’s cloud-computer agent workflow, Grok 4.6 pricing and benchmark interpretation, and Grok Imagine Image 2.0 editing. Those pages cover separate reader jobs; this guide should not replace their model, agent, or image ownership.

Grok Build frequently asked questions

Is Grok Build free?

The official announcement says Build is available on every plan, and the current pricing page lists a Free plan at $0/month. That establishes an entry path, not unlimited prompts or a fixed free quota. Check the account’s live usage and any regional checkout terms.

Which devices support it?

xAI names the web, iOS, and Android. The statement describes where you can use the builder; it does not promise native iOS or Android binaries, app-store submission, or identical controls across devices.

Does memory sync every old conversation?

Not according to the documented boundary. xAI says memory applies to new sessions, with notes beginning after the first completed turn. Treat it as project context to review, not a complete archive or an audit log.

Can I publish straight to production?

You can publish a link, set access, and use a custom domain, but the announcement does not claim production security, monitoring, accessibility, compliance, or rollback. Keep the first version private or link-only until those checks have an owner.

Is GitHub export the same as deployment?

No. Export gives you a repository handoff. You still need to inspect the code, configure the runtime, manage secrets, test the app, and choose hosting.

Does a Grok subscription include API calls?

Do not assume it does. The consumer pricing page and the developer API pricing page are separate ledgers. The API page lists token prices for grok-build-0.1; the product’s built-in per-app model access has its own controls and must be checked in the account.

Should I connect a production data source?

Not for a first prototype. Use synthetic or redacted data, review OAuth scopes, confirm read versus write actions, and require approval before a connector or custom MCP server can touch a production system.

Bottom line

Grok Build’s September 2026 position is clear enough for a bounded trial: every plan, web and mobile entry points, a live prompt-to-app workflow, and newly documented project memory. It is not yet a complete answer to quota, native packaging, privacy, connector governance, API cost, or production readiness. Start with a private synthetic-data prototype, ask for a plan, inspect the generated handoff, and only then choose memory, connectors, GitHub export, or public sharing.