ASURA ENGINE // WINDOWS x64 // SOVEREIGN BUILD

DOWNLOAD
THE
ENGINE.

One file. 13 MB. No runtime to install, no account to create, no API key to paste. The model weights are pulled once by --setup and are never bundled into the executable. Everything you need to verify what you received is on this page.

ARTEFACT MANIFEST

VERIFY BEFORE
YOU RUN IT.

● AVAILABLE NOW — the binary is built and validated, and the checksum below is of that exact artefact. Download it below and verify the SHA-256 before you run it. The source repository stays private; the artefact is served directly.

ASURA_ENGINE.EXE // MANIFEST

ARTEFACT

asura_engine.exe

SIZE

47,968,583 bytes (47.97 MB)

PLATFORM

Windows x64 — the only platform it has been run on

SHA-256

99d2994315c68b16043a5783170d139b6a1d881bcbe438a85f81579f9433bfa3

VERIFY YOUR COPY

certutil -hashfile asura_engine.exe SHA256

DOWNLOAD ASURA ENGINE — 47.97 MB

SYSTEM REQUIREMENTS

WHAT IT NEEDS
TO RUN.

x64

Windows

Windows x64. This is the only platform the engine has been built and run on — never macOS, Linux, tablet or phone.

16 GB

RAM

The reference machine is a 16.8 GB consumer laptop, and every figure this project publishes was produced on it. The largest local model is 9.6 GB; smaller ones need less.

50 GB

Free Storage

13 MB for the engine plus room for open weights. The reference install holds 42 GB across eight models — you choose how many to pull.

Network, After Setup

--setup pulls the weights once. After that the inference endpoint is on loopback and remote egress is off.

INSTALLATION

THREE STEPS.
NO INSTALLER.

STEP 01

Verify the checksum before running anything. certutil -hashfile asura_engine.exe SHA256 — compare the output to the SHA-256 above, character for character. If it differs, stop.

VERIFY

STEP 02

Pull the open weights. asura_engine --setup — the one step that uses the network. It downloads the models and verifies a real completion round-trips before reporting success.

SETUP

STEP 03

Start the engine. asura_engine --serve — binds JSON-RPC on loopback. Open asura_console.html beside it for the console. Nothing listens on an external interface.

SERVE

BEFORE YOU RUN IT

THE EXECUTABLE IS NOT CODE-SIGNED.
Windows SmartScreen will show a "Windows protected your PC" warning the first time you run it, and you will need More info → Run anyway. That warning is telling you the truth: nothing vouches for this binary except the checksum on this page. Compare it first. A SHA-256 detects a changed or corrupted file — it is not a signature and does not prove who built it. If you are deploying this inside an organisation, that distinction is the one your security team will ask about.

WHAT IS IN THE FILE

MEASURED,
NOT ASSERTED.

Reproduce every figure with python asura_model.py, or run the suite inside the binary itself.

180

Tests Inside The Binary

219 pass from source; 180 pass inside the artefact, run from a temporary directory with no source tree beside it. The in-artefact number is the one that says anything about the file you downloaded.

4/4

Sovereignty Conditions

Loopback endpoint, remote egress off, weights present locally, no API key — re-checked at call time rather than asserted once at install.

107

Agent Specifications

42 department + 15 engineering + 12 job + 20 elite = 89 legacy; plus 18 quantum software capabilities = 107 total. Run sequentially — there is no concurrent scheduler over the four rosters.

Local RPC Methods

route, parse, health, introspect, departments, cluster, tenants — read-only, allowlisted, loopback only, and unauthenticated because nothing is exposed off the machine.

ASURA / SOURCE-VERIFIED SOFTWARE

THE QUANTUM SOFTWARE STACK

Bounded classical simulation, local software primitives, and reproducible ordering. 107 agent specifications: 89 legacy agents + 18 quantum software capabilities. These are catalog identities and execution adapters, not 107 distinct agent class declarations or proof of autonomous job performance.

Quantum Fourier Transform (QFT)

The module-level _qft function applies Hadamard gates, controlled phase rotations and qubit-order reversal to a QuantumReasoningCore state vector. Its inverse reverses the circuit. The same input can produce reproducible ordering and audit traces.

The source records unitary norm 1.000000000000 and round-trip error 1.22e-15 for its verification fixture. These are numerical simulation checks, not a speed advantage.

asura_model.py:39970 (_qft); 30859 (QuantumReasoningCore); 40789–40790 (recorded checks).

Quantum Programming Language (QPL)

QuantumProgrammingLanguagesEngine parses, compiles, executes, disassembles and explains a small quantum-flavoured language. Its backend is QuantumComputerEngine. It is bounded, not Turing-complete, and not a physical quantum hardware runtime.

asura_model.py:47097; backend at 46584.

Quantum Algorithms

QuantumAlgorithmsEngine includes Deutsch–Jozsa, Bernstein–Vazirani, Grover search, QFT, phase estimation, a teleportation simulation and quantum counting. Results distinguish classical simulation cost from theoretical quantum query cost; no measured speedup is claimed.

asura_model.py:47584.

The Quantum Agentic Swarm

QuantumAgenticSwarm provides bounded deterministic routing to engine adapters. QuantumAgent is the shared dispatcher. Missing engines are reported unavailable; this is not an emergent collective or a concurrent workforce.

Agentic Swarm Routing is excluded by design: binding the swarm into itself would recurse during broadcast. The exclusion stays visible in the offline harness.

asura_model.py:45200; QuantumAgent:45085.

18 Quantum Software Capabilities

The 18 catalog adapters below map to these engine classes. The legacy catalog remains 42 department + 15 engineering + 12 job + 20 elite = 89; adding these 18 gives 107 total.

Capability	Exact source class	What the software does
Quantum Data Generator	`QuantumDataGeneratorEngine` asura_model.py:41724	Locally authored study material and exercises, ordered by QFT; no credentials or discoveries.
Software Structure Analysis	`QuantumSoftwareEngine` asura_model.py:42134	Bounded Python AST analysis and structural review; never executes or modifies source.
Physics Simulation	`QuantumPhysicsEngine` asura_model.py:42667	Small state-vector and physics simulations with numerical evidence; classical computation.
Bounded Self-Modeling	`QuantumConsciousnessEngine` asura_model.py:43114	Bounded self-model, observations and reflection; no consciousness or subjective experience.
Speed and Throughput Modeling	`QuantumSpeedEngine` asura_model.py:43671	Amdahl, critical-path and throughput models; no workers spawned or hardware speed measured.
Security and Integrity	`QuantumSecurityEngine` asura_model.py:44145	Classical hashing, HMAC verification and integrity envelopes; not post-quantum cryptography.
Template Creation	`QuantumCreationEngine` asura_model.py:44534	Template composition, design skeletons and bounded variant grids; no originality claim.
Agentic Swarm Routing	`QuantumAgenticSwarm` asura_model.py:45200	Deterministic engine dispatch and reporting; Agentic Swarm Routing self-binding is excluded by design.
Integrated Reasoning	`QuantumAlienBrainEngine` asura_model.py:45592	Composes bounded engine outputs with provenance; no autonomous intelligence claim.
Verified State Transfer	`QuantumTeleportationEngine` asura_model.py:46149	In-process payload copies checked by hashes and QFT fingerprints; no physical or network transfer.
Quantum Circuit Simulation	`QuantumComputerEngine` asura_model.py:46584	Small classical state-vector simulation with bounded registers and gates; no physical hardware.
Quantum Programming Language	`QuantumProgrammingLanguagesEngine` asura_model.py:47097	Parses, compiles and interprets a small bounded quantum language on the local simulator.
Quantum Algorithms	`QuantumAlgorithmsEngine` asura_model.py:47584	Classical simulations of canonical algorithms with explicit simulation and theoretical query costs.
Bounded Agentic Planning	`QuantumAgenticAIEngine` asura_model.py:48118	Fixed routing, bounded plans, result grading and retry budgets; cannot choose its own goals.
Offline Execution and API Cost Modeling	`ZeroAPICostEngine` asura_model.py:49015	Guarded local execution, dependency audit and modeled API spend; hardware and electricity remain costs.
Enterprise Connector Emulation	`QuantumEnterpriseConnector` asura_model.py:49866	Offline examples of enterprise data shapes; no live tenant or vendor schema validation.
In-Process AI Federation	`QuantumAIFederation` asura_model.py:50481	In-process message envelopes and digest checks; no connected peers or authenticated network.
Tool Connection Interface	`ToolConnectionSystem` asura_model.py:50998	Local registration and operation routing over emulated tools; no OAuth or real connection.

What We Do Not Claim

No AGI, superintelligence, consciousness, physical quantum hardware or quantum advantage.
No live enterprise integrations or employee replacement. The offline connector records are examples, not validated live API payloads.
No production customer deployments or paying customer outcomes are established by this source evidence. Passing probes does not establish customer outcomes or full role competence.

Offline harness: 106 PASSED / 1 BLOCKED / 0 FAILED / 0 REFUSED. Engineering probes use explicitly labeled caller test doubles. Agentic Swarm Routing carries cause="b" and excluded_by_design=true.

Harness honesty flags: _evidence="MODELED", classical_simulation=True, network_used=False, api_used=False, credentials_used=False, real_tool_called=False, test_harness_only=True. Results also report alignment_status and does_not_prove.

The source release records 306 passing gates and 393 local example deliverables totaling 738,202 bytes. These are source regression and filesystem evidence. The whole-model health report remains DEGRADED; passing gates do not resolve its legacy envelope findings or verify the downloaded binary.

Sources: asura_model.py; docs/ASURA_UNIFIED_RELEASE.md; blocked_agents_final_summary.json. The unified console and founder-review boundaries are also documented in phase150_3_report.md.

DOWNLOAD THE ENGINE.

VERIFY BEFOREYOU RUN IT.

WHAT IT NEEDSTO RUN.