Important
Development on VCP is paused. Ioka has diverted its resources and attention to the Munarium Governance Platform. Much progress has been made on VCP, but it has become too expensive for Ioka to pursue alone. The repository, documentation and published beta downloads remain available as they are. Issues and pull requests may not receive a response while development is paused.
VCP is an open-source local coding agent that combines repository-aware coding, model selection through OpenRouter, persistent memory, and visible delegated work. It includes a native Windows CLI, a TypeScript SDK and a VS Code extension, licensed under Apache 2.0.
Status: paused at a signed limited beta. Download the Windows x64 installer, portable ZIP and matching VSIX from GitHub Releases. Full qualification remains incomplete; this is not a stable-release or clean-host support claim. See the publication record, release plan and implementation status for exact artifacts, actual checks and remaining gates.
The latest release is 0.2.37, published October 6, 2026 (UTC) and available at downloads.ioka.io. The native app, Windows installer, SDK and VSIX all carry version 0.2.37, verified in the built artifacts. Native artifacts carry timestamped Ioka LLC code signatures through Azure Artifact Signing, and all public asset hashes matched the prepared release. The extension accepts VS Code 1.138.0 and newer 1.x releases. Installed-product, installed-editor and clean-host qualification stages were not run for 0.2.37, and full scenario acceptance has not passed. The Visual Studio Marketplace still serves the earlier iokaio.vcp 0.2.4 prerelease. See extension compatibility and the Marketplace publication record. Earlier releases retain their original identities.
Between September 22 and October 6, 2026, VCP moved from a planning-stage build to a series of signed public betas:
- Signed Windows betas. Code signing through Azure Artifact Signing, publication to GitHub Releases and downloads.ioka.io, and a Marketplace prerelease of
iokaio.vcp0.2.4. Signed releases in this period include 0.2.3, 0.2.4, 0.2.5, 0.2.32 and 0.2.37. The native app, installer, SDK and VSIX now share one version, incremented for every candidate (publication record). - Setup and onboarding.
vcp setupwith readable results and a readiness check, per-workspace profiles, model sets with live cost estimates, current-user and all-users installer PATH modes, and recovery of provider metadata after updates (balanced onboarding). - Practical CLI scenarios. Four long-running, multi-turn scenario test plans drive the CLI through real projects in Vue/Node, ASP.NET Core, Java/Maven and Python, with deterministic per-turn scorecards. No scenario is fully qualified yet: scenario C passed all five turns on 0.2.35 with its final review pending, scenario D was stopped after a failed turn-3 check, and A and B have partial runs.
- Execution engine refinements. Current state separated from retained history, incremental validation, adaptive context and token allowances, focused verification, shared provider request pacing across CLI processes, recovery from empty provider responses and model fallback, and native .NET, Maven and Pytest completion checks (EE-00–EE-07). Task deadlines and spending caps are suspended in this beta; charges are still recorded (known issues).
- Skills. On-demand skill references, validation and helper fixes, and a cross-stack toolchain-installation skill (skills upgrade plan).
Open work at the pause includes full scenario acceptance, larger engagements, installed-product and clean-host qualification, cold-open performance, and Marketplace publication of current releases.
VCP supports repository analysis, change review and implementation through one engine that owns task history, model accounting, authorization and recovery. The beta qualification matrix checks these integrated behaviors against the final installed artifacts.
| Capability | Behavior |
|---|---|
| Coding and verification | Inspect the workspace, prepare changes, run relevant checks, and report what actually passed |
| Model routing | Select among model groups through OpenRouter using task needs, capabilities, cost, and project policy |
| Budget control | Reserve and account for model spend across the root task, helpers, and delegated work |
| Local memory | Retain versioned claims with evidence, provenance, disputes, and workspace scope |
| Local retrieval | Use Tantivy for lexical search, DiskANN for vector retrieval, and locally executed embeddings |
| Inspectable history | Preserve full observed work artifacts, expose history, notify about aging data, and prune only by user command or saved policy |
| Skills and MCP | Load development skills and broker Model Context Protocol tools through the same authority and accounting boundaries |
| Visible delegation | Show child tasks, isolate their work, and integrate results through one controlling engine |
| Pause and recovery | Pause root and child work with /pause while keeping the CLI open, or on close; reconcile effects and deliberately resume |
| Portable state | Transfer history, context, memory, and search state using encrypted snapshots and developer-controlled recovery material |
The first-release scope includes these capabilities together. Implementation and historical qualification records do not replace current beta acceptance.
The foundation is a Codex-derived Rust engine and CLI, selected Gemini behavioral adaptations and Munarium memory code. The source map and setup record the initial imports and qualification. Current source inventories and release receipts bind the selected implementations to each candidate.
Selected Codex source is copied into src/third_party/codex/ as ordinary repository files. The native baseline build and source records consume those files directly, without fetching Codex or applying patches. ADR-013 defines independent reconstruction and upstream maintenance. The selected Munarium libraries share that Cargo workspace and have native test commands. A private integration host qualifies VCP controls around the retained loop; the ordinary upstream CLI is not the VCP product.
One engine owns task state, authorization, the canonical store, and cost accounting. UI clients and adapters do not create competing schedulers or bypass those controls. SQLite and Files canonical stores follow the same durability and portability contracts and both require beta qualification.
The engine, memory, indexes, and embeddings run on the developer's machine without a hosted VCP backend. Coding requests and model-assisted work use OpenRouter, so selected prompt/context content is sent to the configured model service. Local embeddings do not imply that all model activity is offline. External MCP tools have their own declared access requirements.
Active local code, databases, history, and indexes remain plaintext. VCP encrypts snapshot objects and manifests locally before publishing to a cloud sync folder. Recovery keys remain under developer control and outside that folder. Follow the recovery instructions; independent-machine recovery remains a current beta qualification gate.
See the architecture for contracts, invariants, failure behavior, and open decisions.
The initial roots are:
docs/ Architecture, implementation plan, and project documentation
src/ Product source, test code, fixtures, and packaged assets as implemented
scripts/ Build, test, evaluation, and packaging entry points as implemented
.github/ Contribution templates and delivery CI
src/tests/ contains the delivery harness and contract tests; scripts/test.ps1 runs them. See the harness setup. The code layout plan defines the future subdirectories, dependency boundaries, upstream provenance locations, and ownership by plan segment. Directories are added when they contain useful work.
| Goal | Document |
|---|---|
| Prepare an internal beta installation | Installation and prerequisites |
| Set up a provider and run a task | First task and metadata renewal |
| Check support limits and report a problem | Known issues and safe support |
| Browse the documentation | Documentation index |
| Understand the intended product | Architecture and requirements |
| Find the next implementation task | Plan and execution order |
| Place code or scripts | Code layout |
| Understand engineering conventions | Delivery contract |
| Design tests and acceptance evidence | Test fixtures and acceptance |
| Trace dependencies and release coverage | Work-item ledger |
| Propose or submit a change | Contributing |
Research notes are indexed separately under architecture documentation. Model tables and upstream comparisons are research inputs, not a live compatibility or pricing catalog.
To read the design or contribute documentation, Git and a text editor are enough:
git clone -c core.longpaths=true https://github.com/iokaio/vcp.git
Set-Location vcp
git switch -c docs/my-changeRead the contribution guide, make a focused change, verify its relative links and status claims, and check whitespace:
git diff --checkWith Git, PowerShell 7 and Node.js 24 or later, run npm ci --prefix src/tests --ignore-scripts --no-audit --no-fund, then pwsh -NoProfile -File scripts/test.ps1 -Suite fast. This checks repository, harness and imported-source contracts. scripts/build.ps1 builds the selected Codex baseline with the documented Rust/native prerequisites. VCP's production build and distribution guide describes the separate product build, package receipts and native qualification runners. A fast-suite pass does not qualify an installed beta.
- Qualify upstream reuse, native Windows execution, local search, storage, and encrypted portability.
- Establish durable engine state, cost accounting, context, tools, and the coding loop.
- Integrate the CLI, governed memory, retrieval, full history, and portable recovery.
- Complete routing, optimization, skills, MCP, and visible delegation.
- Pass integrated owner acceptance and package a native Windows release with notices and provenance.
The public API, TypeScript SDK, VS Code extension, governed executable hooks and foreign configuration import are implemented. The internal beta plan records the packaging and acceptance work that remained when development paused; step 5 is incomplete. Non-Windows and remote workspaces remain outside the selected beta scope.
Design review, corrections, test scenarios, and implementation contributions are welcome. Read CONTRIBUTING.md before opening a pull request. Contributions use Developer Certificate of Origin sign-offs (git commit -s); no contributor license agreement is required. Disclose borrowed material, generated code, and AI assistance, and review everything you submit.
Join the Ioka Discord server to discuss VCP, share ideas, and connect with the community.
Use GitHub Issues for non-sensitive questions, defects, and proposals. Report vulnerabilities through the private routes in SECURITY.md. SUPPORT.md explains the current support scope, and CODE_OF_CONDUCT.md applies to project participation.
VCP's original code and documentation are licensed under the Apache License, Version 2.0. See NOTICE, third-party attribution, and the name and trademark policy. Third-party material retains its applicable terms.
The project draws on OpenAI Codex, Gemini CLI, Munarium, and Anthropic Skills. The community-document structure and contribution conventions were adapted from Munarium for VCP's planning stage. The source records identify the actual Codex and Munarium selections and the bounded, attributed Gemini behavioral ports. The skills plan records the eight workflow additions and per-skill license review; GPL, LGPL, restrictive and unlicensed skill material is excluded. These acknowledgements do not imply endorsement by their maintainers.