Why DeepORG05No hand-built tools
A map of everything, not a tool for each thing.
Most company agents are wired up one tool at a time. DeepORG gives the agent a searchable map of everything you connect, and the agent writes its own queries against it. Connecting a new database or API is a few lines of config, not a new set of tools.
The problem
Your agent is only as good as what it can see.
A capable model still enters your stack blind. It does not know your schema, your permissions, your saved queries, or where a field is written in code, so it works from memory and guesses.
The usual fix is a tool for each question: a “get customer” tool here, a “list invoices” tool there, each written and maintained by hand. They break when a schema changes, and every new question or new system means more tools.
- A tool for every question. Worldwide AI spend is forecast at $2.5 trillion for 2026,1 yet teams still hand-write a brittle API or MCP tool for each thing an agent might ask. The surface never keeps up.
- Guesses, not facts. 21% is the best model’s success rate on real enterprise text-to-SQL, down from 91% on academic benchmarks.2 Without a map, agents invent joins and fields.
- Too risky for production. 88% of organizations saw an AI-agent security incident in the past year.3 Raw credentials mean hoping the agent guesses right, so it stays read-only, shallow, or boxed out.
The fix is not a smarter prompt. It is giving the agent the map, and the guardrails. And it is not another raw connector: 43% of tested MCP servers shipped with command-injection flaws.4
Sources: 1. Gartner, Jan 2026 · 2. Spider 2.0, ICLR 2025 · 3. Gravitee State of AI Agent Security, 2026 · 4. Equixly, 2025
The map
One catalog of everything you connect.
DeepORG keeps a catalog of everything it can reach: databases and sources, tables and columns, relationships and the paths that cross from one database to another, functions, workflows, query patterns, and what each source is allowed to do.
The agent learns one habit: search by intent, then inspect the best match. Every run begins with a search for the person’s own words. It pulls more only when a path it needs is missing, so the map can be very large while the model reads a small part of it. By default the first search returns up to 40 entries and later ones 20.
- Search by intent. “Which accounts are behind on payment” finds accounts, invoices and the relationship between them, whatever the columns are called.
- Inspect by id. One entry at a time: the columns, their types, the values a status column can take, and how the table joins its neighbours.
- Notes people leave. Pin a note to anything on the map: what a column really means, which table is the source of truth. A note is approved before it is shared, and the agent treats it as data, never as an instruction.
The agent loop
Discover, check, validate, act.
The model does not pick from a menu of tools. It writes a short program that calls a small, fixed set of functions: search the catalog, read the query syntax, validate a filter, run a query, and finish.
Discover
gj_catalogCheck
gj_securityValidate
previewAct
executeSome steps cannot be skipped. A write may only run after the target table’s detail has been inspected, and a workflow is rejected until its detail was read. A model cannot talk its way past that: only real results count.
A new system
A few lines of config, not a new set of tools.
Connecting a database is naming it:
sources:
- name: app
kind: database
type: postgres
default: true
connection_string: ${DATABASE_URL}
schema: public
- name: warehouse
kind: database
type: snowflake
connection_string: ${SNOWFLAKE_DSN}Once a source is connected, its tables, columns and relationships are on the map. There is no tool to write for it and none to update when a column is renamed. Every system you run covers APIs, files and source code.
What runs
The agent writes the query. The engine checks it and runs it.
The agent’s query is GraphQL. The engine compiles it into a single database query, applies your access rules while compiling, and returns the result. The model plans and the database computes: sums, counts and rankings are done where the data is.
One honest limit: a question that crosses two databases is not one statement. The engine fetches the parent rows, then runs the child query on the other database.
In the docs
Go deeper.
- The catalog: what is on the map and how the agent searches it.
- Annotations: notes people pin to the map.
- MCP: the fixed set of tools an outside agent sees.
- Sources: connecting databases, files, code and APIs.
- The compiler: how one query becomes one statement.