Build with Flame

• 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.

• In Project Settings, select Export to project root to generate a clean .flame.json or .flame.jsonc configuration file.
• Configure runConfigs, worktreeInitScript (e.g. npm ci), worktreeCopyFiles (e.g. .env.local), review instructions, and favorite package scripts in one place.
• When opening any repository containing .flame.jsonc or .flame.json, Flame automatically loads its settings as initial repository defaults.
• Flame's secret scrubber automatically redacts credentials, passwords, and sensitive environment maps before the file is written to disk.

Good to know: If both exist, .flame.jsonc takes precedence over .flame.json. Comments and trailing commas are fully supported in JSONC.

• In Settings → AI → Agent runtimes, choose Claude Code, OpenAI Codex, 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.

• 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.

• 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 handles token counting, full streaming chunks, and tool calling seamlessly with per-process random authentication tokens.

• 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.

• 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.

• 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.

• 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.

• 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.

• Flame runs local Whisper speech-to-text completely on device; no audio data or transcripts leave your machine.
• Speak wake phrases such as 'Hi Flame' to start dictating prompts directly into AI chat or editor buffers.
• Voice commands support common navigation actions like opening files, switching projects, and triggering agent runs.

• 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.

• 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.

• 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.

• 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.

• 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.

• 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.

• 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.

• 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.

• 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.

• 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.

• 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.

• Flame takes automatic local snapshots on file save, code format, and before risky Git operations (stash, reset, checkout).
• 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.

• 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.

• 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.

• 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.

• Flame exposes 28 targets: PostgreSQL wire (TimescaleDB, Supabase, Neon, AlloyDB, CockroachDB, YugabyteDB, Amazon Redshift, Greenplum), MySQL wire (MariaDB, TiDB, SingleStore, PlanetScale, OceanBase, StarRocks, Apache Doris), MongoDB wire (FerretDB, Amazon DocumentDB), Redis wire (Valkey, KeyDB, Dragonfly), Microsoft SQL Server, ClickHouse, SQLite, and DuckDB.
• 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.

• 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).

• 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.

• Attach table definitions, column types, or failing query error messages to AI chat.
• Let agents generate parameterized SQL, optimize slow queries, or write migration scripts with full context.
• Agents can inspect schemas, execute queries, and update query tabs through permission-gated database MCP tools.

• 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.

• 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 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.

• 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.

• 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.

• 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.

• 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.

• 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.

• 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 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.

• Connect Jira Software (JQL queries & Atlassian Cloud / Data Center), Monday.com (GraphQL board integration), GitHub Issues, GitLab Issues, and ClickUp.
• Token credentials remain safely isolated on the host process using OS keychain encryption and are never written to renderer stores or crash logs.
• Configure per-project board bindings so the Tasks panel automatically focuses on the active project's tracker when opened.

• 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.

• 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.

• 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.

• 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.

• 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.

• 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.

• 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.

• 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 (127.0.0.1:4317). The code is short-lived and single-use, and the extension receives a dedicated bridge token rather than Flame's host API token.

• 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.

• 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.

• 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.

• 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.

• 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.

• 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.

• Launch apps in debug, profile, or release mode with custom entry points directly into an integrated terminal session.
• Trigger Hot Reload (r) or Hot Restart (R) with one click to update UI state instantly while preserving app memory.
• Stop running sessions cleanly from the status bar or sessions management tab.

• 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.

• 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.

• 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.

• 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.

• 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.
• Kill rogue or conflicting dev servers (e.g. EADDRINUSE errors) using graceful SIGTERM escalation to SIGKILL across the full process tree.
• Pin favorite ports and filter out background system daemons to keep your development ports clear.

• 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.

• 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.

• 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.

• 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.

• 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.

• 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.

• 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.
• Review and land completed work by merging, pushing, or opening a pull request; opt-in auto-merge can land successful jobs automatically.

• 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.

• 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.
• Strict read-only tool gating: During planning and review, all file writes, shell commands, database mutations, and browser actions are denied regardless of saved permission rules.
• Native Markdown editor tab: The generated plan is saved to disk and automatically opened as a standard editable editor tab for human review and refinement.
• Interactive review card: Approve the plan to unlock write tools and execute the exact edited document, or choose Request Changes to provide feedback for another read-only planning pass.
• Session continuity: Planning and execution stay in the same runtime session, retaining codebase context and indexing without redundant analysis.

Good to know: Plans default to <app-data>/plans/<project>/, or can be stored directly in <project>/plans/ by enabling 'Store plans in the project' in Settings.

• 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.

• 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.

• Open Remote Access from the phone icon in Flame's status bar and choose Anywhere.
• Scan the short-lived QR code. On the phone, confirm that its six-word computer fingerprint matches the six words in Flame.
• 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.

• Anywhere mode: end-to-end encrypted through Flame Secure Relay (Noise_IK protocol) keeping your server on loopback.
• Same Wi-Fi mode: fast unencrypted direct connection for trusted local networks (FLAME_BIND_HOST=0.0.0.0).
• Secure tunnel mode: automatic Cloudflare quick tunnel (cloudflared) or custom named tunnel (FLAME_PUBLIC_URL).
• 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.

• 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.

• 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 browser client is JavaScript served from connect.flame-ide.com. That delivery origin and its build pipeline are inside Flame's trust boundary; a compromised client delivery path could read plaintext.

• 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.