v3 · Apache 2.0

One AI agent. All your databases and code. Ask anything. Instant answers. No hallucinations.

Ask questions across your whole company. GraphJin finds the right data, runs the query, and shows the evidence.

Run the 2-minute demo

GraphJin Agent · localhost:8083/agent

Which account is most at risk of churn—and why?

query_catalog

3 relevant sources discovered

Postgres accounts + invoicesSnowflake product usageCRM API opportunities

validate_where_clause

relationships + churn filters valid

execute_graphql

3 optimized, policy-checked operations

Evidence checked · 3 systems · 3 operations

Meridian Robotics — renewal in 9 days, usage down 38%, two failed payments, and an unresolved escalation.

Deployed at scale

**Amit Deshmukh**Forward Deployed Engineer, OpenNeko

See it work

Ask in plain English. Get real data back.

Ask a question. Watch GraphJin discover the relevant shape, validate the request, compile the operation, and return the rows behind the answer.

AI Assistant

who's the top customer?

query_catalog

discover -> customers · purchases · products (2 relationships)

validate_where_clause

validate -> filters ok on customers, purchases · order_by total_spent

execute_graphql

{ customers { id full_name email purchases { quantity product { price } } } }

one optimized query, no N+1, no resolvers

SELECT json_agg(__sj.json) AS customers
FROM customers AS c
LEFT JOIN LATERAL (
  SELECT sum(p.quantity * pr.price) AS total_spent
  FROM purchases p
  JOIN products pr ON pr.id = p.product_id
  WHERE p.customer_id = c.id
) __agg ON true
ORDER BY __agg.total_spent DESC NULLS LAST
LIMIT 5;

Done

Based on the purchase data, here are the top customers ranked by total spend:

RankCustomerEmailOrdersItemsTotal Spent

01Antwan Friesenfrancohirthe@medhurst.com20124$928.45

02Lon Cruickshankmargaretbailey@ruecker.info2094$586.50

03Susana Schaeferjewelpowlowski@osinski.biz2091$580.72

Antwan Friesen is the top customer with almost $1,000 in purchases, about 60% more than the runner-up.

Try it yourself

How it works

Why this still works at 5,000 tables.

GraphJin’s reasoning-with-code agent discovers only the schemas and relationships it needs, then writes compact, model-friendly dynamic GraphQL. The compiler turns that into optimized, policy-checked operations—keeping context small enough for smaller models, permissions enforced, and every answer backed by evidence from what actually ran.

Bring Claude or Codex over MCP, or use the built-in agent.

The problem

Your agent is only as good as what it can see.

$2.5 trillion goes into AI this year — and a capable model still enters your stack blind. It doesn't know your schema, your permissions, your saved queries, or where a field is written in code — so it works from memory and guesses.

$2.5T¹

A tool for every question

Worldwide AI spend in 2026 — yet teams still hand-write a brittle API or MCP tool for each thing an agent might ask. The surface never keeps up, and every new question is new glue code.

21%²

Guesses, not facts

The best model's success rate on real enterprise text-to-SQL — down from 91% on academic benchmarks. Without a map, agents invent joins, fake fields, and confuse API shape with database shape.

88%³

Too risky for production

Organizations that saw an AI-agent security incident in the past year. Handing an agent raw credentials means hoping it guesses right — so it stays read-only, shallow, or boxed out.

The fix isn't a smarter prompt. It's giving the agent the map — and the guardrails. And it isn't another raw connector: 43% of tested MCP servers shipped with command-injection flaws.⁴

Sources: 1. Gartner, Jan 2026 · 2. Spider 2.0, ICLR 2025 · 3. Gravitee State of AI Agent Security, 2026 · 4. Equixly, 2025

Only GraphJin

The only system that lets AI agents understand your whole organization.

One question“Which customers are at renewal risk — and why?”

Your systems

12+engines

1,000sof tables

100sof columns

Postgres · Snowflake · MySQL · APIs · Files · Code

GraphJin

Discover
Connect
Run
Check

Agent answer

Who is at risk
Why
What can happen next

Answer · data · evidence · actions

Built-in agent

Use GraphJin as the agent.

Send one plain-English instruction to one endpoint. GraphJin returns the answer, the data behind it, and evidence from what ran.

terminal

curl -sS localhost:8080/api/v1/agent \
  -H 'content-type: application/json' \
  -d '{"instruction": "What should we prioritize next?"}'

response.json

{
  "status": "answered",
  "answer": "Start the Northstar run — priority 1, largest volume.",
  "data": [
    { "product": "Northstar Blend 340g", "bags": 420 }
  ],
  "evidence": {
    "protocol": {
      "executions": [{ "has_data": true }]
    }
  }
}

Run the built-in agent

Highly reactive agents

The agent that notices changes—and silence.

GraphJin keeps governed questions running across your live systems. It detects what changed, notices what failed to happen, distills noise, correlates signals, and wakes the right conversation—or proposes an approved action.

ChangeReact to live data

Cursor-backed questions keep running across your systems.

AbsenceNotice what did not happen

“No shipment scan in four hours” becomes a first-class event.

DigestTurn noise into one signal

Routine events drain into one useful, unseen summary.

RollupCorrelate independent watches

Combine exact watch IDs without unsafe loops.

SnoozeDefer without losing the event

Hide an unseen event until later without acknowledging it.

RecoverReconnect, resume, retry

Persist cursors and back off transient failures automatically.

01Watch change and silence

Green-bean inventorychange

green_lots · below safety buffer

A cursor-backed watch records the live inventory change.

Shipment scanssilent

no scan · 4h absence window

Silence becomes evidence instead of disappearing between polls.

<div class="watch-showcase-arrow" aria-hidden="true">→</div>

<section class="watch-showcase-column watch-control-column" data-watch-stage="2" aria-labelledby="watch-control-title">
  <div class="watch-stage-label"><span>02</span><strong id="watch-control-title">Distill and correlate</strong></div>
  <ol class="watch-control-stack">
    <li><span>Watch</span><strong>Detect change + absence</strong></li>
    <li><span>Flow</span><strong>discard · digest · notify</strong></li>
    <li><span>Rollup</span><strong>Correlate exact watch IDs</strong></li>
    <li><span>Route</span><strong>Wake the exact resource</strong></li>
  </ol>
  <div class="watch-verdict">
    <div><span>rollup</span><span>absence</span><span>critical</span></div>
    <strong>Shipment activity is silent while inventory is below buffer.</strong>
    <p>Two independent streams become one governed operational signal.</p>
  </div>
</section>

<div class="watch-showcase-arrow" aria-hidden="true">→</div>

<section class="watch-showcase-column watch-outcome-column" data-watch-stage="3" aria-labelledby="watch-outcome-title">
  <div class="watch-stage-label"><span>03</span><strong id="watch-outcome-title">Wake or act safely</strong></div>
  <article class="watch-conversation-card"><span>shipping watch only</span><strong>Shipping conversation</strong><p>No shipment scan has arrived in four hours.</p></article>
  <article class="watch-conversation-card"><span>operations rollup only</span><strong>Operations conversation</strong><p>Shipment silence now threatens the inventory buffer.</p></article>
  <aside class="watch-action-gate">
    <div><strong>Draft supplier escalation</strong><span>approval pending</span></div>
    <code>action_hash · exact version</code>
    <p>No workflow runs until this exact action is approved.</p>
  </aside>
</section>

It remembers. Durable watches persist cursor checkpoints, reconnect after drops, and exponentially back off transient failures.

It respects attention. Digest noisy events, route by exact watch ID, or snooze one without marking it seen.

Alerts fail open. If AI triage is unavailable, GraphJin still sends the raw notification. Actions fail closed. A workflow never runs without the required approval.

Explore the reactive agent Run the coffee demo

Answers backed by evidence

The model made up an answer. The ledger caught it.

If no query ran, GraphJin will not let the model pretend that one did.

01 — The claim

The model answers anyway

It names roast batches to hold.

02 — The evidence

No query ran

The execution ledger has no rows behind the claim.

03 — The result

GraphJin blocks it

The invented answer never reaches the caller.

response.json

{
  "status": "blocked",
  "refusal": {
    "code": "saved_query_detail_required",
    "blocked_action": "execute_saved_query",
    "unblock": [
      {
        "tool": "query_catalog"
      }
    ],
    "retryable": true
  }
}

See how the guard works

Try GraphJin

Your first answer is one command away.

Choose a demo, run the command, and ask a question. The data and agent are ready to go.

Coffee roastery

"Which roast batch should be held for quality — and why?"

graphjin serve --demo --path examples/coffee-roastery

SaaS ops

"Which account is most at risk of churning?"

graphjin serve --demo

Corrugated plant

"Which work orders should the corrugator run first?"

graphjin serve --demo --path examples/corrugated-plant

PCB fab

"Which fab order should we release next — and what's the evidence?"

graphjin serve --demo --path examples/pcb-fab

Try a demo

Supported systems

12+ database engines.
APIs, files, and code too.

Postgres, MySQL, Snowflake, Redshift, BigQuery, MongoDB, Oracle, SQL Server, SQLite, Cassandra and Keyspaces — plus remote HTTP APIs, object storage, filesystems, and CodeSQL source trees. Mix as many sources as your deployment needs behind one GraphQL and MCP surface.

PostgreSQL

MySQL

MariaDB

MongoDB

SQLite

SQL Server

Oracle

CockroachDB

YugabyteDB

Snowflake

Redshift BigQuery Cassandra / Keyspaces

AWS Aurora

Cloud SQL HTTP APIs S3 / GCS / Files Code

How it works

One compiler. Any system. Any client.

Point GraphJin at databases, object storage, source trees, and remote APIs. It's a compiler, not a resolver framework: it learns the live shape, plans the work, and emits one optimized database operation — then enforces RBAC and serves AI assistants, REST clients, and federated routers from the same engine. No N+1, no resolver code, test-backed against real compiler paths.

The agent loop

Discover, check, validate, act.

A checked path from question to action.

Discover

gj_catalog

Check

gj_security

Validate

preview

Act

governed

Security model

Safer agents, not smaller agents.

One policy controls what agents can see, query, and change.

RBAC and row filters
Saved queries and allow-lists
Read-only source boundaries
Preview before change

policy-before-action.graphql

query {
  policy: gj_security(id: "summary") {
    mode
    summary
  }

  blockers: gj_security(
    where: { severity: { in: ["high", "critical"] } }
  ) {
    title
    recommendation
  }
}

Checked before every action.

AI integration

Connect any agent over MCP, in one command.

Add GraphJin to Codex or Claude, then start asking questions.

Code intelligence

CodeSQL: query your code as well.

CodeSQL indexes your source tree into a read-only SQLite graph. Agents can ask where a column is used, which code references it, which symbol owns that reference, and what guarded change set would update it — all through the same GraphQL interface.

agent asksWhere is users.email used?

GraphQL · gj_code

query {
  gj_code(where: {
    name: { eq: "users.email" }
    kind: { eq: "db_ref" }
  }) {
    path
    symbol_name
  }
}

matched rows3

api/users.gogetUser

api/invoices.tscreateInvoiceHandler

graph/schema.gouserType

tree-sitter → read-only SQLite

kind=filekind=symbolkind=db_refkind=doc

In the box

A full backend, not just an agent gateway.

The same binary and config that govern the AI surface also run your realtime, files, remote APIs, auth, and federation — no extra services to operate.

1Auditable config for agent access across the AI surface.

12+Database and warehouse engines through one GraphQL surface.

0Lines of resolver code. The compiler does the work.

Files as tables

Uploads stream to local disk, S3, R2, or GCS; each bucket is a queryable table you can join with the rest of your schema.

API

Remote APIs

Drop in an OpenAPI 3 spec and its operations become joinable, RBAC-aware fields with per-spec auth caching.

Realtime

Subscribe with the same GraphQL; cursor-based SSE and WebSocket streams resume after a drop, with polls batched into one statement.

JWT

Authentication

JWT and OIDC from Auth0, Firebase, Okta, or any JWKS — one auth pipeline across HTTP, WebSocket, SSE, and MCP.

Workflows

Discover approved workflows and run them through GraphQL, REST, MCP, or the CLI.

RDS

Caching

Response caching on Redis with an in-memory fallback and stale-while-revalidate.

CLI

One binary CLI

Dev server, database toolchain, device-code login, and MCP wiring. What runs in CI matches production.

FED

Federation

Advanced: flip a flag and every keyed table becomes an Apollo Federation v2 subgraph.

Get started

Run it in two minutes.

Install GraphJin, add your model key, and start the demo.