JWT is stateless, meaning the server doesn’t store the token, so there’s nothing to delete. The token is still valid on the client until it expires.
To actually log out blacklist and check on each request or expire it quickly + revoke refresh token
Without that the token keeps working.
“Please” and “thank you” just tokenize into a handful of extra subword units literally a few more integers in the sequence. The transformer still runs full attention over the entire context, so the marginal compute from politeness is ~O(n²) noise compared to long prompts, chain-of-thought, or giant context windows.
If you’re optimizing GPU usage, those words are a rounding error the real cost is in sequence length and repeated tokens, not courtesy.
@sflorimm Human–AI integration tighter loops, possibly through interfaces like brain-computer links, where the boundary between using AI and thinking with it blurs.
If quantum breaks Bitcoin, it does not instantly nuke the entire internet.
•HTTPS doesn’t rely on a single primitive
•Systems can rotate keys, switch algorithms, and deploy post-quantum crypto
•Most infrastructure is upgradeable; it’s not a one-shot collapse
Also:
•Bitcoin specifically relies on exposed public keys → easier target surface
•Many banking systems don’t expose keys the same way
•Military / critical systems already plan for crypto migration
So no, it’s not:
“quantum = instant apocalypse”
It’s:
gradual break → patch → migrate → repeat
What’s even more interesting is that this turns optimization into a runtime property, not a training artifact the model isn’t getting smarter, the system design is.
Given a fixed set of weights, it’s effectively performing online meta-optimization over its own execution graph tuning prompts, tool policies, memory structures, and control flow in a closed loop.
At that point, the real question isn’t performance it’s stability:
•Does the harness converge or drift?
•Can it overfit to its own eval loop?
•What prevents degenerate self-reinforcing behaviors?
Because once agents can rewrite their own scaffolding,
you’re no longer optimizing outputs you’re optimizing the process that generates them.
2 questions:
What is the latency improvement from removing NMS compared to total inference time on GPU?
When an image is passed through a traditional YOLO model, at what stage is NMS applied, and how does it process multiple overlapping bounding box predictions to produce the final detections?
@GergelyOrosz What’s interesting is not the leak itself, but that a from-scratch Python reimplementation is reportedly matching or surpassing the original from Anthropic.
The interesting part isn’t that Meta is optimizing harnesses — it’s that they’re trying to solve the credit assignment mess we’ve all been ignoring.
Because in practice:
•a change in prompt/tooling today
•affects eval scores hours or days later
•across multiple tasks and traces
and nobody really knows which change actually mattered.
Meta-Harness feels like the inevitable direction:
treat the entire harness (prompts, tools, routing, evals) as one optimization surface, instead of patching pieces blindly.
If this works, “prompt engineering” stops being artisanal tweaking and starts looking more like gradient descent over workflows.
Meta just dropped the Efficient Universal Perception Encoder on Hugging Face — curious how it plays with VLM-style fine-tuning.
Like:
•does it take LoRAs cleanly across both vision + language bridges
•how well multi-teacher distilled features adapt under low-rank updates
•whether you can stack lightweight adapters instead of retraining heads
The inevitable part isn’t the attack — it’s the speed.
AI is already writing code, reviewing PRs, publishing packages so of course it’s also accelerating supply chain attacks. The window between malicious publish and production impact is collapsing to minutes.
Which basically forces a new equilibrium:
AI attackers vs AI defenders, both operating faster than humans can even context-switch.
The takeaway isn’t nice catch it’s that manual review as a security layer is quietly becoming irrelevant.
RF-DETR is the best open-source detector for aerial and drone footage…
but now I’m just wondering how it handles:
•a half-visible bike under a tree shadow at 200m altitude
•3 pixels pretending to be a human
•cars that are basically just vibes + motion blur
•and that one guy wearing camouflage who is literally the background
Claude rolling out “enterprise-grade security”…
Meanwhile:
attack vector: view-source
impact: full source disclosure
severity: politely labeled “oops”
Somewhere in a security report:
Threat model included prompt injection, jailbreaks, adversarial attacks…
Did not include “someone opens the .map file”
Red team:
“Did you exfiltrate weights?”
“No.”
“Find a jailbreak?”
“No.”
“…so what did you do?”
“I clicked a CDN link.”
Zero-day exploits ❌
Zero-click curiosity exploit ✅
Non technical client:we need real time video processing
Me:we should use nvidia…
Non technical client:Lets use tpu to train and deploy our system they are free on google collab
Me:yeah but you wont be able to host it on prem
Non technical client:no we can,we will just buy the tpu’s
Me:nice
Not that surprising if you look under the hood.
MoE ≠ full model capacity per token.
You’re routing through a few experts, not the entire network.
So in tasks like UI recreation:
• layout consistency
• spatial reasoning
• deterministic structure
a smaller dense model can actually be more stable.
Bigger helps with breadth.
Not always with precision.
@heynavtoor 397B parameters… running on a MacBook.
At this point the laptop isn’t “running a model” — it’s just politely pretending not to be a data center.
Cloud GPU startups watching this like:
“yeah… but can your SSD scale horizontally?”
@hxxwhite No they aren’t.
Manual QA doesn’t die it gets pushed up the stack.
Vision agents can click buttons.
They can’t:
• understand intent behind features
• catch subtle UX regressions
• question why something exists
What dies is repetitive QA.
What survives is judgment.
The interesting thing is — it’s not even about beating Gemini.
It’s about where the capability now lives.
A 0.9B model means:
• runs locally
• cheap enough to embed everywhere
• fast enough for real-time workflows
So instead of calling an API,
you just ship the intelligence with the product.
That flips the entire architecture of document-heavy apps.