01
Run from source
Controlled entry
Clone the repo and bootstrap a local install inside the checkout.
git clone https://github.com/rebootix-research/viki-code.git && cd viki-code && python scripts/install.py --path .Rebootix Software Systems
VIKI Code
The governed multi-agent coding system built to operate real repositories
Most coding tools stop at output. VIKI Code is built to continue from there, into planning, execution, validation, approvals, rollback, and governed change across real repositories.
Built for real repositories, governed execution, multi-agent task flow, and production-minded engineering, VIKI Code is Rebootix's coding system for teams that want more than autocomplete and more than chat.
Less assistant. More execution layer.
Built to inspect. Plan. Execute. Validate. Built to move from suggestion to infrastructure.
This is not passive AI. This is controlled software action.
Live repo operation
Planner - Builder - Verifier - Approval
governed
Repo graph
Repo map
Symbols
Impact
Proof metrics
Local tests59 passed
Live suite9/9
Public benchmark8/8
Controlled execution flow
Inspect
→Plan
→Execute
→Validate
→Return proof
Start VIKI Code
Install it fast. Enter the repo. Execute with control.
The current public proof set shows a real install path, real run path, and a built wheel flow documented directly from the repository.
Current public positioning
Live-tested. Repo-executing. Approval-aware. Built for serious software action.
Execution lane
01
Inspect
Read the repo, map the targets, and establish operational context.
02
Plan
Break the work into controlled agent tasks with explicit scope.
03
Execute
Apply edits, surface diffs, and keep risky operations governed.
04
Validate
Return with checks, proof, and a clearer state than the one entered.
Installation surfaces
Three direct routes into the current public VIKI Code workflow.
Repo-ready
02
Run immediately after install
Controlled entry
Launch the local API surface right after setup.
python scripts/install.py --path . --run03
Built artifact after build
Controlled entry
Install from the documented 4.1.4 wheel artifact flow.
pip install dist/viki_code-4.1.4-py3-none-any.whlProduct positioning
What VIKI Code is
VIKI Code is a live-tested coding system built for teams that need more than snippets and more than conversation. It is designed to operate across real codebases with structure, control, and proof.
What makes it different
Repo-executing
Built to work inside real repositories, not outside them.
Governed
Approval-aware, rollback-capable, and validation-driven.
Multi-agent
Designed to coordinate planning, implementation, review, validation, and execution.
Production-minded
Built around real workflows, not novelty demos.
Surface-flexible
Usable across CLI, API, IDE, and messaging-driven flows.
Strategic importance
Why VIKI Code matters
The industry is crowded with coding interfaces that can talk about software. Far fewer can operate software systems with discipline. VIKI Code is built around that difference.
In serious engineering environments, the hard part is not producing text that looks like code. The hard part is entering a living repository, finding the right targets, making controlled edits, validating the outcome, and doing it without chaos.
That is the threshold VIKI Code is built to cross.
Threshold
A new threshold in software execution
VIKI Code is built for a new threshold in software execution, where the machine is no longer limited to suggestion and no longer confined to a passive window. It can inspect, plan, act, validate, and return with evidence.
That shift is powerful. It changes the role of the coding system from assistant to operator.
But power without control is noise. VIKI Code is built around governed execution, approvals, rollback, validation, and explicit task flow, because serious autonomy only matters when it can be trusted inside real repositories.
Serious autonomy is dangerous without control. VIKI Code is built to make it usable.
Execution stack
Core capabilities
Real repository execution
Works against actual codebases, not isolated text prompts.
Multi-agent task flow
Coordinates planning, implementation, review, validation, and execution across the same governed runtime.
Governed change
Supports approvals, rollback, diff visibility, and controlled execution paths.
Validation-first behavior
Built around tests, checks, and evidence-backed completion rather than pure output generation.
Multiple operating surfaces
Available through CLI, API, VS Code integration, and messaging-connected workflows.
Developer surfaces
Operating surfaces
The same governed execution model is exposed across the developer surfaces that matter.
CLI
Direct operator control for repo intelligence, task submission, diff review, and status.
API
Local HTTP routes for orchestration, integrations, health, approvals, and run lifecycle visibility.
IDE
VS Code-oriented flows for repo-aware interaction, task submission, diff review, and session visibility.
Messaging
Telegram and WhatsApp command surfaces for approvals, status, patches, logs, and operational handoff.
Operators
Who VIKI Code is for
- teams working in real repositories, not toy examples
- builders who want governed AI execution, not just code suggestions
- engineering environments that care about control, validation, and repeatability
- operators who want autonomous coding power without surrendering oversight
Evidence
What has been proven
VIKI Code has been exercised across live CLI and API task execution, generic-prompt workflows, benchmark runs, installed-wheel validation, and isolated execution paths. It is built and presented as a real product system, not a concept demo.
Local regression
59 passed
Broader live suite
9/9 passed
Public live benchmark
8/8 passed
Public offline benchmark
8/8 passed
- real CLI task execution
- real API task execution
- repeated generic-prompt live wins
- multi-file rollout success
- installed package validation
- isolated execution validation
- benchmark-backed current release evidence
Primary links
Proof surfaces
Follow the public evidence trail directly from the repository: source, proof, release notes, and benchmark records.
Rebootix
Built by Rebootix
VIKI Code is a project of Rebootix Artificial Intelligence Research and Development.
Rebootix builds advanced AI systems, autonomous software infrastructure, and production-grade machine intelligence products focused on real-world execution. VIKI Code is part of that broader effort: practical AI systems designed to operate across actual developer workflows, governed environments, and serious engineering surfaces.
Closing directive
The next step after coding assistance is governed code execution.
VIKI Code is built for that step. Not as a demo. Not as a trick. As infrastructure.