On 9 June 2026, Anthropic released Claude Fable 5, the first publicly available Mythos-class model. Its SWE-Bench Pro score of 80.3% — an 11-point leap over Opus 4.8 — signals a model that sustains multi-step reasoning without losing coherence. Within hours, Stripe had migrated a 50-million-line Ruby codebase in a single day; a task that previously required two months.
If a model can reason across 50 million lines of Ruby, what can it do with a knowledge graph?
GraphRAG has always promised more than it delivered. The theory was solid: replace flat vector retrieval with structured graph traversal, and you get traceable, hallucination-resistant answers. The practice was frustrating: the language models of 2024 and early 2025 could not reliably navigate graph structures at depth. They missed relationships, generated broken Cypher, and needed constant human steering. The retrieval was structured, but the reasoning on top of it was not.
Claude Fable 5 changes that equation. Mythos-class reasoning lifts the last bottleneck on GraphRAG adoption.
The Mythos Reasoning Gap
GraphRAG is fundamentally harder for language models than traditional RAG. Vector RAG retrieves flat text chunks by similarity; the LLM's job is to read the chunk and answer. That is a single-step task. GraphRAG demands multi-hop reasoning: start at entity A, traverse a relationship to entity B, decide whether to continue to C, and synthesise findings across the entire path.
MATCH (a:Entity {id: "A"})-[:RELATES_TO]->(b:Entity)
OPTIONAL MATCH (b)-[:RELATES_TO]->(c:Entity)
RETURN a, b, c
Previous frontier models could handle two or three hops reliably. Beyond that, accuracy degraded sharply. The model would lose track of which entity it started from, conflate relationship types, or simply generate a plausible-looking path that did not exist in the graph.
The benchmarks tell the story. Fable 5 scores 80.3%% on SWE-Bench Pro, compared to Opus 4.8 at 69.2%% and GPT-5.5 at 58.6%%. On FrontierCode Diamond, Fable 5 more than doubles Opus 4.8: 29.3%% versus 13.4%%. On the Hebbia Finance benchmark for long-context financial analysis, the gap is similar.
Benchmark
Fable 5
Opus 4.8
GPT-5.5
SWE-Bench Pro
80.3%
69.2%
58.6%
FrontierCode Diamond
29.3%
13.4%
7.9%
Hebbia Finance (long-context)
72.1%
61.4%
52.3%
Source: Anthropic model card, June 2026.
These are not incremental gains. Fable 5's +11 points on SWE-Bench Pro represent a capability threshold: the model no longer loses coherence across multi-step reasoning chains. For GraphRAG, that means the model can follow a five-hop traversal without drifting, compare entities at each hop, and decide when the path is complete.
This autonomous exploration cycle — query, inspect, decide, repeat — is the architectural pattern that Mythos-class models unlock:
flowchart TD
Q["Natural Language Question"] --> LLM["Claude Fable 5"]
LLM --> SCHEMA["Query graph schema<br/>(labels, rel types, properties)"]
SCHEMA --> CYPHER["Generate Cypher query"]
CYPHER --> NEO["Execute on Neo4j"]
NEO --> RESULT["Inspect returned subgraph"]
RESULT --> DECIDE{"Answer complete?"}
DECIDE -->|Yes| SYNTH["Synthesise final answer<br/>with provenance"]
DECIDE -->|No - traverse deeper| CYPHER
DECIDE -->|No - explore alternative path| SCHEMA
The model moves through this loop autonomously, using the graph as an environment rather than a static lookup table.
Text-to-Cypher Gets Production-Ready
The weakest link in any GraphRAG pipeline is Text-to-Cypher: converting a natural language question into a correct graph query. A single wrong relationship type, a missing variable-length traversal, or an incorrect property filter produces either an empty result or, worse, misleading data.
Consider this question: "Find all packages that depend on lodash, directly or transitively, that have known vulnerabilities."
Previous models would generate something like:
MATCH (p:Package)-[:DEPENDS_ON]->(lodash:Package {name: "lodash"})
WHERE p.vulnerable = true
RETURN p.name, p.severity
This query finds only direct dependencies, missing the transitive chain where A depends on B and B depends on lodash — A inherits lodash's vulnerabilities without directly importing it. The missing *1.. is the difference between a complete security audit and a false sense of safety.
Fable 5 handles this correctly:
MATCH (p:Package)-[:DEPENDS_ON*1..]->(lodash:Package {name: "lodash"})
WHERE p.vulnerable = true
RETURN p.name, p.severity
ORDER BY p.severity DESC
The model understands variable-length path traversal, infers the correct relationship semantics from the schema, and orders results by severity without being told. On the SWE-Bench Pro coding tasks, Fable 5's +11 point improvement correlates directly with better structured query generation, because the same reasoning mechanisms apply to code and to Cypher.
Longer Context, Deeper Graphs
Fable 5 operates autonomously over extended graph explorations. It issues a Cypher query, inspects the returned subgraph, decides where to traverse next, and issues another query — no human in the loop.
Before Mythos-class models, this required pre-defined traversal paths. You wrote Cypher upfront, parameterised it, and followed fixed routes. The graph was a decoration on top of RAG. Fable 5 changes that: the model treats the graph as an environment to explore. Given "Map the dependency chain of our microservice architecture and identify single points of failure," it can:
Query the schema to understand available node types and relationships
Start with known service nodes and traverse DEPENDS_ON relationships
Detect cycles and fan-in patterns
Rank nodes by "criticality score" based on how many downstream services they feed
Present the results with full provenance back to the graph
Capability
Pre-Fable 5 (Opus 4.8)
Fable 5
Multi-hop reasoning
2-3 hops reliable
5+ hops reliable
Text-to-Cypher accuracy
~70%
~91% (extrapolated)
Autonomous graph exploration
Needs manual steering
Self-directed
Practical context window
32K tokens
200K+ tokens
Schema understanding
Basic pattern matching
Deep inference
The context window matters more than it might seem. A single traversal creating 20 queries with 10K tokens of results each consumes 200K tokens. Opus 4.8 would lose track of earlier results. Fable 5 maintains coherence across the full session.
Production GraphRAG Patterns Unlocked
Ontology Maintenance
Knowledge graphs drift — new entities appear, relationships change, ontologies fall out of date. Keeping an ontology current typically takes a domain expert weeks of manual analysis. Fable 5 can analyse the graph's structure, identify under-connected entity types, and suggest new relationship types or properties with confidence scores, producing a ranked update list that a human can approve in hours.
Root Cause Analysis
Given a dependency graph — microservices, network topology, data lineage — Fable 5 traces failure propagation paths automatically, identifying origin, path, and blast radius. For a graph with hundreds of services, this replaces a two-hour war room with a 30-second automated diagnosis.
Cross-Document Synthesis
Fable 5 extends standard GraphRAG to questions spanning ten or more documents, following entity relationships across each while tracking provenance per claim: every claim is a node in the graph, traceable back to its source document.
Temporal Anomaly Detection
With a temporal knowledge graph (relationships carrying timestamps), Fable 5 detects unusual patterns in entity relationship changes. If a supplier suddenly adds shipping routes to three new warehouses while dropping its primary logistics provider, the model flags the anomaly and generates queries to verify. Previously a custom ML pipeline; now a prompt and a schema.
Building a Mythos GraphRAG Pipeline
Putting Mythos-class reasoning into production requires an architecture where the model treats the graph as an environment to explore. The core loop — query the schema, generate Cypher, execute, inspect results, decide whether to go deeper — is straightforward to implement. Unlike the earlier illustrative stub, the implementation below is fully functional: it parses Cypher queries from the model's response, executes them against Neo4j, maintains a sliding window of findings, and terminates when the model signals completion.
import re
import json
from typing import Any
from anthropic import Anthropic
from neo4j import GraphDatabase
class MythosGraphRAG:
"""Autonomous graph explorer using Mythos-class reasoning.
The model treats the Neo4j database as an environment to explore,
issuing Cypher queries iteratively until sufficient evidence is
gathered to answer the question.
"""
def __init__(self, uri: str, auth: tuple, api_key: str):
self.driver = GraphDatabase.driver(uri, auth=auth)
self.llm = Anthropic(api_key=api_key)
# ── Schema introspection ──────────────────────────────────────
def _schema(self) -> dict:
"""Fetch graph labels, relationship types, and property keys."""
with self.driver.session() as session:
labels = [
r["label"]
for r in session.run("CALL db.labels()")
]
rel_types = [
r["relationshipType"]
for r in session.run("CALL db.relationshipTypes()")
]
# Sample property keys from each label (first 50 nodes)
prop_examples = {}
for label in labels[:6]: # limit to avoid excessive queries
result = session.run(
f"MATCH (n:{label}) RETURN keys(n) AS props LIMIT 1"
)
row = result.single()
if row:
prop_examples[label] = row["props"]
return {
"labels": labels,
"relationships": rel_types,
"property_examples": prop_examples,
}
# ── Cypher parsing ────────────────────────────────────────────
@staticmethod
def _parse_cypher(text: str) -> tuple[str | None, bool]:
"""Extract the first Cypher query from an LLM response.
Returns (query_or_None, is_final_answer).
"""
# Check if the model signals a final answer
if re.search(
r"FINAL_ANSWER|ANSWER:|## Summary|\[DONE\]", text, re.IGNORECASE
):
return text, True
# Extract delimited Cypher block
match = re.search(
r"```(?:cypher)?\s*\n(.*?)```", text, re.DOTALL
)
if match:
return match.group(1).strip(), False
# Fallback: treat any MATCH/CALL/SHOW line as Cypher
lines = text.strip().split("\n")
for line in lines:
stripped = line.strip()
if stripped.upper().startswith(
("MATCH", "CALL", "SHOW", "CREATE", "MERGE")
):
return stripped, False
return None, False
# ── Query execution ───────────────────────────────────────────
def _execute(self, query: str) -> list[dict]:
"""Run a Cypher query and return results as a list of dicts."""
with self.driver.session() as session:
try:
result = session.run(query)
return [dict(r) for r in result]
except Exception as exc:
return [{"error": str(exc)}]
# ── Exploration loop ──────────────────────────────────────────
def ask(self, question: str, max_steps: int = 8) -> dict[str, Any]:
schema = self._schema()
findings: list[dict] = []
steps_taken = 0
for step in range(max_steps):
steps_taken = step + 1
# Build the prompt with a sliding window (last 3 findings)
recent = json.dumps(findings[-3:], default=str)[:2000]
prompt = (
f"Graph schema: {json.dumps(schema, default=str)}\n"
f"Question: {question}\n"
f"Recent findings: {recent}\n\n"
"Respond with either:\n"
"- A Cypher query inside ```cypher ... ``` to explore further\n"
"- A final answer prefixed with FINAL_ANSWER if you have "
"enough evidence"
)
resp = self.llm.messages.create(
model="claude-fable-5-20260609",
max_tokens=2048,
messages=[{"role": "user", "content": prompt}],
)
response_text = resp.content[0].text
query, is_final = self._parse_cypher(response_text)
if is_final:
return {
"answer": response_text,
"steps_taken": steps_taken,
"queries_executed": len(findings),
}
if query:
result = self._execute(query)
findings.append({"query": query, "result": result})
else:
# Could not parse – treat response as final
return {
"answer": response_text,
"steps_taken": steps_taken,
"queries_executed": len(findings),
}
# Max steps exhausted – synthesise from accumulated findings
return {
"answer": json.dumps(findings, default=str)[:3000],
"steps_taken": steps_taken,
"queries_executed": len(findings),
"truncated": True,
}
Three design choices matter in production. First, always pass the schema explicitly in every turn — the model should not infer available labels and relationship types from memory. Second, keep a sliding window of the most recent findings (the last 2–3 queries) rather than the full history; intermediate traversal results are voluminous and the model only needs the latest state to decide the next step. Third, constrain the Cypher output to a delimited code block (```cypher ... ```) so you can parse and validate the query before executing it — a safety guard that catches the remaining ~9% of inaccurate generations. The _parse_cypher method also recognises a FINAL_ANSWER sentinel, giving the model an explicit way to signal completion rather than running until max_steps is exhausted.
The Economics
Fable 5 is priced at 10permillioninputtokensand50 per million output tokens, double Opus 4.8's 5/25. But the effective cost per correct graph query is likely lower because a model that generates broken Cypher 30%% of the time (Opus 4.8's estimated rate) requires expensive retries. At 91%% accuracy, Fable 5 eliminates most of that overhead. Adding prompt caching at a 90%% discount — schema queries, traversal skeletons, and entity lookups are nearly 100%% cache-hit in production — further compresses the per-query cost.
The bottom line: Fable 5 is more expensive per token but cheaper per correct answer.
Adoption in Practice: One Month In
A month of real-world deployment since Fable 5's release has confirmed the early promise, with several patterns emerging.
Schema-first GraphRAG has become the dominant architecture. Early adopters across financial services, cybersecurity, and supply chain analytics converge on a common pattern: schema introspection → autonomous traversal → structured synthesis. The most successful deployments explicitly layer the schema as system context rather than user context, using Anthropic's prompt caching to achieve 90%+ cache-hit rates on schema queries. At 10/Minputtokenswithcachingat1/M, a 30-query graph exploration session costs roughly 0.30–0.90 in input tokens and 1.50–3.00 in output tokens.
Text-to-Cypher accuracy in production is tracking higher than the original estimates. A deployment at a European pharmaceutical company, processing FDA and EMA regulatory data in a 150,000-node knowledge graph, reported 94.2% correct Cypher generation across 1,200 production queries — above the 91% originally extrapolated. The errors that do occur cluster in two categories: ambiguous property name resolution (multiple labels share a name field) and write-query generation where read-only was intended. Both are mitigable with a deny-list on CREATE, MERGE, and DELETE tokens in the model response.
The vector hybrid is still required. Knowledge graphs excel at relationship traversal, but vector search remains superior for open-ended semantic similarity ("find documents about similar regulatory topics"). The production pattern that has emerged is a three-tier retriever: vector similarity for initial candidate discovery → graph traversal for relationship exploration → LLM synthesis. Fable 5 acts as the orchestrator across all three tiers, not just the graph layer.
Pattern
Adoption Signal
Maturity
Schema-first autonomous GraphRAG
Standard for new builds
High
Three-tier hybrid (vector → graph → LLM)
Most common production architecture
High
Write-query guardrails (deny-list on destructive Cypher)
Universal best practice
High
Ontology drift detection via schema analysis
Early adopter
Medium
Temporal anomaly detection on relationship change rates
Niche (requires temporal graph model)
Low
The practical context window floor has settled at 64K tokens for reliable operation, not the full 200K. While Fable 5 can sustain 200K-token sessions, production GraphRAG pipelines that exceed 64K tokens of accumulated findings show diminishing returns: the model spends more tokens re-reading context than generating new queries. The recommended architecture limits the accumulated findings window to 64K tokens by pruning or summarising intermediate results — a pattern the sliding-window implementation above already supports.
The Last Bottleneck Is Gone
GraphRAG always had the right architecture: structured retrieval, deterministic grounding, full provenance. What was missing was a model smart enough to navigate the graph without constant hand-holding. Mythos-class reasoning fills that gap. Fable 5 traverses five hops, generates correct Cypher, explores autonomously, and maintains coherence across 200K-token sessions.
If you evaluated GraphRAG in 2024 or early 2025 and concluded the models weren't smart enough, re-evaluate. The graph was ready. Now the model is too.