No hand-built tools Most company agents are wired up one hand-written tool at a time. DeepORG gives the agent a searchable map of everything you connect and lets it write its own queries, checked against your access rules and run as one database query. why why why/no-hand-built-tools why/no-hand-built-tools.md

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.

a tool for each thing / a map of everything

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.

01

Discover

gj_catalog
02

Check

gj_security
03

Validate

preview
04

Act

execute

Some 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:

YAML
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.