Local project workspaces
Create, import, list, search, update, archive, and remove project records while keeping the repository files where they already live.
FORGE / FEATURE REFERENCE
Forge,
feature by feature.
Forge is a local-first workspace for software work. This reference covers its surfaces, operations, boundaries, and integrations.
Workspace foundations
Start with a project
and keep it close.
Repository inspection
Inspect repositories, dependencies, symbols, architecture, onboarding context, branches, diffs, and project activity from one workspace.
Tasks and activity
Review background work, task status, recent activity, and recoverable async operations while keeping the project thread.
Command palette
Search commands, projects, sources, tasks, and product surfaces from a keyboard-first command palette that stays closed until you open it.
Settings and capability status
Choose privacy mode and model provider, review desktop permissions, inspect connection status, and keep local configuration visible.
First-run walkthrough
A persistent onboarding guide introduces project creation, repository connection, and the first analysis, with progress that can be resumed from Launch.
Neuron
Ask better questions
of your project.
Project-scoped questions
Ask questions using approved project context, with provider selection and invocation boundaries that respect the active workspace.
Resource indexing
Index local resources and keep source boundaries, freshness, citations, and provenance attached to the material Neuron uses.
Hybrid retrieval
Search with lexical, vector, hybrid, and reranked retrieval strategies so useful answers can be found across the project's connected resources.
Connected resources
Add, list, query, and remove local knowledge sources without pulling in unrelated material.
Durable memories
Review and manage accepted memories so useful context can persist deliberately instead of becoming invisible model state.
Conversation history
Save, list, and reopen local sessions so questions and answers remain attached to the project they explain.
Pulse
Capture the moment
before it gets lost.
Journal capture
Write local journal entries and keep ideas, observations, and decisions connected to the moment they came from.
Context capture
Capture active-app context, focused windows, selected text, clipboard content, and screen context only when the required permission is granted.
Workspace profiles
Manage profiles that shape how Forge behaves across different projects, work modes, and contexts.
Hotkeys and prompt launchers
Start known prompts and workspace actions from explicit keyboard launchers instead of rebuilding the same setup each time.
Voice commands
Parse voice command text into an inspectable action without running anything silently or automatically.
Automation rules
Define bounded automation rules with visible boundaries, local persistence, and recoverable outcomes.
Privacy filters
Keep clipboard filtering and sensitive-content rejection enabled so capture does not silently absorb secrets or private material.
Browser Companion
Bring the web
into context.
Page and selection capture
Capture a page or selected text while preserving its source URL and provenance for later review.
Read-later workflow
Save web context for later with its source attached to the project thread.
Screenshot capture
Keep a visual record of the page context that informed a decision, review, or bug report.
DOM inspection
Inspect the structure behind a page so interface context can be understood rather than copied as an opaque screenshot.
Accessibility review
Review page accessibility findings with the browser connection and its permission boundary made explicit.
Design review and token extraction
Review screenshots, inspect frontend structure, and extract design tokens that can return to the project with their source intact.
UI bug reports
Create traceable bug reports from browser context and preserve the evidence needed to understand the issue.
Meeting workspaces
Detect meeting context, ingest transcripts, summarize them, extract action items, and link the result back to a project.
Foundry
Turn intent into
a bounded run.
Agents and tools
Define agents and tools with declared capabilities instead of treating automation as an opaque prompt with unlimited reach.
Reusable workflows
Compose repeatable workflow definitions that turn a known project move into a path other people and future-you can inspect.
Approvals and capability checks
Keep unsafe tools behind explicit approval and capability checks before an action can cross a sensitive boundary.
Retries and recovery
Run steps with retry behavior, failures in view, and recovery paths that do not hide partial work.
Budgets and cancellation
Bound workflow runs with budgets, progress, cancellation, and clear outcomes for long-running work.
Audit-friendly events
Visualize workflow progress and retain events that explain what ran, what was approved, and what happened next.
Architect and Docs
Make the shape
of the work visible.
Architecture graphs
Build editable graphs of services, packages, databases, external systems, and decisions, then connect them to the project story.
Decision records
Record ADRs and rationale so the decision remains clear after the diagram and the original conversation have moved on.
Project generation previews
Preview generated project starting points before accepting them into the local workspace.
Documentation editor
Create and edit README, architecture, API, onboarding, and runbook drafts while keeping generated material editable.
Freshness review
Review whether documentation still reflects its sources before exporting it as an artifact.
Evidence and portfolio exports
Export diagrams, evidence packages, case studies, and career-oriented project summaries when the underlying work is ready to be shared.
Git
Move from change
to confidence.
Diff parsing and review
Read the change in context, collect evidence, and make the implications visible before applying anything.
Patch preview and rollback
Preview mutations, keep destructive actions behind confirmation, and preserve rollback paths when changes are applied.
Test discovery and interpretation
Discover project tests and interpret their results as part of the change review rather than as an afterthought.
Commit and pull request generation
Generate commits and pull requests from reviewed work, with the mutation boundary explicit.
Review comments
Add review comments to pull requests through an approved GitHub connection when the project authorizes that write.
Quality
Make risk
clear.
Accessibility and performance checks
Run bounded accessibility, performance, hydration, bundle, and Web Vitals checks with findings that remain inspectable.
Security and secrets review
Scan for security issues and exposed secrets without turning a missing or partial result into a made-up score.
Retrieval evaluation
Evaluate retrieval datasets and relevance so Neuron quality can be improved with evidence.
Workflow simulations
Simulate Foundry planning, tool use, approvals, retries, budgets, cancellation, and failure recovery deterministically.
Adapter and contract assurance
Compare browser, Electron, service, companion, and integration adapters for schema, permission, offline, and capability parity.
Release readiness
Review milestones, platform gates, readiness, and clear limitations in one local quality and release dashboard.
Plugins and integrations
Extend Forge
with consent.
Plugin manifest inspection
Inspect plugin manifests and requested capabilities before enabling an extension.
Signing and verification
Sign and verify plugin packages so unsigned or tampered packages do not activate by default.
Sandboxed plugin actions
Keep plugin actions isolated behind declared capabilities, permission approval, and a recoverable disable path.
Integration scopes
Review the network scopes and operations an external service can use before a connection is configured.
Secret-bound credentials
Store integration credentials behind the secret boundary, revoke them explicitly, and surface rejected credentials as recoverable errors.
OAuth and consent history
Use authorization-code flows with PKCE, inspect the scopes being requested, and retain enough consent history to understand when access was granted or revoked.
Signed webhooks
Receive provider events with signature verification, replay protection, cursors, and approval-aware processing instead of trusting an unverified callback.
Provider lifecycle controls
Keep provider health, rate limits, retries, token refresh, and degraded states visible so an unavailable service does not become a silent failure.
Team
Share the work
with clear ownership.
Optional accounts
Use accounts only when the collaboration workflow needs them; local work does not depend on an account by default.
Encrypted synchronization
Opt into end-to-end encrypted sync when a project needs to move between trusted workspaces.
Team workspaces and roles
Keep personal and shared scopes visible, assign roles, and make the boundaries of collaboration clear.
Organizations and tenant isolation
Separate organization data, membership, and project access so a shared project never becomes a path into another tenant's context.
Invitations and membership changes
Invite people to an organization or project, change roles, revoke access, and keep those changes explicit and auditable.
Enterprise identity
Support SSO, SCIM provisioning, verified domains, MFA policy, and service accounts when an organization needs its identity system to remain authoritative.
Shared knowledge and approvals
Share selected knowledge, coordinate approvals, and preserve the audit activity around collaborative decisions.
Sync queues and acknowledgements
Queue encrypted changes while offline, retry safely, acknowledge accepted records, paginate pulls, and preserve version information for recovery.
Conflict handling
Surface synchronization conflicts with the competing versions and an explicit resolution path rather than silently overwriting context.
Devices and project keys
Enroll trusted devices, deliver project keys through the device boundary, and rotate keys when membership or device trust changes.
Remote-copy lifecycle
Preview remote deletion, apply retention rules and legal holds, track deletion jobs, and restore an approved copy without hiding its status.
Account lifecycle
Support sign-in, refresh, recovery, sign-out, and account deletion as explicit states, without making an account prerequisite for local work.
Launch and recovery
Stay ready
for the unknown.
Onboarding and capability discovery
Understand what Forge can do, what is available in the current runtime, and which permissions a capability needs.
Signed artifact metadata
Create release metadata and checksums that make the artifact and its origin easier to verify.
Backups and exports
Back up local state and export project artifacts without making network sync a requirement.
Support bundles
Collect recovery-oriented diagnostics while excluding prompts, source text, clipboard contents, secrets, and raw identifiers.
Release notes and runbooks
Keep the operational story documented so updates, recovery, and known limitations remain actionable.
Offline and unsupported states
Show when a capability is unavailable, why it is unavailable, and what the user can do next.
Health and readiness
Expose API health, readiness, dependency status, correlation IDs, and audit events so support work can follow a request across the system.
Backups, restore, and rollback
Pair backups and exports with restore verification, disaster-recovery procedures, deployment rollback, and clear recovery ownership.
Service operations
Define SLOs, alerts, incident response, provider setup checks, and staging gates before a hosted workflow is treated as ready.
Supported integrations
Bring the tools
you already use.
External service connections
Forge currently defines configurable adapters for GitHub, Jira, Linear, Slack, Notion, Figma, Vercel, Supabase, Gmail, Calendar, and Obsidian. Each connection is optional, scope-limited, credential-bound, and protected by explicit network permission.
Read and write boundaries
Read operations and write operations are distinguished. Writes require explicit confirmation, rate limits and retries are handled, and revoked credentials return a recoverable connection state.
Hosted project management
When a backend is configured, authenticated clients can create, list, inspect, and select projects through an organization-scoped API without exposing local repository contents by default.