Skip to content

About

Every team we knew was rebuilding the same thing, badly, and calling it a side quest.

Companies have already written down the answers. Getting from there to something a customer can be shown takes a year of infrastructure that is nobody's actual product — so we built it once.

Where it came from

An internal problem, twice.

GRaaS started as a service for our own products. Thought Industries needed search over large customer-education libraries; another product needed grounded answers over a different corpus entirely. Both teams were quietly building the same pipeline, and both were about to discover the same three problems — entity resolution under concurrency, provenance that survives a delete, and a vocabulary nobody dared change.

So it was built once, as a standalone service with a REST boundary, on the assumption that any consumer should be able to integrate without a code-level dependency on it. That constraint turned out to be the most useful design decision in the project: it forced the whole surface to be documented, and it is why the product is now something anyone can use rather than an internal library with a landing page.

The problem

Seven systems, and the one that takes longest is not on the list.

Each of these has a version that works in a week and a version that survives a second content source. The gap between them is the product.

  • Splitting documents up

    Boundaries that do not cut a claim in half — and the discovery, later, that changing your mind about them means reprocessing everything you have ever stored.

  • Turning text into vectors

    A model choice you are stuck with, because moving off it means recomputing every vector in the corpus and paying for all of it again.

  • A vector store to hold them

    Sizing, capacity planning, and a rebuild path for the day it loses a collection — which is the day you find out whether you could rebuild it at all.

  • Reading facts out of prose

    A language model, run over every document, reliably enough that a bad afternoon at the provider does not leave gaps you cannot see. This is where the quality of everything downstream is decided.

  • Knowing when two things are the same thing

    The account in a billing row and the account in a ticket have to become one thing, while several documents are being processed at once. Get it wrong and the graph quietly fills with near-duplicates that no query joins.

  • A vocabulary that can change

    Your content will outgrow whatever categories you started with. Changing them after the fact, without losing what was already stored under the old ones, is a versioning problem most teams meet only once it is expensive.

  • Writing the answer

    Prose that says only what the sources say, citations that resolve to real documents, and a refusal that arrives instead of a plausible invention. The failure here is silent and lands in front of your customer.

  • And the orchestration

    Nothing you send goes missing, a backfill finishes on its own, and one tenant cannot starve another. This is the part that took us longest and the part nobody budgets for.

How we build it

Six principles, and one of them is uncomfortable.

  • We never reach into anything of yours

    No crawler, no connector that pulls, no credentials to anything of yours. You push documents to an endpoint. That puts the whole boundary on your side of the integration, which tends to make the security conversation short.

  • Graph enhances, never replaces

    Ordinary search always runs, and nothing is traded away to make room for the graph. Every graph feature is additive, and if the graph contributes nothing you get a competent search rather than an error. A graph that can lower your floor is a liability.

  • Losing an index is not losing your data

    The search index and the graph can both be rebuilt from what you sent us, without re-processing a document. Losing one is a rebuild rather than a data-loss event, and changing your vocabulary costs no model spend.

  • Same API, different depth

    Two tiers over one surface. The free tier is not a crippled trial — it is a real retrieval product, and the graph tier adds cross-document reach and governance on top of the same endpoints.

  • Refusal is a feature

    When your sources do not contain the answer, saying so is the correct output. Our evaluation set includes questions the corpus cannot answer, and answering them is scored as a failure.

  • Say the unflattering number

    We publish an evaluation result that does not support the thing we sell, because a category where everyone posts a favourable chart is one where charts stopped meaning anything.

Where we are

Early, and specific about it.

The product is real and running: a published REST API, a 69-tool MCP server, a full admin console, two tiers. What it is not yet is mature in the ways a procurement process measures. There is no SOC 2 certification. There is one managed deployment in one region, with no bring-your-own-cloud and no customer-managed keys. Billing is wired and not switched on.

We list those on the security and enterprise pages rather than leaving them to be discovered, because an evaluation that dies in week six over a fact we knew in week one is a waste of everyone's time. If any of them is a blocker for you, we would rather hear it on the first call.

Start with the free tier. Ship the first answer today.

RAG is free, with no card and no sales call. Add the graph when your corpus earns it.

  • no card required
  • first workspace is free
  • one POST to ingest