AI Characters (embodied agents) and neuroscience. I've been around the metaverse a while. Also I use emacs and an HP35s. Where's my free pocket protector?
Joined November 2021
- Tweets3.3K
- Following65
- Followers58
- Likes6.5K
Pinned Tweet
I think we're going to be seeing a convergent evolution of AI/NN in the coming years.
By accident or on purpose, we're be adopting more brain-like systems not because we want to imitate the brain, but because it works.
Form follows function.
personalityengineer retweeted
LOOK WHAT I FOUND 😲
a new open-source model that just hit #1 on Hugging Face and it runs fully local on a 16GB laptop
it is called Spark-X2.5-4B:
→ 4 billion parameters
→ native 1 million token context window
→ runs completely offline and private
→ strong coding + agent capabilities
→ works with Ollama, LM Studio, llama.cpp, etc.
no cloud and no data leaving your machine. it's free and open source.
repo:
github.com/XHToken/Spark-X2.…
save this for later.
yesterday was a LOT, OpenAI dropped a whole pile of updates around DevDay
here’s what stood out to me:
GPT-6.1 Sol: near Astra performance for coding, computer use and professional tasks, at $2/$10 per 1M input/output tokens.
Astra Ultrafast: faster token generation for demanding workflows.
Pro 500: a $500/month plan with higher usage limits and faster access.
Dots: always-on AI agents that can handle tasks in the background.
Codex updates: cloud workflows, voice support and desktop code review.
Codex Security: AI-powered code security scanning and fixes.
More agent tools: computer-use capabilities and new decision-making tools.
ChatGPT Work: more ways to bring AI into team workflows.
and that’s still not the whole list
honestly there was so much happening that it was hard to process everything at once.
if you’re trying to figure out what’s actually useful to you, start with ChatGPT Work, Codex and the API docs.
personalityengineer retweeted
JEPA Learns What the Mask Leaves Unrecoverable
TL;DR: Why do block masks work so well in JEPA? Not because of their shape itself, but because they hide information that low-level interpolation cannot recover. Experiments on images and videos show that both unrecoverability and context reachability matter.
arxiv.org/abs/2609.32481
personalityengineer retweeted
Ollama now supports Jev-like decision models all locally.
Use decision models like Nimble for tasks like ticket triaging, model routing, and content moderation.
ollama pull nimble
Here’s Nimble playing Ollama racer through the new local /v1/systemone API by making decisions in real-time. 🏎️
personalityengineer retweeted
this is straight f*cking gold for anyone on Claude Code
you already pay for Fable 5.1, and while Opus 5.5 does all the work it just sits there
one command puts it on your session as a senior reviewer:
/advisor fable
Opus 5.5 keeps writing the code
Fable 5.1 reads the whole session, every tool call included, and speaks up at three moments only:
> before a plan: is this the right approach?
> when the same error comes back: am I digging in the wrong place?
> before "done": what did I miss?
Fable 5.1 reviews. Opus 5.5 ships
Jev engineering does the same thing one layer down: forks that need no thinker (which file, which tool, retry or stop) go to Jev in under half a second, and the big model only sees the ones that actually split
• the full tree
> Opus 5.5 on high runs the main session
> explorer reads the code
> worker edits and runs tests
> researcher pulls the docs
> all three on medium
> Fable 5.1 on call as the advisor
paste the tree and this prompt into Claude Code ↓
"Rebuild my Claude Code setup around this tree:
1. Check ~/.claude/agents and .claude/agents for subagents that already fit explorer, worker and researcher. Draft new ones only for missing roles. Give each model: opus, effort: medium. Skip any that pin a different model and list them.
2. Set the main session to high via effortLevel in ~/.claude/settings.json, and set advisorModel to fable.
3. Find anything that keeps the advisor off (CLAUDE_CODE_DISABLE_ADVISOR_TOOL, DISABLE_TELEMETRY, any variable that stops feature-flag fetching) plus CLAUDE_CODE_EFFORT_LEVEL, which overrides subagent effort. Report them, change nothing.
4. Add one rule to ~/.claude/CLAUDE.md: consult the advisor before a large plan, when an error repeats, and before calling a long task done.
Show me every change as a diff first. No edits until I say go"
↳ code.claude.com/docs/en/advi…
personalityengineer retweeted
If you haven't checked Cornell's "Understanding GPU Architecture" roadmap recently, it's worth another visit.
They’ve updated it to cover modern HPC architectures, including NVIDIA's Blackwell B200.
cvw.cac.cornell.edu/gpu-arch…
personalityengineer retweeted
The portal into the background of GPU architecture
www2.eecs.berkeley.edu/Pubs/…
GPUs process thousands of pixels in parallel, but what happens when we write a single pixel to the framebuffer? How is it done?
Watch a CPU paint each pixel in this amazing RISC-V visual simulator (load the bitmap example):
eseo-tech.github.io/emulsiV/
personalityengineer retweeted
In 1747, Euler spent 133 pages proving that logarithms have infinitely many solutions - and in doing so accidentally revealed why every LLM, every signal processor, and every Fourier transform works the way it does. The imaginary unit I doesn't break exponential functions. It rotates them, turning exponential growth into the sine and cosine waves that live inside every transformer attention layer.
The proof runs through Briggs' 1617 zooming algorithm, complex polar coordinates, and a thin-triangle argument that connects imaginary exponents to angles in radians. When you plug I into the exponential function, you don't get growth - you get rotation confined to the unit circle. The same unit circle that softmax maps every attention score onto before the GPU multiplies them.
27 minutes. Bookmark & watch today. The most beautiful equation in mathematics and why it powers every model you have ever used.
personalityengineer retweeted
Yann LeCun's lab borrowed a trick from the human brain and more than doubled how often an AI found its way to a goal.
The paper is called Temporal Straightening for Latent Planning, from NYU with Brown and the University of Toronto.
It was accepted at ICML this year.
LeCun has argued for years that chatbots won't get AI to human-level intelligence. He thinks the path runs through world models, AI that learns how the world moves by watching it. A world model turns each moment of a video into a point in its own internal map, then learns to predict where the next point will land.
To plan a route, the AI imagines moves and heads for the point that matches the goal. The problem is that its internal map is warped. Two spots can look close on the map and sit far apart in real life, like two rooms on either side of a wall. The AI aims straight at the goal and walks into the wall.
The team found the fix in neuroscience. A 2019 study in Nature Neuroscience showed that your visual system takes the messy, twisting paths of what you see and straightens them out inside your brain, which makes it easier to predict what happens next. So the team trained their model with one extra rule, a penalty every time its internal path bends.
Here's what the straighter map did.
In a two-room task with one door in the wall, the AI reached the goal 90.7% of the time, up from 52.7%.
In a U-shaped maze, it reached the goal 94% of the time, up from 44%.
When it could re-plan along the way, it hit 100% in both.
A simple planner using the straightened map kept up with a much heavier one and ran about 10 times faster.
They used the same kind of model on the same data. The only change was the shape of the map it learned.
The tests are small. The AI moves through mazes and rooms and pushes a T-shaped block into place. The authors say mistakes add up over long plans.
Chatbots learn to predict the next word. This model learned to predict the next moment, and it got better by seeing the world the way your eyes do.
LLMs gave AI language.
World models could teach it to move through the world!
personalityengineer retweeted
Self-Attention vs Cross-Attention interactive diagram. Open byhand.ai/self-vs-cross
personalityengineer retweeted
also, save this image... It’s probably the simplest way to understand which Jev primitive fits your use case
Think about what you want to build, follow the diagram, and that’s it
🤖 Made with AI
The best way to learn something is to build with it!
I built Jev Explained with 4 examples that show what Jev is, how its primitives work, and how to use them in practice
Clone the repo, open Claude Code or Codex, and ask it to create a new example using the existing codebase as context
You can run it with either a TypeSafe API key or Vercel AI Gateway
Stop reading articles... open a session and start building
Repo: github.com/davila7/jev-expla…
Live demo: jev-explained-repo.vercel.ap…
personalityengineer retweeted
this is free f*cking gold
Andrej Karpathy joined Anthropic to run a team turning Claude loose on Anthropic's own pretraining research
a model helping build the model that replaces it. that part is on the record
the quote doing the rounds - "two Anthropic seniors made his loop 1000x better with graph engineering" - has no source anywhere, so i'm not selling it as fact
what is public: Anthropic's own Claude cookbook on building knowledge graphs
> extract - pull entities and claims out of raw text
> resolve - work out which mentions are the same thing
> assemble - wire them with typed edges
> query - ask what no single document could answer
four steps, free, sitting in the repo while the timeline repeats a rumor
learn them this weekend and you can build what the rumor described. that's the skill getting handed the AI architecture work this year
start with the cookbook, then judge the article below
personalityengineer retweeted
It’s easy to dismiss Jev it as “just a classifier”.
But people (me included) who have been training encoder-style models for classification for many years know they were usually special-purpose and limited in some way.
The breakthrough of Jev is that it generalizes well.
And I’d say the secret sauce is probably more in the data than in the training algorithm. (Plus a nice API design on top of it.)
poor guy claim to have built Jev a year ago but no one cared, and now Jev stole all the thunder
many people are saying “you gotta tell your story” or “marketing is important”, and they just completely missed what actually made the difference here
i just looked into this laya model laya.convaiinnovations.com/ and:
- it only supports 512-1k context… a lot of use cases won’t fit at all
- evaluating the model directly shows its accuracy is as good as a coin flip. in order to get good results, you need to first fine tune it
i’m sorry, but that’s not Jev
there’s a massive gap between an interesting research and a useful product
you can “tell your story” all you like, but you can’t blame Jev for stealing your thunder when Jev did all the work to make a well-packaged solution anyone can just grab and go
Jev is not completely new from an academic sense, just like how ChatGPT was not the first LLM
don’t underestimate the effort and value in putting together something that’s actually good enough for adoption - it makes all the difference
personalityengineer retweeted
you'll know more about CUDA than 90% of people if you fully understand this guide
this is only the third resource in the ai performance engineering repo btw.
imagine the ball knowledge in the other ones
we launched the most comprehensive ai performance engineering repo in the world
now we'll be posting every single resource
this is Wafer's ai performance engineering series
save this to keep up with the series. links in thread 🧵
part 3: "Intro to CUDA C++" from NVIDIA's CUDA Programming Guide.
NVIDIA covers the execution model, memory movement, and correctness checks behind CUDA programs:
- kernel launches, grid dimensions, and the organization of threads into blocks.
- thread indexing and work assignment, including bounds checks for inputs that aren't multiples of the block size.
- unified memory and explicit memory management, including control over data placement and transfers between CPU and GPU.
- asynchronous kernel execution and synchronization before the CPU uses GPU results.
- shared memory and block-level synchronization for threads that need to exchange data and coordinate their work.
- runtime initialization and the setup costs that can affect measurements of the first runtime calls.
- error handling for kernel launches and execution, including failures that surface in later API calls.
- checking GPU results against a CPU implementation with a floating-point tolerance.
the worked examples connect these concepts in a complete vector addition program, showing how to divide the work, manage its memory, and check the results before moving on to more complex kernels.
figure from An Even Easier Introduction to CUDA (Updated)
personalityengineer retweeted
OpenAI researcher "Alisa Liu" had 57 interviews before joining OpenAI, and then She open-sourced her entire study notes job/learning process.
- her LLM study notes
- her math interview notes
- a full honest write-up of the job process
If you are preparing for research scientist / MTS roles, this is the highest-signal material available right now.
You can use her notes or her topic list to study on your own. That’s rare. Don’t waste it.
personalityengineer retweeted
After co-inventing ChatGPT, I kept asking myself: why have superhuman chat models not led to AGI?
I’ve spent the last 2 years in stealth building a new way to train models (RLCD), and a new type of frontier AI model that we are releasing today: Jev
• 20-200x faster
• 40-400x cheaper (w/ output tokens free)
• Frontier composable intelligence optimized for decisions
AFAICT the shortest path to AI-based economic revolution
personalityengineer retweeted
Unlike LLMs, Jev didn't invent a new concept.
Classifiers have existed for decades, with exactly the same interface → ask a question, get a probability score.
BUT, here's what the hype is all about:
- it works for *any* problem, no training required
- it's fast → you can do stuff in real-time
- it's cheap
You can see it as a democratization of classifiers. Before, only those with a huge amount of their own training data could own one. Now, you get your own at the speed of thought.
This won't disrupt the existing classifier market. Custom-trained classifiers will always beat the one-size-fits-all solution.
But this opens a whole new market for the rest of us where retail is more than good enough.
It's the same thing that happened with digital photography, Canva, 3d printing, and vibe coding.
personalityengineer retweeted
Why choose between Transformers and SSMs?
"Jamba" (2024) interleaves Mamba layers with Transformer blocks.
It captures the massive context windows and O(1) inference of State-Space Models while maintaining the high capacity of Attention! 🧬👇
arxiv.org/abs/2403.19887
