Quick Start

Installation

Amplify supports four installation methods. Pick the one that fits your environment.

First launch — Web UI provider setup

After starting Amplify, open your browser to the configured host:

1. Local: http://localhost:5173
2. Docker: http://localhost:5173 (same port, container mapped)
3. Cloudflare: Your Pages domain

You don't need to edit any .env files. Amplify's Web UI lets you configure providers directly in the browser:

1. Open Amplify in your browser
2. Click themodel selector in the chat interface
3. Pick a provider from the dropdown (OpenAI, Anthropic, Google, DeepSeek, Groq, Mistral, Ollama, and more)
4. Enter your API key directly in the popup that appears
5. Start chatting immediately

Your keys are stored securely in both localStorage and cookies (365-day expiry, sameSite: lax). They persist across sessions and are never sent to Amplify's servers — only directly to the provider's API.

Local AI — zero-cost usage

You can use Amplify entirely for free with local AI providers. No API keys, no cloud costs — just install a local runtime and point Amplify to it.

Ollama is the easiest local provider to set up:

1. Install Ollama from ollama.com
2. Pull a model: ollama pull llama3.1
3. Open Amplify, click the model selector, and select Ollama as the provider
4. Choose your pulled model from the list
5. Start chatting — no API key needed

LMStudio works similarly — download it from lmstudio.ai, load a model, and select LMStudio as the provider in Amplify.

Base context lengths for popular local models

Context length & memory management

Understanding how Amplify manages context is key to getting the best results. Context in Amplify works differently from single-chat tools — here's how.

How context works

Every LLM has a base context window : the maximum number of tokens it can process in a single request. For example, Llama 3.1 has a 128K context window. But effective context is not just about the raw window size.

Amplify uses smart context budgeting to make the most of every token:

• System prompt reserve: 8192 tokens are reserved for instructions, skills, and memory context
• Summarization threshold: When a chat reaches 70% of the usable context budget, older messages are summarized
• Verbatim retention: The last 3 messages are always kept in full — summaries only apply to older content
• Vector store retrieval: On every new chat, Amplify injects targeted context — 500 tokens of user profile and 1000 tokens of project context from the vector store

This means effective context decreases over time in a single chat (as older messages get summarized), but increases across chats via memory persistence. Each new chat starts fresh with a full context window, enhanced by relevant memories from previous conversations.

• Why context budgeting matters

  Without budgeting, a single chat eventually exhausts the entire context window. The AI becomes slower, starts hallucinating, and loses track of earlier instructions. Amplify's approach solves this by:

  1. Summarizing old messages instead of keeping them verbatim (saves thousands of tokens)
  2. Persisting key information in vector stores so it survives across chats
  3. Injecting only the most relevant context at the start of each new chat (not the entire history)

  This is why Amplify's multi-chat architecture produces better results than single-chat tools — each sub-chat worker gets a focused, minimal context window, not the full baggage of every previous message.

Environment variables (advanced)

If you need server-side configuration (e.g., Cloudflare Pages where users shouldn't see keys in the browser), set API keys via environment variables. Amplify uses a priority chain: cookies → localStorage → env vars → config defaults.

Create a .env.local file in the project root:

Your first AI request

Type a natural language prompt and watch Amplify generate code in real time.

Example prompts:

Create a React todo app with TypeScript and shadcn/ui styling

Build a Next.js full-stack blog with SSR and API routes

Make an Expo mobile app with Expo Router and login screen

Design a SvelteKit dashboard with real-time data

Amplify's pipeline processes your request through:

1. Template selection : AI picks the best starter template (or uses a blank workspace)
2. Planning : The planning engine breaks complex tasks into sub-chats
3. Code generation : AI writes files using native tools
4. Verification : FlowVerifier checks the output for errors
5. Live preview : WebContainer runs the project and shows it in the preview pane

• How the chat pipeline works

  The full chat pipeline is:

  Prompt → Plan → Execute → Verify → Respond

  1. Your message enters the SSE streaming endpoint
  2. Context budget estimation checks if summarization is needed (70% threshold)
  3. Skills and memory are injected into the system prompt
  4. Systems calls the LLM with tools and context
  5. Native tools execute (read-only auto-execute, mutating require approval)
  6. Mutation signals are applied to the WebContainer

FAQ

Can I commercialize Amplify by forking it?

If you plan to use the WebContainer architecture (browser-based sandbox), you will need to purchase a license from StackBlitz as they own the WebContainer API and runtime. The WebContainer technology is proprietary and requires a commercial license for production use beyond personal/educational purposes.

However, if you migrate the sandbox layer to a self-hosted Docker container or any other container runtime (local or cloud), you are free to commercialize, fork, and distribute the project under its open-source license. The AI layer, frontend, and all other components are fully open-source — only the WebContainer sandbox runtime has licensing restrictions.

How does Amplify save tokens compared to single-chat tools?

Tools like Bolt, v0, and Lovable continue developing in one single chat, which means the context window grows linearly with each message. This makes the AI progressively slower and introduces wrong context and irrelevant preferences as the chat gets longer.

Amplify's approach is fundamentally different:

1. Sub-chat workers : Each PlanPoint in the planning engine gets its own isolated sub-chat with a focused, minimal context

2. Reusable memory : After each chat completes, key information (decisions, errors, patterns, preferences) is extracted and stored in vector stores

3. Cross-chat persistence : New chats start fresh but with targeted context injection from the vector stores (500 tokens for user preferences, 1000 tokens for project context), not the full history of all previous chats

4. Summarization : Long chats are summarized at the 70% threshold, keeping only the last 3 messages verbatim

This means each new chat is fast, focused, and accurate — not bogged down by hundreds of irrelevant previous messages.