Every prompt, skill, and subagent encodes a hypothesis about what the model can't do. When the model changes, those hypotheses need to be proven again. https://t.co/vmKPRQ5lcf
JEV can be very useful, but not because it's a cheap alternative to an LLM. The problem is that a lot of the hype is presenting it as if it were compressed general intelligence.
Jev, from @typesafeai , runs input at $0.042 per million tokens. Output is free. The phrase they use for it is "too cheap to meter".
Their own comparison table puts the models you're using today at $0.20 to $10 per million input tokens, and output at around five times the input price. Same question, from ten dollars a million down to four cents.
The model is named after William Stanley Jevons, and they say so in their FAQ. Jevons noticed that when steam engines got more efficient, coal demand went up. They picked the name on purpose.
Their home page claims 444.6x cheaper. Knock off an order of magnitude for the real world , halve what's left the decision still changes.
Every project I've watched die in planning died on the same line of the spreadsheet, fine per request, absurd at the volume you actually needed. that's the line this moves.
Jev being free till sept 25 is the clearest sign yet that open-weight stopped being the alternative lane.
it's the cheap default now.
when vercel prices an open model at zero to win dev attention, token share stops being a footnote and becomes the only number worth looking at.
Jev by @typesafeai is free on Vercel AI Gateway until Sept 25.
Build with the fastest adopted model on the Gateway at no cost.
https://t.co/KsFHUhmaLe
https://t.co/7KsKeZElra
I was not expecting things to go this way, but I think MCPs are better than CLIs for most integrations.
The models have gotten much better at tool calling, we can defer tools & MCP is now stateless.
If you need to compose/filter data, add params like query to your MCP tools.
This Company Brain was built by Astra
One prompt, full prompt in comments
- Manages team permissions
- Has MCP for any agent
- 5 layers of context management
- 300 integrations
- And asks you on Slack about contradictions
I built this Company Brain, but not because it's a graph
it governs the data
it has 5 types of search
it structures the information
it integrates with the entire stack
it has user permissions
it looks up missing information by asking the owner via Slack or a call
there are user permissions (important)
Try it: https://t.co/YQS76PNfHc
13M views on a 54-second motion graphic. Here's what I'd steal from it.
01 - DON'T OPEN WITH THE BRAND
Don't open with your logo or your name.
Open with an authority reference β proof someone already trusts this enough to use it.
We opened on "Welcome, Sarah."
Not a tagline. Not a feature. A name β like it already has real users worth greeting.
The brand shows up later. The trust shows up first.
02 - SHOW THE SCREEN, NOT A SLIDE
Don't tell people what it does.
Show a real query going in and a real answer streaming out.
A bullet point is a claim.
A screen recording is proof.
03 - MAKE THE ABSTRACT CONCRETE
"It has all your context" means nothing.
So we showed the sources flying in β Slack, Linear, Notion, Drive, Zendesk β
then a number landing on screen: 1,136 memories.
Specific beats impressive. Every time.
04 - KILL THE OBJECTION BEFORE IT'S ASKED
Right after "it knows everything," people think:
"...who can see it?"
So the next beat was a permissions table.
Role by role. Before anyone had to ask.
05 - SHOW THE THINKING, NOT JUST THE ANSWER
Don't just show the output.
Show the steps: searching memory, retrieving the report, skill found β then the deliverable.
That's what makes it feel real instead of scripted.
This is the part we obsess over when we build these β not the video itself, figuring out what makes someone actually believe the product.
Introducing shared memory across agents.
Not just for Claude: for any agent system.
Share your entire company's knowledge through a company brain.
β Governance and operational knowledge from your calls, apps, projects, team, skills...
β Active search for missing data via Slack, WhatsApp, or phone calls
β Trust, traceability, and permissions by team
β Token savings and faster performance
Try it: https://t.co/LiLgsneLoJ
If you maintain a skill library for your agents, check this out. (bookmark it)
Most skill-evolution setups collapse three things into one. This one keeps them separate: raw execution traces, a persistent wiki, and the executable skills themselves.
The wiki is doing the heavy lifting. In their ablation, giving the Skill Proposer wiki access takes average performance from 48.7% to 63.7%.
Giving the Inference Agent wiki access too, during training, drops it back to 60.9%.
Accumulating knowledge and executing on it aren't the same job.
Qwen-3.5-9B with evolved skills hits 47.4% β beating Qwen-3.6-27B with no skills at 39.4%.
A model several times larger, with no memory, loses to a small one that has it.
Skills evolved by another model can transfer better than self-evolved ones. But not always:
Qwen-3.5-4B's skills (low-level workarounds, one-line commands) tank Gemini-3.5-Flash from
50.5% to 18.1%. Qwen-3.6-27B's skills push it to 63.4%.
Same target model. Opposite outcome, depending on whether the transferred skill is a general procedure or someone else's patch.
What decides which one you get β general procedure vs. model-specific patch β isn't settled here. If your skill library has to survive a model swap, that's the first thing I'd check.
Paper: https://t.co/eMmcAcalkX
Spec Kit just hit 1.0.0: 133K stars, ~12K forks, a year in the making.
The idea: the AI writes a structured spec BEFORE touching code. It figures out what you want to build, asks what's missing, plans the architecture, then codes.
Result: fewer dumb bugs, less inconsistent code, way more predictable.
/speckit.constitution
β rules /speckit.specify
β what to build /speckit.clarify
β open questions /speckit.plan
β architecture /speckit.tasks
β tasks /speckit.implement β execution
Works with 30+ agents (Claude Code, Cursor, Copilot, Codex...). Open source, MIT, from GitHub.
Repo https://t.co/8hMyykik8s
The CEO of @ycombinator open-sourced the brain he runs his own agents on.
It's called GBrain. MIT, TypeScript, on GitHub since April.
Point it at your markdown notes and it builds a memory layer on top.
What you get:
β A graph that wires itself: every page you write extracts entity refs and creates typed edges (attended, works_at, invested_in, founded, advises)
β Actual hybrid retrieval: vector + keyword + RRF + source-tier boost + reranker
β Two separate verbs: search hands you pages, think hands you the answer with citations
β A local PGLite database ready in 2 seconds. No Docker, no server
The detail that made me open the code: the graph is built with zero LLM calls. It's pattern extraction over what you already wrote.
Their own benchmark, on a 240-page corpus: +31.4 points of P@5 over the same install with the graph turned off. Scorecards published in a separate repo.
And think doesn't just answer. It closes by telling you what the brain doesn't know: which page is stale, which claim has no citation, which two pages contradict each other.
What I'm taking from it: a memory system that declares its own gaps beats one that always answers with confidence. Answering isn't the hard part. Knowing when you shouldn't is.
https://t.co/ioywoteWF2
Someone took @karpathy's knowledge graph concept and shipped it as open source.
It's called Graphify, works out of the box with Claude Code and Cursor.
Point it at a codebase. It maps out the entire thing on its own.
No vector database. No setup files.
Here's what it hands you:
β A clickable graph of every idea in the repo
β An Obsidian vault, backlinks included
β A wiki that opens from a single index page
β Answers to plain-English questions about the whole project
Under the hood, it runs in two stages.
Stage one parses the code's structure without touching an LLM.
Stage two sends subagents to pull concepts out of docs and images at the same time.
Every link gets labeled extracted straight from the source, or inferred so you're never guessing what's real.
You can ask it:
"What depends on this function?"
"How are these two ideas linked?"
"Which nodes matter most in this project?"
The biggest win is token cost: your agent queries a compact graph instead of scanning raw files, cutting tokens per query by 71.5x.
That's a genuinely different way for AI agents to understand big codebases.
Works across 13 programming languages, plus PDFs, Markdown, and images.
Get it running in one command:
pip install graphify && graphify install
Free. Open source. No catch.
Link to the repo β
Inspired by this, I made my own: "eli5-for-grownups."
It's like @trq212's, and because I'm a picky consistency freak, it has extra direction on what eli5 means and doesn't.
Should you like, here it is:
https://t.co/bkVN7Usuhz