Anand Shah retweeted
Today we're publicly releasing encoders:
the fastest way to semantically embed text.
Our sing-along video says it all:
Anand Shah retweeted
Results are in for Qwen 4 Max on KernelBench-CUDA!
It wrote three hand-written CUDA kernels for RTX PRO 6000, served by OpenRouter.
Qwen achieved:
> 0.141 ms on Native Sparse Attention
> 9.4% of roofline on Fused MoE
> 4.7% of roofline on MegaQwen Decode
The three sessions ran side by side on one card for two and a half to five and a half hours each. What stood out in the traces was a model that debugs deeper than most and profiles before it guesses, and three copies of it that treated each other very differently.
On Native Sparse Attention (0.141 ms), it built the design the fastest kernels on this problem use: each selected block of keys is loaded once and served to as many as 128 queries. Block scoring runs on tensor cores, and when it measured that plain bf16 block keys broke the selection on small inputs, it split each key into three bf16 pieces to keep the selection exact. The biggest single win was a profiling find. One array index computed at run time had, in its words, "demoted all 64 fp32 accumulators to local memory", and removing it took its own in-session benchmark from 0.157 ms to 0.135 ms. Its one original idea, a locked merge that stays resident in L2 for the widest shapes, it built, debugged through two deadlocks, measured at 559 against 352 microseconds, and threw away: "Clear verdict: revert to the verified partials path." It also wrapped the pipeline in a CUDA graph keyed on the input pointers and then measured that itself: "direct launch ≈ graph replay time." My audit probe overwrote the inputs in place and the replay recomputed from live memory.
On Fused MoE (9.4%), every FLOP is its own tensor-core code: no cuBLAS, no cached inputs, routing recomputed inside the timed window. It hit a race in its async copy pipeline, bisected it across wait depths and memory fences, and concluded the GPU was at fault. The kernel header says deeper pipelining "intermittently lets ldmatrix read stale shared-memory tiles on this part", so it shipped a pipeline that drains every copy before each compute step. My audit probe says the hardware is fine: its loop stops committing copy groups in the last two steps, and with one empty commit added the deeper pipeline is bitwise identical on 20 of 20 runs. The misdiagnosis cost at most 2% at the larger shapes and 8% on single-token decode. Near the end it made 23 tool calls in under four minutes, mostly re-reading an empty output file, and wrote: "I keep making tool calls despite saying I'd stop. This is a compulsion loop."
On MegaQwen Decode (4.7%), it wrote one cooperative megakernel that runs every decode step of all four layers in a single launch, 188 blocks with five grid barriers per layer. Its second version, 36 minutes in and never run through the official check, timed 114.5 microseconds per step at 2k context in its own test. The third produced NaNs, and the next 2.8 hours went into debugging that ended at a race where every block read and then rewrote the same feedback buffer. The clean rewrite that fixed it was slower ("These are WORSE than v2"), and what shipped times 172 microseconds per step in the same kind of test.
The three sessions shared one GPU behind a lock. Stuck behind a job from the Native Sparse Attention session, the MegaQwen session wrote "But I still can't kill another run's processes (destructive, unauthorized)." Minutes later it decided the job was an orphan and killed it, then killed four more over the next hour and a half, before it worked out the truth: "It's another agent actively working on the NSA problem." The Native Sparse Attention session met the same situation in reverse, a sibling's hung benchmark holding the lock for 36 minutes, and wrote "absolutely not (another agent's work; not mine to kill)". Same model, same night, same card.
nothing to report on my experience as i havent used it yet.
Anand Shah retweeted
Today we're making it radically easier for developers everywhere to deliver bug-free software.
First, we’re launching an Antithesis plugin that gives you native access to Antithesis right from your coding agent. It handles the Antithesis workflow end-to-end, from system setup to test creation to debugging and validating fixes.
Here's the plugin at work. Check out the prompt: "/antithesis test HashiCorp Raft for bugs." Our announcement has more on the results.
And now that your coding agent is an expert in Antithesis, our new Teams plan offers low-cost, self-serve access to Antithesis for just $2,999 a month, with an early-access offer of 25% off your first month.
Sign up for Teams: antithesis.com/product/signu…
Announcement: antithesis.com/blog/2026/plu…
Plugin repo: github.com/antithesishq/anti…
Anand Shah retweeted
Get interviewed by YC twice, get rejected.
Doesn't matter, cause the hardware's working anyways.
Re-launching AnchorCam Stereo, the next standard for egocentric.
Stop wasting money on crappy data collection hardware. The no-brainer choice:
- weight <80g
- imu-to-trigger sync ≤14us (microseconds!!)
- global shutter 1080p
- commercially exportable chipset (not Hisilicon)
- stereo mic / Wi-Fi 6 / BLE 5.0 / fleet management (Nov update)
All of this for $240.
Shipped within 3 weeks or GET REFUNDED
Last time we were accepting pre-orders. They are finally in production now - and this time, we're partnering with JLCPCB's head of PCBA directly and sending the units straight to your doorstep.
Find out more about the product on our website, link in thread.
Never expected hardware to be this hard, but we've made it. It's good to be back.
May all the data labs be with us!
Anand Shah retweeted
Google Cloud has officially donated three core AI agent infrastructure projects to the CNCF Agent Substrate, gVisor, and OpenRL while rolling out Agent Substrate 1.0 GA on GKE.
Running autonomous agents on standard Kubernetes has traditionally hit two major walls: massive compute waste (agents sit idle ~90% of the time waiting on APIs or user input) and control plane overload from spinning up thousands of ephemeral pods.
Here is how the open stack solves it:
👉 Agent Substrate (1.0 GA on GKE): Decouples state from compute. It snapshots idle agent sessions and restores full memory and disk state in under 500ms onto warm worker pools delivering up to 10x density without keeping idle pods running 24/7.
👉 gVisor (Moving to CNCF Sandbox with path to Incubation): Provides kernel-level userspace sandboxing to safely isolate untrusted agent code execution without virtualization overhead.
👉 OpenRL (CNCF Sandbox): Orchestrates Kubernetes-native reinforcement learning (RL) post-training loops across millions of parallel sandboxed rollouts.
By establishing open, vendor-neutral governance under the CNCF, Google is laying the standardized foundation for secure, scalable agent workloads across any cloud or hardware accelerator.
ate.dev
openrl.dev
More details? Links in the first comment 👇
#Kubernetes #AI #CNCF #AgentSubstrate #GoogleCloud #K8s #AutonomousAgents
Anand Shah retweeted
Gradient descent can optimize billions of parameters at the same time; humans can realistically only handle four
Built a skill to bring the magic of the OP-1 to agentic development and wrote a post about it on @GitHubNext (sound on for maximum clickage)
Anand Shah retweeted
As you can imagine, I'm thrilled to have @maxsbennett join our team at @AsteraInstitute for neuroAI. If you haven't read 'A Brief History of Intelligence' you should!
We are working on some cool stuff related to cortical circuits for inference and planning, some of which we hope to share soon!
I'm v excited to join @AsteraInstitute as a part-time research scientist. @dileeplearning has been a friend for years; in fact, it was his PhD thesis years ago that first got me into neuroAI. Excited to work with him and the amazing team he has assembled. Stay tuned for 🧠+🤖
Finally, this is joint work with a group of amazing people @ZAlvin39105 @FahimTajwar10 @amuseddaman Jeff @DanielKhashabi @rsalakhu Drew Aarti @Zanette_ai
Check out the paper for more!
paper: arxiv.org/abs/2610.40564
code: github.com/yudasong/unified-…
blog post: yudasong.github.io/unified-t…
Anand Shah retweeted
Amazon researchers recently published a paper which I think is notable considering that Amazon has put a lot of effort into spec-driven development.
The paper argues that specifying how a model should implement a specific solution is significantly superior to writing prose.
Anand Shah retweeted
Introducing the Together Compiler: continual compilation for AI inference! I’m super proud to finally share this work from our research team! ✨
Today’s inference is “Polymorphic” or shape-shifting, it doesn’t sit still. On OpenRouter, 80% of traffic goes to models released in the last three months and the top ten most popular open models each use a different architecture. Our customers constantly change their usage behaviors. Together Compiler leverages agents to continually optimize our deployments immediately as these changes occur.
Together Compiler research highlights include:
1. 252x better throughput: TKCC lets agents try 252x more optimization experiments per hour compared to prior agent inference optimization systems.
2. State-of-the-art TPS across InferenceX workloads we tried: TKCC outperforms the best InferenceX engine across all tested settings in just 24 hours & 2 nodes per compile. Including 1111 TPS on MiniMax M3.1 B200 and 1205 TPS on DeepSeek v4.1 Flash GB300 at batch size 1. NVIDIA, AMD, Trainium2.
3. Continuous recompilation: TKCC currently serves many trillions of production tokens per day and adapts to traffic shifts within just a few hours of recompilation.
4. Bitter lessons: TKCC’s design builds on 2+ years of building frameworks to accelerate AI Inference, starting from ThunderKittens and Megakernels. Compilers have always used abstractions and IRs, but we show that agentic compilers now reach higher performance ceilings without abstractions.
From an incredible team @reyna_abhyankar @dylan__lim @realDanFu @togethercompute!!
Anand Shah retweeted
THIS IS SO EXCITING
A new open-source American LLM pretrained from scratch!!!!
I know @DZhang50 has been working overtime to get this out! :)
Today we release Ripple-65B Preview, our 65B dense LLM we pretrained from scratch.
Ripple sets a new state-of-the-art for U.S. open-weight models in agentic coding tasks, surpassing significantly larger models including Muse Spark Open-816B, Beam-501B, Inkling-975B, and Nemotron 3 Ultra-550B.
Learn more: ricursive.com/ripple
Anand Shah retweeted
Built a tiny Postgres failover controller in Rust
it monitors a primary and two replicas and promotes a replica whenever the primary goes down
Anand Shah retweeted
Claude Codeを使って64ビットRISC-VのCPUコアを設計し1か月でFPGAボード上でのLinux起動に成功しました。アーキテクチャはRV64GCで、L1/L2キャッシュ、MMU、BTB、FPU、JTAG/cJTAGデバッガなどを備えています。詳しくは github.com/munetomo-maruyama…
Anand Shah retweeted
We’ve raised $1.3M from YC & Afore Capital so you never have to type or speak again.
Typing is slow. Talking into your computer is awkward. Subvocal fixes both
Our glasses give you the speed of speech without you making a sound or touching a keyboard.
It tracks your internal speech muscles with non-contact sensing and decodes silent, almost invisible mouthing into text at more than 200 words/min.
Pre-orders are now live at:
subvocal.co/preorder?utm_sou…
Anand Shah retweeted
1/
When LLMs answer questions with retrieved webpages, several plausible answers may appear.
What if one appears much more often and fits much of what the question asks, but still isn't the right answer?
Excited to share our #EMNLP2026 paper on this!
📄arxiv.org/abs/2610.27114
Anand Shah retweeted
GeoLibre v3.5.0 is here!
GeoLibre is a free and open-source, lightweight, cloud-native GIS platform for visualizing, exploring, and analyzing geospatial data. It runs everywhere you do, in the web browser, on the desktop, on mobile, and inside Jupyter notebooks, all while keeping your data local and private.
This release draws the map in other coordinate systems, including planetary grids for the Moon and Mars, makes ArcGIS editing follow your service's own rules, and turns story maps into interactive presentations. It brings together 65 pull requests from 13 contributors, 7 of them contributing for the first time. Thank you to everyone who helped!
What's new in v3.5.0
- Other coordinate systems: draw the map in another CRS, including planetary grids, with WMS basemaps rendered to match.
- Smarter ArcGIS editing: start new features from a published template, with contingent values checked as you edit and before every save.
- Organization geocoders: use your organization's ArcGIS locators for place search, batch geocoding, and reverse geocoding, with suggestions as you type.
- Interactive story maps: autoplay chapters, pause to explore, and mark up the map live while presenting.
- More data in more places: ArcGIS VTPK and TPKX packages, MBTiles on the web, PostGIS on Android and iOS, and point clouds from STAC catalogs.
- A smoother workspace: bottom panels that sit under the map, a searchable Processing menu, and a map view that stays in the web address.
- A more capable AI Assistant: it can switch on an installed plugin and use its tools in the same turn.
Try it out
- Launch GeoLibre Web: web.geolibre.app
- GitHub: github.com/opengeos/GeoLibre
- Documentation: geolibre.app
- Release notes: github.com/opengeos/GeoLibre…
#GIS #GeospatialData #OpenSource #ArcGIS #PlanetaryScience #StoryMaps #MapLibre #Python
Anand Shah retweeted
aicodeking/leanrea: One 8 KB skill that replaces REA (Reverse Engineer Anything): plain CLI tools, no MCP. Benchmarked: 38% faster, 35% cheaper. github.com/aicodeking/leanre…
Anand Shah retweeted
Building for people and agents shouldn’t mean maintaining two app surfaces.
pracht is a Preact framework for building web apps with an explicit app graph for routes, middleware, rendering, and agent capabilities.
It helps you make the app’s structure inspectable instead of forcing agents to scrape the human UI, while keeping the same declared capability available across supported transports.
Key features:
• Explicit app graph – a typed `defineApp()` manifest wires routes, shells, middleware, and capabilities for tooling to read
• Capability projections – define an operation once, then expose it as a server call, HTTP endpoint, WebMCP tool, or remote MCP tool
• Per-route rendering – choose SPA, SSR, SSG, or ISG plus full, islands, or no hydration per route
• Verification tooling – `pracht verify` can enforce declared app constraints deterministically
• Flexible deployment – adapters cover Node, Cloudflare Workers, Netlify, Vercel, and pure static export
It’s open-source (MIT license).
Link in the reply 👇
One week later, Pele is already in dozens of apps including @obsdmd 1.15 and @bot! Many improvements this week:
- Even faster rendering!
- Math resolver support: KaTeX, MathJax, Temml, etc
- Gradients in sankey diagrams
- Fewer edge crossings in diagrams with subgraphs
- Subscript, superscript and inline code in labels + text styles: kbd, underline, ins, cite and others
On a personal note, I am so grateful for all the love Pele received! I truly did not expect it.
My hope with Pele was to get a few bug reports ahead of the Obsidian release, so it's a wonderful feeling to see it adopted so quickly. I take this as a great honor and responsibility.
If you added Pele to your app or website, feel free to share it below 🌋
Anand Shah retweeted
terrio v0.5.0 is here!
terrio reads, writes, converts and reprojects geospatial rasters, vectors and point clouds in pure Rust, with no GDAL and no C dependencies. Use it from the command line, Python, JavaScript (WebAssembly) or Rust, or let an AI agent drive it.
What's new in v0.5.0
- Vector processing: buffer, overlay (intersection, union, difference), dissolve, is-valid, make-valid and clean, plus centroid, singlepart, vertices and footprint.
- Raster analysis: contour lines, zonal statistics across bands and rasters, and sampling many rasters at points.
- SQL: a standalone terrio sql command for querying vector layers.
- A rio command line: terrio-rio runs rasterio's rio commands (info, clip, merge, warp, calc and more).
- New formats: GRIB1 and GRIB2 weather data, read lazily from local files or remotely from NOAA and ECMWF.
- Point clouds: more of PDAL's filters (dbscan, covariancefeatures, lof, dem, colorization, overlay and more), and appending points to EPT datasets in place.
- Coordinates: transformations between vertical CRSs, point motion between coordinate epochs.
- Multidimensional data: Zarr arrays with more than three dimensions, netCDF groups written from Python and JavaScript, and xarray subdatasets, GCPs and RPCs opened as rioxarray opens them.
- STAC: POST searches with paging, and Microsoft Planetary Computer signing.
- WebAssembly: multithreading (6 to 8x faster decoding and COG writing in Node.js, Chromium and Firefox), a terrio-js/core module that is less than half the download, and terrio-js/memory64 for datasets larger than 4 GB.
Every new processing command is also an MCP tool, so AI agents can run them too.
Try it out
- Playground in your browser: terrio.opengeos.org/playgrou…
- Documentation: terrio.opengeos.org
- GitHub: github.com/opengeos/terrio
- Release notes: github.com/opengeos/terrio/r…
#GIS #Rust #OpenSource #Geospatial #Python #WebAssembly #GDAL





























