Arnav Tripathy

cs @utaustin, nanotech, neuromorphic computing, Godot game dev
@Bucks fan
cofounder at

[Arnav Tripathy @aatri07]

@happytatoes noah and i are looking forward to hearing what yalls have to say (emphasis on the brutal feedback!)

[Noah W. @happytatoes]

(pip install) agent-sleuth 0.0.1 is live.

agent-sleuth tracks where untrusted data comes from and blocks it from reaching consequential actions (send_email, write_file, post_slack)

deterministic, three lines to integrate.

brutal feedback encouraged.
https://t.co/v29LL938Sl

[Arnav Tripathy @aatri07]

@jackprice bunch of other people have prob pointed it out before me, but this gradient:

[Zy @ZyMazza]

Expect to see a lot more of this. Vibe coding, 3d printing, cheap motors, and boards (soon, after the Great Correction) WILL lead to a true cambrian explosion of robotics

Home-built robotics projects will be the new "my first weather/calendar app" entry point for "SWE" types

[Michal Malewicz @michalmalewicz]

I literally love every part of this.

[Arnav Tripathy @aatri07]

@aestheticsguyy

[Arnav Tripathy @aatri07]

@BarathAnandan7 same here, i’ve been running Gemma 4:26b with fairly high TPS on my RTX 5070 ti laptop (12 GB VRAM)

[Arnav Tripathy @aatri07]

@codewith55 install firefox

[Jorge Bravo Abad @bravo_abad]

Efficient training of neuromorphic electronics

A neural network "learns" by adjusting thousands of internal values, the connection strengths between its artificial neurons. Finding those values is expensive, so it's normally done once on a powerful computer, then copied onto a separate, smaller chip that runs the model out in the world. On ordinary digital chips this copy is perfect, because a connection strength is just a number, and numbers copy losslessly.

Neuromorphic chips break that assumption. These brain-inspired devices are fast and energy-efficient because they merge memory and computation the way the brain does, but each connection strength is stored as a physical property of a tiny component rather than as a clean digital number, and physical components are never exactly what you set them to. So a model tuned to near-perfection in software can come out distorted on the actual hardware.

Shuangming Yang and coauthors survey how the field tackles this, and the answer is less a single best method than a set of trade-offs. They organize training into three families. Offline training does everything in software and just deploys the result, keeping the chip simple but unable to adapt once running. Online training updates weights directly on the hardware using local rules like spike-timing-dependent plasticity or backpropagation-through-time, buying real-time adaptability at the cost of higher power and circuit complexity. Hybrid training splits the difference: pretrain in software, then fine-tune a few key layers on-chip to absorb device variability, which their examples show can recover software-level accuracy in a handful of gradient steps, even with 4-bit weights.

A recurring theme is that standard deep learning tooling doesn't fit, so surrogate gradients, ANN-to-SNN conversion, and dedicated frameworks like SpikingJelly and Lava have grown up to bridge the gap. The authors are also blunt that no fair benchmark yet exists across digital, mixed-signal, and emerging hardware.

For edge AI in wearables, autonomous systems, or IoT sensors, the lesson is that training strategy has to match your power budget and how much on-device adaptation you need, not accuracy alone. Hybrid training looks like the pragmatic near-term path for privacy-sensitive, battery-constrained deployments.

Paper: Yang et al., Nature Electronics (2026), journal license | https://t.co/YIIGvWQTgs

[Vox @Voxyz_ai]

stop telling Claude Code/Codex "read this file".
stop telling Claude Code/Codex "now read that one too".
stop telling Claude Code/Codex "grep the whole repo".

install codebase-memory. it indexes the Linux kernel, 28M lines, in 𝟯 𝗺𝗶𝗻𝘂𝘁𝗲𝘀. your repo takes seconds.

index once and the whole repo becomes 𝗼𝗻𝗲 𝗴𝗿𝗮𝗽𝗵 of every function, file and dependency. one query replaces dozens of grep and read cycles.

benchmarked across 31 real repos:
→ 10x fewer tokens on structural queries
→ 83% answer quality on complex tasks
→ 2.1x fewer tool calls

two prompts. send them straight to your agent 👇

[Defileo🔮 @defileo]

What the f*ck is this GitHub repo, 33k+ stars in less than a month.

It's called OpenHuman, and the newest feature is why it's exploding, Super Context.

> The moment you open a new chat, it runs a context pass first
> Gathers what's relevant about you, your screen, your work
> Then answers turn one like it's turn ten, already grounded

It lives at the OS level, speaks in your voice across your whole system, connects to 118 apps you already use.

Runs locally, never leaves your machine, and keeps learning you the longer you use it.

It was #31 trending on GitHub for ten days straight and now it's the #1 repo on GitHub.

> Repo: https://t.co/jHEsjQn4Rq

[Ahmad @TheAhmadOsman]

Local AI hardware = capacity X bandwidth X software stack

- Capacity tells you what fits
- Bandwidth tells you how hard the box can breathe
- The software stack tells you how much of the spec sheet you can actually cash out.

Hardware by Memory Bandwidth
- Mac Studio M3 Ultra: up to 512GB @ 819 GB/s
- RTX PRO 6000 Blackwell: 96GB @ 1792 GB/s
- RTX 5090: 32GB @ 1792 GB/s
- RTX 4090: 24GB @ 1008 GB/s
- RX 7900 XTX: 24GB @ 960 GB/s
- Radeon PRO W7900: 48GB @ 864 GB/s
- AMD Radeon AI PRO R9700: 32GB @ 640 GB/s
- Intel Arc Pro B65: 32GB @ ~608 GB/s
- Tenstorrent Wormhole n300: 24GB @ 576 GB/s
- Tenstorrent Blackhole p150: 32GB @ 512 GB/s + 800G
- MacBook Pro M5 Max: 460-614 GB/s
- MacBook Pro M5 Pro: 307 GB/s
- DGX Spark: 128GB @ 273 GB/s (coherent + CUDA)
- Mac mini M4 Pro: 273 GB/s
- Ryzen AI Max / Strix Halo: ~256 GB/s (~96GB usable GPU)
- MacBook Air M5: 153 GB/s
- Snapdragon X2 Elite: 152-228 GB/s
- Intel Lunar Lake: 136 GB/s
- Snapdragon X Elite: 135 GB/s
- Mac mini M4: 120 GB/s
- Arc Pro B60: 24GB @ ~456 GB/s

Verdict

- GPUs are still the bandwidth kings

- Apple wins: stupid amounts of memory, don't want to shard across GPUs
- Apple loses: when raw tokens/sec & concurrency matter more

- DGX Spark: coherent memory + NVIDIA stack

- Strix Halo / Ryzen AI Max: first real x86 unified-memory contender

- Tenstorrent: fully OSS stack, excited to see this mature

Fitting != serving

Even if it fits, you still pay for
- bandwidth during decode
- KV cache growth
- dequantization
- batching + concurrency
- scheduler quality
- framework overhead

The only mental model that matters:

1. What must fit?
2. What bandwidth tier do I need?
3. What software stack can actually deliver it?

In short:
- NVIDIA -> fastest raw speed
- Apple Studio M3 Ultra -> biggest one-box memory
- Strix Halo -> first real x86 unified
- DGX Spark -> coherent NVIDIA dev appliance
- AMD / Intel Arc -> rising alternatives
- Tenstorrent -> fully opensource stack

Do ask: "which bottleneck am I buying?"

Not: "which hardware is best?"

[Rukshi @Rukshi101]

I got tired of spending weeks probing and debugging PCB prototypes, so I built a robot to do it for me

[Yifei Hu @hu_yifei]

Announcing constant-attention-1.0, a new type of model that uses constant memory footprint (O(42)) for any context window and has near perfect recall at 1000M tokens.
Will provide this to trusted partners once i fix some tokenizer issue.

[Moysei @0xMoysei]

Karpathy just wrote the manual for Claude + Obsidian as a real second brain.

Most vaults die the same way. A year of saved articles and highlights. None of it linked. The graph rots while it still looks impressive.

So he moved the upkeep to the model. You curate sources and ask questions. Claude files, links, and reconciles. You keep judgment. It keeps the books.

raw belongs to you and never gets edited. wiki belongs to Claude. It isn't RAG. Your sources compile once into linked pages and compound from there.

9 rules. Start with 10 sources, not 10,000.
Most people hoard notes. This turns them into a brain that maintains itself.

[Arnav Tripathy @aatri07]

@dark_coderz def depends. i believe PostgreSQL should be used when data integrity is super important, but MongoDB (NoSQL) should be used when you’re using document-based data or schema changes are constant (correct me if im wrong)

[Arnav Tripathy @aatri07]

@sudoingX very good to know. went into local llms with ollama, but i’ll be looking into llama.cpp now

[Sudo su @sudoingX]

if you're just getting into local llms, do yourself a favor and start by building llama.cpp from source. not ollama, not lm studio.

build llama.cpp once, it's genuinely just a git clone and a make command with cuda on, and it clicks. you see the flags, you control the quant, you run any gguf on the planet, and llama-bench gives you real numbers instead of a vibe. when something's slow, you know why, and you can fix it.

ollama and lm studio are fine for "just chat with a model." but if you actually want to understand local inference, they're a ceiling, not a foundation. start one level deeper. it pays off every single day after.

[Arnav Tripathy @aatri07]

@sudoingX none, thankfully. i use Claude Max through my university email for free

[Ahmad @TheAhmadOsman]

Wanna replace Anthropic/OpenAI? START WITH THIS

The bible for running LLMs locally is now available online to read for free

Covers what to use on

- Laptop / edge / odd hardware
- Mac-first workflows
- Single RTX GPUs
- 2-4+ NVIDIA / CUDA GPUs
- General production serving
- Long-context / MoE / routing
- NVIDIA max performance
- Cluster orchestration

Software

- llama.cpp
- MLX / MLX-LM
- ExLlamaV2
- ExLlamaV3
- vLLM
- SGLang
- TensorRT-LLM
- NVIDIA Dynamo

You should read this, and if you cannot now then you most definitely wanna bookmark it for later

Opensource & Local AI FTW