Out of the box, FRYTAG turns source code, build structures, and version history into one living knowledge graph. But enterprises run on more than code. With custom extensions, FRYTAG ingests the material your business actually runs on — and weaves it into the same graph.
Procedures, requirements, specifications, process descriptions, test protocols: the material that holds the why behind the what. Standard tools ignore it. FRYTAG was built to take it in.
Its ingestion architecture is extensible by design — new knowledge domains, new ingestion strategies, new links between domains, added as extensions without touching the core. We build them with you.
A domain is a typed world of things and relationships: classes and calls in code, modules and dependencies in builds, commits in your history. We shape your material into a domain of its own — typed, versioned, and queryable with the same rigor as code.
An ingestion strategy is a packaged extension that decides what a source contributes to the graph and how. Yours can carry your naming conventions, your structures, your validation rules — versioned and configurable, so every run is reproducible and every fact carries provenance.
Knowledge pays off when it connects. Custom cross-domain links declare how your world relates to the technical one: this procedure governs that module, this requirement is realized in those classes. One graph, traversable end to end — ask anywhere, follow the evidence everywhere.
Your documentation, procedures, processes, and formats — wherever they live, whatever shape they take. We build the extraction that turns them into graph facts: structured, evidence-backed, and kept fresh as your sources evolve.
Every company has its own documentation culture, its own procedures, its own way of recording how things work. That is not an obstacle — it is the material. FRYTAG extends to ingest arbitrary machine-readable material and interweave it into the knowledge graph through custom extensions, so the answers your teams get are grounded in everything you know. And where a system has an API, FRYTAG reads it directly — no exports, no stale copies.
Formats and sources we regularly work with:
A requirements PDF, a Confluence page describing the current process, and the module that implements it — three places, no links, and the only person who sees all three retires next year.
Requirement PROC-42 — realized in these classes, changed by these commits, covered by these tests. One question, one answer, with evidence.
No export, no snapshot — your tracker has an API, and we read it where it lives. Commit messages citing a ticket become graph edges: open PROJ-1284 and find the commits, the diffs, the tests, and the people behind them. Impact analysis starts at the ticket, not at the class.
Process descriptions, architecture notes, decision records — read through the API and linked to the modules they talk about. When a page changes, the graph catches up; when the code moves on, the graph shows exactly where the two have drifted apart.
ReqIF or Excel — however your requirements arrive, they become first-class nodes. Every requirement shows the classes that realize it and the tests that verify it. Coverage becomes a query you run, not a spreadsheet you trust.
We sit down with your people and your material: which sources matter, what they mean, and how they relate to code and history.
We design and build the custom extensions — domains, strategies, links, extraction — for exactly your world.
Before anything lands, the new ingestion runs in dry-run: inspect what would enter the graph, refine, repeat until it is right.
The extensions run as part of normal FRYTAG ingestion — versioned, observable, and evolvable as your sources change.
You do. Everything an engagement produces — source, configuration, tests, documentation — is handed over and documented. Nothing about your extension is closed off from you.
Extensions build on a stable, versioned contract, not on internals — the same discipline code dependencies use. And every ingestion can run in dry-run first: drift surfaces before it lands, not after.
Yes. Extensions are ordinary, versioned components with documented contracts — your team can maintain them, we can maintain them with you, or any mix that fits. No lock-in by design.
Read-only API access, nothing more — credentials stay in your configuration, scoped to the projects we ingest together. If a system is unreachable, the run reports it and the graph keeps its last consistent state. And if a system must not be reached at all, we take exports instead — the graph does not care where the material came from.
We operate under NDA before the first workshop. Your material stays in your environment: ingestion runs on your infrastructure, and nothing you share leaves your control. Confidential material is our daily business, not the exception.
If your most valuable knowledge lives in formats no standard tool understands, that is exactly where we come in. Tell us what your business runs on — we will tell you how it becomes a graph.
