AIEP Miner — Governed Compute Research
AIEP Miner is a governed compute proof-of-concept exploring how AIEP evidence records, negative proofs, replay and node attestation can be applied to constrained, repurposed or distributed compute environments. It is not presented as a production autonomous systems platform. Published benchmark results, general hardware adapters and wider deployment tooling remain future work.
The initial implementation applies AIEP evidence governance to ASIC cryptocurrency miners — a hardware environment that produces clear, measurable telemetry and operates under well-defined constraints. This made it a practical starting point for testing whether AIEP’s governance primitives can operate at the hardware level.
→ View on GitHub · → Get involved
What the proof of concept demonstrates
AIEP Miner connected to ASIC mining hardware and applied full AIEP evidence governance to every hardware interaction cycle:
| What it does | AIEP mechanism |
|---|---|
| Every telemetry poll committed as a content-hashed record | P41 recall substrate |
| Every suppressed action committed as a Negative Proof — absence proven, not asserted | P37 divergence proof |
| Anomalies (staleness, temperature gate, physical impossibility) committed as Divergence records | P37 |
| Every decision reproducible from committed inputs under deterministic replay | P80 dual-ledger |
| MANUAL → AUTONOMOUS mode transition requires a valid authority hash before hardware dispatch | P80 execution gate |
| Append-only chain-linked ledger — any alteration detectable | GENOME R1–R4 |
Every governance property that AIEP defines in the abstract — evidence-bound decisions, negative proofs, deterministic replay — has been exercised in this proof-of-concept environment. What it does not yet provide is a general platform that other developers can adapt to different hardware and environments.
The bigger problem
Logging is not governance.
Most autonomous systems write logs. A log tells you what happened. It does not tell you:
- whether what happened was the only thing the system could have done given its inputs
- whether the suppressed actions were genuinely suppressed, or simply absent
- whether the decision chain can be independently replayed by a third party
- whether the telemetry the decision was based on was tampered with
For an IoT device, this is an annoyance. For industrial control systems, autonomous infrastructure, or any system where machine decisions have regulatory, financial, or safety consequences, it is a governance void that no log file can fill.
AIEP’s evidence substrate — hash-bound records, Negative Proofs, deterministic replay, node attestation — is the architectural answer. AIEP Miner is the first implementation. The platform needed to make this broadly accessible does not exist yet.
What needs to be built
This is an honest statement of where the project is and what developer contributions would unlock:
Hardware adapter layer
The current implementation targets ASIC mining hardware over a specific telemetry protocol. A generalised adapter interface — analogous to a device driver model — would let the governance layer operate on any hardware that exposes telemetry:
- MQTT bridge for IoT devices and sensors
- Modbus/OPC-UA adapter for industrial PLCs and SCADA systems
- Raspberry Pi / single-board computer reference adapter
- REST/WebSocket bridge for any HTTP-capable device
Skill fit: Python, embedded systems, protocol engineering
Evidence dashboard
The ledger accumulates governed records, but there is no visual interface for operators to inspect decisions, replay cycles, or verify Negative Proofs. A dashboard — even a minimal one — would make the governance properties visible and demonstrate the value to non-technical stakeholders.
Skill fit: TypeScript/React or any modern UI framework, familiarity with append-only data structures
Attestation layer for constrained environments
Node attestation (proving that a specific hardware node produced a specific evidence record) currently relies on environment fingerprinting. Extending this to hardware security modules (HSMs), TPMs, and secure enclaves would allow deployment in regulated environments.
Skill fit: Security engineering, embedded systems, cryptography
Integration with IoT platforms
Connecting the AIEP governance layer to established IoT platforms (Home Assistant, AWS IoT, Azure IoT Hub) as a governed evidence sidecar — so existing deployments gain auditability without rearchitecting.
Skill fit: Cloud integration, IoT platform experience
Benchmarks and stress tests
The proof of concept ran under real operating pressure, but there are no published benchmarks for governance overhead across different hardware classes and network conditions. Reproducible benchmarks would support deployment decisions.
Skill fit: Systems programming, benchmarking, statistics
What already exists and is open source
The full AIEP protocol stack that AIEP Miner builds on is publicly available:
| Component | Repository | Licence |
|---|---|---|
| Evidence schema and canonical record types | AIEP Hub | Apache 2.0 |
| Cryptographic primitives (R1–R8, GENOME) | AIEP-GENOME-SDK | Apache 2.0 |
| Divergence detection and Negative Proof | AIEP-VALIDATOR | Apache 2.0 |
| Append-only dual-ledger | aiep-dual-ledger | Specification published; source access controlled |
| Recall substrate | aiep-recall-substrate | Specification published; source access controlled |
| AIEP Miner reference implementation | aiep-miner | Apache 2.0 |
The miner reference implementation is Apache 2.0. The dual-ledger and recall substrate specifications are published; source access is controlled. See Strategic Access for partnership terms.
Why autonomous systems governance matters now
Every sector that deploys autonomous systems is facing the same question from regulators, insurers, and operators: can you prove what the system decided and why?
The EU AI Act, UK AI frameworks, and sector-specific regulations (HSE, FCA, FDA) are all moving toward mandatory audit trails for autonomous decision-making. The audit trail they are describing is exactly what AIEP Miner produces — except AIEP Miner produces it as a cryptographically verifiable evidence chain, not a log file.
The window for establishing the reference architecture for governed autonomous systems is open now. A log-file industry standard established in the next three years will be much harder to displace than one established before the pattern is set.
Get involved {#get-involved}
AIEP Miner is an open project. The right contributors are:
- Embedded / systems developers who work with constrained hardware and want to explore governance architectures
- IoT engineers who have seen the audit gap at first hand and want to solve it properly
- Security engineers interested in hardware attestation and tamper-evident evidence chains
- Researchers in autonomous systems, AI governance, or formal methods
The practical paths in:
- Clone and run the reference implementation — aiep-miner on GitHub. Read the
GOVERNANCE.md. Run the emulator. See the ledger build. - Pick an open problem — the adapter layer, dashboard, attestation extension, or benchmarks above. Any of these can be started independently.
- Write to us — [email protected] with what you want to build. We can share architecture context, point you to relevant protocol specs, and coordinate with other contributors.
For NDA-gated technical briefings on the broader autonomous systems roadmap, see Strategic Access.
Related
- Build with AIEP — integration guide and SDK documentation
- GENOME SDK — cryptographic primitives
- Showcase — full test coverage record across the open-source stack
- Case Studies — AIEP Miner governance in context
- Builders Programme — conformance badge and developer registry