-
-
Terminal execution output showing local-to-cloud auto-switching and successful telemetry upload to Alibaba Cloud OSS.
-
Alibaba Cloud OSS Console verifying the actual telemetry JSON files landed securely in our bucket
-
Alibaba Cloud OSS Console verifying the actual telemetry JSON files landed securely in our bucket
-
Edge Reflex Kernel Latency Stress Test
Inspiration:
Two of our own projects had been solving opposite halves of the same problem without knowing it. One was a structural-health monitoring system built around a spiking reflex kernel — fast, local, safety-critical, but cognitively simple, with hand-coded rules deciding what a sensor reading actually meant. The other was an adaptive runtime built for exactly the conditions industrial and infrastructure devices actually live in: unreliable power, unreliable bandwidth, and hardware that can't always afford a big model on-device. When the Qwen Cloud EdgeAgent track described "perceive via edge sensors, reason via cloud APIs, act locally, degrade gracefully offline" almost word-for-word, it was obvious neither project alone was the answer — the orchestration engine from one was exactly what the cognitive layer of the other had always been missing.
What it does:
Nomad Sentinel is a structural-health nervous system with three layers. A dense simulated sensor mesh and an event-driven spiking reflex kernel run entirely on-device, detecting anomalies in microseconds with zero network dependency — a safety reflex should never wait on a round trip. Above that sits a cognitive layer that decides what to actually do about a detected risk: forecast how it'll evolve, veto unsafe responses, and pick an action. That layer runs two ways. When the device has the network budget for it, it escalates to Qwen Cloud, which reasons over the telemetry and returns not just an action but a plain-language justification a human operator can read. When it doesn't — degraded link, high latency, no connection at all — it falls back instantly to fast local heuristics, and the system never once fails to produce a decision. A mode-switching engine polls device and link conditions on a cadence and decides which path to take, with asymmetric hysteresis: cautious to escalate, fast to retreat.
How we built it:
We treated the merge as additive, not a rewrite. The sensing and reflex layer stayed untouched. The orchestration engine's plugin architecture — built to let any inference backend register itself with zero router changes — turned out to be exactly the seam we needed: we wrote one new plugin that speaks Qwen Cloud's OpenAI-compatible API, wired it into a mode that already existed in the runtime but had been disabled under a different competition's rules, and let the existing plugin registry auto-discover it. The only genuinely new integration code is the module that lets the cognitive layer ask "is the cloud path available right now?" and fall back cleanly if the answer is no, or if the cloud call fails, times out, or returns something malformed. Everything else is the two original systems, unmodified, meeting at a boundary that was already there. The backend and telemetry log run on Alibaba Cloud — an ECS instance hosting the API and dashboard, and OSS storing the decision history so it survives even if the edge device itself goes offline.
Challenges we ran into:
Getting the mode-switching logic to be provably correct, not just plausible, took the most work. It's easy to write orchestration code that looks right; it's harder to actually watch it behave right under a real outage. We ended up building a demo scenario that runs a compound multi-fault case through a scripted network outage — up, then dead, then recovered — specifically so we could watch the system's decisions switch sources in real time and confirm zero missed actuator calls on either side of the fence. We also had to be disciplined about what "cloud reasoning adds value" actually means: it would have been easy to just wrap every decision in an LLM call for the demo effect, but that misses the point of an edge-first system. We kept the reflex layer untouchable and cloud-free by design, and made sure Qwen Cloud only gets used where its reasoning genuinely beats a rule — ambiguous, compound failure patterns and operator-facing explanations — rather than everywhere. Building the stress tests themselves became its own challenge. Our first pass at a compound-fault test required the system to literally isolate the fault zone to count as a "pass" — and every configuration failed, which looked like a real finding until we traced it: all three were actually succeeding, just via an earlier, less drastic intervention that our test wasn't designed to recognize. We rebuilt the test around a harsher, more honest scenario — a fault severe enough locally to be undeniable, but small enough that a panel-wide average dilutes it into invisibility — which is what actually separates a system that only sees the mean from one that can see the max.
Accomplishments that we're proud of:
The whole pipeline is real, runnable code, not a diagram with a demo bolted on afterward — sensing through reflex through orchestration through cloud reasoning through actuation, with a test suite covering the escalation and fallback paths specifically. We're proud that a bad or missing cloud response never produces an unsafe action; it just quietly becomes "as if the cloud weren't there," which is the property that actually matters for a system like this. We measured this rather than asserted it: run head-to-head against a naive cloud-only baseline and a local-only baseline across a full network outage, a sustained high-latency link, and a compound fault, our system was the only one of the three that passed all three conditions — the cloud-only baseline produced zero valid actuator commands across 400 steps under either connectivity failure, and the local-only baseline never detected a small, severe, spatially concentrated fault that our mean-pooled risk field structurally dilutes below its own escalation threshold. And we're proud the integration required almost no changes to either original codebase — a sign the two were more architecturally compatible than either of us realized going in.
What we learned:
The most reusable insight wasn't about Qwen Cloud specifically — it was that a genuinely good edge-cloud architecture already knows how to answer "what if the cloud isn't there" before you ever plug in a real cloud backend. The mode-switching and plugin-registry design existed before Qwen Cloud entered the picture at all, and that's exactly why adding it was cheap. If we'd designed the cloud integration first and tried to retrofit graceful degradation afterward, it would have been much harder to get right.
What's next for Nomad Sentinel:
Moving from the simulated optical-skin digital twin to a real sensor deployment is the obvious next step. We'd also like to extend the stress-test suite itself — right now it runs against a mocked Qwen Cloud response for offline reproducibility, so validating the same pass/fail results against the live API, and adding scenarios beyond the single diluted-hotspot case, are the natural next steps toward a comparison that's not just real but comprehensive. Beyond that, we'd like to open the plugin contract up further — the same boundary that let us drop in Qwen Cloud with almost no code should make it straightforward for other teams to swap in their own reasoning backend, or extend the sensor layer to other structural domains beyond the panel case we built first.
Log in or sign up for Devpost to join the conversation.