Refact Cloud shuts down as the coding agent moves to an open-source local-first future
Hosted accounts, subscriptions, credits and managed inference are being retired, while the local engine, IDE plugins, BYOK, local models and integrations continue.
By WhatAI Editorial Team ·
Refact announced on April 30, 2026 that Refact Cloud would be retired and that the coding agent would continue as an open-source, local-first and community-maintained project.
The shutdown affects the hosted product layer: Refact accounts, managed inference, cloud-hosted models, subscriptions, balances, credits, cloud workspaces, organization features, remote project storage and cloud telemetry. Refact said the final shutdown date would be announced separately.
The local architecture continues. Developers can run the Refact engine from their machine, use the VS Code or JetBrains client, connect their own cloud-provider keys or local model runtimes and keep using agent tools such as shell, browser, Git hosting, databases, Docker, MCP and command-line integrations.
Existing cloud users should update the plugin and local engine, configure at least one provider or local runtime, export any cloud-only data and move credentials and integration settings into the local configuration. Active subscriptions will be terminated, with refunds promised for invoices paid during the final thirty days before shutdown.
This is not a normal feature update. It changes the product's buyer profile. Refact is now more attractive to developers who value open-source control and less suitable for teams that depended on managed billing, centralized cloud administration, commercial support or a vendor-operated service.
ℹ️
WhatAI Decision Box
✓
Best for:
Developers and technical teams that want an open-source local coding agent with BYOK, local models, subagents, worktrees, MCP, developer-tool integrations and direct control over runtime data and model routing.
✗
Not for:
Users seeking a managed Refact cloud account, centralized subscription, bundled model credits, vendor SLA, hosted team administration, commercial cloud support or a zero-configuration coding assistant.
Refact's strongest advantage is the combination of a local open-source runtime, provider flexibility and broad agent orchestration inside familiar developer tools.
Do not evaluate Refact using the old Pro pricing or enterprise-cloud claims because the hosted commercial service is being retired.
Refact.ai is transitioning from a hosted coding service into an open-source, local-first agentic coding engine. The current product runs a local Rust engine and connects to the model providers, local runtimes and developer tools the user configures.
What changes when Refact Cloud shuts down?
Hosted accounts, managed inference, cloud-issued credits, subscriptions, remote workspaces and cloud team features are being retired. The local engine, IDE plugins, BYOK providers, local models and agent integrations continue without Refact Cloud.
Who should still use Refact.ai?
Refact is now best for technical users who value local control, open-source inspectability, provider choice and extensible agent workflows. It is a weaker fit for teams expecting a managed SaaS account, vendor SLA, centralized billing or commercial cloud support.
About Refact.ai
Refact.ai is an open-source, local-first agentic coding engine that runs from a developer's machine and connects only to the model providers, local runtimes, repositories, databases, browsers, shells, and tools the developer configures. The current architecture uses a local Rust engine with a resident daemon, terminal interface, browser-based GUI, per-project workers, and thin IDE clients for VS Code and JetBrains. It supports autonomous coding tasks, repository search, AST-aware symbol analysis, file creation and patching, shell and process execution, Git checkpoints, rollback, worktrees, subagents, task planning, memory, knowledge, context compression, scheduled jobs, MCP, reusable skills, commands, hooks, marketplace extensions, code completion, chat, voice input, browser automation, and integrations with GitHub, GitLab, Bitbucket, Docker, PostgreSQL, MySQL, command-line tools, and custom services. Developers can use Bring Your Own Key providers including OpenAI, Anthropic, Gemini, DeepSeek, OpenRouter, Groq, xAI, and OpenAI-compatible endpoints, or run local models through Ollama, LM Studio, vLLM, and other supported runtimes. Refact Cloud is being retired in 2026. Hosted Refact accounts, managed inference, cloud-issued credits, subscriptions, remote workspaces, cloud telemetry, and team cloud features will no longer be part of the product. The future product is open source and community maintained, with model charges paid directly to configured providers and local infrastructure operated by the user. Refact.ai is strongest for developers and technical teams that want an inspectable local coding agent, flexible provider choice, local data control, extensible tools, and deeper workflow automation than a simple autocomplete plugin. It requires technical ownership: users must install and update the local engine, configure providers or runtimes, secure credentials, review tool permissions, manage local data, and validate agent-generated changes.
Use Cases
Run an AI coding agent without a hosted Refact accountKeep repository context and project data localUse personal OpenAI Anthropic Gemini or other provider keysRun coding models through Ollama LM Studio or vLLMDelegate feature implementation across an existing repositoryUse worktrees to isolate agent changes from the main working treeSpawn subagents for research testing review or implementationPlan complex engineering tasks with task cardsSearch definitions references and similar code across a repositoryRefactor code while checking affected symbol usagesGenerate and update testsDiagnose bugs using code shell browser and database contextRun shell commands with review or approvalInteract with PostgreSQL and MySQL during developmentAutomate GitHub GitLab and Bitbucket workflowsUse MCP servers and tools inside coding tasksCreate reusable engineering skills commands and hooksSchedule recurring maintenance or coding tasksUse browser automation for application testingOperate Refact through VS Code JetBrains terminal or local browser GUIBuild private coding workflows around local modelsInspect and modify the open-source agent runtimeCreate local coding-agent extensionsMigrate away from the retiring Refact Cloud service
Key Features
✓Open-source local-first coding agent
✓Single local Refact binary
✓Resident local Rust daemon
✓Terminal user interface
✓Local browser-based graphical interface
✓Per-project workers
✓VS Code plugin
✓JetBrains plugin
✓Thin IDE clients connected to the local engine
✓Bring Your Own Key model providers
✓OpenAI provider support
✓Anthropic provider support
✓Google Gemini provider support
✓DeepSeek provider support
✓OpenRouter provider support
✓Groq provider support
✓xAI provider support
✓Custom OpenAI-compatible endpoints
✓Ollama local model support
✓LM Studio local model support
✓vLLM local model support
✓Configurable model selection by task
✓Autonomous coding agent
✓Agent planning and step-by-step execution
✓Task Planner and task cards
✓Subagents for delegated work
✓Git worktrees for isolated task execution
✓Multiple agent modes
✓File creation and editing
✓Patch preview and approval
✓Automatic patch approval option
✓Shell-command execution
✓Long-running process and PTY management
✓Repository-wide semantic search
✓AST-aware symbol definitions
✓AST-aware reference search
✓Codebase vector database
✓Context compression
✓Repository memory and knowledge
✓Reusable hidden roles and plans
✓Checkpoints and Git rollback
✓Chat-conversation rollback
✓Scheduler and cron jobs
✓Buddy agent capability
✓Model Context Protocol support
✓Skills
✓Custom commands
✓Hooks
✓Extension marketplace
✓Built-in agent tools
✓Browser automation
✓Web-page context
✓GitHub integration
✓GitLab integration
✓Bitbucket integration
✓Docker integration
✓PostgreSQL integration
✓MySQL integration
✓Command-line tool integration
✓Command-line service integration
✓Chrome integration
✓PDB debugger integration
✓Local HTTP API
✓Code completion using fill-in-the-middle models
✓In-IDE AI chat
✓AI Toolbox commands
✓Code explanation
✓Bug finding and fixing
✓Code improvement and refactoring
✓Naming assistance
✓Test generation through agent workflows
✓Voice input
✓Local project-data storage
✓Provider-direct request routing
✓No hosted Refact account requirement
✓No Refact-managed inference requirement
✓Community-maintained roadmap
✓Open-source contribution through GitHub
Pricing
Open-Source Local Refact
$0 software subscription
• Open-source local-first coding engine
• Local daemon terminal interface and browser GUI
• VS Code and JetBrains clients
• BYOK cloud model providers
• Local model runtimes
• Agent tools worktrees subagents memory scheduling MCP and integrations
• No Refact-issued credits
• No managed Refact Cloud account
• No paid cloud subscription
• No hosted team or workspace service
• Community support through GitHub
• Model provider and infrastructure costs paid separately
The Refact.ai specific capabilities video covers the SWE-bench milestone and the specific capabilities that produce that benchmark result. Resolving 352 out of 500 real-world software engineering issues from GitHub autonomously is the benchmark that requires clarification to appreciate. SWE-bench Verified does not test code generation quality. It tests autonomous end-to-end issue resolution: read the issue, understand the codebase, implement the fix, pass the existing tests. That is a multi-step autonomous engineering task, not completion assistance. The self-hosting and enterprise deployment options being available is the security consideration that determines whether Refact is viable for organisations with code confidentiality requirements. Your code stays on your infrastructure rather than passing through a cloud service. The customisation via fine-tuning on your specific codebase being available changes the suggestion quality from generic to project-specific over time. An agent that has learned your team's patterns, naming conventions and architectural preferences is different from one suggesting… Read full discussion →
The AI coding agents state of the art video is not specifically a Refact.ai video but it provides the industry context that makes Refact's SWE-bench ranking meaningful. The structural shift from AI as smart autocomplete requiring line-by-line supervision to AI agents that autonomously plan, execute and verify multi-step development tasks is the change that makes the SWE-bench benchmark relevant. SWE-bench tests whether an AI can resolve real GitHub issues autonomously, not whether it can suggest good code completions. The 2026 landscape described in the video has agents that understand project-wide context, write and run tests against their own code, identify and fix failures and integrate changes following team conventions without requiring step-by-step human guidance. That is a qualitatively different capability from the AI coding tools most developers are familiar with from 2023-2024. The implication for evaluation: the right benchmark for current AI coding tools is not whether they suggest good… Read full discussion →
The AI code review tools landscape video frames the problem accurately: as AI coding assistants generate more code, human code review has become the bottleneck, and a new category of AI review tools exists specifically to address that bottleneck. The structural irony is elegant: AI generates more code, which creates more review work, which slows development, which means AI generation speed advantage is partially cancelled by review bottleneck. AI code review tools close that loop by making the review step faster and more thorough simultaneously. The tools in this category are not replacing human judgment in code review. They are handling the systematic checks, security pattern detection, test coverage gaps, style consistency, architectural violations, that are tedious but critical, and surfacing the results so human reviewers can focus on the architectural and logic questions that actually require judgment. Refact.ai's position in this landscape as both a generation and review tool… Read full discussion →
When a tool ranks first on SWE-bench verified, resolving over 70% of real-world software engineering tasks, it gets my attention. I have been using Copilot and Cursor for a while and I was curious whether Refact.ai was actually meaningfully different or just benchmark-optimized. Spent a few weeks with it in VS Code and here is what I found. The codebase context is the first thing that stands out. It does not just work from the current file or a few tagged references. It analyzes your entire codebase and fine-tunes itself to your specific project, so suggestions are grounded in how your code actually works rather than generic patterns. That difference is noticeable when you are working in a large or idiosyncratic codebase rather than a clean greenfield project. Autonomous operation is the capability that separates it from standard autocomplete tools. You can give it a task and it plans, executes… Read full discussion →
I work on client projects that involve sensitive codebases and I have always been uncomfortable with the idea of sending proprietary code to a third-party cloud service for AI completions. GitHub Copilot is useful but the fact that code snippets are sent to Microsoft's servers is a hard no for some of the clients I work with, and it is a blocker to adopting AI coding tools more broadly on those projects. Refact.ai has come up as an option that can be self-hosted, which would address the privacy concern entirely. But I want to make sure that the trade-off in terms of completion quality is not so large that the privacy benefit is not worth it. I have seen self-hosted AI coding tools before and some of them have been significantly worse than the cloud alternatives to the point where they create more friction than they remove. Has anyone run… Read full discussion →
The coding agent survives the cloud shutdown as an open-source local-first project
👎 Con
The managed cloud product subscriptions accounts credits and team service are being retired
Privacy
👍 Pro
The local engine and project data remain under the user's control
👎 Con
BYOK cloud providers can still receive code context and tool integrations can expose sensitive data
Model Choice
👍 Pro
Supports multiple cloud providers custom endpoints and local runtimes
👎 Con
Users must compare quality latency context limits cost and data terms themselves
Agent Capability
👍 Pro
Includes planning subagents worktrees memory scheduling MCP shell browser databases and Git controls
👎 Con
Broad tool access increases the potential impact of an incorrect or manipulated agent action
Developer Interfaces
👍 Pro
Works through VS Code JetBrains terminal and a local browser GUI
👎 Con
The local engine and client architecture requires more setup than a managed extension-only service
Cost
👍 Pro
The Refact software no longer requires a subscription or bundled credit plan
👎 Con
Provider tokens local GPUs electricity storage and engineering time remain real costs
Open Source
👍 Pro
Developers can inspect extend and contribute to the runtime
👎 Con
The former company repository was archived and the roadmap now depends on community maintenance
Support
👍 Pro
Support and development can continue through GitHub issues discussions and pull requests
👎 Con
There is no paid hosted service or commercial cloud support after the transition
How to Get Results with Refact.ai: Step-by-Step Workflow
Confirm the local-first fit
Decide whether the team can own installation, provider credentials, local data, updates, tool permissions, testing and community-based support.
Decision point: Choose a managed coding assistant when centralized billing, vendor support and minimal local operations matter more than runtime control.
Export Refact Cloud data
Before the final cloud shutdown, export any account data, remote project information, settings or records that exist only in Refact Cloud.
Install the current local engine
Install the current Refact binary, start the local daemon and connect the VS Code or JetBrains client, terminal interface or local browser GUI.
Configure one model path
Start with one BYOK provider or one local runtime. Record endpoint, model, context limit, price, retention terms, hardware requirements and fallback.
Decision point: Use a local model when code must remain local. Use a cloud provider when model quality and speed justify sending approved context externally.
Set project and secret boundaries
Exclude credentials, production data, restricted repositories and files the agent should never read. Use scoped provider keys and integration accounts.
Test repository understanding
Ask the agent to explain architecture, locate definitions and references, identify tests and summarize a change path without modifying files.
Run a task in an isolated worktree
Create a bounded engineering task with acceptance criteria, tests, prohibited changes and a separate Git worktree.
Review the plan and tools
Inspect the proposed plan, model choice, shell commands, database access, browser actions, MCP tools and expected file changes before execution.
Decision point: Keep patch and command approval enabled until the team understands the agent's behavior on the repository.
Validate generated changes
Review diffs, run tests, lint, type checks, security scans and the application itself. Compare behavior with the acceptance criteria.
Test rollback and recovery
Create a checkpoint, intentionally reject or revert a change and confirm that Git, worktree and conversation rollback behave as expected.
Add memory skills and integrations
After the basic workflow is reliable, add project knowledge, skills, commands, hooks, MCP servers, databases, Git hosting, browser automation or scheduled tasks.
Operate it as engineering infrastructure
Track model cost, latency, failed commands, reverted patches, test failures, secret exposure, local storage, updates, repository outcomes and community security notices.
Refact.ai Gotchas and Limits to Know Before You Start
Refact Cloud is being retired
The April 2026 announcement did not provide the final shutdown date
Hosted Refact accounts and login will stop working
Managed Refact inference and hosted models will stop working
Refact-issued credits balances subscriptions and cloud billing are being removed
Cloud team workspace and organization features are being removed
Remote project storage and cloud telemetry tied to Refact Cloud are being removed
Active subscriptions will be terminated
Only invoices paid during the final thirty days before shutdown were promised refunds
The main Refact marketing site still contains stale Pro cloud and enterprise language
The former smallcloudai repository was archived in May 2026
Current documentation and maintenance moved to a community fork
There is no paid hosted service or commercial cloud support after the transition
The software is free but model and infrastructure costs remain
BYOK requests can send repository context to the selected cloud provider
A local Refact engine does not make cloud-provider use local
Local models require compatible hardware and enough memory
Local model quality may be lower than frontier cloud models
Provider context windows and tool-use support vary
Provider outages rate limits and policy changes affect the agent
API keys stored locally still require encryption rotation and least privilege
Shell access can delete files install software or expose secrets
Database integrations can read or change sensitive data
Browser automation can interact with authenticated sessions
MCP servers can expose broad tools and untrusted instructions
Community skills hooks and marketplace extensions require source review
Automatic patch approval increases the impact of an incorrect plan
Worktrees isolate changes but do not prevent unsafe external side effects
Checkpoints and rollback cannot undo every database network or third-party action
Subagents can multiply model cost and tool activity
Scheduled jobs can repeat a bad task without supervision
Memory and knowledge can preserve outdated or sensitive information
Context compression can omit details needed for a safe change
Repository-wide vector search can index files that should have been excluded
AST analysis can be incomplete for generated dynamic or unsupported code
Tests generated by the same agent can confirm its own incorrect assumptions
A clean diff does not prove application correctness security or performance
The local HTTP API should not be exposed to untrusted networks
Open-source availability does not guarantee rapid security fixes
Community maintenance can change release cadence compatibility and roadmap
Teams need their own backup incident response and update policy
Refact is not a drop-in replacement for the hosted team administration being retired
Which Refact.ai Feature Fits Your Use Case
Feature
Good for
Common mistake
Fix
BYOK Providers
Using preferred frontier models without a Refact credit layer
Adding a broad production API key and assuming code remains local
Use a scoped key, review provider retention terms and limit which repository context can be sent
Local Models
Keeping inference data on controlled hardware
Choosing a model that cannot reliably use tools or fit the project context
Benchmark representative tasks, context size, latency, memory and tool-calling before standardizing
Worktrees
Isolating autonomous code changes from the main working tree
Assuming worktree isolation protects databases external services and secrets
Use test environments and scoped integrations in addition to Git isolation
Subagents
Delegating research implementation review and testing into separate contexts
Spawning many overlapping agents with broad write access
Give each subagent a narrow role, explicit outputs, limited tools and a controlled model budget
Task Planner and Cards
Breaking complex engineering work into inspectable stages
Approving a plausible plan without checking repository assumptions
Require evidence for architecture, affected files, tests, migration and rollback before execution
Shell and PTY Tools
Running builds tests package managers servers and diagnostics
Allowing unrestricted commands in a machine with production credentials
Use containers or restricted accounts, approval gates and an explicit command denylist
Memory and Knowledge
Preserving architecture decisions conventions and recurring project context
Saving secrets temporary workarounds or outdated instructions
Define what can be remembered, assign owners and periodically review or delete stale entries
Scheduler and Cron
Recurring maintenance tests reporting and repository tasks
Scheduling write actions before error and cost behavior is understood
Start read only, add alerts, cap execution and require approval for consequential changes
MCP
Connecting reusable developer tools and data sources
Trusting a server's tool descriptions and returned content automatically
Approve servers, scope credentials, validate outputs and isolate tools that can change external systems
Checkpoints and Rollback
Reverting repository changes from an agent session
Treating Git rollback as recovery for every external side effect
Design separate rollback or test-mode controls for databases deployments APIs and third-party systems
How Well Refact.ai Fits Common Use Cases
Open-source local coding agent — 5/5
Refact combines a local engine IDE clients terminal GUI and inspectable agent runtime
Consider instead: Continue for a lighter configurable open-source IDE assistant
BYOK and local-model coding workflows — 5/5
Refact routes work to configured cloud providers local runtimes or compatible endpoints
Consider instead: Aider for a terminal-centered provider-flexible Git workflow
Complex agentic repository work — 5/5
Task planning subagents worktrees memory tools checkpoints and scheduling support broad engineering workflows
Consider instead: Cline or another IDE agent with a larger managed extension ecosystem
Private self-operated coding assistance — 4/5
Local inference and local project storage can minimize external data transfer when configured correctly
Consider instead: Tabnine Enterprise for a commercially supported private deployment
Extensible developer automation — 4/5
MCP skills commands hooks marketplace integrations and a local HTTP API provide extension paths
Consider instead: OpenCode for another provider-flexible agent runtime
Community-maintained team coding platform — 3/5
The runtime is capable but hosted team services and commercial cloud support are being removed
Consider instead: GitHub Copilot Enterprise for managed administration support and policy controls
Managed Refact SaaS subscription — 1/5
Refact Cloud accounts subscriptions credits and managed inference are being retired
Consider instead: GitHub Copilot Cursor or another active managed coding service
Zero-maintenance private coding agent — 1/5
Local control requires installation credentials updates model selection security and operational ownership
Consider instead: A commercially managed private coding platform
Starter Prompts for Refact.ai
Repository Change Plan
Analyze this repository for [requested change]. Do not modify files yet. Identify the architecture, relevant definitions, references, tests, data migrations, external integrations, risks and acceptance criteria. Propose a staged plan with the exact files likely to change and the commands needed to validate each stage.
Isolated Worktree Implementation
Create an isolated Git worktree for [task]. Implement only the approved scope. Preserve [interfaces and behavior], add or update tests, run [lint type check test and build commands], summarize every changed file and stop for approval before any database deployment or external-service action.
Subagent Review Team
Delegate this change to three read-only subagents: one architecture reviewer, one security reviewer and one test reviewer. Each must cite repository evidence, list assumptions and propose checks. Synthesize disagreements before recommending implementation. Do not edit files until the combined review is approved.
Local Privacy Configuration
Design a Refact configuration for this repository that keeps restricted code local. Identify excluded files, approved local models, permitted cloud-provider tasks, scoped API keys, MCP servers, shell commands, database permissions, browser access, memory rules, logs, update process and incident-response steps.
Scheduled Maintenance Task
Design a scheduled Refact task for [maintenance job]. Start in read-only mode. Define cadence, repository scope, model, tools, maximum runtime, cost limit, output report, failure alert, approval gate and rollback. The scheduled task must never merge deploy delete data or change external systems automatically.
Prompt pattern: Analyze [repository and task], gather evidence with [search AST and tools], propose [plan and affected files], execute in [worktree and permission boundary], validate with [tests scans and acceptance criteria], stop before [external side effects], and report [diff risks cost and rollback].
Iteration tip: Begin with read-only repository analysis, then one approved patch in an isolated worktree. Add shell, database, browser, MCP and scheduled access only after rollback and security controls are tested.
WhatAI verdict on Refact.ai
Refact.ai should no longer be evaluated as a normal paid coding-assistant subscription. The company announced in April 2026 that Refact Cloud would shut down and that the project would continue as open source, local first, BYOK and community maintained.
The change removes the hosted product layer. Refact-issued credits, cloud billing, hosted accounts, managed inference, cloud workspaces, team features, remote project storage and cloud telemetry are being retired. Users who depended on those services need to export remaining cloud-only data, update their plugins and move provider credentials and settings into the local configuration.
The continuing product is technically substantial. A local Rust engine runs as a resident daemon and supports a terminal interface, local browser GUI and per-project workers. VS Code and JetBrains act as clients of that engine. The agent can plan tasks, search code, inspect AST definitions and references, edit files, execute shell commands, work through Git checkpoints, spawn subagents, use isolated worktrees, retain memory, compress context, schedule work and connect to MCP and developer integrations.
Refact now competes less directly with the managed version of GitHub Copilot and more with local or extensible coding-agent runtimes. Its key advantage is control. Developers choose the provider, endpoint, local runtime and tool permissions. Requests go to the services they configure instead of through a Refact-managed inference layer.
That control creates operating responsibility. A user must secure API keys, review shell and database permissions, update the local engine, choose models, manage local data, test patches, monitor costs and accept community-based support. A local architecture does not make an agent safe automatically. It can still delete files, leak secrets to a configured provider, run unsafe commands or introduce plausible-looking bugs.
Choose Refact over Copilot when local-first architecture, BYOK, open-source extensibility and broad agent tools matter more than managed service polish. Compare Aider for a terminal-centered Git workflow, Cline for a VS Code agent ecosystem, Continue for configurable open-source IDE assistance and OpenCode for another provider-flexible coding-agent environment.
A serious evaluation should install the current local engine in a non-critical repository, configure one provider and one local model, run the same task in an isolated worktree, inspect every tool call, test rollback, compare cost and output quality, and confirm that another developer can understand and recover the resulting changes.
Refact.ai — Frequently Asked Questions
Is Refact.ai shutting down?
Refact Cloud is shutting down, but Refact itself is continuing as an open-source, local-first and community-maintained coding agent. The hosted account, billing, model-credit and managed-inference services are the parts being retired.
When will Refact Cloud shut down?
Refact announced the retirement on April 30, 2026, but said the final shutdown date would be published separately. Users should migrate now rather than waiting for the final date.
How much does Refact.ai cost now?
The continuing Refact software is open source and has no Refact subscription fee. Users pay their selected cloud model provider directly or cover the hardware, electricity and maintenance costs of local inference.
What happens to Refact Pro and cloud credits?
The hosted subscription and credit system is being removed. Active cloud subscriptions will be terminated, and invoices paid during the last 30 days before shutdown are scheduled for refund under the official announcement.
Can Refact.ai run fully locally?
Yes, when the local engine, local model runtime and required integrations all run on infrastructure controlled by the user. Using a cloud BYOK provider still sends selected prompt and context data to that configured provider.
Which model providers does Refact support?
The local-first architecture supports providers such as OpenAI, Anthropic, Gemini, DeepSeek, OpenRouter, Groq and xAI, plus custom OpenAI-compatible endpoints. Local runtime options include Ollama, LM Studio and vLLM.
Which IDEs does Refact.ai support?
The current open-source architecture documents VS Code and JetBrains as primary thin clients of the local Refact engine. The engine can also be used through its terminal and local browser interfaces.
What can the Refact agent do?
Refact can inspect repositories, search symbols and references, plan tasks, modify files, execute shell commands, use databases and browser tools, create checkpoints, work in Git worktrees, spawn subagents, retain memory, schedule jobs and connect to MCP and developer integrations.
Does Refact keep code private?
The local engine keeps project data under the user's control, but privacy depends on the configured providers and tools. Cloud model requests can include code context, while a fully local model avoids sending inference data to a cloud provider.
Is Refact.ai suitable for enterprise teams?
It can be technically suitable for teams able to operate and govern an open-source local agent. It no longer offers the managed cloud account, commercial support and hosted enterprise service described by older pages, so organizations need their own deployment, security and support plan.
