CodeFlare v1.43.0 : Memory map, budget-aware missions, four languages

Highlights since v1.42.1

🎨 Interface

• Header bar with a visible Settings button and a model chip (provider · model) that warns when an API token is missing.
• Plan as a side column next to the conversation instead of an overlay. It collapses and shows a Now: line for the current step.
• Light/dark toggle, a Help tab, and a Settings dialog that keeps keyboard focus inside it.
• The chat survives a window reload, with the full conversation.

🌍 Four languages

• The interface is available in English, Nederlands, Français and Deutsch.
• Four flags in the header, each labelled in its own language, so you can find yours even if you can't read the current one.
• Only the interface is translated. Messages, code and model output are left as they are.

⚙️ Settings & mission budget

• Budget has its own Settings tab, with five ordinary settings.
• Defaults are 16× higher than v1.42: 24M tokens, 192 turns, 9,600 tool calls, 24 h of model time.
• An "Unlimited" switch for every ceiling, and no token ceiling on a local model by default.
• The agent steers by its budget. It sees what is left, also as model calls remaining. At 50% it prioritises, at 80% it wraps up, and at 100% it writes a final report and stops.
• Fast mode: the model reasons less per call, which is faster and cheaper.

🧠 Memory

• Memory map: a visual overview of what the agent remembers, and how each part reaches the model: always, automatically, on request only, or never.
• Memory tab now names the project its counts belong to, and shows how many skills are validated.

🚀 Smarter, leaner runs

• Leaner context for local models. Stale and superseded tool results are pruned during a turn without breaking llama.cpp's prompt cache.
• Parallel agents are capped at the server's slots (e.g. 4 instead of 32), and the UI shows that real limit.
• Genuinely original ideas. For "invent something original" requests, the agent first drafts at least five concepts and checks whether each one already exists.
• Metrics report with prompt tokens per call, the largest prompt, and what pruning saved.

🐛 Notable fixes

• A failed dir could reject a finished mission. Read-only inspection commands no longer count as checks.
• Projects without a test framework, such as a single HTML game, never got tests. The test author now uses node --test.
• The 3D-model mesh check read HTML and JS files as broken STL files, which polluted memory.
• Prove It, Break My Solution and the editor code actions called a command that didn't exist.

v1.42.1 : Hotfix: model calls overflowed the stack

Hotfix — install this instead of v1.42.0. In v1.42.0 every model call failed with "Maximum call stack size exceeded": the client's settings accessor called itself after a blanket rename during the independent-judge work. Fixed, with a regression test. Nothing else changed — see the v1.42.0 notes for what this release contains.

v1.42.0 : Persistent missions, evidence-backed memory, and the self-improvement layer

v1.42.0
Persistent memory now tracks evidence, uncertainty and revision history across projects.

SQLite outside the runtime. Project and global knowledge use separate memory.sqlite files in VS Code storage, with content-addressed artifact directories. Existing knowledge.json files migrate with backups retained. The embedded SQLite/WASM runtime ships with the extension; self-updates leave stored memory in place.

Confidence and relearning. Skill confidence combines current-version successful/failed uses with a 90-day decay; it is an evidence heuristic, not a probability. Inconclusive trials are neutral. Global automatic reuse needs current successful evidence from two missions in two workspaces and confidence of at least 0.70. Failures trigger a 24-hour cooldown. Correction and merging create fresh candidates; promotion does not copy project proof, and forgetting retires a skill with a tombstone rather than securely erasing history.

Typed recall. recall_memory balances relevant skills, experiments, observed failures and project constraints using confidence, freshness, domains and type diversity. Project episodes and vectors remain scoped to the workspace. CodeFlare: Memory Status reports storage readiness and counts.
Optional semantic retrieval. Set codeflare.memoryEmbeddingModel to use real embeddings from the active local/OpenAI-compatible provider. Queries and selected memory snippets are sent there. Blank uses local lexical matching; provider errors fall back with a warning. The implementation uses bounded cosine scans and cached vectors, with SQLite file locking and atomic exports.
The self-improvement layer

What turns a thoroughly verifying tool into a system that can learn without supervision — and what keeps that safe.

Guardrails the agent cannot loosen. The files that constrain the agent (policy and its gate, evidence and acceptance, git isolation, write ownership, self-update and the recovery scripts) are locked during a self-improvement task in three layers: unwritable through the file tools, unwritable and un-committable through run_command (a shell write followed by git commit would otherwise make the edit look like the baseline), and a self-update candidate whose guardrails differ from the last human-activated version is refused unless the exact files are approved in a modal. The command-trust list in tools.ts/config.ts is deliberately not locked — it is the normal improvement surface — and that gap is documented, not hidden.

Independent judge. codeflare.judgeProvider/Endpoint/Model route requirement review, Prove It, Break My Solution and reflection to a different model than the one that did the work. A judge that resolves to the working model is treated as absent, and metrics record judgeModel only when the judge was really independent.

Reflection. CodeFlare: Reflect on Experience (or the Memory tab, or codeflare.memoryReflection: after-mission) reads recorded experiments and proposes candidate skills, project constraints, contradictions between stored skills and recurring failure patterns. Every constraint must cite at least two known episodes; proposals that would weaken verification are rejected; nothing is validated by reflection itself.

Calibration that feeds back. The per-turn record of what the model claimed versus what a check demonstrated now changes behaviour: a model with a measured habit of "done" without a demonstrating check is told its own numbers and gets a mandatory behavioural check on every turn. A thin sample changes nothing; a reliable record is acknowledged.

Mission budget and stop rule. codeflare.missionBudget bounds an autonomous mission as a whole (turns, tool calls, tokens, wall time) and pauses one that makes no measurable progress for several turns, with the reason shown. Resuming an exhausted mission is refused before anything runs.

Causal skill validation. In a fraction of autonomous missions (codeflare.skillHoldoutRate, default 0.1) an eligible skill is deliberately withheld and the outcome recorded as a control trial. Once enough controls exist, a skill's lift over its own absence is computed; a skill with no lift drops back to candidate however often a mission passed with it. Interactive turns never withhold.

Night Shift. Reflection also derives a backlog of evidence-cited goals — recurring failures, contradictions, missions that ended unaccepted (CodeFlare: Show Backlog). CodeFlare: Night Shift works them one autonomous mission at a time under the mission budget and the guardrail lock; each goal prompt requires acceptance criteria first and tells the mission to stop and report when the problem does not reproduce. A human still presses the button, and only in a non-interactive autonomyProfile.

Memory tab. The chat settings panel gained a Memory tab: current counts, Reflect on recorded experiments, and Clear this project / agent memory / everything — each behind a confirmation, each reporting what was actually removed. Clearing archives a legacy knowledge.json instead of letting it re-import what was just deleted.

Fix: global storage under a vscode-userdata URI (a plain local install) was treated as "not file-backed", which disabled memory entirely. Any storage URI that resolves to a local absolute path is now accepted; remote and virtual filesystems are still excluded.
Memory remains local to the VS Code profile/extension host, without automatic cloud synchronization. Tests of restart and cross-project recall verify persistence and isolation; improved coding speed or quality requires a separate controlled benchmark. See README.md for eligibility rules, storage, migration and privacy details.

v1.41.1
Memory now lives in VS Code's extension storage, with separate workspace and cross-project scopes.

Three memory layers. Conversations and active missions stay in workspaceState. Project facts, landscapes and project skills use storageUri; reusable agent skills use globalStorageUri. New memory files are stored outside the repository.
Explicit skill scope. save_skill and try_skill accept project (default) or global, and list_skills shows the scope. Relevant global skills enter future task context only after validation with passing execution evidence. Saving a skill alone does not validate it.
Project-only migration. Existing .codeflare/memory.md and .codeflare/knowledge.json are imported once into private project storage. Original files remain as backups; no legacy content is automatically promoted to global memory.
Global memory is shared across workspaces using the same extension storage; it is not automatic cloud sync across machines, profiles or remote hosts. Project run logs, checkpoints and verification settings remain task artifacts. See README.md for the storage layout.

v1.41.0
Persistent missions, independent test authoring and controlled self-updates.

Live progress footer. Exploration, design, build/repair, verification and delivery stay visible above the input. Backward transitions include their reason; expandable history shows agent tasks and results. Stop remains available during the separate test stage.
Remembered task controls. Autonoom uitvoeren and Tests schrijven en uitvoeren both default to off. Autonomous mode includes testing and skips plan approval while preserving existing command permissions, path rules and budgets. A separate test agent works from the original request; the coordinator actually executes the tests and sends failures back for bounded repairs. Missing or inconclusive test evidence does not count as a pass.
Parallel work. codeflare.maxParallelAgents sets a shared pool of 1–32 concurrent subagents per mission, default 32. Additional tasks queue. Ownership checks and serialized mutations coordinate the shared workspace; the coordinator handles commands and integration. New limits apply to the next mission.
Resume after reload. Saved mission state includes phases, transitions, changed files and agent results. Interrupted work is reconciled through CodeFlare: Resume Mission or Hervatten, rather than automatically replaying tool calls. CodeFlare: Save Mission and Reload saves an idle mission before reloading.
Landscapes and reusable skills. The agent can record sources, acceptance criteria, decisions and unknowns, and save candidate procedures in .codeflare/knowledge.json. Skills need a successful trial with current passing test/runtime evidence before automatic reuse. This records observed success, not benchmark-proven improvement.
Self-improvement workflow. CodeFlare: Improve CodeFlare works in the extension's source repository. The default codeflare.selfImprovement: "suggest" prepares a candidate; "automatic" opts into activation after validation. Prepare and Validate Self-update checks an isolated snapshot against committed tests, type checking, build and a VS Code activation/command-registration smoke test. Activate Validated Self-update installs the tested artifact and reloads.
Self-updates require an initial manual installation of a working release with the smoke and recovery runners. Before activation, set codeflare.selfUpdateKnownGoodVsix to a retained VSIX matching the installed bundle, and ensure codeflare.selfUpdateCli targets the same VS Code installation. An external helper attempts automatic reinstallation of that package if startup health fails; a manual reload may still be needed after a crash or rollback. The smoke test does not cover every UI flow or establish improved coding performance.

Packaging no longer deploys. npm run package builds the VSIX; installation is explicit with npm run deploy. Older packages are preserved.

Requires VS Code 1.85+. Source-based self-updates also require Git, Node.js/npm and the locked development toolchain. See ...

v1.40.0 — Agentic coding with verified results

CodeFlare is an agentic coding assistant for VS Code that verifies its own work instead of telling you it's done. It runs against a local model on your own machine, or against OpenAI or Anthropic — your choice, switchable per project.

The design principle: the model is the brain; CodeFlare provides the eyes, hands, and feedback.

Why this is different
Most assistants stop when the model stops talking. CodeFlare doesn't consider a turn finished until something actually demonstrates it worked:

It reads its own mistakes. After every edit, new editor errors — including regressions in files it never touched — are fed back for bounded fix rounds.
It runs your project's own checks. The build, typecheck and test commands come from your repo's config, not from a guess. Failures go back to the model.
It can't mark a requirement "done" on a claim. Before finishing, it maps each requirement in your request to the evidence of what actually ran. A requirement to verify behaviour cannot be satisfied by a build alone — if nothing exercised it, the result is [UNVERIFIED] and that blocks "done". The evidence is order-aware, so "reproduce the bug before fixing it" isn't satisfied by a run that only happened afterwards.
It measures instead of guessing. Performance claims need numbers: profile, benchmark the baseline, change, benchmark again, and diff-test old against new for equivalence. "Looks faster" is not evidence.
It reasons proportionally. Requests are classified — debugging, performance, puzzle, open-ended — and the matching discipline is applied to that turn only. A small edit stays fast; a hard problem gets hypotheses and reproduction steps.
Two commands let you turn that scrutiny on the work directly: Prove It independently verifies the last change, and Break My Solution attacks it. Both run write-locked, so they can't quietly "fix" what they're examining.

What it can do
Edit and navigate — ranked retrieval over a compact repo map, atomic multi-file patches, whitespace-tolerant search/replace, language-server symbol renames. Deletes are recoverable and every turn is checkpointed, so you can revert a whole turn even after a window reload.

Run and investigate — shell commands with output fed back, temporary runtime probes, and full debugger control (breakpoints, stepping, variable inspection) built on your own launch.json.

Work safely unattended — opt-in autonomous profiles with hard change budgets, protected paths, and a command deny-list. Each autonomous turn runs on its own git branch: accepted work is fast-forward merged, rejected work is committed on the branch with your known-good tree restored.

Experiment in isolation — scratch scripts, reproductions and benchmarks run in a separate lab directory, never in your project tree.

See its output — generated images are pixel-checked for blank or broken output and sent back to a vision-capable model when the look matters. Web pages are captured with a real headless browser.

Use any web API from a key — hand it an API key and it finds the OpenAPI spec, reads the operation it needs, and makes the call. Keys live in encrypted storage, are only ever sent to that service's own host, and are redacted from everything the model sees.

Generate 3D models — point it at a Blender install and it builds meshes headlessly and exports STL. Every mesh is then geometrically checked — triangle count, bounding box, degenerate faces, watertightness. An empty export or truncated file goes straight back for a fix round. Watertightness is a proven property of the geometry, which makes it stronger evidence than a screenshot.

Remember — durable project facts it has actually proven, kept per project.

Install
Download codeflare-1.40.0.vsix below, then either drag it into Extensions → … → Install from VSIX… or run:

code --install-extension codeflare-1.40.0.vsix
Reload the window afterwards (Developer: Reload Window).

Updating is manual. A .vsix installed from a file isn't tracked by a marketplace, so VS Code won't offer updates. To move to a newer version, download it and install it the same way. CodeFlare isn't published to the VS Code Marketplace or Open VSX.

Requirements
VS Code 1.85 or newer
A backend: any OpenAI-compatible server for local use (llama.cpp, VLLM, Ollama — the model name is auto-detected), or an OpenAI/Anthropic API token
For the verify gate: your project's own toolchain. CodeFlare never invents a build strategy or installs tools.
For 3D generation: Blender 4.2 or newer (tested against 5.1)
MIT licensed. Built by Redflare.