Ten agents chasing one question run ten web searches, spend ten times the tokens, and come back with answers that need not agree. Sprawl reads the web into a single graph memory instead - one fills it, the rest read it, and every claim carries the sentence that proves it.
One record per thing named - person, company, place, event - resolved against everything read before, so a name met in forty articles is still one entity. Answers come back in milliseconds over a single endpoint, with the evidence attached - and where an answer is not enough, you leave a handler behind and the graph calls you.
# one entity and its whole neighbourhood curl -s https://sprawl.bemjax.com/api/ \ -d "path=graph/entity" \ -d 'args=[1042]' # 895 bytes · 0.10 s · every edge with its evidence
One markdown file and the public API - no key to mint, no package to install. Drop it in and Claude reaches for the graph before it answers from memory.
sprawl# bash
mkdir -p ~/.claude/skills/sprawl
curl -o ~/.claude/skills/sprawl/SKILL.md \
https://sprawl.bemjax.com/resources/skills/sprawl/SKILL.md
Download SKILL.md
Four kinds - people, groups, places, events - plus their facts and the relations between them. Every claim keeps its sentence, its document and its minute, and is resolved against everything read before, aliases included.
News, wires, official pages, registers, transcripts, an archive you hand us: one shape out, one endpoint over all of it.
The entities you picked and where you put each one travel in the link. Whoever opens it gets that picture, live against the graph rather than an image of it.
Open a shared diagramWhat a fleet reads, a person has to be able to correct. Open any entity, see every claim with its source, and write.
Ten agents on the same question is ten crawls of the same pages: ten times the tokens, ten times the wait, and ten summaries under no obligation to agree with each other. Sync them to Sprawl instead - whichever one goes and looks writes what it found, and the rest read it.
| Ten agents, one question | Each searches the web | All read one graph |
|---|---|---|
| Pages fetched | about eight each - eighty in total, the same eighty | none · the crawl already happened |
| Read into context | tens of thousands of tokens each, most of it page furniture | 895 bytes of JSON, all of it the answer |
| Time to an answer | seconds each, and they wait in turn for the same sites | 0.3 s average at most, each, in parallel |
| Do they agree? | not necessarily - ten summaries of ten reading orders | byte-identical · one record, one answer |
| Can it be audited? | whatever each model remembers of what it read | the sentence and the document behind every claim |
| Agent without web access | no answer at all | the same answer · reading the graph is reading the news |
published by Bemjax
News and common knowledge, swept continuously and read into entities, facts and relationships - each with the sentence behind it.
A sprawl graph: a system fills it - the crawl, the model that reads each page, the resolver that decides a name met twice is one record - and we measure what that makes. The picture is the embedding of the whole graph, its own shape rather than a list of rows.
Sprawl is not just a graph API - it is a platform for publishing and maintaining graphs, ours among them, and all of it is there for you to use. Join your own graph to public entities and query across both.
Yours on the same platform, joined to the public one - so a subscriber's single query crosses from your records into ours and back.
The same machinery pointed at what matters to you: a set of sites, a market, a public conversation, an archive nobody has ever been able to query. We run it - on our metal or inside your perimeter - keep the graph, and hand you the endpoint.
A space, a list of names, an archive, or a question you want answered the minute it changes.
The whole of it runs inside your perimeter: the ingest, the reading, the graph, the API, the viewer. No call leaves the network, no document is sent anywhere to be understood, and the model that reads your material runs where your material already is - which is the only arrangement some sectors are allowed to consider.
And not only an endpoint for agents. We build the interface the people in the building will use: search over the graph, an entity to read, the paper trail behind every claim, a standing question that pages someone when it changes.
Law firms, public bodies and anyone else sitting on decades of documents: we take the corpus as it is, vectorise it, pull out the entities and the relationships between them, and give you the same graph and the same endpoint over material that has until now only been searchable by filename. What was an archive becomes something a question can be put to - and something your own agents can read.
You name the sources; we sweep them at minute resolution and turn what appears into entities and relationships, with the sentence behind each one kept for audit.
Who clusters with whom, and when that changes. Communities are recomputed as the graph grows, so a group forming around a company, a case or a candidate is something you watch happen rather than something you learn afterwards.
A standing question, answered the moment it becomes true. If a named person says something, if two entities are linked for the first time, if a term starts spreading - your endpoint is called with the entity, the sentence and the source.
Write your own entities and relationships into a graph of your own - clients, cases, holdings, whatever you keep - connected to the public graph, so one query can cross from your records into the news and back.