In my opinion and that of the colleagues I've spoken with, working with Opus 5 feels like a downgrade compared to Opus 4.7, Opus 4.8, and Fable.

I'm not claiming a step backwards in capabilities – it is a more capable model than Opus 4.7 and Opus 4.8 and even rivals Fable in benchmarks, yet these other models feel better to work with. I believe this is because they:

• stop and ask questions if my intent was unclear,
• don't make assumptions without checking,
• and don't reinterpret or update my plans without asking.

Because of this, they don't require the careful babysitting that Opus 5 does.

Baseless speculation

I suspect this is the result of two compounding forces at Anthropic, and in current frontier labs in general.

First, the desire to create a self-improving AI that is capable of recursively bootstrapping itself to AGI/ASI.

Second, the pressure to score highly on benchmarks. Although it's an open secret that many benchmark tasks are ill-defined, unfair, hackable, or otherwise broken, a good benchmark task is self-contained. It can be solved. It doesn't require hints, reading the task creator's mind, or outside information to pass.

That doesn't mean a good task can only have one correct answer, just that it should score all unambiguously correct answers equally.

Selecting for models that do well on benchmarks (and indeed training for them or on RLVR tasks in general) inherently selects for models that make bold, usually-correct assumptions in the face of ambiguity. It penalizes models with a tendency to stop and ask for clarification or direction.

Unfortunately, that's exactly what most of us want from a coding agent.

Try as you might, it's nearly impossible to get the entirety of the context, intentions, business implications, budget constraints, and what-have-you written down and accessible to a coding agent. There will invariably be ambiguity and choices to be made, and it is nice to know that an agent will stop and ask when needed.

Real life just isn't a benchmark. There isn't a guaranteed right answer to every question, nor even a set of right answers, and with real-life consequences on the line, I do not want an agent taking its best guess!

Today we're excited to showcase HEIR, the latest powerful tool added to our Private Computing Toolkit. HEIR is an open source compiler that unlocks cryptographically-secure private AI inference.

Homomorphic encryption

As new benefits emerge with the growth of AI, balancing privacy and security is top of mind. Standard protections like end-to-end encryption present a trade-off: user-data can be protected from data breaches, but then the service provider cannot provide features that depend on the data, such as spam or virus detection. Critical sectors like healthcare and finance are even more averse to these risks, and strict regulations limit data sharing across institutions. Alternative mechanisms to provide the same features, like local processing, are limited by the capabilities of the local device and the sensitivity of the service provider's IP. Shipping proprietary AI to a device risks leaking the model.

A solution to these issues is homomorphic encryption, a rapidly maturing technology that fundamentally alters this trade-off by allowing computations to be performed directly on encrypted data. Servers can process ciphertexts and return encrypted results without exposing any underlying information. For example, a cloud service can provide content recommendations without being able to see the user's features. This is no exaggeration: one of the demos featured in this post does exactly this. But while homomorphic encryption has a nontrivial cost overhead, it shifts the capability/privacy trade-off to a question of cost. And the cost of homomorphic encryption is rapidly decreasing.

Google’s history of innovations in privacy technology—from differential privacy and private set membership to private information retrieval and secure enclaves on Google Cloud—has always focused on securing user data. Homomorphic encryption is another powerful tool we're adding to our private computing toolkit. Like private information retrieval, and in contrast to hardware-based solutions, homomorphic encryption's strong security and privacy guarantees are purely cryptographic. However, manually converting an existing program to use homomorphic encryption efficiently requires a team of cryptographers.

About HEIR

To overcome the usability challenges and advance the opportunity homomorphic encryption provides, researchers and engineers at Google built the HEIR compiler project. HEIR (Homomorphic Encryption Intermediate Representation) is an open-source compiler toolchain and development platform for homomorphic encryption. In particular, HEIR can convert pre-trained AI models that operate on unencrypted data to operate on encrypted inputs. Our vision is to make HEIR a one-click solution to enable non-experts to incorporate encrypted inference into production applications.

Since announcing our intentions in 2023, we’ve seen the homomorphic encryption community embrace HEIR. We have partnered with companies developing hardware accelerators for homomorphic encryption, including Belfort, Niobium, Cornami, and Optalysys. The fruits of those efforts are shown in our demos below, and we plan to demonstrate the latency benefits of these accelerators in the near future. HEIR has also become a productive research platform. By building on HEIR, cryptographers can focus on their specific optimization and use the existing infrastructure for testing, benchmarking, and comparisons. This has resulted in collaborations with Georgia Tech, Carnegie Mellon, UC Santa Barbara, Illinois Institute of Technology, Purdue, the University of Edinburgh, Tsinghua University, and others. To date, four peer-reviewed publications were built on HEIR, with more in preparation, and HEIR has accumulated numerous citations.

Applications of HEIR

To demonstrate how far homomorphic encryption has come, we’re sharing four private inference applications. Each application was compiled with HEIR, and latency numbers are presented for a single-threaded CPU. The source code for all examples is available in our GitHub repository.

• A Deep Learning Recommendation Model unlocks serving private content recommendations, joint work with Belfort Labs, LG, and New York University.
• Credit card fraud detection: Together with Niobium and hardshell.ai, we compiled a credit card fraud detector.
• Threat intrusion: Together with Niobium we compiled the Kitsune system for anomaly detection of encrypted network traffic. This allows a service provider to detect anomalies without revealing the contents of network packets to the service provider.
• Hotword Detector: Together with Belfort Labs we compiled a hotword detection model, which could allow an audio-triggered AI agent to recognize hotwords while protecting the privacy of the audio recordings.

As the software industry adapts to security and privacy changes amid AI, our research team is working to make homomorphic encryption, easy to develop, fast to run, and ubiquitous across industry.

Toast 1, our first specialised search agent, is available today. It provides frontier search quality, matching or outperforming Claude Opus 5 and GPT-5.6 Sol while being up to 10× cheaper and 12× faster. It performs best with Mixedbread Search, but it can work with any search backend.

Today, frontier models are now able to perform real knowledge work. They can reason, analyse, and find information in complex document collections. But they are also the most expensive models in the stack. As intelligence is increasingly metered, the need for specialised agents able to match their capabilities at a fraction of the cost is greater than ever.

Toast 1 can run as a standalone specialized retrieval agent, or as one of many subagents your frontier model already knows how to rely on. It fully takes over the search loop: given an initial query, it decomposes it into subqueries, gathers evidence, inspects sources, and curates the relevant context before returning it. This lets your agent spend its context and compute on the task that requires a generalist, frontier-level model: reasoning, acting, and producing the final answers.

Waterfall trace of a Toast 1 agentic search: 16 tool calls across 3 rounds answering an employment-rate comparison query in just over 5 seconds.

Pareto Optimal Search

This specialisation of agentic labor results in considerably cheaper search, but also in better end-to-end results on many realistic tasks. We found that Toast 1 establishes a new Pareto frontier across agentic workloads across cost per task and speed per task.

Financial Analysis: OfficeQA Pro V2

OfficeQA Pro V2, released by Databricks, evaluates answer correctness across 90 questions in realistic, complex enterprise financial situations.

GPT‑5.6 Sol with Toast 1 made available as a sub-agent within Codex reaches 70% answer correctness at approximately $1.15 per task: that is the highest score among the systems evaluated by Databricks in the OfficeQA v2 release, establishing new state-of-the-art performance in both quality and efficiency.

Scatter plot of answer correctness versus cost per rollout on OfficeQA Pro V2, log-scale cost. GPT-5.6 Sol running in Codex with Toast 1 as a sub-agent reaches 70 percent correctness at about $1.20 per task, above the previous Pareto frontier from the Databricks evaluation, where Claude Fable 5 on Databricks Genie reaches 60 percent at about $4.

Cost–quality Pareto on OfficeQA Pro V2

By comparison, the previous best performer, Claude Fable 5 on Databricks Genie, reaches 60% correctness at approximately $4 per task, while GPT-5.6 Sol within Codex without Toast 1 only reaches 33% correctness.

This improvement stems from reformulating the economics of evidence gathering. Toast 1's specialization allows it to produce high-quality, token-efficient evidence packages, leaving ample resources for the reasoning process to reach the final answer.

Legal Agentic Benchmark - Firm Knowledge

Harvey LAB's Law Firm Knowledge benchmark seeks to evaluate how well an agent can search and use institutional legal knowledge at large, realistic scales.

Legal work, by nature, is context-heavy. You cannot outargue someone with access to better, more relevant precedents and details. But it is also noisy: many situations are similar but vary by simple details, making it tricky to collect high quality evidence packages without numerous false positives.

On a randomly selected subset of 33 tasks,1 we found that GPT-5.6 Sol's answer quality remained constant across search methods.

Bar chart of total tokens used on the Harvey LAB firm-knowledge benchmark. A vanilla agent uses 80.6 million tokens at 21.7 turns per task. Adding Mixedbread Search cuts that by 42 percent to 47 million tokens at 14.6 turns per task. Adding Toast 1 as a subagent cuts it by another 51 percent to 23 million tokens at 11.2 turns per task. All three configurations reach the identical task score of 55, so the end result is the same performance with 3.5 times fewer tokens.

3.5× fewer tokens with the same performance.

However, increasing search quality drastically increased token efficiency: replacing the vanilla agent's filesystem search with Mixedbread Search cut token usage from 80.6M to 47M at an identical task score. Subsequently adding Toast 1 as its dedicated search subagent reduced it further to 23M, and allowed it to finish in half the turns required by vanilla agent.

The introduction of a Mixedbread Search-powered Toast 1 preserved answer quality, while consuming 3.5× fewer tokens, leading to a cost reduction of over 60%. Toast 1 frees up the context window of frontier models to let them spend their tokens on reaching the right answer.

Demo: Dig Deep Into Dwarkesh's Podcast

Benchmarks and numbers can only tell one part of the story. To truly understand how Toast 1 works, there is no better way than watching it search in action. At Mixedbread, we really enjoy Dwarkesh's podcast, and thought being able to search deep into its transcripts would be fun.

You can try it yourself here.

Frontier Class Retrieval

Although it is a capable subagent for complex tasks, Toast 1 is also a capable standalone model, trained specifically for deep search. It represents the next step of our co-design approach behind our embedding models and Silo: the model, agent harness, and retrieval primitives are designed to work together.2

Retrieval quality versus cost and latency per query on BrowseComp Plus, OfficeQA Pro, and LongSeal. Toast 1 matches or approaches the best frontier-model sweeps on each benchmark while costing a fraction per query and answering in about 8 to 10 seconds, far faster than the frontier sweeps.

On a variety of deep search benchmarks, it reaches frontier model performance, standing in the same league as GPT-5.6 Sol and comfortably outperforming models such as Kimi K3 or GLM-5.2.

It remains lightweight in doing so. A standard Toast 1 run costs approximately 0.016−0.016 - 0.016−0.023 per query and has an eight-second median latency. Our highest-quality fusion configuration costs approximately 0.05−0.05 - 0.05−0.07 per query and has an eleven-second median latency. In practice, among the systems in our evaluation that reached similar performance, Toast 1 was 7–11× cheaper and considerably faster: Frontier-model retrieval agents took between 20 seconds and four minutes on the same evaluation.

Availability and Pricing

Toast 1 is available immediately through the Mixedbread API at the discounted launch pricing:

• $0.30 per million input tokens
• $0.036 per million cached input tokens (cache writes are free)
• $0.72 per million output tokens

Mixedbread search invoked by Toast 1 is priced at a special rate.

With Your Existing Retrieval Stack

Toast 1 was co-designed with Mixedbread Search's primitives and will be at its strongest performance with it. But we put special care in ensuring that it remains backend agnostic: it can run over your existing retrieval indexes, and does not require migrating your existing backend. We conducted thorough testing to ensure that Toast 1 remains competitive with the performance of frontier models in similar conditions at a fraction of the cost and latency, no matter the provided index.

You can use Toast 1 with our Chat Completions API and add it as a retrieval tool to your existing agentic workflows in just a few minutes. Here is a golden harness you can use directly.

With Coding Agents

Let your coding agents handle the integration with npx skills add mixedbread-ai/skills. Or use Toast 1 directly as a subagent with our OpenCode integration.

With Your Mixedbread Stores

from mixedbread import Mixedbread

client = Mixedbread()

results = client.stores.search(
    store_identifiers=["legal-documents"],
    query="does the MSA allow assignment on a change of control?",
    search_options={
        "agentic": True,  # enable Toast 1
    },
)

Get an API key with $5 in included credits to try it out.

Footnotes

1. We evaluated a randomly selected subset of 33 tasks to make repeated comparative runs tractable. Every configuration used the same tasks and evaluation setup; only the retrieval stack changed.
2. Toast 1 is part of a growing body of work on specialised search agents, alongside SID-1 and Chroma's Context-1. While each takes a different approach, they share the goal of bringing frontier-level retrieval to production at lower cost and latency.

I’m coming down from spending a few days at Usenix Security, right here in my hometown of Baltimore. This means that my days have been taken up with two kinds of conversation: first, explaining to colleagues why Baltimore isn’t actually like The Wire. And second, trying not to talk about AI.

Here I’m going to break that second rule.

I have many worries about what AI means for our field, for various definitions of “field”. But in this post I want to focus on just one thing I’ve started worrying about, and it’s a perverse thing: specifically, I’m concerned that AI is going to make software much too secure.

While that doesn’t sound so bad on the surface, there’s a consequence to this. I mean something very specific: I’m concerned that U.S. intelligence and law enforcement agencies are about to go dark, meaning: that they’re going to suddenly lose a huge portion of their capability. And that this isn’t going to be simply a problem for those agencies, but also for those of us who value computer security and privacy in general.

Going Dark, and the era of law enforcement hacking

To explain how we got here, we need to talk about recent history. This actually gives me a real excuse to reference The Wire, just because it’s a perfect snapshot of what electronic surveillance looked like way back in 2002. If you’ve seen the first season, you’ll recall that it’s about cops wiretapping drug dealers who use payphones and burners. The mobile phones in the show are relatively new technology for the time, but from a technological perspective nothing in this scenario would have shocked a cop who jumped forward from, say, 1989.

In less than a decade from the premier, everything in those episodes became totally quaint.

The change began in the late 2000s, thanks to the rise of smartphones and texting. Because smartphones can actually store data as well as conveying it, the contents of those phones quickly became a useful new source of law-enforcement capability. Or they were until 2010, when Apple began encrypting iPhone storage using a key derived from the user’s passcode (Android phones followed shortly thereafter.) The next year, Apple deployed end-to-end encryption in iPhone text messages. By 2014, a tiny texting startup named WhatsApp had gathered 600 million users worldwide. By 2016 those users, now nearly a billion strong, were all using default end-to-end encrypted messaging and calls. These two trends — the move from calls to texts, and texts to encrypted data — happened very rapidly. The chart below gives one view of the transition:

The FBI and law enforcement agencies were not insensitive to what was happening. In 2014, Director Comey announced an initiative called Going Dark, which would launch a “national conversation” about what providers could do — or be compelled to do — to make these new communications media legible to law enforcement and counterintelligence.

In 2016, the agency quit talking and took their theory to court. When a terrorist attack left the FBI holding a shooter’s locked iPhone, the agency ordered Apple to give them access. The company refused. What broke the stalemate — and, to some extent, ended “Going Dark” itself — was something that neither the FBI nor Apple expected. An outside company announced that there was no need for Apple’s assistance: they could simply hack the phone.

The Apple v. FBI case turned out to be microcosm of the whole Going Dark debate. For the next decade, law enforcement and intelligence agencies continued to ask for “exceptional access” backdoors. But the urgency was gone: both agencies and manufacturers knew that law enforcement could purchase targeted hacking tools like GrayKey (for phone unlocking), or even remote exploitation tools like NSO Group’s Pegasus, assuming they needed them badly enough. Vendors like Apple and Google played a vigorous defense, closing vulnerabilities as soon as they learned about them. But offensive vulnerability hunters consistently managed to keep the edge.

And now there’s a very good chance that all this is about to be history.

The era of AI bug hunting is here

This April (just four months ago!) Anthropic announced a new model called Mythos that happened to be unusually skilled at software vulnerability finding. The U.S. government temporarily blocked its export, restricting access to U.S. agencies and trusted vendors. While the ban was dramatic and made for good PR, it turned out to be mostly pointless. OpenAI, along with Chinese open-weight model labs like Z.ai and Moonshot, have since demonstrated that vulnerability finding isn’t something that a single lab is likely to hold a monopoly on. The list of serious vulnerabilities that these models have found is getting scarier (or more impressive) by the day.

At first glance, this might seems like good news for the offensive team, and for hackers in general. But I doubt that’s how this will play out in the long term. Defenders are now in the process of patching every bug they can find — often decades worth of bugs — and the backlog feels huge. But they’re making progress. Entire CI toolchains are being rebuilt to incorporate AI-based vulnerability scanning before software ever reaches the point where a human will touch it. While I doubt this means that every bug will be found (even calculating the number of bugs in a piece of code is probably uncomputable), in the real world, it does feel likely that we’re going to hit some sort of a ceiling on the number of useful bugs, and probably we’ll hit it soon.

Thus: over the next two years, major pieces of software are likely to run out of remotely-exploitable bugs.

Obviously I think this is great. But for law enforcement and offensive intelligence agencies, it’s going to be a nightmare. For the first time since 2010, law enforcement might experience what it looks like to really “go dark”, across a huge category of advanced (well-maintained) devices and pieces of software.

So how is this a problem?

The debate over “exceptional access” mechanisms never really went away. In some places, like the UK, it even metastasized into something worse. Here in the US it mostly went into hibernation. Some of the slowdown can legitimately be attributed to expert pushback — academics and industry engineers pointing out the risk that backdoors might be abused by the very adversaries that Agencies are supposed to be protecting us against. But I fear that this was less of a principled pause, and more of a market that was just pricing supply.

The destruction of the low-hanging vulnerability fruit will make law enforcement (and intelligence) agencies’ need much more acute. The demand for constructed, intentional backdoors will re-start in earnest. The result will be enormous pressure on industry to re-architect their systems to make their systems amenable to exceptional access. In some cases, governments will ask for these capabilities in the expectation that they’ll be useful for spying on other governments — a strategy that might have been undetectable in the pre-AI era, but that probably will be less productive now. The results are unpredictable. One result might be that non-US governments entirely remove their dependence on US software.

The worst part about this dynamic is that these potential new backdoors will probably only affect the countries that demand them, meaning that they will be primarily useful for allowing the US to weaken its own systems. This will in turn allow foreign adversaries to find new ways to attack our communications. This deliberate self-sabotage will happen just at a moment when we’re finally getting a handle on securing our own infrastructure.

So what do we do about it?

I honestly have no idea. This is not a call to action for experts to rally behind a sophisticated plan. Like so many things about the AI revolution, it’s just occurring to me that we’re on a long greasy slide to a place that will look different than where we are today. Just realizing this doesn’t mean that I have a clever plan to avoid it. In this case, we’re just going to have to hope that this time we make the right choices, for no other reason than that they’re right.

A new home for the infrastructure Bluesky runs on the open network — including Jetstream v2 with network replay, a new Jetstream SDK, and a lex-based TypeScript SDK

Today we’re launching Bluesky Protocol Services: a new brand, and a new website, for the public infrastructure Bluesky operates on the AT Protocol network.

Bluesky has always run more than the Bluesky app. We operate Jetstream instances, relays, and the Bluesky API endpoints built on atproto. But if you were a developer trying to build on that infrastructure, our docs didn’t always make it easy to tell what we run as a service or where to start. We’re fixing that today. Bluesky Protocol Services organizes all the documentation developers need within the ecosystem, clarifies the service contracts around Bluesky-provided infrastructure, replaces the old docs.bsky.app site and gives us a clean way to ship future releases like the ones in this post!

Jetstream v2: Network Replay

The headline release shipping alongside the new site is Jetstream v2. Jetstream is the best way for most developers to use the network at scale: you describe the slice you want, and it arrives as plain JSON over a WebSocket. What it couldn’t give you was history. If you needed the records that already existed on the network, you had to backfill repos yourself then cut over to the live stream.

Jetstream v2 adds that capability to the server. It keeps a compressed archive of the whole network and adds a new way to consume it, alongside the live tail:

Network Replay lets you catch up from any point in the past and cut over to live with no gap. You POST your filters to planSnapshot, download the sealed segments it returns over plain HTTP, then connect the live WebSocket once at the tip. Replay is stateless on the server, with no per-consumer cursor, no subscription to register, and nothing to stage on the client. Jetstream is your buffer. You can also just snapshot the network — a point-in-time copy of the archive over HTTP only (listSegments + getSegment), with no live tail. Same archive, same filters, no WebSocket.

This unlocks much more sophisticated server-side slicing without ever backfilling locally: you can spin up an App, run an analysis over a month of posts, or recover from downtime, all through the same JSON shape as the live tail.

Serving these archives is bandwidth-intensive. To ensure the service remains reliable and cheap to run, we’re now requiring an API token just for these requests. The live tail remains open and unauthenticated, it’s only when you request an archive that we require a token. We have no plans to introduce an auth requirement for the live stream.

The v2 instances are live now at wss://jetstream.us-west.bsky.network and wss://jetstream.us-east.bsky.network. The existing v1 instances will keep running unchanged for a while, and the live tail behaves identically on both, so there’s no rush to move. Read the full flow in the Network Replay docs.

And! As always, this infrastructure is open source and self-hostable. See Running your own Jetstream for details.

A Jetstream SDK

Jetstream is plain JSON, so you never need an SDK. But there’s some common glue: reconnecting, deduping, cursor management, decoding events into typed records. Hence, the new Jetstream SDKs: TypeScript and Go clients where you construct a Jetstream object, pass a filter, and for await over decoded, typed events:

import { Jetstream } from '@bsky/jetstream'
import { app } from '@bsky/sdk/lexicons'

const js = new Jetstream('https://jetstream.us-east.bsky.network')

for await (const evt of js.live({ collections: [app.bsky.feed.post] })) {
  if (evt.kind === 'commit' && evt.commit.operation === 'create') {
    console.log(evt.commit.collection, evt.commit.record.text)
  }
}

The TypeScript SDK is available from npm, including npmx.

The Go SDK is available as part of the Jetstream project.

The Jetstream SDK docs go into more detail.

The Bluesky TypeScript SDK, rebased on lex

Back in May we promoted the lex SDK to stable preview and promised that the standalone Bluesky docs would follow. That’s now done: the Bluesky TypeScript SDK is rebuilt on top of @atproto/lex, which means we’re no longer maintaining legacy code paths for Bluesky-specific helpers. This is the lexicon toolchain, fully typed end to end, from the protocol layer up through app.bsky records.

Every TypeScript example on this new site is written against it, marking a huge move away from legacy technical debt—this is good code hygiene for us, and should eliminate LLM recommendations for deprecated SDKs. If you’re still using @atproto/api code, it continues to work as before, and the Bluesky API guides serve as a migration reference.

Updates to endpoints.bsky.app

Finally, the HTTP reference has been updated. Spinning those docs out of https://docs.bsky.app was actually step 1 of this overhaul; we’re now landing the remainder.

The new network.bsky.jetstream.* methods that power Replay — planBackfill, listSegments, getSegment, and getBlock — are now browsable with full request and response schemas, and the reference now documents Jetstream’s WebSocket endpoints too, so the entire Jetstream v2 surface lives in one place.

What’s next

Everything above is live today: the new site, the v2 Jetstream instances, the SDK preview, and the updated HTTP reference. If you’re new to the network, start with How It Works, a visual walkthrough of how records, lexicons, and the firehose fit together. If you’re building against the Bluesky app’s data model, the Bluesky API guides are all still there, freshly rewritten (more on that below)

If you build something on Replay in the next few weeks, we’d love to hear about it; the fastest way to shape where the SDK’s orchestration goes is to show us what you’re folding the stream into.

Using LLMs to classify products, search queries, etc is by now boring. Yet it can still be difficult to constrains the LLM’s output to the legal vocabulary of brands, colors, categories, etc your system allows.

In the Wayfair WANDS e-commerce dataset, for example, you want to classify a query like “wood coffee table” into its most appropriate category. Of which there are hundreds:

Furniture / Office Furniture / Desks
Furniture / Living Room Furniture / Coffee Tables & End Tables / Coffee Tables
Furniture / Living Room Furniture / Coffee Tables & End Tables / End & Side Tables
Décor & Pillows / Decorative Pillows & Blankets / Throw Pillows
Furniture / Bedroom Furniture / Dressers & Chests

The classic way to implement this would be with structured outputs. You tell your provide it must constrain its outputs to a list of legal values. In Pydantic, you create a giant literal of legal output values:

from typing import Literal
from pydantic import BaseModel, Field

FullyQualifiedClassifications = Literal[
 'Furniture / Bedroom Furniture / Beds & Headboards / Beds',
 'Furniture / Living Room Furniture / Chairs & Seating / Accent Chairs',
 'Rugs / Area Rugs',
  ...
  # times 500
]

class QueryClassification(BaseModel):
    """
    Structured representation of a search query for furniture e-commerce.
    Inherits keywords from the base Query model and adds category and sub-category.
    """
    classifications: list[FullyQualifiedClassifications] = Field(
        description="A possible classification for the product."
    )

response = client.responses.parse(
    model="gpt-5.4-mini",
    input="Classify the query: brown coffee table",
    text_format=QueryClassification,
)

print(response.output_parsed.message)
# Outputs: Furniture / Living Room Furniture / Coffee Tables & End Tables / Coffee Tables

This works. But there’s a way to do this a lot cheaper with small / dumb models at scale. Not to mention, there’s an upper limit you can send

Luckily, there’s an easy pattern that makes LLM classification pretty seamless.

Just ask a dumb LLM to invent plausible, fake classifications for your query:

hallucination_prompt = f"""
Your task is to create novel, never seen before, furniture, home goods, or hardware classification that best fit a search query. 

Product classifications might look like:

Furniture / Living Room Furniture / Coffee Tables & End Tables / Coffee Tables
Décor & Pillows / Decorative Pillows & Blankets / Throw Pillows
Furniture / Bedroom Furniture / Dressers & Chests
Kitchen & Tabletop / Kitchen Organization / Food Storage & Canisters
School Furniture and Supplies / School Furniture / School Chairs & Seating / Stackable Chairs
Baby & Kids / Toddler & Kids Bedroom Furniture / Kids Beds

Here's the query to generate classifications for:

brown coffee table

Now we’re not sending the list of legal classifications. We’re instead, asking the LLM to make stuff up:

response = client.responses.parse(
    model="gpt-5.4-mini",
    input=hallucination_prompt,
    text_format=list[str],
)

It’ll then make up some BS that doesn’t actually exist in your real taxonomy like:

Furniture / Living Room / Tables / Coffee

Well that’s not very helpful.

Actually it’s extremely helpful. You can now resolve that into the real vocabulary.

It’s very cheap to build an in-memory set of embeddings of the REAL classifications. As I’ve done in this notebook and this utility.

In the notebook, I compute a MiniLM embedding of every real Wayfair classification. I compute the embedding of the fake, hypothetical embedding from the LLM. I then dot product the fake embedding into the real ones to find the most similar. Producing:

Furniture / Living Room Furniture / Coffee Tables & End Tables / Coffee Tables

You can give these hallucination tasks to dumb / cheap LLMs. And you don’t need to ship the schema over to the LLM every time.

A deep-research agent with an enforced budget, verified quotes, and a privacy boundary for local data.

Ask a question. mole decomposes it, searches, reads sources, extracts claims, checks each claim against the text it came from, looks for contradictions between them, and writes an answer with citations. Every model call is reserved against a budget before it happens and settled after, so the ceiling you set is the ceiling it hits.

It runs as a single static binary on your machine, uses your own API keys, and speaks MCP so a coding agent can drive it — either by handing mole a question and collecting the answer, or, in toolkit mode, by doing the reasoning with its own model while mole supplies the parts that are not model calls.

---

Why mole

Three things mole does that a chat interface with web search does not.

The budget is enforced, not estimated. Every call is reserved before it is made and settled after, against a ledger with non-negative constraints in the database schema itself. --usd 0.50 means the run stops at fifty cents. Measured overshoot across the test corpus is 0%.

Every claim carries a quote, checked against the source. A claim whose quote does not appear verbatim in the page it was mined from is discarded at extraction, before it can reach an answer. Claims that survive can be re-read against their source afterwards, and one that turns out not to be supported is marked as such in the report rather than quietly dropped.

Your local data stays local. Point mole at a CSV or a folder and it will analyse it without the contents leaving your machine: the model chooses a hypothesis template and column names, mole renders and runs the SQL, and only aggregates — counts, means, test results, buckets covering at least five records — are allowed back. mole crossings shows you exactly what left.

---

Install

Script — Linux and macOS, amd64 and arm64:

curl -fsSL https://raw.githubusercontent.com/lajosdeme/mole/main/install.sh | sh

Downloads the release archive for your platform, verifies its SHA-256 against the checksums published with the release, and installs mole and mole-mcp into ~/.local/bin (or /usr/local/bin if that is writable). It uses sudo only if the target directory needs it, and --dry-run shows what it would do. If piping a script into a shell makes you uneasy — reasonable — read it first, or use one of the paths below.

Homebrew — macOS and Linux:

brew install lajosdeme/mole/mole

Fully qualified, and it has to be: an unrelated mole (a macOS cleanup tool) is in homebrew/core, so brew install mole will always mean that one. Both install a binary called mole, so only one can be linked at a time.

Arch Linux — from the AUR:

yay -S mole-research-bin      # prebuilt release binaries
yay -S mole-research          # build from source

Not mole: that name and mole-bin on the AUR belong to an SSH tunnelling tool that has held them since 2020. The package installs /usr/bin/mole and declares the conflict, so pacman will tell you rather than overwrite anything.

Debian and Ubuntu — .deb from the releases page:

curl -fsSLO https://github.com/lajosdeme/mole/releases/latest/download/mole_amd64.deb
sudo dpkg -i mole_amd64.deb

An .rpm is published for the same platforms.

From source — needs Go 1.25+:

go install github.com/lajosdeme/mole/cmd/mole@latest
go install github.com/lajosdeme/mole/cmd/mole-mcp@latest

Or clone and make install, which stamps the version so mole version reports the tag rather than dev.

Every path installs the same thing: two static binaries with no runtime dependencies, built CGO_ENABLED=0. The database is SQLite, created on first use under your XDG data directory.

Configure

You need a search provider and a model provider. Keys live in ~/.config/mole/config.json, mode 0600 — never in environment variables that leak into process listings, and never in .mcp.json.

mole config set search.provider tavily          # or: brave
mole config set search.tavily-key tvly-...

mole config set llm.provider anthropic          # or: openai-compatible
mole config set llm.api-key sk-...
mole config set llm.model claude-sonnet-5
mole config set llm.cheap-model claude-haiku-4-5

mole doctor                                     # verify everything above

Any OpenAI-compatible endpoint works — DeepSeek, Ollama, llama.cpp, vLLM, a proxy:

mole config set llm.provider openai-compatible
mole config set llm.base-url https://api.deepseek.com/v1
mole config set llm.model deepseek-chat

A model served from localhost is priced at zero and still counted in tokens, so --tokens bounds a self-hosted run that costs no money at all.

---

Usage

Research a question

mole research "how much electricity does the bitcoin network use?" --usd 0.50
mole research "..." --tokens 200000            # token budget instead of dollars
mole research "..." --max-sources 8 --max-depth 3
mole research "..." --json                      # machine-readable result

Budget is required, and the two units are mutually exclusive. Only dollar mode can price a search call; only token mode can bound a model whose rates mole does not know.

Ask a follow-up

mole ask <session-id> "what did the Cambridge estimate say?"

Answers from the claims that session already collected. No new searching, no new spending beyond the one call to phrase the answer.

Build a dataset instead of prose

mole research "largest UK supermarket chains and their revenue" \
  --mode dataset \
  --schema 'company:text!,revenue:number=annual revenue in GBP,employees:number' \
  --usd 0.50

mole dataset <session-id> --format csv > chains.csv
mole dataset <session-id> --format json          # every value every source gave

! marks the field that identifies a row. Rows are merged across sources by fuzzy key, so Aldi and Aldi UK become one row with two sources. CSV holds one value per cell and says so — it carries a source count and a contested column naming the fields the sources disagree about. JSON carries every disagreeing value with the sources behind each.

Analyse local data

mole connect add sales ./exports/sales.csv       # one file
mole connect add exports ./exports               # or a whole folder
mole research "how does spend differ between regions?" \
  --actors local_compute --usd 0.30

mole crossings <session-id>                      # what left the machine

CSV, TSV, JSON and JSONL are supported; Parquet is not. The model never sees a row and never writes SQL — it picks a template and column names, and mole renders the statement.

Serve MCP clients

mole serve

Listens on a unix socket, mode 0600, in a private directory, and refuses connections from any other user. Point a client at the shim:

{
  "mcpServers": {
    "mole": { "command": "mole-mcp" }
  }
}

No credentials in that file — the shim forwards to the daemon, which holds them.

Use the subscription you already pay for (toolkit mode)

mole serve --toolkit

The arrangement above has mole own the model: it plans, mines and writes with your API key, and the coding agent driving it is pressing a button. Toolkit mode inverts that. The agent's model does the reasoning; mole contributes the deterministic half — which is the half worth having, and the half that does not care whose model is on the other side of it.

If you are inside Claude Code or Qwen Code on a subscription, your model tokens are already paid for. This is the mode for that.

Fourteen tools, each named mole.<tool>, alongside the research.* tools — the flag adds a surface rather than replacing one:

• session session_open, session_close
• retrieval search, fetch — through mole's SSRF guard, robots handling and rate limiter
• evidence verify_quote, claim_add, claims_list, citations
• local data connect_list, aggregate — the privacy boundary, unchanged
• graph pairs_candidates, edge_add
• dataset rows_add, dataset

Inspect a run

mole sessions                # recent sessions and what they cost
mole trace <session-id>      # per-call cost and timing breakdown
mole stats --fetch           # why fetches failed, across sessions

---

How it works

question
   ↓  planner            decompose into sub-questions, replan as evidence arrives
   ↓  executor           one lead at a time per worker, reserved and settled
   ↓  actor              search → fetch → extract → mine claims
   ↓                     every claim quote-checked against its source
   ↓  verifier           pair up related claims, adjudicate, build the claim graph
   ↓                     re-read a sample of claims against their sources
   ↓  output             synthesise from claims that survived, with citations
answer

Three actor types feed the same graph. web searches and reads pages. academic queries Crossref, OpenAlex, arXiv and PubMed, deduplicates by DOI and prefers open-access full text. local_compute runs deterministic SQL over data you registered and never lets a row reach the model.

Toolkit mode runs the same machinery with the arrows reversed: the agent decides what to search, what to read and which claims relate, and mole does the quote checking, the pair retrieval, the merging and the SQL rendering. Both modes share one copy of each — the same AcceptRow for dataset rows, the same aggregation gate, the same lexical retriever — so a toolkit graph and an autonomous one are built the same way.

---

Honest numbers

mole grades its own runs. mole eval <session-id> prints a scorecard, and any metric it cannot compute says so instead of quietly reading zero.

budget overshoot 0% — no run has exceeded its ceiling
claim integrity 100% — every stored claim carries a source and a verbatim quote
citation accuracy 100% — every quote found in the source it cites
grounding rate 80% — of claims re-read against their source, confirmed
contradiction precision 70% with the confirm pass, 51% without
merge precision / recall 1.000 / 1.000 on constructed ground truth

---

Contributing

Bug reports and issues are welcome. Code contributions go through a CLA — see CONTRIBUTING.md, which explains what it is for and what it cannot do.

Maintainers: the release runbook is RELEASING.md.

The one practice this project asks for that most do not: falsify your own fix. After a change, revert the mechanism and confirm the test fails. A test that passes with the fix removed proves nothing, and several of this project's own tests have been caught doing exactly that.

gofmt -l .      # must print nothing
go build ./...
go test ./...   # must be clean, and no new skips

Licence

Apache-2.0. See LICENSE and NOTICE.

Scriptable CAD with Lua. Write parametric 2D and 3D models in Lua and export them to 3MF, STL, OBJ, PLY, OFF, AMF, or SCAD, or render them straight to a PNG.

LuaCAD embeds Lua 5.4 in a Rust engine that evaluates CSG operations directly (via Manifold) or generates OpenSCAD code for external rendering.

Why Lua?

• Similar syntax as the OpenSCAD language, but better:

  • More powerful
  • More consistent
  • Faster
  • Easily embeddable

• Operator overloading for natural CSG syntax (a + b, a - b, a * b)

• Already used in other CAD software like LibreCAD and Autodesk Netfabb

Example

LuaCAD:

my_cube = cube { size = { 1, 2, 3 } }

function my_sphere(radius)
  return sphere({ r = radius }):translate(5, 0, 0)
end

model = my_cube + my_sphere(2)

render(model)

Equivalent OpenSCAD:

module my_cube() {
  cube(size=[1,2,3]);
}

module my_sphere(radius) {
  translate([5,0,0]) sphere(r = radius);
}

union() {
  my_cube();
  my_sphere(2);
}

Getting Started

cargo install luacad         # CLI for running and converting LuaCAD scripts
cargo install luacad-studio  # GUI desktop app with live 3D preview

Or from source, which requires Rust:

git clone https://github.com/ad-si/LuaCAD.git
cd LuaCAD
make install

Both crates vendor their C/C++ dependencies, so no system libraries need to be installed — but a C++ compiler and CMake must be available to build them. luacad builds Manifold and Clipper2; luacad-studio additionally builds OpenCSG, which needs OpenGL development headers (on Debian/Ubuntu: libgl1-mesa-dev, libx11-dev, libxcb1-dev, libxkbcommon-dev, libxrandr-dev, libwayland-dev).

CLI Usage

luacad convert model.lua output.3mf   # Convert to 3MF
luacad convert model.lua output.stl   # Convert to STL
luacad convert model.lua output.scad  # Export as OpenSCAD
luacad watch model.lua output.3mf     # Rebuild on file changes
luacad render model.lua preview.png   # Render to a PNG image
luacad info model.lua                 # Print triangle counts and bounding box
luacad lint model.lua                 # Lint with selene (also takes directories)
luacad run model.lua                  # Execute (side-effects only)

convert and watch infer the format from the output extension; --format <fmt> overrides it, and --via-openscad hands the export to an installed OpenSCAD binary instead of building the mesh with Manifold.

BOSL2

LuaCAD has full support for the Belfry OpenSCAD Library v2, reimplemented in LuaCAD itself, so it renders, previews and exports to a mesh without OpenSCAD or BOSL2 installed:

bosl.cuboid { {40, 40, 40}, rounding = 2 }
bosl.regular_prism { 5, r = 10, h = 25 }
bosl.spur_gear { circ_pitch = 5, teeth = 20, thickness = 5 }

Exporting to .scad still writes the BOSL2 call itself, which keeps the exported file as short as the script that produced it.

Text and Imports

text() outlines a system font into a sketch and text3d() extrudes it in one step, so text becomes real geometry rather than SCAD output:

render(text("LuaCAD", { size = 12, halign = "center" }):linear_extrude(2))

import() reads every mesh format LuaCAD writes and returns a solid you can transform and combine like any primitive; SVG and DXF return a 2D sketch instead, ready to extrude.

Supported Export Formats

• SCAD - OpenSCAD format
• 3MF - 3D Manufacturing Format
• STL - Standard Triangle Language for 3D printing
• OBJ - Wavefront 3D object format
• PLY - Polygon File Format
• OFF - Object File Format
• AMF - Additive Manufacturing File Format

Every value your script returns becomes its own 3MF object, so slicers load them as individually movable parts. Label them with :name(…) to control how they appear in the object list. The other formats cannot express separate objects, so they flatten everything into a single mesh.

For more information, check out the GitHub Repository

rbr_ss22 rbr_ss3 rbr_ss1

Video of an example game made with the engine

ArcadeMaker is a simple 2D cross‑platform game engine that includes its own programming language (its prototype is called Exp) and an integrated IDE.
The engine and IDE themselves are written in C#, but the language you use inside ArcadeMaker to program your games is my custom language, not C#.

Currently, the graphics and audio backend is powered by MonoGame, which allows exporting to desktop, mobile, and consoles. I’m also planning to add a KNI-engine implementation to enable web support.

This project is not finished yet.
But since I have very little time to work on it, I decided to open‑source it in the hope that others will find it interesting and help turn it into something real.

ArcadeMaker is based on GameMaker 8, so if you’ve ever used it, you’ll find it very easy to learn.

---

Project Background

ArcadeMaker has been built in several stages over the span of a few years, and different parts of it were written at very different points in my programming journey.

• The IDE was written about three years ago, when my programming skills were very different from what they are today.
• The Exp language was created after the IDE, but still before the current core engine and before the MonoGame implementation existed.

Originally, ArcadeMaker started as a C#‑based engine where users wrote their game logic directly in C#. After leaving the project for a while, I eventually created my own programming language and decided to return to ArcadeMaker — replacing the old C# scripting layer with my language and rewriting the core engine around it.

Because of this long, staggered development history, the IDE currently includes many features that the new engine backend does not yet support. For example:

• Parent objects — supported in the IDE, not yet implemented in the engine.
• Dll package manager - exists in the IDE, but currently has no any effect (it had when the engine used C# for scripting).

The long‑term goal is to bring the new engine up to feature parity with the old C# version — and then expand far beyond it.

---

Planned Features

• Full implementation of the missing IDE features in the engine
• KNI-engine backend for web export
• A more complete and stable version of the Exp language
• Implementing all the common, daily‑use game functions such as drawRect(), deactivateInstancesInRegion(), setRoomWidth(), and many more
• Cross‑platform templates for mobile and console builds
• Documentation, tutorials, and example projects

---

Why Open Source?

I love working on ArcadeMaker, but I don’t have enough time to develop it at the pace it deserves.
By open‑sourcing it, I hope others will:

• Experiment with the engine
• Improve the language and tooling
• Add missing features
• Fix bugs
• Help shape the future of the project

If you enjoy GameMaker‑style workflows or want to contribute to a lightweight, beginner‑friendly 2D engine, you’re more than welcome to join.

---

How to Build

1. Clone the repository.
2. Open the solution in your preferred C# IDE (Visual Studio, Rider, or VS Code).
3. Restore NuGet packages.
4. Build the project.
5. Run the IDE project to start ArcadeMaker.
6. (Optionally) - After the IDE is loaded, go to "File -> Open Project" to load an example project from "tests/Example Projects".

---

Contributing

Contributions of all kinds are appreciated:

• Code improvements
• Bug fixes
• Documentation
• Feature proposals
• Engine backend implementations
• Language design ideas

Before submitting a pull request, please open an issue to discuss your idea. Currently I'm only one dev working on this project alone in my free time, so documentation is really, really missing. I'll try do my best to improve it, but please feel free to ask any question you have about anything related to the project, I'll answer to anything!

---

License

This project is licensed under the MIT License.
See the LICENSE file for details.

---

Note About This README and AI Usage

I used GPT to help write this README file.

And since AI is mentioned, a few words about it:
This project contains almost 0% AI‑generated code or architecture. The only exception is that I used Claude to write the Separating Axis Theorem formulas for collision detection, because that math is a bit too heavy for me. Other than that, everything — the engine, the IDE, the language, the architecture — is hand‑written.

Not because there’s anything wrong with using AI as a programming tool. I know it’s a huge part of the future of software development.
It’s just that I built this project for fun and for the challenge, and personally I enjoy writing the code myself rather than having a machine do it for me.

In the era of AI and its growing power, I still believe a complete version of this project could be genuinely useful. ArcadeMaker is a beginner‑friendly engine, and people will always need to understand how code works, even if they eventually stop writing every line by hand. The only real way to learn that is by actually writing code.
And beyond learning, this engine can also be a great tool for anyone who simply wants to make games for fun, by themselves, without relying on AI to do all the work.

combined ultraviolet and visible light

visible light

ultraviolet

The irridescent display feathers of Anna's hummingbird reflect red and ultraviolet light, giving them a hidden dimension of color that is not visible to humans. The main photo represents what birds might see. It's a combination of the ultraviolet and visible light images. Unlike Anna's hummingbird, the ruby throated hummingbird throat feathers do not reflect UV light. The presence or absence of UV reflectance might help hummingbirds recognize their own species.

Here are all of the captions from the slides shown above:

The irridescent display feathers of Anna's hummingbird reflect red and ultraviolet light, giving them a hidden dimension of color that is not visible to humans. The main photo represents what birds might see. It's a combination of the ultraviolet and visible light images. Unlike Anna's hummingbird, the ruby throated hummingbird throat feathers do not reflect UV light. The presence or absence of UV reflectance might help hummingbirds recognize their own species.

The flamingo also reflects UV light. As with the hummingbird, the combination of red and UV shows up as purple in the main photo. Read the "about" link above for an explanation of how this works. Unlike the flamingo, the red on this blackbird appears dark in the UV photo. The blackbird has different red pigments, which absorb more UV light.

The same thing happens with yellow pigments in birds. The yellow belly of the plush-crested jay reflects ultraviolet, causing it to show up as pink in the combined photo. But not all yellows are the same. The eye also appears yellow to us, but in the UV photo it's totally dark (except for the highlight). Birds would see the eye and the belly feathers as two different colors!

This is an alternative presentation of the plush-crested jay, in which I have used a pattern of dots to indicate which areas are reflecting ultraviolet light. This makes it possible to show the UV information, without altering the visible light colors.

In contrast to the plush-crested jay, the yellow on this toucan appears quite dark in the ultraviolet. This is indicated by the lack of pink color in the combined photo. The bare skin around the eye has some UV reflectance.

This photo shows hidden UV coloration in both the chicory flower and the goldfinch. The back of the bird is more UV reflective, compared with the cheek and belly.

Blue color in birds is caused by the microscopic structure of the feathers, instead of blue pigments. In most cases, like this western bluebird, the UV reflectance follows the same pattern as the blue light reflectance. The indigo bunting is another example.

The blue-bellied roller is an exception. It has three different shades of blue, and the very dark blue of the belly is quite bright in the ultraviolet. The blue back of this trogon doesn't reflect much UV, causing it to appear green in the combined photo.

White feathers always reflect UV. Black or brown feathers are always UV-dark. The striking black and white pattern of the red-bellied woodpecker is exactly the same in ultraviolet or visible light.

In this green-winged macaw, the beak and the facial skin both look almost white, to the human eye, but the beak does not reflect as much ultraviolet light. Birds will likely perceive two different colors. The common parakeet or budgie has some interesting UV features. There is a small UV reflective patch on the chin, which appears dark violet to humans. Notice also, unlike most yellow birds, the yellow feathers on the head of the parakeet strongly absorb ultraviolet light.

The bookshelf by my elbow, the one that I can reach without getting up, has seven books on it, not necessarily the ones I look in the most, but the ones whose emanations I most hope will infuse me as I write.

Roget's Thesaurus (4th edition)

The one I actually refer to most often is the Harper and Row Roget's Thesaurus. I thought I had acquired this in my teens, but the note on the flyleaf says 1989.

This is the fourth edition. I was very excited to get the eighth edition, which I thought I might like better, and for some time I kept them next to each other so that I could look up the same things in both, and compare. my conclusion was that while the eighth edition had more stuff in it, it wasn't stuff I needed. And it is really fat. So I have retired it to a farther shelf and will eventually get rid of it.

The thesaurus is a book that is widely misunderstood. It is not, as many people mockingly imagine, just a compendium of synonyms, and its correct and intended use is not to replace common words with more impressive-sounding ones. just as the correct use of a screwdriver is not to scrape the veneer off of an expensive cabinet.

“Thesaurus” means “storehouse" or “treasure room”. Roget's idea, similar to that of John Wilkins before him, was to classify everything in the world into a hierarchy, in this case a hierarchy with a thousand divisions. At the top level the divisions are grouped into "Abstract concepts", "Space”, “Physics”, “Matter”, “Sensation” and so on. Then under “abstract concepts” there are subclasses, of which subclass VI is “Time”, subdivided into five smaller sections:

A. Absolute time
B. Relative time
C. Time with reference to age
D. Time with reference to season
E. Recurrent time

At the next level down, section (1)(VI)(B) is divided into:

§116. Priority
§117. Posteriority
§118. Simultaneity
§119. The Past
§120. The Present
§121. The Future

Roget's idea is that if you are thinking or writing about time, and specifically about how it goes by, you will leaf through those sections for inspiration, not to find a more pompous way of expressing something you have already written, but to refine your own idea of what it is you wanted to express.

Perhaps you are trying to say that one event followed immediately after another. You might look at “§117 posteriority (later time)” which mentions “ensue”, “consequence”, “aftermath”, and “subsequent” — not synonyms, but related aspects of similar concepts, worth more or less consideration depending on what you are trying to emphasize. §117 will also suggest common phrases like “step into the shoes of” — not a synonym by any means, but a related idea. This is probably not what you wanted in this case, but it in another it might be just the thing, and in any case it might give you a bright idea.

If nothing in section 117 seems suitable, it is right next to “§116 priority”, and you might discover that instead of saying that the second event followed immediately after the first, you would rather say that the first immediately preceded the second. Or perhaps you realize, looking at “§118 Simultaneity”, that what you really want to say is that the two event were not quite simultaneous. Or perhaps, finding your way to “§131 Earliness” and “§132 Lateness” you realize that your meaning would be more clearly expressed if you said that the second event was a little tardy, or that the first event was premature.

Looking through the index for “immediately” you will see that the index distinguishes several senses of “immediate”: are you trying to suggest instantaneity, or continuity, or haste, or promptness, or punctuality? And in this way the book helps you refine your understanding of what you were trying to say.

One can use the thesaurus for more concrete tasks. Perhaps I am trying to remember a word, but I can't quite put my finger on it. I know it it is not “coexisting”, but is something like it. I can look up “coexisting” in the index, and it will take me to “§118 Simultaneity” where I find “contemporaneous”… aha, that's what I was looking for! The really important thing about the thesaurus is this large-scale organizing principle, which puts related ideas near one another.

Note that none of this works for someone who doesn't know what the words actually mean. All that person can do with the thesaurus is to replace one wrong word with another one, more or less at random. Effective tool use requires skill and training, and careful thought.

An online version would be more convenient, but again, it wouldn't have the same stuff and I am very attached to the one I have.

My banishment of the 8th edition left a lot of space on the shelf, some of which I have filled with an anthology of the prose of Sir Thomas Browne. I think this will be healthful and inspiring for me, especially if I remember to take it up and thumb through it from time to time.

The Prose of Sir Thomas Browne

One recurring theme on this blog since the very earliest days has been the writers of the English Baroque period. In 2008 I wrote:

[Browne] is witty, and learned, and wise, and humane, and to read his books is to feel that you are in the company of this witty, learned, wise, humane man, one of the best men that the English Renaissance has to offer, and that you are profiting thereby.

His work was also a favorite of Jorge Luis Borges', in case you consider that a recommendation.

Browne has shown up here a number of times, although not so much as he should have, because I started the blog the year after I was on my big Thomas Browne kick. One reason I have put this book next to my elbow is that I hope it will spark a new Browne kick. (I wrote in 2006 “I'm sure I will return someday”, and it is long past time for that return.)

My favorite book by Browne is his Pseudodoxia Epidemica, which is a compilation of stuff that people in 1646 believed that Browne thought was probably wrong. I wrote about that in some detail in 2008 although I didn't get around to publishing it until 2020. And somehow the other three articles I was writing about this have never seen the light of day. One is about his discussion of whether John the Baptist actually ate locusts or whether they were locust beans or something else. Browne is firmly on the side of it being actual locusts, as am I. My unpublished article says:

Chester Brown's version of the gospels makes it clear that John was a crazy old bug-gobbler.

Panels from Yummy Fur #17, page 15, by Chester Brown.

Also Sir Thomas comes up in connection with whether snails have eyes in their horns — a rare example where he was wrong, and for a dumb reason:

If we concede they have two eyes, we must alse grant, they have no lesse than four… And therefore if they have two eyes, they have also four, which will be monstrous, and beyond the affirmation of any.

Browne seems to be noping out of the very idea of four-eyed snails, and therefore that they must have none at all. In a later edition of the book, he changed his mind, which is to his credit.

He had a thoughtful and well-informed opinion about whether Pythagoras forbade his followers from eating beans, supposedly because he thought they contained the souls of the dead. (Browne says the former is true, but not the latter.)

I have trouble connecting with the thinkers of the Middle Ages. Their thinking seems to me to be frightened, so overcautious, so cramped and circumscribed, I can't read it without sadness for the way that medieval Christianity strangled the human spirit for so long. But in the early Renaissance there is a flowering of a joyfully brave willingness to try to understand the world, and to follow any inquiry, no matter how extravagant or ridiculous. The whole idea of God has transformed, changed from something constricting to something empowering. The world before belonged to God, and humans were in it only grudgingly and on promise of good behavior. But when the Renaissance started, the world became a beautiful gift, in which humans had been placed to honor God by admiring and marveling at his creation.

This admiration and marvel, the willingness to follow any path to understanding, is how I want to be about knowledge and how I hope I am. Reading Browne, I always feel like he and I would have gotten along well, and that that is one of the best parts of myself.

Boccaccio's Decameron

The story of the Decameron is this: It is 1348, and Florence is devastated by Black Plague. Nothing can be done, despair is everywhere, and there are not enough left living to bury the dead. So ten young people, still healthy, decide to turn their backs on suffering and quit town. They take provisions and servants, retire to the country, and try to forget the horrors they have seen. There they spend the time feasting, walking in the gardens, playing chess, and, once a day, for ten days, they meet, choose a theme, and then each of them tells a story on the theme.

I explained this once to a friend who said “That sounds cool, when was it written?” I said “In 1348!” It is one of the two great works of classical Italian literature, the other of course being Dante. Dante is solidly medieval, hierarchical, doctrinaire, and obsessed with a God who is supposedly loving but doesn't seem to know how to show it. That was in 1308 or so, and then, only a few decades later, we have the Decameron which could not be more different. It is about people, doing people things in the real world, eating, drinking, singing, arguing, and making love. God is present, but not oppressive. He has sent a terrible plague for who knows what reason, but rather than submit to it the characters of the Decameron try to take practical steps to make the best of it.

There is a story in the Decameron for every mood, usually more than one. Some are sad, some romantic, some funny and salacious. Dioneo is exempt from following the daily theme and usually has a story that is more or less dirty.

My favorite story is probably the one about the cross-dressing English princess, or perhaps the one about how young Caterina wanted to sleep on the balcony so that she could hear the nightingale, which I find very sweet. But the funniest one is about the abbess who is called out of her cell one night to berate a nun for having her lover stay over, and who doesn't realize that in her hurry she has put her own lover's trousers on her head instead of her wimple.

I have several different Decamerons, but this copy is the Cormac Ó Cuilleanáin translation, which has made several previous appearances here:

• On the word “squillions”. Following up a chance encounter in the Oxford English Dictionary is what led me to discover the Decameron in the first place
• The phrase “two-bit huckster”
• “soup-guzzling pie-muncher”
• “soup-guzzling pie-muncher” again

There's also an unpublished blog article inviting me to look into this passage:

Messer Lotto Gualandi gave him a daughter of his, Bartolomea by name, one of the fairest and handsomest young ladies of Pisa — although most of the females from that benighted town look like tarantulas.

The J.M. Rigg translation says “spotted lizards”. This is closer to the original Italian, which is lucertole verminare, literally small wormy lizards.

I have my doubts about the desirability of living to be a thousand years old, but if I do decide to do it, one reason will certainly be that I will need the time to learn Medieval Italian and translate the Decameron.

From Frege to Gödel, edited by van Heijenoort

This is a collection of the most important papers in mathematical logic from the time of Frege (who, I have written before, was responsible for kicking the field of logic out of its medieval period into the modern world) to Gödel (who spoiled everything).

In between these van Heijenoort hits all the most important ideas, starting with Frege's explanation of Begriffsschrift, which is wacky and weird and which didn't catch on except it kind of did and it still underlies half of mathematical logic and which is the prototype for many of the symbols we still use. After this there is Russell's tragic correspondence with Frege in which he pointed out, too late, that Frege's foundational theory didn't work.

The book reprints Peano's original description of the Peano numbers, perhaps the most successful single mathematical theory of all time.

The book includes Zermelo's proof of Zermelo's theorem that every set can be well-ordered, and Ackermann's discovery of Ackermann's function, which demonstrated the not every computable function is primitive recursive.

The book has Russell on type theory and early work by Kolmogorov and Brouwer on the origin of intuitionism. (Heyting is missing.)

Van Heijenoort has come up here when I wanted to quote from Schönfinkel's paper about the SKI-calculus, Wiener's paper inventing the ordered pair, and implicitly in probably a dozen other math and logic articles here over the years.

The book is on my shelf because I refer to it pretty often, but also because I can usually find something interesting just by thumbing through it. For example, these remarks by Thoralf Skolem about the futility of deriving induction from set-theoretic foundations.

Bonus trivia: Van Heijenoort was the personal secretary of Leon Trotsky, and while he was accompanying Trotsky during the latter's exile in Mexico, he was one of Frida Kahlo's lovers.

Orbis Sensualium Pictis (English edition), Johannes Comenius

I adore this book. My heart swells with love when I think of it.

I don't have a blog article about it and there is a story behind that. In 2018 I went to a conference in Cleveland and my hotel was in a building that had formerly been the Cleveland Department of Education. It contains two big murals, one depicting “The Progress of Education”:

I planned to write a blog article about these people. It's clear who some of them are. For example, Moses is easy to recognize at lower right, because of the glowing horns, and Confucius is next to him. Some people I was familiar with once they were identified for me: the red-haired guy second from right in the back row is Friedrich Fröbel, who I knew; his “gifts” are a forerunner of the Montessori materials.

But in doing the research I got to the bearded hat-wearing dude topmost on the right side and completely fell off the bus, because that is Johann Comenius who is famous because he wrote one of the most marvelous and enchanting books I've ever read, the Orbis Pictus.

I have to resist the temptation to say too much, because Orbis Pictus derailed the article about “The Progress of Education”, it then derailed its own article which has been in progress for eight years, and if I let it it will derail this article too, because every time I pick up Orbis Pictus I forget whatever I was doing and I am lost in the pages with a happy and innocent smile on my face.

I'm going to precommit to writing only one paragraph about this incredible book. It was the first illustrated children's book published in Europe, in 1658, and it was an immediate hit, being translated from German into English the following year, then into French, Italian, and many other languages. It swept the continent because everyone loved it.

Most of the book follows this pattern: there will be an engraved illustration, depicting some aspect of ordinary human activity, such as (I open it up to a random page) “Tame Foul” (that is, “fowl”):

Items of interest in the engraving are annotated with numbers, and the facing page explains the illustration, one item at a time:

The Cock 1 (which croweth in a morning), hath a comb, 2.

In a second column to the right of this is the same text, but in Latin, so that while the reader is learning about tame fowl, they are also learning Latin:

Gallus 1. (qui manè cantat) habet Cristam, 2.

The prose is limpid, gentle, pithy, and direct. It hits the important points of interest, invites questions, and ends before anyone can get bored. There are pages on anatomy, butchery, feasting, winemaking, various principal virtues, family trees, cities, burials, ships, wells, horology, amphibians.

Now I will reluctantly put it down, rather than leaving this article unfinished as I have so many before.

The Bible (New International Version, large print)

This of course is the cornerstone of Western culture and no well-educated person can be without a knowledge of what is in it. It is full of great wisdom and great stories, and also cruelty, evil lies, and reminders that the world now is in many ways better than it was because people are better.

I would like to understand the world I live in, and there is no way to understand 21st-century America without understanding the Bible.

The NIV is not the most poetical translation, but it is clear, modern, and accurate. (I got it on the recommendation of Sterling Hanenkampf. Thanks, Sterling!) In former times I had a collection of Bibles but this is the only one that remains. I even got rid of the old King James that belonged to my mother, since office space is precious and I have had a digital copy on my computer since the early 1990s.

I find that most of my articles mentioning the Bible are unpublished for some reason. It comes up a bit in connection with Ploni Almoni, and in passing in many other places.

One of the unfinished articles is a series of notes on the theme of Jesus's admonition “Do not put the Lord your God to the test” (Matthew 4:7) and its relationship to a lot of other things like lightning rods, Christian Science (not Christian science), how Larry Wall became a computer programmer, Pikuach nefesh, and the story of the old lady who refused to evacuate from her house during a flood. It'll be epic if I ever finish it, but I probably won't.

Another incomplete one is about the incredible story of Samson and Delilah:

She asks him flat out:

[Judges 16:6] Tell me the secret of your great strength, and how you can be tied up and subdued.

Instead of just telling her to fuck off, Samson lies:

[16:7] If anyone ties me with seven fresh bowstrings that have not been dried, I'll become as weak as any other man.

The Philistines bring her bowstrings and she tries it that night, but Samson snaps the bowstrings as easily as a piece of string snaps when it comes close to a flame. …

Then it goes as before! He tells her a different lie, knowing full well that she will betray him, and she does betray him, and he makes a fool of her again! (16:11–12)

Okay, that was fun. Let's do it again! (16:13–14)

After several repetitions of this, Samson decides that being shaved, blinded and crushed will be less exasperating than listening to any more of Delilah's nagging.

I read once that the whole point of the book of Judges is that the people in it are all terrible, they are all far from the path of righteousness, and so you definitely shouldn't act like them. I don't know if that interpretation is correct, but it is certainly true that the people in it are all terrible.

The Belles Heures of Duc de Berry

This book turned up in one of my very first blog articles, on abbreviations in medieval manuscripts, although I didn't know it at the time. In my teens, on a visit to the Metropolitan Museum of Art, I picked up a print of this:

Then I carried it with me for the next forty years, eventually framing it and hanging it up, and it is hanging in my house now.

Many years after, when I was still on Twitter and Twitter was still fun, I subscribed to a daily feed from the Met, and one day they tweeted this page, or perhaps another page from the same book, stylistically similar enough that I recognized it immediately. They said where it was from: it's the Belles Heures, a “book of hours”, which tells the reader when to pray and how, and which days are sacred to which saints. Very wealthy people had super-fancy ones made from the very best materials, with illustrations by the very best craftsmen.

The Duc de Berry was so wealthy that he had more than one, as I found out when I accidentally ordered and received the Tres Riches Heures. But I got the one I wanted eventually.

The Duc de Berry book is by Millard Meiss and Elizabeth H. Beatson, and alternates beween the magnificent color plates and prose discussing each one. From the inscription on the page above I had been able to figure out that this was John the Baptist (see previous article), and the authors aren't sure who the other two people are, but they did at least tell me that John was the Duc de Berry's name-saint. (Funny how John keeps popping up, isn't it?)

More recently I had another very similar Internet revelation. I've had this framed postcard hanging up for many years:

and thanks to a recent Mastodon toot by Cam Larios, I found out that it is from the “Black Hours” of the Morgan Library.

#8?

The banishment of the very large Roget 8th edition has left enough space on the shelf for an eighth book. I took a quick look around my office to see if there was anything else that wanted to fill that space, but nothing volunteered.

(Actually I think Tristan Needham's Visual Complex Analysis might be waving to me from across the room.)

Other stuff

There are other things in the photo that should not be on this shelf and I don't know why they are:

• A packet of googly eye stickers
• Glass and ceramic coasters that I don't use because my coffee cup is always on my electric mug warmer
• A small audio speaker that might or might not work
• A boxful of 8mm-helical scan backup tape from the 1990s
• A pair of old laptop 2.5-inch hard disks that I hope to someday get the data out of
• A set of Korean playing cards

The shelf is like my brain, I guess, full of stuff, and and what's in it doesn't always make sense or go together with the other stuff.

This article was prepared by GNU Emacs, Rael Dornfest's “Blosxom” software, GNU grep, and the Kubuntu desktop environment, with minor assistance from me. Spelling correction was provided by ispell. The four em-dashes were organically cultivated and sustainably harvested.

Getty Images

Count Binface is standing against Nigel Farage in the Clacton by-election

Count Binface, the self-styled intergalactic space warrior, has received nearly 10,000 votes in the Clacton by-election, his best performance yet.

The much-photographed election veteran was the main rival to Reform UK leader Nigel Farage in an election race caused by Farage resigning, only to run again - which sparked a mass boycott by the other main UK parties.

Farage has re-won his seat, receiving more than 22,000 votes in Clacton, on the Essex coast.

Binface received 26.9% of the vote while Farage won 63.3%. Binface had his highest share yet with 9,455 votes, having lost to no fewer than three prime ministers, and one who later became prime minister, in previous attempts.

But how many votes has he previously received? And where does he fit into the British tradition of spoofing politicians?

2017: May the force be with you

Getty Images

Theresa May (far left) keeps her distance from Lord Buckethead at her election count

The man inside the bin is the comedian Jon Harvey, an Oxford graduate who has specialised in satire, writing scripts for BBC comedy shows The Thick of It and Have I Got News For You.

He first donned a bin on his head to stand for election in 2017, when he challenged the then Prime Minister Theresa May in her Maidenhead constituency, although back then he was known as Lord Buckethead, a character inspired by a Star Wars parody film.

He won 249 votes and viral fame, leading to an appearance on John Oliver's HBO show Last Week Tonight - as well as a legal dispute with another Lord Buckethead he described at the time as "an unpleasant battle on the planet Copyright".

2019: The bin takes on Boris Johnson

Getty Images

Binface gets in the picture as Boris Johnson is re-elected as MP for Uxbridge

Harvey found himself a different bin to cover his head and switched characters to Count Binface to take on the next Conservative leader, Boris Johnson, announcing himself as the leader of the Recyclons from planet Sigma IX.

He only won 69 votes, but was again able to take his place on stage as the election result was declared alongside a sitting prime minister, who was also flanked by a candidate dressed as the Sesame Street character Elmo, at his Uxbridge election count.

2024: Sunak takes out the trash

Getty Images

Binface had competition from a Monster Raving Loony ventriloquist at Rishi Sunak's count

A third Conservative leader, Rishi Sunak, was in Count Binface's sights in the 2024 general election campaign.

He got 308 votes, which at the time was his best result.

The Monster Raving Loony Party's candidate, Sir Archibald Stanton, received 99 votes - 0.2% of the vote share.

2026: Burnham courts the Count

Getty Images

Newly-elected MP for Makerfield Andy Burnham shakes hands with the Count

In June this year, it was Andy Burnham's turn to face Binface in the by-election that paved the way for the then Greater Manchester Mayor to become prime minister.

Rather than studiously ignoring the intergalactic warlord, as some may have been tempted to do, Burnham shook him warmly by the hand as he was elected Labour MP for Makerfield.

Binface bagged just 95 votes to Burnham's 24,927.

2026: The Bin's best result yet

While Nigel Farage won the Clacton by-election on Friday morning, Count Binface came second.

The Reform UK leader got 22,239 while Count Binface received 9,455. The intergalactic space warrior celebrated the number with his usual two peace sign fingers.

Speaking to BBC Breakfast after, Binface said: "I promised to be a local champion for Clacton and I thought to hear the verdict of the Clactonites was the least I could do."

A great British tradition?

The UK has a rich history of novelty candidates standing in elections, with Monster Raving Loony Party founder Screaming Lord Sutch - a rock musician who fought more than 40 elections in his trademark top hat and gold lame suit - first standing in a by-election in the 1960s. A different Lord Buckethead stood in 1987 and 1992, while comedian Al Murray's pub landlord stood against Farage in 2015.

Objections to such "frivolous" candidates date back even further - to 1918, when a £150 deposit was introduced for candidates. That was later upped to £500, in 1985, in large part due to the popularity of the Monster Raving Loony Party.

BBC/ Willie Smith

Screaming Lord Sutch was co-founder of the Monster Raving Loony Party in 1982

But the bar for entry remains fairly low: anyone over the age of 18 who can scrape together a £500 deposit and get support from 10 people in the form of signatures is allowed to stand as a candidate in UK elections.

That's why Count Binface has been able to stand in so many high-profile elections. He has, however, lost his £500 every time, after failing to meet the minimum 5% of votes cast in order for his deposit to be returned.

Yet Binface has had his moment in the spotlight each time.

That is because another British tradition means all election candidates must stand side-by-side on a stage at the election count to hear how many votes they have each received - it's a literal leveller, where everyone from prime minsters to a bloke dressed as a bin has the right to be seen and heard as an official candidate.

But all of these no-hope novelty candidates share a few serious aims: to poke fun at power, prick the pomposity of political elites, and allow people a protest vote.