RAME Code — Your PC. Your Models. Your Rules.
A free, open-source, local-first AI coding agent for Visual Studio Code. Build software with Ollama, LM Studio or llama.cpp, use permission-based web search, and access optional Meta Muse intelligence.
Watch the 3-minute demo · Support RAME Code on X
Public preview. Try it on a disposable project: it is not a production security boundary.
What the published release contains.
Your AI coding agent. Your models. Your decisions.
AI should remember what matters, respect what you decide, and prove what it actually accomplished.
RAME stands for Relational Adaptive Memory Engine. The name comes from earlier research into persistent state and relational memory, but RAME Code is a new, independent open-source project built during the Meta Global AI Developer Hackathon 2026. The AI proposes, you authorize, and RAME checks the result instead of accepting the model's word that everything is finished.
Today's coding agents often work through opaque conversations, lose important context and blur the line between what a model suggests and what is authorized. RAME answers with a host-governed architecture: the AI proposes, the human authorizes, and the host executes and verifies. The result is persistent, auditable, privacy-conscious and verifiable AI-assisted development.
- v0.2.0
Native VS Code agent
Chat, Agent and Mission in a graphical development environment.
- v0.2.0
Local and private-network models
Locally served models through configurable inference endpoints: RAME's managed llama-server, Ollama and LM Studio, from a personal computer to a more powerful inference server on your network, with explicit authorization for private-network servers. Cloud processing is never mandatory.
- v0.2.0
Meta Model API
Direct cloud Chat and Agent with Muse Spark and Muse Wonder, plus optional, bounded advice during local Missions (advice validated only with a simulated Meta).
- v0.2.0
Governed memory
Project decisions and context can persist across interactions, with versioning, provenance and human approval before any durable change. Real demonstrations document approved memory updates and later retrieval.
- v0.2.0
Verifiable Missions
Supervised and autonomous coding with human authorization, controlled workspace access, resumable checkpoints and host-side verification. A recorded real Mission created a JavaScript project and completed three passing tests.
- v0.2.0
Precise permissions and evidence
Scoped, one-use approvals and a host-written record linking what the model proposed, what the host did and what was checked.
- v0.2.0
Web research
The Agent can run approved web searches and retrieve online sources; real Internet access was demonstrated with a locally served model over a LAN. Web capabilities in Chat and Mission are experimental, within the same permission boundaries.
- v0.2.0
Privacy by design
Explicit consent before anything goes from local to cloud; RAME shows what local context would be shared with Meta and asks for authorization. You decide when external AI services are enabled and what may be transmitted. The controls support data-minimization and GDPR-conscious workflows, without claiming automatic regulatory compliance.
- v0.2.0
Modular architecture
Designed for extension: additional models, tools, security controls and development workflows can be integrated and improved over time.
The download button gets v0.2.0, the latest published release. Model availability is discovered through the API, but effective compatibility depends on each model and its capabilities; no universal compatibility with Meta models is claimed.
RAME Code v0.2.0 is an experimental release under development.
A free, local AI coding agent for VS Code
Open-source AI coding in VS Code
RAME Code is a free AI coding assistant and VS Code AI extension under the Apache-2.0 license. Chat, Agent and Missions live in one view, and you can read, run and audit the source.
Ollama, LM Studio and llama.cpp
Connect a local LLM through RAME's managed llama-server, Ollama or LM Studio, including servers on your LAN with explicit authorization. Muse Glimmer runs through a compatible local inference server.
GPU-powered local AI
Use your own hardware, including GPUs such as the NVIDIA RTX 3090, depending on the model, quantization and available memory. Local inference needs no mandatory AI subscription; external API services may have their own costs.
Autonomous and supervised Missions
Run coding Missions with human authorization, controlled workspace access and verification checked by the host, either supervised step by step or autonomously within the limits you set.
Persistent project memory
Project decisions persist across sessions with versions and provenance, and only change after you approve them.
Permission-based web search
The Agent can search the web and read sources once you allow it; this was demonstrated with real Internet access. Web access in Chat and Mission is experimental.
Meta Muse Glimmer, Spark and Meta Model API
Muse Spark is integrated through Meta Model API, with real Chat responses recorded. Meta Advisory in Missions is experimental and has only been validated with simulated tests.
Privacy-conscious, human-controlled AI agent
Permissions decide what the agent may read, run or send out. The architecture is oriented to privacy and data minimization; it is not a certification and does not claim automatic GDPR compliance.
Published in v0.2.0.
How a Mission works
1. Define a goal
You state what has to be achieved.
2. Plan and propose
The local agent plans and proposes the work.
3. You authorize
You approve the scope and the acceptance checks.
4. Bounded execution
RAME works within the limits and can request optional Meta advice.
5. Host verification
The host runs the authorized acceptance checks and records the evidence.
Spark can advise, but it does not take control of the tools inside a Mission: the local model keeps them. The design prioritizes local inference and limits remote queries with budgets; no quantified cost saving is claimed.
Governed memory, by example
RAME detects that linked artifacts are stale; it does not migrate the project automatically.
What is a SHA-256, and what RAME uses it for
A SHA-256 is the fingerprint of some content: a 64-character code that changes completely if even one letter changes. It cannot be forged by hand: if two fingerprints match, the content is the same.
Never overwrite what the model has not seen
Before editing, the model reads the file and RAME stores its fingerprint. When writing, RAME computes it again and applies the change only if it is still the same. If you, another program or a sync touched the file in between, the change is rejected instead of wrecking your version.
Tie your approval to the exact action
The approval card shows a code (for example 27a14634…) computed over the whole action: path, content and expected file. By approving, you approve that code, and it works once. If the model tried to change the path or the content afterwards, the code would no longer match and RAME would run nothing.
Leave proof
The record keeps “this was before, this is now”, with the fingerprints. Anyone can recompute them later.
Not editing blindly is not unique to RAME: Claude Code requires reading a file before editing it and fails if it changed since, and Codex applies patches that only fit if the surrounding text is unchanged. What sets RAME apart is that the check is visible (the fingerprint appears on the card and in the record), that the approval is tied to a one-use code RAME verifies before running, and that the record is written by RAME, not the model: “Host record — verified by RAME Code, not written by the model”.
Published in v0.2.0.
Controlled Cloud Escalation
Local-first, with optional cloud assistance under explicit control.
Cloud escalation is OFF by default. If a local Agent reaches an eligible capability stop, RAME presents a visible choice before delegating the current request to Meta.
For Missions, users can authorize between 0 and 5 Meta Advisory consultations and set byte and token budgets. Spark provides bounded advice, while Glimmer retains control of tools and the host reruns the original verifier before considering the blocker recovered.
No silent fallback
You see and choose before anything goes to Meta.
No unlimited cloud calls
0 to 5 consultations, with byte and token budgets.
No transfer of tool control
Inside a Mission, the local model keeps the tools.
In v0.2.0, direct Spark Chat has real-API validation. Agent delegation and Mission Advisory are implemented and tested with a simulated Meta API.
How RAME Code uses Meta products.
Meta as an optional intelligence layer
We integrated Meta Model API and Muse Spark into RAME Code as an optional cloud layer within a modular, local-first development environment. RAME separates model inference, human authorization, persistent memory, tool execution and host-side verification, so developers can combine locally hosted AI with Meta's cloud while keeping explicit control of their projects.
- REAL
Real Meta Model API integration
Muse Spark is supported through Meta Model API. Three successful real responses from muse-spark-1.3 were recorded in Chat, demonstrating functional API connectivity.
- v0.2.0
Several local inference backends
llama-server (llama.cpp, without requiring Ollama), Ollama and LM Studio, including compatible servers reachable over a local network. You pick models by hardware, privacy needs and computing resources; Meta's API adds a layer without replacing local inference.
- Simulated
Optional Meta Advisory for Missions
A configurable mechanism asks Meta for guidance when a local coding model hits a recoverable obstacle. It needs explicit authorization, limited data budgets and restrictions on what is sent; the cloud model gets no authority to modify files or run tools. Tested through simulated API scenarios; live execution during a Mission remains to be validated.
- v0.2.0
Privacy and human authorization
External model access is optional and governed by permissions. RAME is designed to minimize what leaves the local environment and to support privacy-conscious, GDPR-aware workflows. You control external connectivity; the host answers for authorized actions and verification.
Where it is heading: better code quality and reliability, model orchestration, multimodal capabilities, and wider compatibility with the Muse family as suitable models and API features become available. We also want closer cooperation between local models and Meta's cloud without sacrificing user control. None of this is claimed as available today.
Long-term vision: a modular AI development environment where local and cloud models collaborate under transparent permissions, persistent memory and independently verified execution.
Only what the release does today.
What works today
Agent, Mission, Chat
Three modes in a single Activity Bar view.
Local and private-network models
Locally served models through configurable inference endpoints: RAME's managed llama-server, Ollama and LM Studio, from a personal computer to a more powerful inference server on your network, with explicit authorization for private-network servers. Cloud processing is never mandatory.
Meta Model API
Direct cloud Chat and Agent with Muse Spark and Muse Wonder, with your own key stored in VS Code SecretStorage.
Governed memory
Only decisions you approve become persistent, versioned project memory. Changing a decision can mark dependent verified work as stale.
Verifiable Missions
Bounded autonomous work, resumable checkpoints and acceptance checked by the host, not by the model.
Optional Meta advice
Local Glimmer can request budget-limited advice from Muse Spark during a Mission and keeps control of the tools. Implemented and tested with a simulated Meta only.
Web research
The Agent can run approved web searches and retrieve online sources; real Internet access was demonstrated with a locally served model over a LAN. Web capabilities in Chat and Mission are experimental, within the same permission boundaries.
Bounded tools
Workspace inspection, file operations, patches and allowlisted test commands. No arbitrary shell tool.
One-use approvals
Each approval is bound by digest to the exact action, thread, provider, workspace and file preconditions.
Path and secret protection
Blocks absolute paths, traversal, symlink escapes and selected secret and control paths.
Host-written action record
Kept separate from what the model says, so the record is evidence and not a claim.
Privacy controls
RAME shows what local context would be shared with Meta and asks for authorization. They aim to support data minimization and transparency; not a claim of full GDPR compliance.
Persistent threads
Local threads, cancellation, per-provider usage accounting and explicit consent before anything goes from local to cloud.
Generation controls
Reasoning effort, context and output budgets, validated per provider and model. Cut-off responses are discarded.
Install
Download the VSIX, then in VS Code open Extensions, the … menu, Install from VSIX. Or from a terminal:
code --install-extension rame-code-0.2.0.vsixKnown limits
- Not a production security boundary. Use disposable projects.
- run_command has no operating-system sandbox; permission control is not a sandbox.
- Project test scripts run with the operating-system permissions of VS Code.
- Web Chat and Web Mission are implemented but validated only with simulated servers; web Agent has real evidence.
- Real Meta is demonstrated only for three Chat inferences with Spark. Mission Advisory, Delegated and cloud Agent tools lack real validation.
- Vision is not integrated yet. Not on the Visual Studio Marketplace, and not fully validated on Windows.
- The local audit is bounded but not tamper-proof; passing tests do not guarantee that a program is fully correct.
Found by testing v0.2.0, with a workaround for each.
Known Issues & Troubleshooting
RAME Code v0.2.0, the version submitted to the hackathon on November 5, 2026, has the known issues below, each with a workaround. None of them sends anything to Meta: cloud escalation is off by default, and every request to Meta needs your explicit approval. All of them will be fixed in the next version, after the evaluation.
1LM Studio: "The local runtime returned HTTP 400" after the model was unloaded
What you see: A request to Muse Glimmer on LM Studio fails with "The local runtime returned HTTP 400". The LM Studio log says "No models loaded".
Why: While a model is loaded, LM Studio also lists it under a short temporary name. If you choose that name in RAME, it stops working once LM Studio unloads the model (after idle time, a restart, or closing LM Studio).
What to do: Load the model again in LM Studio, or open Settings → Runtime → Find models, choose the model's full name (for example lmstudio-community/muse-glimmer-30b-gguf/...) and press Use this model. With its full name, LM Studio can load the model by itself when a request arrives.
Next version: RAME shows the server's own message and tells you to load the model, instead of a bare "HTTP 400". The reload button described under issue 2 also solves the temporary-name problem, because it reloads the model under its full name.
2LM Studio or Ollama: "HTTP 400" in Agent once a project folder is open
What you see: Agent works with no folder open, but fails with "HTTP 400" after you open a project folder.
Why: The model was loaded with a small context, often 4,096 tokens. With a project folder, Agent sends its project tools and needs about 16,384 tokens of context.
What to do: In LM Studio, load the model with a context length of 16,384 or more (32,768 recommended). If LM Studio loads models on demand, set that context length as the model's default so automatic loads use it too. In Ollama, start it with OLLAMA_CONTEXT_LENGTH=16384 or more.
Next version: RAME says the context is too small, with the sizes, and what to change. With LM Studio it will also offer a button to reload the model with more context. It asks for confirmation first and uses that computer's GPU memory; if the model does not fit, LM Studio rejects it and the model stays unloaded. This button is in development: so far it has only been tested against a simulated LM Studio, and the Ollama equivalent is still pending.
3"Run this request with Spark" does nothing when clicked
What you see: The card stays on screen, and clicking Run this request with Spark changes nothing.
Why: The offer expires after 15 minutes, and each offer belongs to the thread where the local request failed. An expired offer, or one from another thread, can no longer be approved. Nothing is sent to Meta.
What to do: Click Dismiss, then send your request again to get a new offer.
Next version: Expired offers leave the screen by themselves, and an offer shows only in its own thread.
4Empty model list in Settings after reloading VS Code
What you see: In Settings → Runtime → Model servers, the Model list is empty, although the line "In use: ..." shows your model.
Why: The list is filled only after Find models. Your model is still saved and still used.
What to do: Press Find models to list the server's models again.
Next version: The saved model always appears in the list, with a note if the server no longer lists it.
5Same threads and settings on this computer and over Remote SSH
What you see: Threads and settings from a remote server also appear in VS Code on your own computer, and the other way round.
Why: VS Code keeps this extension data on your computer and shares it between local and remote windows. Project memory and Missions are kept on each machine.
What to do: Nothing is lost. A thread bound to a folder that does not exist on this machine asks you to choose a folder.
Next version: Threads and settings will be kept per machine, as other coding assistants do.
6Many approvals for a single question with web search
What you see: One question that needs web search can ask you to approve up to ten searches, one after another. In one test, 3 of 8 searches were variants of the same query.
Why: Each search sends text of yours out of your network, so asking for permission is correct. The problem is the number: that many clicks invite approving without reading.
What to do: Read each search before approving it, or answer without web search. Nothing is sent without your approval.
Next version: Proposed: one approval per question with a maximum number of searches, ending when the answer ends; the other searches stay in the record. Near-duplicate searches would be limited. This is a proposal, not yet built.
7“I can't read files or run commands yet” in Chat mode
What you see: In Chat mode the model says it cannot read files or run commands yet.
Why: Saying it cannot is correct: Chat mode does not read files or run commands. The word “yet” is what confuses, as if it were coming later.
What to do: Switch to Agent mode to read files or run commands.
Next version: Proposed: the model will tell you to switch to Agent instead. The current Chat-mode instructions have to be reviewed first.
Before you start with LM Studio or Ollama
These four steps avoid issues 1 and 2.
- Load Muse Glimmer with a context length of at least 16,384 tokens (32,768 recommended). In Ollama, start it with OLLAMA_CONTEXT_LENGTH=16384 or more.
- In RAME, open Settings → Runtime → Model servers, choose LM Studio or Ollama, and press Find models.
- Choose the model by its full name and press Use this model.
- To work on files with Agent or Mission, open your project folder in VS Code (File → Open Folder).
How much context fits on my GPU?
It depends on the model. In Muse Glimmer's GGUF, only 13 of its 52 layers keep the full context; the other 39 remember just the last 2,048 tokens, so each token of context takes very little memory. Rough estimate of the extra memory: about 0.4 GB at 32,768 tokens, 0.9 GB at 65,536 and 1.7 GB at 131,072 (the model's maximum). In one test setup (an RTX 3090 with 24 GB), 32,768 tokens used 20.2 GB.
These figures are an estimate, not a measurement: LM Studio does not log the real size of that memory. To try a larger context, set 65,536 and watch Windows Task Manager: if “Shared GPU memory” starts to rise, the model is spilling into system RAM and becomes very slow, so lower it. RAME needs about 16K for Agent and does not read the context a model was loaded with, so more than 32K or 64K only gives room for long runs.
Report a problem
Open an issue at github.com/caimari/rame-code/issues. We read and answer every report. Please include:
- the RAME Code version from Settings → About (for example “v0.2.0 · release · be1240b…”);
- your operating system, and whether you use VS Code locally or over Remote SSH;
- the model server (RAME's own llama-server, LM Studio, Ollama, or Meta Model API) and the model name;
- the exact message RAME showed, and the steps that led to it;
- for LM Studio or Ollama, the error line from the server's log, if there is one.
Never include your Meta API key, passwords, private file contents, or anything else you do not want to make public. GitHub issues are public.
Planned items are not part of any published release.
What comes next
- Implemented · real validation pending
Real-API validation of cloud workflows
Mission Advisory, Delegated and cloud Agent tools are implemented but validated only with a simulated Meta. Real Meta is demonstrated for three Chat inferences with Spark.
- Implemented · real validation pending
Reload in LM Studio when the context is too small
In development for the next version. When LM Studio rejects a request for lack of context, RAME offers a button to reload the model with more context (32,768 by default, never above the model's maximum). It asks for confirmation first and uses the official LM Studio API (version 0.4.0 or later). If cloud escalation is on and a Meta key is saved, Spark is offered alongside it and you choose. Tested with a simulated LM Studio (791 tests on Node 20 and 24); not yet tested against a real LM Studio. The Ollama equivalent is pending.
- Planned
Multimodal capabilities and the Muse family
Vision is not integrated yet. Wider compatibility with the Muse family will follow as suitable models and API features become available; it is not claimed today.
- Planned
Quality, reliability and model orchestration
Better code quality and reliability, and closer cooperation between local models and Meta's cloud without giving up user control.
- Planned
Visual Studio Marketplace and Windows
Publication on the Marketplace and complete validation on Windows are pending.
- Planned
Onboarding, optional sandbox, wider compatibility
A smoother first run, an optional operating-system sandbox for run_command and wider model compatibility. Not in any release.
Built during the hackathon. Tested with evidence.
Check it yourself
User Guide
Install, configure models and use Chat, Agent and Missions.
For Judges
What to read and run first.
Verification guide
How to reproduce the checks, including the sabotage tests.
Recorded evidence
Recorded runs, kept with the build they came from.
GitHub Actions
Continuous integration results.
CHANGELOG
What changed in each version.
Public repository
Apache-2.0, with the original attribution.
What each piece of evidence does and does not show
Entries come from the repository log, which separates verified work from unverified work.
How it was built
Repository created
New independent repository: Apache-2.0 license, README, no functional code yet.
First vertical slice
API key in SecretStorage and a bounded command that sends a mission goal to Meta Model API, with unit tests.
Local Glimmer tool-calling check
Local Muse Glimmer tested with tool calls before building the Agent loop on it.
Permission-gated Agent
Agent slice with permission profiles, one-use approvals and fixes found while closing the slice.
Sidebar and Settings rework
Home, conversation and unified composer; conditional Settings and a corrected model catalog.
v0.1.0 public preview
First public release with a VSIX, 269 automated tests passing and 0 vulnerabilities in production dependencies.
v0.2.0 published
Governed memory, resumable Missions with host-checked acceptance, Ollama and LM Studio support, web research and privacy controls. 759 tests passing on Node 20 and 24, a 44-case adversarial battery (24 blocked, 17 detected, 3 documented limits) and the VSIX checked byte for byte against the local build.
Only runs that can be checked against evidence in the repository.
See it work
The demo video is not published yet; it will be featured here when it exists. Meanwhile, the recorded runs and the text evidence are available in the repository.
An independent project
Mission. To make AI development more transparent, adaptable and accountable: local intelligence by default, optional cloud assistance, human authority and independently observed results.
RAME Code is an independent open-source project, started from scratch on 10/31/2026 for the Meta Global AI Developer Hackathon 2026, Indie Developer track. Author: Antoni Caimari Caldés.
Its public code and Git history begin in this repository. No earlier private code, services, data or results are included or required.
Its design draws conceptual inspiration from earlier RAME research. That work is documented separately and is not part of this project: ramesystem.com.