Not @TheEconomist coming up with those subheadings?
Jake 🦇 🔊 retweeted
The most interesting Fable tip I've heard so far is to let the model use its own judgement as much as possible
I told it "For all coding tasks use your judgement to decide an appropriate lower power model and run that in a subagent" and it seems to be saving a lot of tokens
Jake 🦇 🔊 retweeted
21/
LNO Effectiveness Framework
This framework improved the quality of my life as a PM & my work more than anything else I've encountered.
The main insight is that all your tasks are not created equal. There are 3 types of PM tasks:
1) Leverage
2) Neutral
3) Overhead
Jake 🦇 🔊 retweeted
Esto es espectacular como se movió Marruecos defensivamente. Esto se entrena. No es aleatorio. Tremendo bloque corto defensivo. Imposible de entrar sin alguna magia o pase filtrado con extrema exactitud. Por eso Brasil se la pasó lateralizando.
Jake 🦇 🔊 retweeted
The US government, citing national security authorities, has issued an export control directive to suspend all access to Fable 5 and Mythos 5 by any foreign national, whether inside or outside the United States, including foreign national Anthropic employees.
The net effect of this order is that we must abruptly disable Fable 5 and Mythos 5 for all our customers to ensure compliance.
Access to all other Claude models is not affected.
We apologize for this disruption to our customers. We believe this is a misunderstanding and are working to restore access as soon as possible.
Read our full statement: anthropic.com/news/fable-myt…
Jake 🦇 🔊 retweeted
i hooked my whoop to my work calendar to find which coworker gives me the most stress 🚨
thanks to fable, I reverse engineered whoop to pull per minute heart rate. nd matched spikes with cal events and attendees
I now have a leaderboard and I think about it daily.
few info masked for obvious reasons ;)
Jake 🦇 🔊 retweeted
supervision just hit 40,000 GitHub stars!
it now powers over 6.5k open-source computer vision projects, including all my demos like basketball AI
link: github.com/roboflow/supervis…
Jake 🦇 🔊 retweeted
Today, we’re open-sourcing the draft specification for DESIGN.md, so it can be used across any tool or platform. We’re also adding new capabilities.
DESIGN.md lets you easily export and import your design rules from project to project. Instead of guessing intent, agents know exactly what a color is for and can even validate their choices against WCAG accessibility rules.
Watch David East break down this shared visual language in action👇. New capabilities and links in 🧵
Jake 🦇 🔊 retweeted
LLM Knowledge Bases
Something I'm finding very useful recently: using LLMs to build personal knowledge bases for various topics of research interest. In this way, a large fraction of my recent token throughput is going less into manipulating code, and more into manipulating knowledge (stored as markdown and images). The latest LLMs are quite good at it. So:
Data ingest:
I index source documents (articles, papers, repos, datasets, images, etc.) into a raw/ directory, then I use an LLM to incrementally "compile" a wiki, which is just a collection of .md files in a directory structure. The wiki includes summaries of all the data in raw/, backlinks, and then it categorizes data into concepts, writes articles for them, and links them all. To convert web articles into .md files I like to use the Obsidian Web Clipper extension, and then I also use a hotkey to download all the related images to local so that my LLM can easily reference them.
IDE:
I use Obsidian as the IDE "frontend" where I can view the raw data, the the compiled wiki, and the derived visualizations. Important to note that the LLM writes and maintains all of the data of the wiki, I rarely touch it directly. I've played with a few Obsidian plugins to render and view data in other ways (e.g. Marp for slides).
Q&A:
Where things get interesting is that once your wiki is big enough (e.g. mine on some recent research is ~100 articles and ~400K words), you can ask your LLM agent all kinds of complex questions against the wiki, and it will go off, research the answers, etc. I thought I had to reach for fancy RAG, but the LLM has been pretty good about auto-maintaining index files and brief summaries of all the documents and it reads all the important related data fairly easily at this ~small scale.
Output:
Instead of getting answers in text/terminal, I like to have it render markdown files for me, or slide shows (Marp format), or matplotlib images, all of which I then view again in Obsidian. You can imagine many other visual output formats depending on the query. Often, I end up "filing" the outputs back into the wiki to enhance it for further queries. So my own explorations and queries always "add up" in the knowledge base.
Linting:
I've run some LLM "health checks" over the wiki to e.g. find inconsistent data, impute missing data (with web searchers), find interesting connections for new article candidates, etc., to incrementally clean up the wiki and enhance its overall data integrity. The LLMs are quite good at suggesting further questions to ask and look into.
Extra tools:
I find myself developing additional tools to process the data, e.g. I vibe coded a small and naive search engine over the wiki, which I both use directly (in a web ui), but more often I want to hand it off to an LLM via CLI as a tool for larger queries.
Further explorations:
As the repo grows, the natural desire is to also think about synthetic data generation + finetuning to have your LLM "know" the data in its weights instead of just context windows.
TLDR: raw data from a given number of sources is collected, then compiled by an LLM into a .md wiki, then operated on by various CLIs by the LLM to do Q&A and to incrementally enhance the wiki, and all of it viewable in Obsidian. You rarely ever write or edit the wiki manually, it's the domain of the LLM. I think there is room here for an incredible new product instead of a hacky collection of scripts.
Jake 🦇 🔊 retweeted
🚨 BREAKING: researchers planted a single bad actor inside a group of LLM agents. the whole network failed to reach consensus.
this is the Byzantine Generals Problem. a 40-year-old distributed systems nightmare.
and it's now your agent pipeline's problem too.
in fully benign settings, with zero bad actors, LLM agents still fail to converge on shared values. and it gets worse as you add more agents to the group.
the failure mode is revealing. it's not subtle value corruption. it's not one agent sneaking in a wrong answer. the models just... stall. they time out. they go in circles. the conversation never lands on agreement.
this matters because the entire multi-agent AI hype assumes coordination works. autonomous agent swarms, collaborative problem-solving, decentralized AI systems. all of it assumes that if you put multiple LLMs in a room and give them a protocol, they'll converge on a shared decision.
Byzantine consensus is one of the oldest, most studied problems in distributed systems. classical algorithms solved it decades ago with strict mathematical guarantees. the question was whether LLM agents could achieve the same thing through natural language communication instead of formal protocols.
the answer, at least for now, is no. and the reason is worth sitting with.
traditional consensus algorithms work because every node follows an identical deterministic protocol. LLMs are stochastic. the same prompt produces different outputs across runs. an agreement that holds in round 3 can dissolve in round 4 as agents revise their reasoning after seeing peer responses.
this is the fundamental mismatch: consensus protocols assume deterministic state machines. LLMs are the opposite of that.
it also means that "more agents = better answers" has a ceiling nobody's measuring. at some group size, coordination overhead and convergence failures outweigh any benefit from diverse perspectives.
the practical implication is uncomfortable for anyone building multi-agent systems for high-stakes tasks. reliable agreement isn't an emergent property of putting smart agents in conversation. it has to be engineered explicitly, with formal guarantees, not hoped into existence.
we're deploying multi-agent systems into finance, healthcare, autonomous infrastructure. and the consensus problem, the most basic coordination primitive, isn't solved yet.
Still can't get over @SlackHQ not using cmd+k for adding hyperlinks, like every single other productivity SaaS.
¯\_(ツ)_/¯
Jake 🦇 🔊 retweeted
I'm Boris and I created Claude Code. I wanted to quickly share a few tips for using Claude Code, sourced directly from the Claude Code team. The way the team uses Claude is different than how I use it. Remember: there is no one right way to use Claude Code -- everyones' setup is different. You should experiment to see what works for you!
Jake 🦇 🔊 retweeted
Diagrams are becoming my primary way of reasoning about code with Agents. And I didn't find anything there that I'm happy to look at all day long.
Mermaid as a format is amazing - so we built something beautiful on top of it. It's called Beautiful Mermaid
agents.craft.do/mermaid
































