Documentation
UpdatedSet up Flame, learn the tools, and find answers to common questions.
Your first workspace
Follow these steps in order. You can add more tools and automation as your projects need them.
Choose the projects root
In Settings, choose the parent folder containing your repositories, such as ~/projects. Open a repository from the Projects panel to work with its files, terminals, and Git changes.
Organize with Project Groups
Create a Project Group for related repositories. Add projects manually or use rules based on folder names, files, scripts, dependencies, or Git state. Groups can share run configurations and worktree defaults.
Configure at the right scope
Use global Settings for your editor and appearance. Use Project Settings for one repository, or Group Settings for shared defaults. A project can inherit group settings or opt out.
Connect an AI provider
Open Settings → AI. Sign in to a coding-agent runtime or configure a model provider, then choose the model for your task. Review permission requests before allowing tools to change files or run commands.
Create a Run Configuration
In Project Settings, add a named run configuration with your package script or shell command and, optionally, a browser URL. Run it to open the tools your project needs together.
Sharing settings and reusing runsProject files, portable exports, and inherited configurations.
Built for many projects. Search, groups, worktrees, and broadcast commands all start from the projects root.
Portable settings & groups. Export a versioned configuration bundle from Settings. Flame removes credentials, project roots, histories, and run-configuration environment maps before the file is written.
Project-local .flame.json. Export repository settings to a versioned .flame.json or .flame.jsonc file at the project root to share run configurations, worktree scripts, and review guidelines with your team.
Group inheritance & reconciled run. Projects can inherit launch recipes from their groups. Running a recipe reuses matching active terminals and browser tabs. HTTP request actions are sent again on every run.
Feature walkthroughs
Focused guides with setup steps, everyday workflows, and practical limits.
Mobile Preview
Run Android devices and iOS simulators in a dedicated IDE panel, with live previews, logs, and deliberate AI context.
Read the guideDashboard Widgets
Build a personal My Activity canvas with activity, Git, tasks, notes, commands, and AI summaries. Keep a separate layout for each project.
Read the guideTodos & Reminders
Keep personal todos beside your code, choose a project or global scope, set a reminder, and turn a todo into a prepared AI conversation.
Read the guideFlame Mobile
A native iOS and Android companion for your Flame workstation. Follow agents, review changes, manage todos, and reach your terminal from your phone. Available soon.
Read the guideLearn the workspace language
A few concepts connect everything in Flame.
- Projects root
- The parent folder Flame scans to build the Projects panel.
- Project
- A repository or app with its own files, Git state, terminals, tabs, tests, and AI context.
- Group
- A manual or rule-based collection of projects used to filter workspace views, organize repositories, and share inherited settings and Run Configurations.
- Worktree
- A separate checkout of one repository, usually on another branch, that Flame can open as a project.
- Agent job
- A managed task with projects, a model, status, optional worktree isolation, and a reviewed landing path.
- Run Configuration
- A named, ordered set of package, shell, file, browser, test-watch, and HTTP actions with dynamic environment sources, variable interpolation, and auto-run/stop lifecycle behavior.
More workspace termsTools, agent context, settings, and connections.
- Tasks panel
- A dedicated Right-panel tab in Flame that syncs assigned tasks from Jira, Monday.com, GitHub Issues, GitLab Issues, and ClickUp, enabling in-editor task tabs, live commenting, status transitions, and one-click AI agent handoff with auto-named branches.
- API Client
- A built-in HTTP and GraphQL workbench for constructing, testing, and debugging requests across environments, with OpenAPI and collection import and agent-executable test tools.
- Dependency Auditor
- A cross-project package manager and security scanner covering 9 ecosystems (npm, cargo, pip, go, composer, bundler, maven, gradle, pub) with one-click AI vulnerability remediation.
- Profiler & Flame Graph
- Interactive Node CPU flame graphs, hot line gutter markers, memory heap snapshots, and leak comparison with one-click Optimize with AI handoff.
- Ports Explorer
- A bottom-panel socket inspector showing listening host ports, process details, project attribution, browser previews, and process controls.
- Flutter Runner
- Native status bar integration for device discovery, emulator launching, hot reload, hot restart, flutter doctor diagnostics, DevTools, and flutter test execution.
- Agent context
- The active file, open files, selection, attachments, and tool-readable browser or terminal state available to a chat.
- Browser Bridge extension
- A separate, optional Manifest V3 Chrome extension (available on the Chrome Web Store) that pairs a real Chrome profile with local Flame IDE so approved agents can inspect, debug, and control Chrome tabs over loopback. Learn more on the Flame Browser Bridge guide.
- Settings scope
- The level where a choice applies: global IDE settings, group defaults shared by member projects, or a project-specific value.
- Plan Mode
- A server-owned planning, review, and approval workflow (planning → review → executing → completed). Read-only tool gates let the agent prepare a Markdown plan, reviewed in a dedicated Plan tab with decisions and recommendations, before you approve execution.
- SSH Remote Host
- A remote development target connected over SSH with automated Flame backend deployment, bastion jump host support, and forwarded loopback workbench access.
- Local Snapshots
- Automatic point-in-time file backups created on save, format, and before risky git operations, enabling one-click historical diffs and file restoration independent of Git commits.
- SVG Visual Editor
- An interactive vector editor tab with Bézier curve path tools, anchor/handle manipulation, vector shapes, element hierarchy tree, styling, and two-way code synchronization.
- Project Config (.flame.json)
- A versioned JSON/JSONC configuration file saved in repository root to standardize run configurations, worktree init scripts, file copying rules, and review instructions across team checkouts.
Choose a topic. Open a guide for the steps.
Configure Flame
Start with searchable global settings, then use project and group settings only where the behavior should follow a repository or stack.
Know where a setting belongs
Put personal IDE behavior globally and repository behavior with the repository.
- Open Settings from the gear or command palette, then search across projects, appearance, editor, files, Git, terminal, AI, language servers, integrations, layout, gestures, wellness, voice, logging, and more.
- Use Project Settings for run configurations, session restore, worktree setup and copy rules, code-review instructions, favorite scripts, and project color.
- Use Project Groups for shared settings and launch recipes. Member projects inherit group values by default and can turn inheritance off.
Set up a coding-agent runtime
Choose Claude Code, Codex, GitHub Copilot, or Gemini through Antigravity and sign in with your account.
- In Settings → AI → Agent runtimes, configure Claude Code, OpenAI Codex, GitHub Copilot, or Gemini through Google's Antigravity CLI.
- Claude Code and Codex are installed on demand from npm. Antigravity runs Google's installer only after you explicitly choose Install, with the command shown before it runs.
- Use Flame's integrated terminal to complete Claude, ChatGPT, or Google sign-in with shell-aware quoting, then select the runtime and model for a conversation or agent job.
Use GitHub Copilot in AI Chat
Connect GitHub Copilot as an AI Chat provider while keeping Flame's conversation controls and project context.
- In Settings → AI → Providers, connect GitHub Copilot and sign in with the GitHub account that has your Copilot plan.
- Choose GitHub Copilot for an AI Chat conversation, then attach the files, diffs, terminal output, tests, or browser context that matter to the question.
Transparent Anthropic-to-OpenAI Translation Proxy
Use supported OpenAI-compatible providers through Flame's built-in translation proxy.
- Flame embeds a transparent loopback proxy (/internal/anthropic-proxy/) that dynamically translates Anthropic Messages API calls and tool schemas to OpenAI format.
- Point Claude Code at local Ollama, LM Studio, vLLM, OpenRouter, or Gemini without installing external routers like LiteLLM or claude-code-router.
- The proxy translates streaming responses and tool calls and uses per-process authentication tokens. Provider model and tool support can differ.
Configure model providers
Choose the provider for each AI surface instead of using one global model for everything.
- In Settings → AI, add Anthropic, OpenAI, Gemini, OpenRouter, Ollama, LM Studio, Bedrock, Vertex, or another compatible endpoint for model-powered surfaces.
- Set separate defaults for AI Chat, agent runs, inline completion, and one-shot assistants such as conflict resolution.
- Provider keys are write-only in the UI and protected locally. Local Ollama and LM Studio endpoints keep model requests on the host.
Set agent permissions deliberately
Decide what the agent may do once, always, or never at the relevant scope.
- Review permission prompts before file writes, terminal commands, browser interactions, or IDE mutations.
- Save rules globally, for a project, or for a conversation when the same decision should apply again; remove a saved rule in Settings when it no longer fits.
- Agent tool activity remains visible, and risk-tiered IDE commands still require confirmation when they mutate or expose sensitive state.
Build a Run Configuration with dynamic sources & stop actions
Encode repeatable multi-action launch and teardown recipes with dynamic environment variables.
- Add ordered actions to run a package.json script or shell command, open a file, open an embedded or external browser URL, start a test watcher, or send an HTTP request.
- Dynamic environment sources (envSources): load environment variables at runtime from disk files (.env, .env.local, .json, .jsonc with jsonPath extraction), shell command stdout (e.g. Vault CLI), or HTTP responses.
- Use {{NAME}} template interpolation in commands, URLs, script names, headers, and request bodies; sources resolve in list order, and the literal env map overrides last.
- Configure stop actions executed during session finish or window unload (npm scripts, shell commands like docker compose down, or HTTP teardown calls) bounded by timeouts.
Good to know: Portable configuration export removes every Run Configuration environment map because environment values often contain secrets.
Link to this guideSwitch Keymap Presets and import settings
Keep your muscle memory with one-click presets or import your existing configuration.
- Select Keymap from the Shortcuts settings header to switch between Flame, VS Code, JetBrains, or Vim keybinding schemes.
- Import existing VS Code keybindings.json or settings.json files with automated schema mapping.
- Import JetBrains keymap XML files directly; custom keybindings merge cleanly onto your current profile.
Customize Mouse & Touchpad Gestures
Trigger IDE navigation, terminals, and custom commands using fluid gestures.
- Configure right-click mouse drag gestures in cardinal and diagonal directions (up, down, left, right, up-left, etc.).
- Map two-finger and three-finger trackpad swipes with optional modifier keys (Alt, Shift, Meta) to tab switching, panel toggles, or AI chat.
- Bind gestures to custom shell commands, command palette actions, or workspace views.
Voice control and chat dictation
Dictate an editable chat draft and choose where speech is processed.
- In Settings → Voice, choose Browser Whisper (audio stays on this device), native whisper.cpp (runs on the Flame server), Deepgram, or a configured speech endpoint. Native whisper.cpp requires a manually installed runtime.
- Click the chat microphone to start and click again to finish, or hold it to record and release to finish. A short-click recording can stop after the configured silence interval. Escape discards it.
- Dictation appends editable text to your draft. Review it and use Send when ready; dictation does not send a message or execute an IDE command. Title-bar and command-palette voice commands are separate controls.
Clock, Wellness & Pomodoro Focus
Keep track of active coding time and maintain healthy work routines without third-party widgets.
- Enable the status-bar Pomodoro timer with customizable work, short break, and long break intervals.
- Configure 20-20-20 eye strain reminders, posture and movement prompts, and long-session warnings.
- Set end-of-workday notifications, configure sound alerts, and enable Do Not Disturb (DND) mode during deep work.
Move safe configuration between machines
Use Import all and Export all without turning a settings file into a credential bundle.
- The versioned JSON bundle includes IDE settings, project and group preferences, groups, commands, browser favorites, file shortcuts, and snippets.
- Provider and browser-profile credentials are excluded, and secret-looking values in URLs, headers, commands, or snippets are redacted.
- Project roots, histories, sessions, and notifications are device state and are not imported.
Tune the host tooling
Point Flame at the runtimes and integrations already used by the project.
- Choose a Node runtime, use nvm or nvm-windows, and respect a project's .nvmrc for scripts and tooling.
- Enable, inspect, or restart language servers and configure formatters, linters, indexing exclusions, terminal profiles, and external debug adapters.
- Add GitHub or GitLab integration, task-link reference patterns with predefined regex presets (Jira, Monday.com, GitHub, GitLab, ClickUp, Linear, Trello), custom commands, and notification behavior.
Open Flame from a terminal
Add the flame command to your PATH, then open files, folders, line locations, and diffs without leaving the terminal.
- In Settings → Diagnostics → Command line launcher, choose Add flame to PATH. Flame installs a user-level launcher on Windows, macOS, or Linux; open a new terminal after the change.
- Run flame <file> to open one file, flame <file1> <file2> to open several files, flame <folder> to open a project folder, or flame <folder1> <folder2> to open several folders.
- Jump to a location with flame -g <file>:<line>, flame -g <file>:<line>:<column>, or flame --goto <file>:<line>:<column>.
- Compare two files with flame -d <file1> <file2> or flame --diff <file1> <file2>.
- Use flame -h or flame --help to view usage, and flame -v or flame --version to print the installed Flame version.
Projects & worktrees
Keep repositories, branches, worktrees, and project actions in one workspace instead of one window per repo.
Find the project that needs attention
Use the Projects panel as the workspace home screen.
- Search projects or filter by All projects, Favorites, Changes, or a project group.
- Read the branch, changed-file count, upstream status, package manager, and project type from each card.
- Open files, search, a folder tab, terminal, or AI chat directly from the project card.
Organize and create projects
Keep a large projects root useful as it grows.
- Pin or favorite important projects and create manual or rule-based groups.
- Rules can match names, paths, branches, project types, package metadata, files, remotes, or uncommitted changes.
- Create an empty, npm, Git, or Python project, start from a template, or clone from Git.
Update a filtered set of repositories
Use the current group, search, favorites, and change filters to choose a batch.
- Right-click the Projects panel and choose Update projects. Check the matching count; the selection is fixed when you start, even if filters later change.
- Updates use fast-forward-only pulls. Repositories with local changes, conflicts, detached HEAD, no upstream, or diverged history are skipped, with per-project results.
- Switch to default branch works on the same filtered selection and skips unsafe checkouts. It does not stash changes or force a checkout.
Isolate work with worktrees
Give a branch its own checkout and open it as a first-class project.
- Create a worktree from a new or existing branch, choose its base and folder, and optionally open it as a project.
- Start AI chat in that checkout or let a new chat create a worktree from its title; selected local files such as .env can be copied in.
- Inspect changes or bring committed and uncommitted work into the current branch, unstaged for review.
Good to know: Dependency installation and task restart when switching worktrees are optional settings and are off by default.
Link to this guideAutomate launches with Run Configurations
Start a repeatable set of project actions from one named control.
- Combine package.json scripts, shell commands, files, embedded or external browser URLs, test watchers, and HTTP requests.
- Open the exact local preview URL you configure in a Flame internal-browser tab beside the code.
- Running again reuses matching active terminal actions and browser tabs instead of launching duplicates.
- Group inheritance: define launch recipes on a Project Group so all stack repositories inherit the same boot sequence.
- Ask AI to configure: prompt an agent to build and register project launch configurations automatically.
Files & assets
Use a project tree for code, visual folder layouts, vector SVG editing, rich non-code file viewers, and automatic local snapshot history.
Compare files and pasted text
Inspect two versions in an editable split or inline diff, including files from different projects.
- Open File Compare from New tab, or choose Compare with from an editor tab. Select files from the same project, different projects, or supported external paths.
- For a new comparison, use Project file, Open file, or Paste for each side, or type directly into either pane. Swap reverses the current contents.
- Choose Split or Inline, set the language, and use F7 or Shift+F7 to navigate changes. Ignore trim whitespace, Word wrap, and Hide unchanged lines help focus the diff.
- Both text panes are scratch buffers and do not save to disk. Copy text into a real file to keep it. Ask AI can prepare a question or review using the current text diff.
- Open file accepts UTF-8 text up to 10 MiB. Supported binary selections use media or file previews instead of a text diff.
- Compare two images side by side or with a reveal Slider. Zoom and pan both views together, and turn on Highlight differences to see changed pixels and their percentage. From an image diff, Compare images opens both revisions.
Browse a folder visually
Open any folder as an editor tab instead of expanding a deep tree.
- Switch between List, Details, Grid, and Preview views, then adjust sorting, zoom, hidden files, and folders-first behavior.
- Use breadcrumbs, back and forward history, and Filter this folder… to move through large directories.
- Preview images, video, audio, PDFs, fonts, text, and code without leaving the folder.
Edit vector graphics with SVG Visual Editor
Design and modify vector SVGs in an interactive visual canvas with live code sync.
- Use the Pen and Path tools to inspect and modify Bézier curves, move anchor points, adjust control handles, split segments, and toggle smooth curves.
- Insert vector shapes including Rectangles, Circles, Lines, Triangles, and freeform paths with corner bounding boxes.
- Inspect and organize elements in the visual hierarchy tree; adjust fill color, stroke color, stroke width, and opacity.
- Switch seamlessly between the visual vector editor and Monaco source code view with live two-way synchronization.
Preview rich media, data grids & Jupyter notebooks
Preview non-code assets in editor tabs. Notebook execution requires a configured Jupyter kernel.
- Archive Viewer: inspect Zip, Tar, GZ, and TGZ archives; view compressed file trees, byte sizes, and compression ratios, or extract single files directly.
- Data grids: open CSV and Excel (XLSX) spreadsheets in interactive, paginated, and sortable data viewers across multiple worksheet tabs.
- Font Viewer: preview custom web fonts (WOFF, WOFF2, TTF, OTF) with glyph tables, character maps, and configurable sample text sizes.
- Audio & Video: play MP3, WAV, OGG, MP4, and WebM media files with integrated timeline scrubbing, volume control, and loop toggles.
- PDF & Notebooks: read PDFs with zoom and page controls; run interactive Jupyter Notebooks (.ipynb) with real Python/R kernels and cell outputs.
Local File History & Edit Snapshots
Recover past edits and protect against accidental changes with automatic local snapshots.
- When local snapshots are enabled, Flame captures file history on save, before formatting, and around supported Git operations. Capture is best effort and follows your retention settings.
- The File History panel displays a unified chronological timeline combining Git commits and local edit snapshots.
- Inspect side-by-side or inline diffs against any point in the timeline and restore prior file versions with one click.
- AI agents can inspect file evolution and restore previous snapshots using the get_file_history and restore_file_snapshot MCP tools.
Trace architectural file dependencies
Inspect inward and outward project imports on an interactive canvas.
- Open the Dependency Diagram tab to visualize file relationships, upstream imports, and downstream consumers.
- Inspect indexed symbol counts and external package links connected to your active source files.
- Toggle between force-directed and hierarchical layouts, search nodes, and zoom to focus on architectural subsystems.
Move files without breaking flow
Common file operations stay close to the editor and remain recoverable.
- Create, rename, move, copy, paste, and drag files within a project or copy them across projects.
- Flame can update imports during supported moves and can paste real desktop file references into Finder, Explorer, and other apps.
- Delete sends items to Flame's workspace trash, where the file operation can be undone; it does not use the operating system Trash.
- Oversized files are streamed deliberately to prevent memory exhaustion; binary files display hex/binary diff notices instead of corrupting editor buffers.
Make quick image changes
Handle basic raster edits without opening another application.
- Rotate, flip, crop, and resize raster images with optional aspect-ratio locking.
- Save as PNG, JPEG, or WebP and adjust JPEG or WebP quality before writing the file.
Database workspace
Manage database connections, explore tables and collections, run SQL/JSON/Redis queries, and attach database schema context to AI conversations.
Connect to local and remote database engines
Configure database connections with native protocol support.
- Choose PostgreSQL, MySQL, MongoDB, Redis, Microsoft SQL Server, ClickHouse, SQLite, or DuckDB. The connection catalogue also includes compatible services such as Supabase, Neon, MariaDB, and Valkey.
- Set host, port, database name, username, password, SSL requirements, or connection URI string.
- For SQLite databases, select a local file path directly from your workspace.
- Test connection status with real-time feedback (disconnected, connecting, connected, or error) before saving.
Browse database schemas, tables, and structures
Inspect namespaces, table columns, data types, and primary key constraints.
- Explore database namespaces and schemas in a collapsible tree sidebar.
- Inspect table columns, data types, nullability, default values, and primary key markers.
- View estimated row counts and object kinds (tables, views, collections, and keys).
Run queries and edit data inline
Execute multi-dialect queries with syntax highlighting and instant data grid editing.
- Query runner supports SQL syntax for relational databases, BSON/JSON query syntax for MongoDB, and CLI commands for Redis.
- View query duration in milliseconds, total row counts, and paginated data tables.
- Edit supported cell values directly in the result grid; column-oriented or otherwise read-only targets stay read-only.
API client
A built-in HTTP & GraphQL workbench for crafting requests, inspecting responses, managing environments, and letting AI test endpoints.
Build multi-protocol API requests
Construct and run REST, GraphQL, and specialized HTTP requests directly beside your code.
- Full HTTP method support: GET, POST, QUERY, PUT, PATCH, DELETE, HEAD, OPTIONS, CONNECT, TRACE, and GRAPHQL.
- Authentication options: Inherit from collection, Bearer token, Basic Auth, API Key (in header or query), OAuth 2, JWT, and custom header definitions.
- Flexible request bodies: JSON, Raw text, XML, URL-encoded forms, Multipart form-data with file attachments, Binary uploads, and GraphQL queries with JSON variables.
- Server-side execution proxy (/api/http/exec) routes calls through Flame's host process, eliminating browser CORS limitations.
Manage scoped environments & dynamic variables
Keep base URLs, authentication tokens, and headers organized across development stages.
- Define variables at Global, Group, or Project scope; active requests resolve variables hierarchically using {{VARIABLE}} syntax.
- Switch active environments (e.g. Local, Staging, Production) with one click from the API Client header.
- Inspect variable resolution previews before sending requests to verify templated values.
Import collections, diff responses & organize endpoints
Bring existing API collections into Flame and compare execution results.
- Import endpoints from cURL commands, OpenAPI specs, HAR archives, or Flame collections.
- Organize requests into nested collections and folders with shared collection-level authentication and headers.
- Inspect chronological execution history, view response timing and status codes, and diff two responses to identify API regressions.
- Export your API collections as portable JSON bundles to share across your engineering team.
Delegate API testing to AI agents
Empower agents to build endpoints, verify contracts, and debug server responses.
- Use the 'Auto-build with AI' button to let agents inspect your backend route code and automatically generate matching saved API requests.
- Agents interact with the API Client through dedicated MCP tools: list_api_requests, create_api_request, update_api_request, remove_api_request, and send_api_request.
- When agents make server-side code changes, they can send live requests to verify responses and troubleshoot failing status codes autonomously.
Dependencies & security
Monitor package security, outdated versions, and license compliance across 9 ecosystems with one-click AI remediation.
Multi-ecosystem dependency discovery
Inspect project manifests and lockfiles across modern engineering stacks from one panel.
- Supports 9 primary ecosystems: JavaScript/TypeScript (npm / package.json), Rust (cargo / Cargo.toml), Python (pip / pyproject.toml), Go (go / go.mod), PHP (composer / composer.json), Ruby (bundler / Gemfile), Java (maven / pom.xml), Android/Kotlin (gradle / build.gradle), and Dart/Flutter (pub / pubspec.yaml).
- Distinguish between direct dependencies and transitive dependency trees.
- Filter by ecosystem, update impact, or advisory severity to isolate high-priority packages.
Security advisories & duplicate detection
Identify CVEs and redundant packages before code reaches production.
- View real-time security advisories categorized by severity: Critical, High, Moderate, Low, and Info.
- Inspect affected version ranges, fixed version recommendations, advisory descriptions, and external reference links.
- Detect duplicate package versions across monorepos and dependency graphs to optimize bundle sizes and avoid version drift.
One-click 'Fix with AI' & report generation
Remediate vulnerable dependencies in isolated worktrees and export audit reports.
- Click 'Fix with AI' on any security advisory to launch an agent task in a dedicated worktree to bump dependencies, resolve breaking API changes, and verify test suites.
- Generate and copy structured Markdown reports: Security Vulnerability Reports, Outdated Dependencies Reports, or Combined Audit Reports.
- Share exported reports with security teams or paste them directly into pull requests.
Containers & Docker
Monitor container fleets, track Compose applications, view live CPU/memory resource stats, read log streams, and exec into container shells.
Manage Docker containers & Compose stacks
Control container lifecycles directly from the workspace sidebar or editor tabs.
- Group containers by repository, project group, or Docker Compose application stack.
- Start, stop, restart, pause, unpause, and remove containers with instant visual status indicators.
- Inspect container configuration JSON, environment variables, image tags, port mappings, and volume mounts.
Monitor container resource utilization
Track live CPU, memory, network, and disk I/O metrics in real time.
- View real-time CPU percentage gauge, memory usage and limit, network rx/tx bytes, and block I/O statistics.
- Historical resource utilization sparklines help identify memory leaks or CPU spikes during dev tests.
Stream logs and attach container terminals
Access container log outputs and run shell commands inside container environments.
- Stream live container stdout and stderr with search filtering, auto-scroll, and log download options.
- Exec directly into container interactive shell terminals (sh, bash) as dedicated PTY tabs.
- Pass container logs or execution error messages directly to AI chat for assistance.
Tasks & task tracking
Connect Jira, Monday.com, GitHub Issues, GitLab Issues, and ClickUp to view tasks, reply to comments, transition status, and launch AI agents on tasks.
Connect task trackers (Jira, Monday, GitHub, GitLab, ClickUp)
Set up multi-account API connections securely without exposing credentials.
- Connect Jira Software (JQL queries & Atlassian Cloud / Data Center), Monday.com (GraphQL board integration), GitHub Issues, GitLab Issues, and ClickUp.
- Configure credentials on the Flame host and review the permissions required by each tracker. Available task actions depend on the connected provider and your account access.
- Configure per-project board bindings so the Tasks panel automatically focuses on the active project's tracker when opened.
Full-page Task Tab: view, comment & transition status
Work with complete task descriptions, team comment threads, and status controls without leaving Flame.
- Click any task card to open a full-page editor tab featuring rendered Markdown descriptions, checklist checkboxes, and attachment previews.
- Read historical comments and post new replies directly from Flame, complete with smart @ user mention autocomplete.
- Transition task workflow status (e.g. To Do → In Progress → Done) directly via the status selector dropdown.
- Inspect attached images and downloadable files associated with the issue.
Filter, search, and organize assigned tasks
Find actionable work across connected accounts or project boards.
- Toggle between 'Assigned to me' account-wide scope and active project board scope.
- Filter by status category chips: To Do, In Progress, Blocked, and Done.
- Search task keys, titles, summaries, and labels with debounced instant search.
- Sort by last updated date, creation date, priority rank (P0 to P4), status category, task ID, or title in ascending or descending order.
One-click AI Agent handoff & auto-named branches
Bridge tasks directly into code changes and isolated worktrees.
- Click 'Start Agent on Task' on any card to pass task key, summary, description, comments, and attachments directly to an AI agent.
- Flame automatically generates sanitized git branch names (e.g. fix/FE-104-update-auth-flow) and optional isolated worktrees.
- Click 'Open Agent Chat' to jump back into the exact AI conversation that worked on or is currently working on the task.
- Agents can query issues, inspect details, and post progress comments using the list_issues, get_issue, and comment_on_issue MCP tools.
Diagnostics & auto-refresh settings
Understand connection state and customize background sync frequency.
- Review clear per-connection diagnostics explaining query counts and error hints so an empty panel is never ambiguous.
- Configure background auto-refresh intervals in Settings → Tasks to keep task status synced automatically.
Internal browser + AI
The browser built into the Flame desktop app keeps rendered output, console evidence, DOM state, screenshots, and code changes in one workspace.
Browse inside Flame
Keep a live page next to the code that produces it.
- Navigate, reload, search history, favorite a page, pin the tab to a project, zoom, or open DevTools.
- Switch among Desktop, Tablet, and Mobile sizes or customize the responsive viewport.
- Use browser profiles when pages need separate cookies or custom headers.
Good to know: Flame's internal browser and its capture tools are available in the desktop app, not the plain web build. Browser Bridge is a separate Chrome extension.
Link to this guideCompare two live page states
Find visual and structural regressions without exporting screenshots first.
- Compare two live panes at Element, Viewport, or Full page scope.
- Measure a pixel mismatch, use an opacity overlay, and inspect a DOM diff in the editor.
- Assign a different browser profile to each side when authentication or headers should differ.
Send useful browser evidence to AI
Let the agent inspect the same page instead of describing it from memory.
- Ask about this page, stage a Fix an issue report with console errors, or attach a viewport or selected element screenshot.
- The agent can read rendered text, DOM, console logs, load failures, screenshots, and interactable elements from an open browser tab.
- Clicks, typing, navigation, and other page-changing actions require permission; staged browser reports remain reviewable before you send them.
Browser Bridge extension
Browser Bridge is a separate Chrome extension, not Flame's internal browser. Use it when an agent needs an explicitly paired, observable connection to your real Chrome profile.
Install and pair the extension
Create a local, revocable connection between Chrome and the Flame instance on the same computer.
- Install directly from the official Chrome Web Store listing.
- Start Flame IDE, open Settings > Browser Control > Chrome Browser Bridge, and select Create pairing code.
- Open the Flame Browser Bridge extension popup in Chrome, review the data-use disclosure, paste the 6-digit code, and select Pair with Flame.
Good to know: Pairing is loopback-only. The extension discovers the local Flame instance automatically, including after its port changes. The short-lived, single-use code grants a dedicated bridge token rather than Flame's host API token.
Link to this guideInspect and control real Chrome tabs
Give an agent browser evidence from the profile you already use for development and testing.
- List, activate, and navigate tabs; read rendered text or HTML and accessibility-oriented element snapshots; and capture viewport, full-page, or element screenshots.
- Inspect console errors and Chrome DevTools Protocol (CDP) network events, or run approved page JavaScript when deeper debugging is needed.
- Approve trusted mouse and keyboard input, cookie changes, or per-tab request and response header overrides through Flame's normal agent permission prompts.
Good to know: Chrome blocks control of internal and other restricted pages (such as chrome:// URLs). Incognito access is not enabled for the extension.
Link to this guidePause, forget, or revoke access
Keep the bridge visible and remove its access as soon as you no longer need it.
- Use the extension badge and popup to confirm the bridge is on (ON badge), or choose Pause to detach debugger sessions, remove temporary header rules, and clear captured console and network state.
- Choose Forget to remove the pairing from Chrome, or revoke it from Flame Settings to invalidate the bridge token and clear Flame's in-memory activity trail.
- The passive activity trail can include clicks, focus changes, scrolling, special keys, and input length, but it never captures typed input values.
Good to know: Browser data stays on the loopback connection to the local Flame server. Learn more on the Flame Browser Bridge overview page or read the Flame Browser Bridge privacy policy.
Link to this guideTerminals, tests & debugging
Keep command output, test results, and debugger state connected to the active project and agent conversation.
Inspect structured logs
Turn files, pasted output, Docker logs, and terminal snapshots into searchable log entries.
- Open Log Viewer from New tab → More tabs, or use Open in Logs Viewer from a container or terminal.
- Open or drop text and gzip files, or paste logs. Flame detects JSON / JSONL, syslog, logfmt, Apache / Nginx, W3C, CSV / TSV, Kubernetes, runtime, and plain-text formats.
- Combine search, severity, structured field, and time filters. Use the Activity timeline, inspect an entry's original text, or switch to Raw text and search with Ctrl/Cmd+F.
- Choose Ask AI after loading logs, then enter your question. Flame stages a bounded sample of matching entries with secrets masked, even if they are revealed in the viewer. The agent can read more and request filter changes, which require confirmation.
- Export matching entries as CSV or JSON Lines. Exports respect the current reveal setting. Docker, terminal, and Flame log sources support manual and optional automatic refresh of bounded snapshots.
- Files are parsed on the Flame host by its authenticated backend. Uploads are limited to 25 MiB, gzip expansion to 100 MiB, and parsing to 200,000 entries and 256 KiB per line.
Use real project terminals
Open as many shells as the project needs and keep their output visible.
- Split terminals side by side, search output, save reusable commands, mirror a terminal in an editor tab, or open it in a separate window.
- Broadcast one templated command across selected projects in parallel or sequence, guard dangerous commands, and retry only failed targets.
- Fix with AI stages recent output, the working directory, and changed files; permissioned tools can also read output or run a visible command.
- The Resources tab shows CPU and memory for Flame, language servers, agents, and each terminal. Turn on Always monitor to badge a terminal that passes the memory threshold or keeps a CPU core busy for too long. See the Integrated Terminal guide.
Run tests from one explorer
Discover supported suites and keep results attached to their project.
- Test Explorer supports Vitest, Jest, node:test, Pytest, Go test, Cargo test, and Flutter test adapters.
- Run discovered tests, inspect grouped assertions, and view coverage gutters directly in editor tabs.
- An agent can run selected tests and read structured results through permissioned IDE tools.
Debug with Node or DAP
Use one interface for the built-in Node debugger and external Debug Adapter Protocol tools.
- Set breakpoints; start, continue, pause, stop, step over, step into, or step out.
- Inspect the call stack, scopes, variables, watch expressions, and Debug Console while paused.
- Node uses Flame's built-in Inspector backend; other runtimes need a configured external DAP adapter.
Python development
Keep each service's environment, data models, tests, and profiling tools connected to its project.
Select a Python environment per project
Discover existing environments or create one with the appropriate toolchain.
- Select among detected virtualenv, Conda, Poetry, Pipenv, system, or custom interpreters. Flame stores the chosen executable per project.
- Create a virtualenv with uv or venv and use the project's intended install or sync workflow. Supported isolated runtime downloads need host and network support.
- Pyright, Ruff, debugpy, and Jupyter kernels require their appropriate installation or project configuration.
Inspect Python types and data models
Make an untyped boundary or an unexpected payload easier to inspect.
- Generate .pyi stubs for supported targets and review the resulting signatures.
- Inspect supported Pydantic, dataclass, NamedTuple, and TypedDict definitions, read the schema, and validate a sample JSON payload.
- Use the Python development guide for a complete environment-to-regression-test workflow.
Test and measure the Python workload
Connect Pytest cases, fixtures, coverage, and profiling evidence.
- Run Pytest through Test Explorer, inspect parameterized tests and fixture relationships, and supply compatible coverage output for editor coverage views.
- Python CPU profiling uses py-spy with a cProfile fallback. Memory tools such as memray depend on platform, installation, and permissions.
- The Python profiling path differs from the Node Inspector engine; choose tools for the actual runtime.
Flutter & mobile
Manage physical devices and emulators, trigger hot reload, run doctor diagnostics, launch DevTools, and execute Flutter test suites.
Flutter with Mobile Preview
Keep a running device beside the editor and connect it to the Flutter run target.
- Follow the Flutter development workflow for SDK setup, device selection, hot reload, and project terminal commands.
- Use Mobile Preview to choose a connected phone or start a configured emulator. Select its running device in the Flutter status bar once Flutter detects it.
Device discovery & Android emulator management
Connect mobile devices and launch emulators from Flame's status bar.
- The Flutter status bar item automatically detects connected physical Android/iOS devices, running emulators, and desktop/web targets.
- Launch configured Android Virtual Devices (AVDs) directly from the device picker popover.
- Switch active deployment targets without running terminal CLI commands.
Run apps with Hot Reload & Hot Restart
Iterate using Flutter's run and reload controls.
- Launch apps in debug, profile, or release mode with custom entry points directly into an integrated terminal session.
- Use Hot Reload (r) to apply compatible Dart changes in a running debug session. Hot Restart (R) restarts the app and resets its state.
- Stop running sessions cleanly from the status bar or sessions management tab.
Flutter Doctor diagnostics & DevTools integration
Inspect toolchain health and open performance instrumentation.
- Run 'Flutter Doctor in Terminal' from the status bar menu to audit Android SDK, Xcode, Chrome, and VS toolchains.
- Click DevTools to automatically launch Flutter's web-based performance, memory, and widget inspector attached to your app's VM Service URI.
- Manage pubspec.yaml dependencies and run flutter pub get or melos commands directly.
Flutter testing in Test Explorer
Run and diagnose Flutter test suites alongside your code.
- Test Explorer discovers and organizes flutter test suites across test/ directories.
- Run individual test files, suites, or failing assertions with detailed stack trace parsing.
- AI agents can run flutter test suites and resolve test failures autonomously in isolated worktrees.
Profiler & host ports
Inspect interactive flame graphs, trace memory leaks, mark hot source lines, and monitor or terminate listening sockets across your machine.
Record CPU Flame Graphs & hot execution lines
Identify execution bottlenecks in Node.js applications with visual call trees.
- Record CPU profiles from Flame's built-in Node debug engine to generate interactive, searchable Flame Graphs.
- Inspect top-down and bottom-up call stacks with total and self-time execution percentages.
- Flame marks hot source lines directly in Monaco editor gutters so performance bottlenecks are visible while editing.
- Use 'Optimize with AI' to hand off profiling flame graphs and hot functions directly to an agent for targeted optimization.
Heap memory snapshots & leak detection
Track memory growth and identify retainers across application lifecycles.
- Capture V8 heap snapshots and inspect object allocation tables, retained sizes, and constructor names.
- Compare two heap snapshots taken at different times to surface memory leaks and lingering closures.
- Inspect object retainer trees to understand what is preventing garbage collection.
Inspect and manage host listening ports
Monitor active listening sockets and terminate stale background processes.
- The bottom-panel Ports tab enumerates all listening TCP sockets on your machine with PID, process name, protocol, and project attribution.
- Open any listening port in Flame's internal browser or your system browser with one click.
- Inspect the owning process before stopping a conflicting dev server. Process termination uses the host platform's supported controls.
- Pin favorite ports and filter out background system daemons to keep your development ports clear.
- Stop gracefully then by force, stop with child processes, or force kill. Flame's own processes are protected, and Docker-published ports point you to the container instead.
Git, agents & safety
Use isolation, visible evidence, permission boundaries, Git graphs, notes, and AI code review to keep automation under your control.
Commit with checks, conventions, and AI messages
Catch leaked keys, follow the team's commit style, and fix failing hooks before the commit lands.
- The Changes panel tracks files, line deltas, and size on disk, groups nested changes by folder, and flags unsaved editor tabs.
- A secret scanner checks changed lines for API keys, tokens, private keys, and credential URLs, and links each finding to its line.
- Choose Conventional Commits, Task-first, Linux-kernel style, Semantic Commit Messages, or a custom convention from Settings → Git → Custom commit conventions. Generate commit message drafts the message in that style.
- When a pre-commit or commit-msg hook fails, Fix with AI stages its output in a chat. See the Commit Assistant guide.
Explore commits with the interactive Git Graph
Read commit lanes, branches, tags, and diffs on a visual canvas.
- View full commit history across branches with colored visual commit lanes, tag labels, and HEAD indicators.
- Click any commit to inspect author metadata, changed file lists, and side-by-side diffs in the commit details panel.
- Perform interactive Git actions directly from the graph: cherry-pick, reset, revert, create branch, or create tag.
Attach metadata with Git Notes
Read, write, and sync git notes without modifying commit hashes.
- Inspect, add, edit, or append Git notes (git notes) directly from commit cards and history views.
- Support for custom note namespaces and refs/notes/* synchronization with remote repositories.
- Automated merge conflict resolution strategies for notes: union, ours, theirs, and cat_sort_uniq.
Interactive squash & submodules management
Clean up local history and coordinate nested repositories.
- Use the interactive Squash Dialog to combine the last N commits or a selected commit range with custom messages.
- The Submodules view inspects pointer commit SHAs, branch tracking, and dirty states for nested repositories.
- Initialize, sync, and update submodules or open them directly as standalone projects or worktrees.
AI Code Review & Monaco review threads
Request automated AI reviews and discuss findings inline in diff editors.
- Run AI code reviews on uncommitted changes, branches, or specific commits with customizable focus prompts.
- Findings are categorized by security, bug, performance, style, and maintainability with severity badges (critical, warning, info).
- Review findings appear as durable, line-anchored review threads in Monaco diff editors where you can reply or resolve items.
- Configure organizational review instructions in Settings → AI → Code review to enforce team coding standards permanently.
My Activity Dashboard & automated standup summaries
Track cross-project activity and generate natural-language status reports.
- View aggregated commits, branches, pull requests, CI pipeline statuses, and assigned issues across every project in your workspace.
- Track active development time per project with idle-gated precision.
- Generate automated AI standup summaries that narrate your accomplishments over a chosen timeframe, ready to export.
Resolve conflicts in context
Work through current, merged, and incoming content in one dedicated view.
- Move between conflict blocks and accept current, incoming, both, or the base version when available.
- AI resolve proposes a block or file result for review; it does not write or stage the proposal automatically.
- Save a partial resolution at any time, then Mark resolved & stage only after every conflict marker is gone.
Manage agent work as jobs
Turn longer tasks into observable work with a clear checkout and landing path.
- Choose a primary project, optional extra projects, provider and model, and whether to isolate the job in a new worktree.
- Run now, schedule a job, or wait for another job; monitor status, logs, questions, and terminal activity.
- After review and a deliberate commit, choose local merge, branch push, or push and prepare a PR/MR form. Submit the prepared form on the provider. Automatic landing is a separate opt-in policy.
Run your scripts on agent events
Agent hooks run shell commands when a prompt is submitted, a tool runs, an agent waits for you, or validation fails.
- Configure hooks in Settings → AI → Agent hooks, or per group or project. Each command receives the event as JSON on stdin.
- Thirteen events cover sessions, prompts, responses, permissions, tool calls, and validation. Hooks observe and cannot block or change the agent's actions.
- Recent runs show stdout, stderr, exit code, and timeouts. See the Agent Hooks guide.
Inspect native delegated workers
Distinguish workers inside a conversation from independent manager jobs.
- On supported native Claude sessions, toggle Multi-agent mode beside Plan Mode. Auto lets the lead assign read-only research and review; the lead keeps edits, commands, and synthesis.
- Open Agents in chat or expand a team in the manager to inspect recorded worker assignments, activity, reports, and pending requests. Claude and Copilot observation depends on runtime capabilities.
- Direct child stop, follow-up, retry, and isolated writer controls are unavailable. Codex and Antigravity retain ordinary sessions without Flame-managed native teams.
- Interrupted work remains available for inspection after a backend restart; Flame does not automatically rerun uncertain worker execution.
Fork a conversation or continue after a usage limit
Keep an alternative investigation separate and preserve a scheduled retry.
- Use a message's actions to Fork from here or Fork in new tab. Navigate the parent or related forks from conversation controls. A fork preserves checkout context; it does not create a worktree.
- On a usage-limit error, choose Continue when limits reset or Choose continuation time. Flame persists the pending prompt and its context; execution needs the backend to be running.
- Review the optional keep-awake choice. Host shutdown still prevents execution, and uncertain in-flight sends pause for review instead of silently repeating tool work.
Import and export chat history
Keep useful past conversations alongside the right project.
- Open Settings → AI → Import and export chats. Scan supported Claude Code, Codex, or Copilot histories on the Flame server computer, or choose supported export files.
- Claude and ChatGPT account exports and Flame chat archives are also supported. Preview titles and dates, filter the list, select conversations, and map them to projects or global chats before import.
- Export selected conversations without changing their source histories. Imported worker summaries are history, not running workers; importing does not resume execution.
Keep AI actions explicit
Flame gives agents useful tools without pretending they see or control everything.
- Chats receive active editor context; files, snippets, images, browser pages, and terminal output can be attached deliberately.
- File writes, terminal commands, browser interactions, and IDE mutations follow permission rules and visible tool activity.
- Browser Fix an issue and terminal Fix with AI stage evidence for review; the conflict editor's AI returns a proposal you decide whether to save.
- When an agent needs human guidance mid-task, it raises interactive structured questionnaires with selectable options and write-in fields.
Set up agent work validation
Let Flame run configured final checks after an agent turn and review the results before committing.
- Configure Agent work validation in Settings → AI, Project Settings, or Group Settings. Add shell commands, npm scripts, or an independent AI review, then save the validation editor.
- Use More chat actions → Validate agent work to control validation for the conversation. Plan, discussion, and simple-chat turns do not run validation.
- Flame holds the chat's Ready to commit? card until the configured checks pass or you explicitly ignore validation. Direct Git operations and the Changes panel remain available.
- For commands that accept file paths, use {{files}} as a separate, unquoted argument, such as npx eslint -- {{files}}. Keep whole-project checks such as typechecking free of that placeholder.
Good to know: Checks resolve separately for each assigned project. A skipped check is not a passing check, and validation covers only the rules you configured.
Link to this guideChoose how agent work lands
Merge locally, push a branch, or prepare a pull request after reviewing committed work.
- Set the Agent landing default in Settings → Projects. A job's explicit choice takes precedence, followed by project, group, and global settings.
- Merge into local base integrates the branch and removes the worktree after success. Push branch only publishes commits and keeps the worktree.
- Push and prepare PR/MR publishes the branch and opens the host's prefilled creation page. Submit the form yourself; preparing the link does not create a pull request.
- Choosing a landing method does not enable automatic execution. Automatic landing is a separate policy, and commit requirements and protections still apply.
Plan Mode: inspect, review, and approve before execution
Generate and edit an implementation plan with read-only tools before approving execution. Tool gating is separate from an operating-system sandbox.
- Server-owned lifecycle: Plan Mode enforces a 4-phase state machine (planning → review → executing → completed) persisted across UI reloads so the review gate cannot be bypassed.
- Plan Mode is supported by Claude Code, Codex, and GitHub Copilot with runtime-specific read-only controls. Antigravity is not supported because its headless protocol cannot provide Flame's required tool gate.
- Plan tab: The generated plan is saved as Markdown and opens in a dedicated Plan tab with decisions first, each option's consequence and a recommendation, an At a glance summary, optional architecture diagrams, section feedback, and saved versions. Open .md file shows the same document in the normal Markdown editor.
- Review and approval: Ask AI about a section or the whole plan, request a revision in another read-only planning pass, then choose Approve & Implement to unlock write tools and execute the saved plan with your decisions. Approve; AI uses the recommended options settles any open decisions explicitly.
- Session continuity: Planning and execution stay in the same runtime session, retaining codebase context and indexing without redundant analysis.
Good to know: Store plans in the project is on by default. Flame uses an existing project plans/ folder, otherwise the project root. Turn it off to use the app-data plans folder.
Link to this guideConfigure Task Reference Patterns with predefined regex
Auto-detect task keys in commits, branches, and terminal output using built-in tracker regex presets.
- Select built-in predefined regex presets for Jira ([A-Z][A-Z0-9]+-\d+), Monday.com (MON-\d+|#\d+), GitHub Issues (#\d+), GitLab, and ClickUp.
- Optionally override or customize regex capture groups and target URL templates (e.g., https://jira.company.com/browse/$1).
- Detected task keys in commit history, branch names, diff titles, and terminal output are rendered as clickable links and AI agent target triggers.
Remote Access & SSH
Use encrypted phone access through Flame Secure Relay, or connect a development host over SSH. Each serves a different workflow.
Connect to remote dev machines over SSH (Remote Hosts)
Run a Flame backend on a remote development host and work through the local desktop UI.
- In Settings → Remote Hosts, configure remote dev targets with Host, User, Port, Identity File (SSH private key), and ProxyJump (bastion host) settings.
- Flame opens an SSH connection, automatically deploys and supervises its backend server on the remote machine, forwards ports, and launches a remote workspace.
- All files, terminals, language servers, testing, debugging, and AI agent executions run on the remote machine while you use Flame's local desktop UI.
Pair Flame Mobile through Secure Relay
Use the recommended end-to-end encrypted path without opening a listening port.
- Flame Mobile for iOS and Android will be available soon. When you have access to the native app, open Remote Access in Flame Desktop and choose Secured Access.
- Generate a short-lived QR code and scan it inside the Flame Mobile app. The QR pins the desktop's identity key.
- Enter the two-digit number shown on the phone into Flame. The phone remains paired until its expiry or until you revoke it.
Good to know: A QR image alone is not enough to finish pairing: approval requires the two-digit code to be entered by someone at the host.
Link to this guideRemote Access controls & mobile companion
Use Secure Relay for the native companion and turn access Off when you do not need it.
- Secured Access uses Flame Secure Relay with an end-to-end encrypted Noise IK channel. The host and phone both connect outward; no public desktop URL or inbound mobile port is needed.
- Off immediately closes relay connections, cancels unused pairing codes and pending approvals, and leaves desktop host access available.
- Mobile Companion: receive real-time permission approval prompts on your phone when an agent asks to edit files or run commands, browse files, and chat with running agents.
Flame Mobile companion app (iOS & Android)
Available soon for iOS and Android. Follow agents, review changes, manage shared todos, and reach your connected workstation from a native app.
- End-to-end encrypted Remote Access: Pair the native app through Flame Secure Relay. The relay carries ciphertext and connection metadata without receiving the workspace session key.
- AI Coding Assistant On the Go: Chat with models configured on your desktop (Claude Sonnet, OpenAI, Google Gemini, or local models via Ollama). Answer tool execution prompts, inspect proposed file changes, and unblock autonomous agent tasks in real time with syntax highlighting and mobile-tailored Markdown.
- Streamlined Git Management: View working tree status, staged vs. unstaged files, and ahead/behind commit counts. Review unified line diffs with syntax coloration, stage changes, compose commit messages, and push branches directly from your device.
- Real Mobile Terminal: Access a complete, responsive shell with dedicated developer keyboard keys (Ctrl, Esc, Tab, arrows, pipe), full ANSI colors, and fluid scrollback history.
- The relay transports encrypted workspace traffic. Requests you send to a cloud AI or speech provider still follow that provider's data handling, so review the configured providers separately.
Control paired devices
Manage a paired phone's access to the workstation and end connections when needed.
- Set or change a device expiry. Pairing codes are single-use, and pending codes expire after three minutes.
- Revoke a device to close its live connections immediately and reject future reconnects.
- Rotate the host identity when you want a clean slate; every paired device must scan and pair again.
Understand what the relay can see
Encryption protects content, but it does not erase connection metadata.
- The relay never receives the end-to-end session key or plaintext files, requests, terminal data, Git content, or AI conversation content.
- It can observe that a registered host is online, rotating rendezvous identifiers, connection timing and byte volume, and the two live socket IP addresses while the connection exists.
- The current client is the native Flame Mobile app. Its device access is limited to the host's advertised capabilities; host-only routes remain unavailable to paired devices.
Disable relay contact
Use environment controls when an organization needs a stricter deployment policy.
- Set FLAME_RELAY_DISABLED=1 to prevent contact with the configured relay and bootstrap origins. This does not disable update checks or optional error reporting.
- Set Remote Access to Off in Flame when you do not need paired-device connections.
Capabilities at a glance
Look up supported tools, configuration scopes, and access boundaries.
Worktree actions
- Create
- New or existing branch, chosen base, sibling folder, and optional open-as-project.
- Inspect
- Branch, path, SHA, state, and changed-file count.
- Finish
- Open changes, bring changes for review, lock, remove, or prune.
API Client capabilities
- Protocols & Methods
- REST, GraphQL, GET, POST, QUERY, PUT, PATCH, DELETE, HEAD, OPTIONS, CONNECT, TRACE.
- Authentication
- Inherit, Bearer, Basic, API Key (header/query), OAuth 2, JWT, custom headers.
- Body formats
- Raw text, JSON, XML, URL-encoded, Multipart form-data, Binary, GraphQL.
- Environments
- Hierarchical variables across Global, Group, and Project scopes with {{NAME}} syntax.
- Import / Export
- cURL, OpenAPI specs, HAR, and Flame collection JSON.
- Agent MCP tools
- list_api_requests, create_api_request, update_api_request, remove_api_request, send_api_request.
Dependency Auditor
- 9 Ecosystems
- npm (JS/TS), cargo (Rust), pip (Python), go (Go), composer (PHP), bundler (Ruby), maven (Java), gradle (Android/Kotlin), pub (Dart/Flutter).
- Security audits
- Vulnerability scans ranked Critical, High, Moderate, Low, Info with fixed version targets.
- Remediation
- One-click 'Fix with AI' launching an agent in an isolated worktree to upgrade and test code.
- Reports
- Exportable Markdown reports for vulnerabilities, outdated packages, and combined audits.
Profiler & Ports
- CPU Flame Graphs
- Interactive visual call trees, function timing breakdowns, and hot line editor markers.
- Heap Snapshots
- V8 heap capture, retainer trees, and allocation delta comparison between snapshots.
- Listening Ports
- Host TCP socket scanner with PID attribution, project detection, and browser preview launch.
- Process Termination
- Inspect the owning process and stop it using the host platform's process controls.
Flutter & Mobile
- Device Management
- Status-bar selector for physical Android/iOS devices, Chrome web, and AVD emulators.
- App Runner
- Debug, profile, and release execution with Hot Reload (r) and Hot Restart (R).
- Doctor & DevTools
- flutter doctor -v in terminal and automatic VM Service DevTools browser launch.
- Test Explorer
- First-class flutter test discovery and assertion execution.
Internal browser evidence
- Read
- Rendered text, live DOM, console logs, errors, and load failures.
- Capture
- Viewport, full-page, or element screenshots with optional interactable bounds.
- Act
- Permissioned navigation, clicks, typing, selection, hovering, and key presses.
Containers & Docker
- Containers
- Lifecycle controls (start, stop, restart, pause, remove), image tags, status tones.
- Compose
- Stack grouping, compose project attribution, multi-container lifecycle execution.
- Stats
- Real-time CPU %, memory usage, network rx/tx, disk block I/O charts.
- Terminal & Logs
- Live stdout/stderr stream, interactive shell PTY exec tabs.
Run tooling & Configurations
- Run Configurations
- Ordered package, shell, file, embedded/external browser, test-watch, and HTTP actions.
- Dynamic Sources
- envSources loading variables from file (.env, .json), command stdout, or API endpoints.
- Teardown Actions
- Session stop and window unload actions (npm scripts, terminal commands, HTTP requests).
- Tests
- Vitest, Jest, node:test, Pytest, Go test, Cargo test, and Flutter test.
- Debug
- Built-in Node Inspector or a configured external DAP adapter.
- Terminal
- Multiple PTYs, split panes, saved commands, popout, and multi-project broadcast.
Flame Browser Bridge
- Pair
- Chrome 116+, a short-lived single-use code, and a loopback-only connection to the local Flame IDE.
- Inspect
- Tabs, rendered content, element snapshots, screenshots, console output, and network events.
- Control
- Permission-gated input, navigation, page JavaScript, cookies, and per-tab header overrides.
- Disconnect
- Pause to clear temporary sessions and buffers; forget or revoke to invalidate the pairing.
Configuration boundaries
- Global
- Personal IDE behavior, providers, runtimes, tooling, appearance, input, integrations, and host-level controls.
- Group
- Shared run configurations and worktree defaults inherited by member projects.
- Project
- Repository-specific launch, worktree, review, restore, script, and color preferences.
- .flame.json
- Versioned team configuration file at repository root with automated secret scrubbing.
- Portable
- Versioned JSON bundle with secrets, project roots, histories, and run-configuration environment maps excluded.
Remote Access modes
- Off
- No paired device can connect.
- Secured Access
- Native Flame Mobile pairing through end-to-end encrypted Secure Relay (Noise IK protocol). Flame Mobile is available soon.
- Remote Hosts
- SSH remote development with automated server deployment and port forwarding.
Task reference patterns
- Predefined presets
- Built-in regex presets for Jira ([A-Z][A-Z0-9]+-\d+), Monday.com (MON-\d+|#\d+), GitHub Issues (#\d+), GitLab, ClickUp, Linear, and Trello.
- Custom regex
- User-configurable regex capture groups for internal or proprietary task tracking tools.
- Destination URLs
- Templated link formats using replacement tokens like $1 or {id} to construct deep links.
AI Agent Plan Mode
- Supported runtimes
- Claude Code, Codex, and GitHub Copilot. Antigravity does not support Plan Mode.
- Planning phase
- Runtime-specific read-only controls restrict execution while the plan is prepared and reviewed.
- Review phase
- Plan persisted to Markdown and opened in the Plan tab; the developer settles decisions, comments on sections, asks AI, edits the text, or requests a revision.
- Approval & execution
- Server re-reads edited Markdown as authoritative instruction, unlocks execution in the same session.
- Persistence
- Review gate and plan state are persisted with the conversation, surviving window or IDE restarts.
A faster way around
These are the default Flame bindings. Use Command on macOS and Ctrl on Windows or Linux. Presets and custom keybindings may differ; check Settings → Shortcuts.
- Open command palette
- Cmd/Ctrl Shift P
- Quick open file
- Cmd/Ctrl P
- Focus Search panel
- Cmd/Ctrl 5
- Focus Files tree
- Cmd/Ctrl 1
- Focus Changes / Git
- Cmd/Ctrl 2
- Focus AI Chat
- Cmd/Ctrl 3
- Toggle terminal panel
- Cmd/Ctrl J
- Open Keyboard Cheat Sheet
- Cmd/Ctrl Shift H
- Start or continue debugging
- F5
- Toggle breakpoint
- F9
- Step over debugger
- F10
- Step into debugger
- F11
- Open quick action / search
- Cmd/Ctrl K
- Open Settings
- Cmd/Ctrl ,
Get back to building
Start with the active project, required local tools, and permission settings.
A project does not appear.
Confirm that the projects root is the parent folder, clear the active search or group filter, and refresh the Projects panel. Hidden or removed projects stay out of the list.
A worktree is marked Missing or Prunable.
Check whether its folder still exists. Open it if the path is valid, or use Prune to remove stale Git worktree metadata before creating a replacement.
The agent can read a page but cannot click or type.
Keep the browser tab open, then approve the requested browser interaction. Reading page state is separate from permission to navigate, click, type, or select values.
Tests do not appear in Test Explorer.
Confirm that the project uses a supported adapter (Vitest, Jest, node:test, Pytest, Go test, Cargo test, or Flutter test) and that its runner is installed in the project or available on PATH, then refresh discovery.
Flutter devices or emulators are not detected.
Ensure flutter is installed and available on PATH. Run 'flutter doctor -v' via the status bar menu to verify Android SDK, Xcode, or Chrome dependencies, then click Refresh Devices.
A Run Configuration fails with missing variable errors.
Check whether your dynamic environment sources (envSources) are accessible. If using a file source (like .env.local), verify the file exists or mark the source as Optional so execution is not blocked.
SSH Remote Host fails to connect.
Verify that the remote machine has OpenSSH running and accepts key-based authentication. Confirm your private key path in Identity File and verify ProxyJump syntax if connecting through a bastion jump host.
Docker containers do not appear in the Containers tab.
Ensure Docker Desktop or the Docker daemon engine is running on your host system, then refresh the Containers panel.
Mark resolved & stage is disabled.
Conflict markers still remain in the merged file. Resolve or remove every marker, save the result, review the diff, and then stage it.
Flame Browser Bridge will not connect.
Confirm Flame is running on the same computer, then use Retry now in the extension. It discovers the local IDE automatically. If pairing has expired, create a fresh code in Settings > Browser Control > Chrome Browser Bridge. A manual loopback address remains a fallback when discovery is unavailable.
My phone has scanned the QR but is not paired.
Scanning the QR does not grant access. Enter the two-digit number shown on the phone into Flame Desktop, then choose the device access duration. If the code has expired, generate a new QR and start again. Keep the host running and connected to the network.
Imported configuration is missing a credential or environment value.
That is intentional. Flame excludes provider and browser credentials, removes Run Configuration environment maps, and redacts secret-looking values from portable exports. Configure those values locally on the new device.