EvoSpikeNet-Core Hardware-Aware Plugin Architecture: Feasibility Assessment

Assessment Date: August 21, 2026
Scope: EvoSpikeNet-Core plugin infrastructure, device backends, quantum-inspired layers, IBM Quantum integration

Conclusion

The earlier assessment that "plugin architecture requires architectural changes" does not apply to the current implementation. Key integrations are already in place. However, availability depends on the runtime environment. CPU and simulator paths can be validated locally, while Loihi, Jetson, Edge TPU, and IBM Quantum require the corresponding SDKs, hardware, and credentials.

Item	Current Status	Notes / Remaining Work
Plugin infrastructure	✅ Implemented	BasePlugin, PluginMetadata, lifecycle, config validation, allowlist, PluginFactory
DevicePlugin	✅ Implemented	Plugins and bridges for CPU/GPU/Loihi/Jetson/EdgeTPU/G-QuAT/IBM NorthPole/IBM Quantum
Dependency management	✅ Implemented	Optional dependencies in pyproject.toml, DependencyChecker, split requirements files
Neuron layers	✅ Implemented	EntangledSynchrony compatible signatures, HH/Conductance, quantum layer plugins
Quantum layers / plasticity	✅ Simulator implemented	Quantum/QAOA/VQE layers, QuantumAnnealingPlasticity. Gradients and performance on quantum hardware not yet validated
IBM Quantum	⚠️ Connection ready / hardware unverified	IBMQuantumPlugin implements Runtime, Sampler, Estimator, and fallback. Authenticated execution is environment-dependent
Optimization pipeline	✅ Implemented	Quantization/Pruning/Fusion with YAML-driven pipeline

Implementation Verification

Plugin Infrastructure

Key implementation files:

• evospikenet/plugins/__init__.py: PluginType, BasePlugin, PluginMetadata, config validation, allowlist
• evospikenet/plugin_factory.py: Plugin registration and instantiation
• evospikenet/plugins/device_plugin.py: DevicePlugin abstract base
• evospikenet/plugins/optimization_plugin.py: OptimizationPlugin abstract base

PluginType already includes DEVICE, OPTIMIZATION, QUANTUM_LAYER, SYNAPSE, CHANNEL, and SOLVER. The earlier claim that these types and config_schema were missing is no longer valid.

Device Integration

The built-in public facade is in evospikenet/plugins/builtin/device_plugins.py, with implementations split under plugins/builtin/device_backends/. CPU/GPU can be validated locally. Loihi, Jetson, and Edge TPU detect SDK availability and use each plugin's fallback path when the SDK is absent.

universal_integration.py retains a compatibility bridge with existing APIs, so the earlier concerns about complete separation of adapters/plugins and inability to register without modifying core are resolved. The legacy PlatformAdapter API does not need to be deprecated immediately.

Dependencies and Configuration

pyproject.toml defines optional dependencies for loihi, jetson, edge_tpu, and quantum. setup_awareness.py's DependencyChecker provides detection for LAVA, TensorRT, torch2trt, pycoral, and Qiskit.

A missing SDK is distinct from a missing implementation. CI without the SDK should validate no-dependency capabilities and fallbacks; actual backend tests should only run where the SDK is present.

Quantum Layers and EntangledSynchrony

• quantum_neuron_layers.py contains Quantum, QAOA, and VQE layers.
• Each layer can be instantiated as a plugin from neuron_backends/quantum_plugins.py.
• plasticity_plugins.py contains QuantumAnnealingPlasticityPlugin.
• EntangledSynchronyLayer in core.py supports num_neurons, individual parameters, and the legacy params dict concurrently; compatibility issues are fixed.

These are "quantum-inspired" or simulator implementations. The probabilistic synchrony of EntangledSynchrony and the classical fallbacks of QAOA/VQE must not be treated as evidence of physical quantum entanglement or real hardware performance.

Remaining Issues and Validation Plan

IBM Quantum

IBMQuantumPlugin implements Qiskit Runtime connectivity, Sampler, Estimator, cost/retry policies, and simulator/offline fallbacks. VQE is also covered by VQENeuronPlugin and VQENeuronLayer; the earlier claim of "VQE not implemented" was incorrect.

Remaining items:

1. Validate IBM Quantum authentication and job execution in an environment test.
2. Pin and verify the supported Qiskit and qiskit-ibm-runtime versions in CI.
3. Monitor real hardware job cost, wait times, and retry behavior on failure.

Hardware

1. Validate Loihi conversion results and spike I/O using the LAVA CPU simulator.
2. Validate Jetson/Edge TPU conversion and deployment on a dedicated runner with TensorRT, torch2trt, and pycoral installed.
3. For G-QuAT and IBM NorthPole, test not only SDK availability but also each runtime adapter's simulator contract.
4. For CI without real hardware, validate available, capabilities, fallbacks, and clear error results.

Quantitative Quality Gates

• Unit/integration tests for target plugins must pass
• Core import and CPU fallback must succeed without optional dependencies
• Config schema violations must be caught at initialization
• Without real hardware or cloud, available / runtime_connected must correctly return false (no false positives)
• If real hardware validation is performed, record SDK version, backend name, execution date, and cost

Validation Test Targets

• tests/unit/test_plugin_phase_roadmap.py: Integration contracts, EntangledSynchrony, quantum layers, plasticity
• tests/unit/test_device_plugin_integration.py: Device plugin lifecycle and CPU/GPU fallback
• tests/unit/test_ibm_quantum_plugin.py: IBM Runtime mock connectivity, Sampler/Estimator, QAOA
• tests/unit/test_optimization_pipeline.py: Optimization plugins and pipeline

Execution Status

pytest was not available in the current environment; the above tests were not executed. Run the four files with python -m pytest -q in a Core environment with all dependencies installed.

Changelog

Date	Change
2026-05-15	Initial version. Documented issues before DevicePlugin integration
2026-08-21	Cross-referenced with current code and tests. Updated to reflect completed items, VQE implementation, and unverified hardware status