
Powering Local Communities through DeFi & Smart City Services | Powered by @MSocietyLabs.
Web3
Joined January 2022
- Tweets10.7K
- Following393
- Followers629
- Likes10.7K
Pinned Tweet
π¨ Big milestone: Locale Network + @MSocietyLabs just open-sourced L{CORE} π
The first decentralized IoT attestation infrastructure.
In partnership with @ReclaimProtocol & @CartesiProject, weβre bringing trustless sensor data verification to @Arbitrum.
π§΅π
paragraph.com/@localenetworkβ¦
Community-owned means the accountability is shared, not missing.
Decentralized doesn't mean ownerless; every layer still needs someone accountable for it.
teapaw.org/Eggheadfx/status/21223β¦
7
Pruning a model to fit cheap hardware is how edge networks stay cheap to join.
From neural network to edge inference: see how to optimize TinyML on RISC-V.
How can hardware-aware pruning and vector acceleration help embedded AI workloads run more efficiently?
In our upcoming webinar, Dr. Yueh-Feng Lee from Andes Technology will walk through a practical, end-to-end TinyML deployment workflow using the Andes RISC-V AI software stack.
The session includes a live technical demo using the MLPerf Tiny Visual Wake Words model, showing how model pruning and RISC-V Vector (RVV) optimizations can deliver measurable cycle savings.
You'll also learn how to build, simulate, and benchmark optimized machine learning workloads on #RISCV.
π
November 18, 2026
π 4:00β5:00 PM CET | 7:00β8:00 AM PST
Save your spot:
hubs.la/Q04DdVYt0
9
Every idle phone that can run a model is a node your network didn't have to buy.
Can a phone run a real language model? @Acurast published the measurements, and my takeaway changed.
I used to assume that job belonged in a data center. On November 6, engineer Lukas SchΓΆnbΓ€chler shared mainnet tests of Qwen3.5-9B running on 16 GB Android phones.
Coinbase had already shown this open model, fine tuned on internal fraud data, could beat Opus 4.5 at that narrow task. Acurast measured what happens when you serve it from a phone.
On the fastest Snapdragon 8 Elite class phones in the test, the model wrote at 9.3 tokens per second.
A 7,000 token prompt took 3 minutes and 15 seconds on one phone. A larger run rented more than 100 phones in an afternoon.
That last part is what stuck with me. One phone is a neat demo. A hundred of them working in parallel is a different kind of cloud.
The study put the cost at about 0.6 to 1 ACU per phone per day.
I haven't run this myself. But if a 9B model can live on a phone, the question isn't whether it can. It's what else we still assume needs a data center.
Would you host a model on a phone, or do you still want a server?
8
The cheapest device you trust is the real spec sheet for a community network.
Question for @InferenceEx and anyone doing edge inference: what's the cheapest device you'd actually trust in production?
NIL-3B is a 1.8GB GGUF, minimum 3GB RAM, zero cloud calls. On the triage presets in our public lab it parses in 38ms. The target is a 4GB phone with no signal.
What I can't decide is how much to trust lab timings vs what happens on a cheap phone that's thermal throttling, half charged, with five apps open. How do you test for the device people actually own instead of the one on your desk?
labs.nioncorp.com
1
13
Cheap edge silicon is what turns a DePIN map into something people actually host.
SiMa.ai Palette 3.0 runs many AI models on one chip at up to 3.5x throughput. Edge inference isn't waiting on the cloud, and these chips get deployed.
siliconangle.com/2026-11-17/β¦
16
Proving one phone isn't a thousand fake ones is the whole Sybil problem in a sentence.
teapaw.org/dhavied_brown/status/2β¦
Good night Legends. π
How does @Acurast know a phone is actually a phone and not one server pretending to be hundreds of smartphones?
I was reading about device attestation, and I found something interesting.
Every Processor needs to prove that it's a genuine, untampered device before it can participate in the network.
Here's how that works.
Your phone uses hardware-backed security to generate a cryptographic proof.
β Android uses Google's Key Attestation.
β iPhone uses Apple's App Attest.
These mechanisms help verify that the device is genuine and its security hasn't been compromised.
But here's where things get interesting.
Attestation isn't a one-time check.
Sometimes manufacturer signing keys leak or security flaws allow attackers to extract them.
With those keys, someone could create fake attestations using servers or emulators and make them look like hundreds of genuine phones.
That's why Google and Apple maintain revocation mechanisms.
When an affected key gets revoked, Acurast checks for it and removes affected devices from its Processor pool.
No deployments. No rewards.
And there's another side to this.
Older Android phones sometimes share factory-issued attestation keys with an entire batch of devices.
So an honest phone sitting in someone's drawer could also be affected if its shared key gets compromised.
I appreciate that Acurast is transparent about this.
They even explain that they cannot simply override a revoked key, because doing so could allow compromised credentials back into the network.
If your Hub shows "Revoked", the recommended steps are:
β Wipe the device.
β Install the latest official firmware.
β Make sure it's not rooted and the bootloader is locked.
β Try onboarding again.
Unfortunately, this isn't guaranteed to fix the issue.
What caught my attention is that decentralization isn't just about having thousands of phones.
It's also about making sure those phones can actually be trusted.
One question before I call it a night:
Has anyone here had a genuine phone marked "Revoked" even after trying the recommended recovery steps?
More research to come.
Sleep well, Legends. π
1
20
One-time attestation is a snapshot; trust decays, so you have to keep re-checking.
teapaw.org/Z3NITSUxZz/status/2122β¦
A binary decision shouldn't cost a paragraph of tokens, especially on a metered edge node.
teapaw.org/iotex_io/status/211073β¦
Most AI agents still waste precious compute βthinking out loudβ β generating walls of text just to make a binary decision. That architecture breaks the moment intelligence moves to edge devices and robotics.
Trio-Spark v1.3 changes the paradigm:
β’ Pure SOTA multimodal System-1 decision engine: zero generated tokens, single forward pass
β’ 90.9% across 10 benchmark tasks, #1 on 4 major benchmarks outperforming top peers
β’ Near-zero calibration error (0.019) β real confidence you can actually trust
This is how IoTeX powers autonomous, verifiable intelligence across robots, machines, and decentralized agents.
5
Inference is the workload that wants to live where the data already is.
teapaw.org/Acurast/status/2086842β¦
Most AI compute demand comes from inference, exactly what the centralized cloud is worst at.
The fix isn't bigger datacenters. It's the billions of idle phones already in our pockets, ready to run autonomous AI agents that work in the background.
1
1
8
Idempotency is what lets a flaky node retry without double-charging the network.
teapaw.org/MSocietyLabs/status/21β¦
5
Billing on a usage read means a dropped node is lost revenue, not just a gap.
A transaction can succeed. The application can still think it failed.
And in financial infrastructure, that misunderstanding can become expensive.
Something in @unicity_labs November 2β8 weekly update caught my attention.
Two separate issues appeared across the ecosystem:
A bridge payout could complete successfully, but a network interruption could make it appear unsuccessful, potentially causing a member to be charged again.
Some bridged USDC deposits appeared in Sphere's transaction history but weren't correctly recognised by the application.
Different symptoms. One interesting engineering lesson:
A successful transaction and a correctly recognised transaction are not always the same thing.
Let's break this down.
01 / THE PROBLEM: WHEN SYSTEMS LOSE TRACK OF SUCCESS
Imagine Alice sends $200 through a cross-chain bridge.
The transfer completes on the destination network.
But before the originating system receives confirmation, the connection drops.
Now the system faces an ambiguous situation:
Did the transfer fail?
Did it succeed but the confirmation get lost?
Is it safe to retry?
If the system treats every missing response as a failed transaction, Alice could be charged twice.
The dangerous assumption is:
NO CONFIRMATION = NO SUCCESS
That isn't necessarily true.
02 / WHY RETRIES CAN BECOME A FINANCIAL RISK
Retries are essential in distributed systems.
Networks disconnect. Requests time out. Services become temporarily unavailable.
But retrying a financial operation is different from retrying an ordinary webpage request.
Consider this sequence:
USER REQUESTS PAYOUT
|
v
BRIDGE PROCESSES TRANSFER
|
v
DESTINATION TRANSFER SUCCEEDS
|
v
NETWORK CONNECTION INTERRUPTED
|
v
ORIGINATING SYSTEM SEES TIMEOUT
|
v
RETRY WITHOUT RECONCILIATION
|
v
POTENTIAL DUPLICATE CHARGE
The problem isn't necessarily the original transfer.
It's the decision made after the system loses visibility of its outcome.
A timeout describes communication failure. It does not establish financial failure.
03 / WHAT A SAFER FLOW SHOULD LOOK LIKE
The important engineering principle is to distinguish an unknown outcome from a confirmed failure.
A more reliable workflow looks like this:
PAYOUT REQUEST
|
v
TRANSFER INITIATED
|
v
CONFIRMATION INTERRUPTED
|
v
CHECK ACTUAL PAYOUT STATUS
|
+--+----------------+
| |
v v
SUCCESS CONFIRMED FAILURE
| |
v v
MARK COMPLETE HANDLE RETRY
If the outcome is still unknown, the system should reconcile it before initiating another financial operation.
This is closely related to idempotency: repeating a request should not accidentally produce another financial effect.
Importantly, the weekly update doesn't claim a particular idempotency implementation. It describes additional checks before a payout is marked failed, alongside alerts for detecting similar issues earlier.
04 / THE SPHERE CONNECTION: RECOGNISING THE DEPOSIT
There's another interesting detail in the same update.
Some users had bridged USDC into Sphere.
Their deposits appeared in transaction history, but the application didn't correctly recognise them.
Think about the difference:
The transfer record exists.
But the application hasn't correctly reflected that deposit in the user's account experience.
For a wallet, that distinction matters enormously.
A user doesn't just need to know that a transaction happened somewhere. They need the application to correctly recognise and reflect the resulting funds.
The issue has been fixed, and affected accounts are being corrected.
This is a different failure mode from the bridge payout problem, but it highlights another important part of financial reliability: keeping transaction records and application-level recognition aligned.
05 / THREE LAYERS OF FINANCIAL RELIABILITY
I think this week's updates illustrate three responsibilities that infrastructure must handle:
1. Execution
Did the transfer actually happen?
2. Reconciliation
Can the system establish the outcome when communication is interrupted?
3. Recognition
Does the receiving application correctly reflect the completed operation?
All three matter.
A successful transfer is not enough if the application cannot recognise it. A visible transaction is not enough if the system cannot establish its actual financial outcome.
06 / WHY THE OTHER NETWORK IMPROVEMENTS MATTER
The same weekly update also mentions a mainnet upgrade.
Unicity introduced:
Stricter transaction verification.
More reliable proof requests.
Better protection against invalid signatures and malformed requests.
Additional bridge payout alerts.
These improvements address different parts of the reliability problem.
Transaction verification protects what the network accepts.
Proof-request reliability improves how applications obtain the evidence they need.
Operational alerts help teams detect problems before they become larger incidents.
They aren't interchangeable features. Together, they contribute to a more dependable financial infrastructure.
MY TAKEAWAY
I find this week's update interesting because the improvements aren't about introducing another flashy feature.
They're about handling the uncomfortable situations that appear when real financial systems operate across networks.
A transfer can succeed while its confirmation gets lost.
A deposit can exist in transaction history while the wallet fails to recognise it.
A retry can turn a temporary communication problem into a financial problem.
Reliable infrastructure must understand the difference between an operation failing, its confirmation failing, and its result failing to appear in the application.
That's the kind of engineering detail that matters when people start trusting systems with real money.
And it's worth paying attention to what @unicity_labs is improving behind the scenes.
Edge means the network drop is your normal case, not your edge case.
Running Kubernetes at the edge sounds exciting, until the network goes down.
Many DevOps teams try to run Kubernetes in places like
retail stores, factories, IoT devices, or branch offices.
When planning, it would be a good idea, but in reality, you face issues.
Because edge locations do not work like data centers. The network is often slow or unstable. Nodes are usually behind NAT or firewalls.
Short network outages can cause pods to restart or fail.
Meanwhile, Kubernetes assumes it can always talk to the control plane.
But, the result is frustrating. Even when the edge node itself is healthy, the application goes down just because the connection drops.
This is the real challenge of running Kubernetes at the edge.
That is where OpenYurt comes in.
OpenYurt extends standard Kubernetes so it can handle edge environments properly.
You keep using the same tools you already know, like kubectl, Helm, YAML, and CRDs.
Your workloads keep running even if the edge node temporarily loses its connection.
And you still manage both cloud and edge from a single Kubernetes control plane.
There is no Kubernetes fork and no new APIs to learn.
The core idea behind OpenYurt is simple
Edge nodes should keep running even when the cloud is unreachable.
A short network issue should not bring down your applications.
To make this work, OpenYurt adds a few edge-aware components on top of Kubernetes.
Each edge node runs something called YurtHub. It acts as a local proxy and cache between the kubelet and the Kubernetes API server.
When the connection drops, YurtHub serves cached data so the node can continue operating normally.
There is also YurtTunnel, which allows edge nodes to connect back to the cluster securely, even when they are behind NAT or firewalls.
OpenYurt introduces NodePools as well.
These let you group edge nodes by location or network conditions, which makes region-aware management much easier.
On top of that, edge-aware controllers prevent unnecessary pod eviction during temporary disconnections.
The end result is that edge nodes become more autonomous, but they are still centrally managed through Kubernetes.
Compared to similar tools, OpenYurt takes a very Kubernetes-native approach.
It is fully compatible with upstream Kubernetes, requires minimal changes to existing clusters, and focuses strongly on keeping edge workloads running independently.
It is also a CNCF incubating project.
If you want full Kubernetes capabilities with better reliability at the edge, OpenYurt is a strong fit.
OpenYurt is especially useful in retail stores, manufacturing plants, IoT and sensor networks, 5G or MEC environments, and remote branch offices, anywhere the network is unreliable but uptime is still critical.
π§πΌπΌπΉ πΉπΆπ»πΈ - openyurt.io/
Have you used OpenYurt or KubeEdge in real projects?
Drop your comments below
7
Inference moving to the edge only pays off if the nodes stay honest and online.
Edge AI is the biggest shift in computing since the cloud. Inference is moving to the edge, cutting cost ~90%. My new piece: use cases, the capex story, and where to build. #EdgeAI
1
1
34
Consistency at scale is the hard part; raw coverage without it is just noise.
Choose by operating model. Titan fits managed cloud delivery. Bright Data and Oxylabs fit API and infrastructure-led workflows. Apify fits DIY testing. In-house fits maximum control when engineering can own the system.
Read: titannet.io/learn/resources/β¦
6
Edge attestation is what makes a node's data worth paying for, not just storing.
teapaw.org/MSocietyLabs/status/21β¦





















