Glossary of Emergent terms

Agentic development

Agentic development describes a workflow where autonomous AI agents write, test, debug and publish code on behalf of the user. In Emergent, you describe what you want in natural language and agents handle the implementation, selecting frameworks, scaffolding components, wiring APIs and iterating on feedback.

Credits (ECU)

A credit (internally called an ECU) is Emergent's billing unit. Building, testing and publishing apps consumes credits. Different operations cost different amounts: a simple front-end change may use a few credits, while generating video or refactoring a large codebase costs more. Credits are valued at 1 USD = 5 credits. Your plan includes a credit allowance that refills each billing cycle; subscription credits do not roll over, but purchased top-up credits never expire.

There is no overage billing. When your credit balance reaches zero, the current job pauses automatically and resumes once you top up.

Most users on the Free plan build several full-stack projects per month before hitting their credit limit.

Deploy / Deployment / Redeploy

Deploy / Deployment / Redeploy: Earlier Emergent names for what is now called Publish, published app, and Re-publish. The platform renamed these terms; the process is unchanged. If an older guide, video, or support reply says "deploy your app", that means clicking Publish. See Publishing types.

Job

A Job is an app or task in Emergent, each with its own conversation, code workspace and published app. When you start a new project or task, you create a new Job. Jobs are not sub-tasks or per-request work items; each one is a self-contained unit you work on over time, with its own chat history and codebase.

Re-publish vs Replace

Re-publish pushes your latest code to the live production URL. The app's environment variables, custom domain, database and settings remain unchanged. Use this for routine updates. Re-publishes are free of charge (beyond the monthly tier fee).
Replace performs a zero-downtime blue-green swap of a different job onto a live app. User secrets are carried over; you choose whether to keep the existing database or start fresh. Custom domains and subdomains persist through a Replace. Use it when you want to swap an entirely different codebase onto an existing live app.

Replace swaps the underlying job

Replace is intended for putting a different job onto a live publish slot, not for routine updates to the same app. Use Re-publish for standard code changes.

Universal LLM Key

The Universal LLM Key is a single API credential (prefixed

sk-emergent-

) that routes requests to 44+ models across 7 providers through a unified interface. Emergent apps can call any supported model without managing multiple API keys. The Universal Key is billed at platform per-token rates with no markup; your balance is funded from your Emergent credits.

Current model families include Claude Fable 5.x / Opus 5 / Sonnet 5 / 4.6 / Haiku 4.5; GPT-6 / GPT-5.x; and Gemini 2.5-3.8.

Learn more in The Universal LLM Key.

Maxx mode

Maxx mode is a Pro-only feature that gives agents extended autonomy: deeper reasoning, permission to refactor multiple files in parallel and the ability to iterate without waiting for your approval at each step. Maxx mode consumes significantly more credits but produces higher-quality results for complex requests. Enable it by toggling the "Maxx" switch in the chat composer when you want the agent to "go deep" on a feature.

Tip

Use Maxx mode for new features with unclear requirements or when you want the agent to explore multiple design options.

Preview vs Published

Preview is the live URL that updates every time the agent saves changes. Use it to test work-in-progress features. The Preview URL is publicly accessible and sleeps after 30 minutes of inactivity. Preview and production environment variables are separate after the first publish.
Published (also called "Production") is the stable, published version of your app. It only updates when you explicitly click Publish (first time) or Re-publish. This is the URL you share with real users and link to custom domains, served at
```
<appname>.emergent.host
```
.

Preview URLs are not indexed by search engines.

Read the full comparison in Preview vs Published.

Bundle Identifier (Bundle ID)

A Bundle Identifier is a unique reverse-domain string (for example

com.yourcompany.appname

) that identifies your mobile app on iOS and Android. Emergent seeds this into

app.json

at setup using the format

com.emergent.<words>.<suffix>

. You can edit it in the pre-populated first-build form. The Bundle ID must match across builds, code-signing certificates and app-store listings; changing it later requires new builds and re-submission to app stores.

Note

The app name locks after the first build. Display name is changeable at any time. Register your package name in your own Play Console.

Custom domain

A custom domain lets you serve your published app from your own URL (for example

app.yourcompany.com

yourcompany.com

). Emergent provides automatic HTTPS via Cloudflare Custom Hostnames (not Let's Encrypt). The recommended setup method is Auto-Link (Entri); for manual DNS, add two A records pointing to 162.159.142.117 and 172.66.2.113 (plus a

www

CNAME). If your DNS is on Cloudflare, keep records set to DNS-only (gray cloud) permanently to avoid Error 1014.

See the step-by-step guide in Custom domain.

MCP (Model Context Protocol)

MCP is an open standard for exposing data sources and tools to LLMs. Emergent supports MCP servers so your agents can query databases, SaaS APIs and internal systems. You configure them in Account Settings → Manage Agents → MCP tab using a JSON

mcpServers

config. MCP tool lists are cached for 5 minutes. Public MCPs are admin-created only.

Learn how to add them in Custom & MCP integrations.

Expo & EAS (Expo Application Services)

Deploy / Deployment / Redeploy: Other platforms' terms for what Emergent calls Publish, published app, and Re-publish. If a guide elsewhere says "deploy your app", on Emergent that means clicking Publish. See Publishing types.

Expo is the React Native framework Emergent uses for all mobile apps. EAS (Expo Application Services) is Expo's cloud build and submission platform. When you generate iOS or Android builds, Emergent triggers EAS Build behind the scenes. Emergent fully manages the Expo/EAS account, you do not need to create an Expo account, install eas-cli, purchase EAS credits or edit

eas.json

. Native builds (APK/AAB/IPA) require a paid Emergent plan and are triggered from the Publish panel, built from your last published code.

Info

Emergent handles all EAS configuration automatically. Do not modify

eas.json

, changes there can break the managed build pipeline.

Keystore (Android) & Certificates (iOS)

Keystore (Android): Cryptographic signing credentials required for publishing to Google Play. Emergent manages signing automatically. If you have a pre-existing Play Store app, Emergent provides a public
```
.pem
```
; you then request an upload-key reset in Play Console (takes 1-2 business days). Own-keystore cases go through support.
Certificates & Provisioning Profiles (iOS): Apple-issued credentials managed by Emergent through EAS. TestFlight upload is handled for you; the App Store Connect API key is auto-created and Emergent-managed. If you supply a
```
.p8
```
file, it is your APNs push key, uploaded at build time, missing push credentials will fail the build.

Warning

Store any credentials you manage securely. Losing signing keys means you cannot update your app on the respective store.

Web → Mobile conversion

Web → Mobile conversion is Emergent's ability to transform a web app into an Expo/React Native mobile app. The feature is available via the Publish panel's "Add Mobile App" option (feature-flagged; excludes Next.js projects). It forks the project into a mono setup where both platforms share the same backend, managed in one project. Conversion is one-way, mobile to web requires a rebuild. Not all features convert automatically; native device APIs, camera access and push notifications may require additional work.

Read the detailed guide in Web to Mobile conversion.

Database (MongoDB)

Every Emergent project includes an optional MongoDB cluster. Agents can create collections, define schemas and wire CRUD operations on your behalf. The database runs on managed infrastructure; connection strings and credentials are auto-injected as the

MONGO_URL

and

DB_NAME

environment variables. You can inspect and edit data in the workspace Database Manager (edits are live and cannot be undone).

Important: the managed MongoDB cluster only accepts Emergent-internal connections. You cannot connect an external Mongo client using the provided URI. For browsing data, use the built-in Database Manager at

mongoview.emergent.host

(accessible only from inside Emergent). For data exports, use

mongodump

from an allowlisted machine after migration, or migrate to your own Atlas instance.

See Database (MongoDB) for schema design and querying tips.

Object storage

Emergent's built-in Object Store supports upload, download and list operations. Deletion of uploaded assets is not currently supported, uploads are permanent. The storage quota is 5 GB; exceeding it returns error 439 (

storage_quota_exceeded

). For large or permanent file storage where deletion is required, use your own AWS S3 or GCS bucket via your own keys.

AI media generation

Emergent can integrate image and video generation models through it's integrations catalogue. Imagen 4 bills at 5× the base credit rate; GPT Image 1 bills at the standard rate; Sora 2 videos are available in 4, 8 or 12-second lengths (default 4 seconds). Free tier users cannot access the heavy media models.

Explore available models in AI media generation.

Custom agents

Custom agents are specialized assistants you configure for domain-specific tasks, for example a "Marketing Copy Agent" with tone guidelines and brand vocabulary, or a "Data Analyst Agent" with SQL templates. Custom agents are a Pro plan feature. They are configured via a 4-step wizard (system prompt, tools, sub-agents) in Account Settings → Manage Agents.

Learn how to create them in Custom agents.

Key integrations catalogue

The Key integrations catalogue lists pre-configured connectors (Stripe, Twilio, Resend, Shopify, ElevenLabs, etc.) that agents can install and wire. Integrations are managed from Preview → Manage → Integrations or by asking the agent directly; keys are stored in

.env

via the agent. Browse the full list in Key integrations catalogue.

Environment variables

Environment variables store secrets (API keys, database URIs, OAuth client IDs) outside your code. Emergent auto-provisions variables for internal services (for example

MONGO_URL

DB_NAME

REACT_APP_BACKEND_URL

CORS_ORIGINS

and

EMERGENT_LLM_KEY

). The Secrets UI (Preview → Manage → Secrets) can edit values of existing keys only, it cannot add or delete keys. To add new keys, ask the agent to add them to

.env

, then re-publish.

Tip

Never paste real secrets into the chat. Chat content goes to the AI provider. Ask the agent to read keys from environment variables and enter real values under Preview → Manage → Secrets → Custom keys.

Workspace

The workspace is the web interface at app.emergent.sh where you review code, manage published versions, inspect logs and configure settings. It includes a file tree, live preview iframe, terminal, database browser and published app controls. Tour the interface in A tour of the workspace.