Vegard

Vegard is the autonomous systems coordination platform for the Enotrium stack — a software-defined mesh fabric that coordinates autonomous assets (UAV hyperspectral drones), fuses their sensor data into a shared operational picture, tasks platforms in real time, and routes intelligence downstream into the AIP supply chain system.

Vegard is the control layer between physical drones in the field and the economic decisions that flow from their soil data.

Three-Layer Architecture

Layer 1: Command

Fused Field Picture

Materialized projection of the state mesh. The operational picture AIP and human operators consume:

• Time-series store of all entity states (drone positions, soil prediction coverage, contamination flags)
• GeoJSON export: drone flight paths + soil prediction maps → compatible with AIP's Mapbox/Deck.gl frontend
• Streaming API: WebSocket feed for real-time map updates in AIP dashboard

Mission Planner

Converts AIP's farm contracting goals into concrete scan tasks:

• Receives target field list from AIP (farms under evaluation for contracting)
• Generates scan priorities based on: contract value, soil uncertainty, contamination risk
• Publishes TaskRequest objects to task allocator
• Tracks mission completion: reports back to AIP when a field's scan coverage meets threshold

AIP Bridge

The clean interface between Vegard and AIP. AIP should never need to know Vegard's internal architecture:

• POSTs structured SoilPrediction payloads to AIP's /api/vegard/ingest endpoint
• Translates Vegard entity model to AIP's farm pipeline schema
• Attaches drone attestation signature and provenance metadata
• Handles retry logic and delivery guarantees

Clean boundary: AIP never imports Vegard. Vegard POSTs structured payloads to AIP's ingest endpoint. No circular coupling.

Layer 2: Fabric

State Mesh (Gossip Protocol)

Each node broadcasts its entity state to peers without a central broker:

• Entity model: {entity_id, type: "drone"|"scanner", position: (lat, lng, alt), soil_prediction, drift_flag, battery, timestamp}
• Gossip fanout: each node relays to N peers, eventual consistency
• Topic-based pub/sub for selective subscriptions
• Transport: gRPC + Protobuf for drone↔node; MQTT for cloud↔AIP bridge

Task Allocator (Auction-Based)

Distributes scan tasks across the drone fleet without central coordination:

• Mission planner publishes a scan request (field polygon, priority, deadline)
• Available drones bid based on: distance to field, battery level, current task load
• Lowest-cost bidder wins the task
• Supports preemption: higher-priority tasks can re-task a drone mid-flight

Drift Monitor (Key Differentiator)

The genuinely novel piece. Arthedain handles per-node drift. Vegard correlates drift spatially across nodes:

• Each node reports its Arthedain E(t) trace and drift flag
• Drift monitor computes spatial correlation: if drones over the same region all show drift, the soil model needs recalibration
• Triggers model update request to Hyperspectral-Restruct pipeline
• Flags contamination anomalies: sudden correlated drift = possible new contamination event

This is the agricultural intelligence that neither a single Arthedain node nor generic mesh systems can produce alone.

Attestation

Every soil prediction published to AIP is cryptographically signed by the drone node that produced it:

• Each drone node has a deterministic identity: drone:{region}:{serial}
• Outputs signed with node private key (openpgp-compatible, consistent with AIP)
• AIP verifies signature before ingesting soil prediction
• Feeds into AIP's ZK proof chain for supply chain traceability

Transport Bus

Wraps both gRPC (drone-to-node, performance-critical) and MQTT/REST (node-to-AIP, async):

• gRPC + Protobuf: hardware integrations — binary, streaming, low-latency
• REST/MQTT: async data push to AIP — familiar HTTP/JSON, compatible with AIP's FastAPI

Layer 3: Node

The bridge between a single drone's onboard intelligence and the Vegard fabric. This is the only module Vegard adds to the Arthedain execution environment.

Node Agent

• Receive scan task from fabric (field coordinates, spectral resolution, altitude)
• Execute hyperspectral capture sequence (interface to drone flight controller)
• Pass spectral cube to Arthedain's spike encoder for online processing
• Call Hyperspectral-Restruct API with the cube → get soil prediction map
• Publish entity to state mesh: {drone_id, position, soil_prediction, drift_flag, health}
• Sign output with node private key (for attestation layer)
• Report drift signal to fabric drift monitor when E(t) deviates beyond threshold

Spectral Bridge

Adapter between Arthedain's SNN streaming output and the Hyperspectral-Restruct CNN API:

• Buffers spike stream into spectral cube frames
• Handles cube normalization before API call
• Returns structured SoilPrediction protobuf object

Data Model

Three core message types flow through the system:

EntityState — Drone position, battery, soil prediction, drift score, and cryptographic signature.

TaskRequest — Target field polygon, priority, deadline, and spectral capture config.

SoilPrediction — Nutrient map, contamination flags, land value score, and spectral hash for provenance.

All messages use gRPC/Protobuf for drone-to-node transport and JSON for AIP bridge integration.

Where Arthedain Fits

If you were building an autonomous sensor node that needed to run onboard inference — say, a UAV that must adapt its signal processing in the field without cloud connectivity or a full GPU — Arthedain is the learning substrate that runs on the edge hardware (FPGA, implantable chip). The repo includes FPGA footprint estimates for an Artix-7 at ~2.5 mW.

Vegard sits above that entirely. Vegard doesn't care how a node's internal inference works — it cares about the network topology, data links, and tasking protocol between nodes.

So: Arthedain is a component inside an edge node; Vegard is the fabric connecting the nodes.

Dependency Map

Icarus (future hardware)
       ↓ runs on
Vegard                     ← THIS REPO
       ↓ imports
arthedain                  (pip install -e ../arthedain)
       ↓ calls API
Hyperspectral-Restruct     (running as sidecar service)
       ↓ pushes data to
AIP                        (POST /api/vegard/ingest)

Vegard is the only repo that imports from both arthedain and Hyperspectral-Restruct. AIP imports from neither — it only receives structured payloads from Vegard via HTTP.

Reference

github.com/EnotriumSyndicate/Vegard →