Garth / Products / GKS
GKS GKS Foundation Layer · The Brain

One governed brain
behind every agent.

GKS connects your engineering ecosystem behind one governed boundary, turns your code into a tenant-isolated graph of every file, function, call, and import, and serves each Garth product the exact context it needs, with every write-back running through your keys.

Book a demo See how it works
8+7Node & relationship types in your code graph
Your keysEvery read and write, on a boundary you govern
1 SDKEvery Garth product calls the same brain
YOUR ENVIRONMENT Git repos CI / CD Issues & PM Docs & Wiki Cloud infra Comms GKS THE BRAIN THE GOVERNED SPINE authorize isolate graph ground scope scoped context → every product GReview G360 GScan GRelease G-IDE GAssist your keys · your permissions every write-back passes through your keys

A graph, not fuzzy search

Your code becomes a deterministic property graph of files, classes, functions, calls, and imports, rebuilt on every commit. Not a pile of text chunks.

Deterministic by design

Governed by design

Every node is cryptographically keyed to your tenant. Only repos you authorize are ingested, and write-back runs on short-lived keys you control.

Your data stays yours

Grounded, not guessed

Deterministic IDs and an explicit absence protocol mean an agent knows when context was found, checked-and-empty, or unavailable. No hallucinated code.

Hallucination-resistant

One brain, every product

GReview, GScan, G360, GRelease, GAssist, and G-IDE all call the same SDK. Connect a repo once; the whole suite gets smarter.

Shared foundation
The governed spine

Every request travels the same governed spine.

Data doesn't reach an agent by accident. It passes, in order, through five stages, deciding what may enter, what stays isolated, and what a job is allowed to see, before any product is ever handed context.

01

authorize

Only the repositories and branches you activate are ever ingested. Nothing you have not connected enters the graph.

02

isolate

Every node is keyed to your tenant with a cryptographic ID. One tenant cannot address another's graph, by construction, not just a filter.

03

graph

Your code is parsed into a deterministic graph of files, classes, functions, calls, and imports, rebuilt on every commit.

04

ground

Answers carry an explicit absence protocol, found, checked-and-empty, or unavailable, so nothing downstream is ever invented.

05

scope

Each product gets only the context that job needs, assembled from the graph, and nothing beyond it.

Only then is context served. And every write-back, from GKS or any product, runs through per-tenant, short-lived keys you provision and revoke.

What it builds

Not fuzzy RAG. A deterministic graph of your code.

GKS understands structure, not just similarity: the dependency graph, the call graph, and the exact relationships between the things in your codebase.

Nodes in your code graph

Repository Folder File Class Function Variable Module Import

Relationships between them

DEFINED_IN HAS_METHOD CALLS IMPORTS EXPORTS RE_EXPORTS PR_CHANGE

Every node carries a deterministic, reproducible ID derived from your tenant, repo, file, and symbol, so the same function is the same node across every commit. No fuzzy matching, no duplicate graphs.

Virtual Mergeunique

GKS patches an open PR's diff over the committed graph in memory, so agents reason about unmerged code against production state, without ever mutating your source of truth.

Blast radius & conflicts

It walks the CALLS graph to find every function a change touches, and flags two open PRs mutating the same code before they collide in production.

Explicit absence protocol

Every answer states whether context was found, checked-and-empty, or couldn't be checked, so downstream agents never invent what isn't there.

One brain, every product

Everything the suite knows, it knows through GKS.

Each product asks the same brain for a different slice of the same governed graph. Connect a repository once, and all of them get grounded.

GReviewWhole-codebase review context and inter-PR conflicts
G360Repository and delivery signals for the ROI board
GScanCode and dependency structure for security scans
GReleaseChange surface and readiness state per release
G-IDEIn-editor context, grounded in the real graph
GAssistAnswers about the codebase, backed by the graph

One graph, assembled once and shared. Improve the brain, and every product gets smarter at the same time.

Deployment & residency

Runs in our cloud, or entirely inside your boundary.

GKS runs
Garth Cloud
On-prem

Multi-tenant in Garth Cloud. Your graph is isolated by cryptographic tenant identity, code is reduced to structure and metadata, and write-back runs on your own short-lived keys.

Included with every Garth plan

You don't buy the brain. You build on it.

GKS is the knowledge backbone under every Garth product and the full suite. Connect a repo, and the whole platform starts reasoning about your code, on a boundary you govern.

Book a demo Explore the suite