The top 10 libraries under Fable 5 and GPT Sol.

The wrong read on Claude Fable 5 and GPT-5.6 Sol is to stare at the leaderboard and decide the model got magical. The useful read is sharper: these models became good enough to exploit old software primitives that were waiting for a patient operator.

The thesis:

The frontier demos are library demos wearing model names. Fable and Sol supply the planning, persistence, and taste. The underlying libraries supply state, actions, constraints, rendering, execution, and proof. Builders who install the right library layer get more leverage than builders who only switch model names.

What changed this week

OpenAI's July 9 GPT-5.6 launch positions Sol as the flagship model, with stronger coding, knowledge work, cyber, science, computer-use, and design behavior. The key operator detail is not just raw intelligence: OpenAI also highlights ultra as a multi-agent setting, Programmatic Tool Calling for bounded deterministic reduction, and stronger rendered-result inspection for design work.

Anthropic's Fable 5 launch and model docs frame Claude Fable 5 as its highest capability widely released model, with 1M-token context and long-running agent focus. The public demos are revealing: Fable 5 builds a physics-derived solar-system simulation, plays Factorio, and designs a 3D-printable model in a browser-based CAD editor.

Then Riley Goodside's Pokemon crossword turned into the cleanest public cartoon of the moment: Claude Fable 5 generated the puzzle, and GPT-5.6 Sol Pro solved an empty version without numbered clues. That is not only "reasoning." It is recall plus global constraint satisfaction plus search plus verification.

The ranking rule

I ranked libraries by four tests: they expose a world the model can act on, they create a checkable feedback loop, they compound with other libraries, and they explain more than one public demo family. This is not a claim that every provider demo used the exact packages below. It is the stack map for recreating or industrializing the capability the demos point at.

1. Playwright and Stagehand

Browser automation is the most important unlock because it closes the perception-action loop. Playwright gives one API to drive Chromium, Firefox, and WebKit for tests, scripts, and agent workflows. Stagehand sits on the same axis but adds natural-language browser primitives like act, extract, observe, and agent.

This is why Sol's design gains matter. A model that can generate a UI is useful. A model that can open the UI, click it, inspect spacing, catch the broken state, and patch the code is a product operator. Browser control is the difference between "wrote code" and "saw the thing work."

2. Model Context Protocol SDK

MCP is the tool and data bus. The official intro describes it as an open-source standard for connecting AI applications to external systems: files, databases, search, and workflows. That makes it less glamorous than a demo video and more fundamental than most demo videos.

Fable 5 and Sol both get more valuable when the agent can discover bounded tools, read local context, call narrow workflows, and avoid giant prompt stuffing. MCP turns a local machine or company system into a set of typed doors instead of one vague text dump.

3. OpenAI Agents SDK and stateful graph runtimes

The new frontier is not one huge agent thinking harder. It is multiple workers with state, handoffs, guardrails, and resumable runs. OpenAI's Agents SDK documents built-in agents-as-tools, handoffs, input and output guardrails, approvals, sessions, and resumable state. The same slot is where stateful graph runtimes become useful: they keep long-running agent work from collapsing into one opaque transcript.

This explains why Sol's ultra setting is interesting and why Fable 5 demos keep leaning into long-horizon work. You need a graph when the job includes research, coding, review, browser verification, and final packaging. A transcript alone is not an operating system.

4. E2B

Strong coding models create a new mundane problem: where do you safely run all that code? E2B provides isolated sandboxes for agents to execute code, process data, and run tools, with SDKs for starting and managing those environments.

This is the difference between "the model wrote a script" and "the script ran somewhere disposable, produced logs, failed safely, and returned evidence." As Fable and Sol take longer coding swings, the sandbox becomes the seatbelt.

5. Agent Skills

Skills are the most underrated library-shaped primitive in the stack. Anthropic's docs describe Agent Skills as modular capabilities containing instructions, metadata, and optional scripts or resources. OpenAI's API docs describe skills similarly: a versioned bundle of files plus a SKILL.md manifest.

This matters because the next frontier is not "put everything in the system prompt." It is progressive disclosure. The model sees the small trigger, loads the relevant procedure, runs the script or template, and leaves a receipt. That is how agent behavior becomes repeatable without making every prompt obese.

6. Three.js and React Three Fiber

The solar-system simulation, game prototypes, interactive explainers, and 3D product demos all need a graphics substrate. Three.js remains the default JavaScript 3D library for getting WebGL and WebGPU-shaped scenes into the browser; React Three Fiber adds a React mental model around Three.js scenes.

Fable 5 can reason through orbital mechanics, but Three.js is what lets the result become a scene a user can inspect. Sol can produce interactive visualizations, but the rendering library is what turns the idea into a movable, debuggable object.

7. OpenCascade.js and Manifold-style CAD kernels

The browser CAD demo is a different class of "AI made a thing." A 3D-printable model is not just pixels. It needs solid geometry, boolean operations, export paths, and manufacturable constraints. OpenCascade.js ports the Open Cascade CAD library to JavaScript and WebAssembly so CAD applications can run in the browser or cloud.

This is where frontier models start touching engineering substrates. The model can propose the part. The CAD kernel says whether the part has actual geometry.

8. Factorio Learning Environment

Factorio is a toy only if you ignore what it tests: long-horizon planning, spatial reasoning, resource routing, program synthesis, and recovery from compounding mistakes. The Factorio Learning Environment is an open-source framework for developing and evaluating LLM agents in Factorio. It exposes a REPL-style loop where agents observe output, generate Python actions, and receive feedback.

That makes it a frontier lab for agentic systems work. It is one of the cleanest ways to test whether a model can maintain a world model after the easy short-horizon wins are gone.

9. Z3 and OR-Tools

The Pokemon crossword demo points here. Z3 is a theorem prover used to check satisfiability of logical formulas over theories. OR-Tools CP-SAT is a constraint programming solver for combinatorial problems. The important pattern is not "the model must call Z3." The pattern is that hard puzzles become easier when the model can hand a crisp constraint set to a solver.

This is the library family behind crosswords, schedules, layouts, packing, route choices, dependency ordering, and "make all of these conditions true at once" problems. Models bring the translation. Solvers bring the search discipline.

10. Pyodide and DuckDB-Wasm

Frontier models are getting better at producing useful research artifacts, but artifacts need local compute. Pyodide brings Python and many scientific packages into the browser through WebAssembly. DuckDB-Wasm brings analytical SQL to the browser, reads Parquet, CSV, JSON, and Arrow-shaped data, and can run without a backend server.

These libraries matter because the next wave of AI apps should not send every small analysis back to a remote backend. A Fable or Sol-built data tool can ship with local computation, local privacy boundaries, and a user-inspectable proof path.

The pattern

The common primitive is not intelligence. It is inspectable state. Playwright exposes the browser state. MCP exposes tool state. Agents SDKs and graph runtimes expose workflow state. E2B exposes execution state. Skills expose procedural state. Three.js and CAD kernels expose spatial state. Factorio exposes world state. Z3 and OR-Tools expose constraint state. Pyodide and DuckDB-Wasm expose compute and data state.

That is the actual frontier stack: give the model a world with handles, then make every handle produce evidence.

What to cook next

For a UI agent, start with Playwright, screenshots, and one failing visual assertion.
For a local operator, wrap one real tool as MCP before adding another prompt.
For coding work, add E2B or another disposable sandbox before trusting generated code.
For a puzzle, planner, or layout job, translate the problem into Z3 or OR-Tools constraints.
For a science or analytics artifact, try Pyodide or DuckDB-Wasm so the result computes in front of the user.