Every system you run DeepORG connects databases, warehouses, HTTP APIs, files and source code into one map the agent can search, so one question can draw on several of them. Adding a system is a few lines of config. why why why/every-system why/every-system.md

Why DeepORG08Every system you run

Every system you already run, behind one agent.

Databases, warehouses, HTTP APIs, files and source code. Each becomes part of one map the agent can search, and one question can draw on several of them.

many systems / one map / one agent

One question

Real questions do not stay inside one system.

Who is at renewal risk is partly in the accounts table, partly in product usage in the warehouse, partly in the CRM, and partly in a policy document. An agent that sees one of those gives a partial answer and does not know it.

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

Your systems

12+engines
1,000sof tables
100sof columns

Postgres · Snowflake · MySQL · APIs · Files · Code

02

DeepORG

  1. Discover
  2. Connect
  3. Run
  4. Check
03

Agent answer

  • Who is at risk
  • Why
  • What can happen next

Answer · data · evidence · actions

Databases and warehouses

Name it, and it is on the map.

DeepORG works with PostgreSQL, MySQL, SQLite, MongoDB, Oracle, SQL Server, Snowflake and Cassandra, and reads from BigQuery as an experimental source. The support matrix says how far each one goes.

PostgreSQL MySQL MariaDB MongoDB SQLite SQL Server Oracle CockroachDB YugabyteDB Snowflake BigQuery Cassandra / Keyspaces AWS Aurora Cloud SQL HTTP APIs S3 / GCS / Files Code
YAML
sources:
  - name: app
    kind: database
    type: postgres
    default: true
    connection_string: ${DATABASE_URL}

  - name: warehouse
    kind: database
    type: snowflake
    connection_string: ${SNOWFLAKE_DSN}

relationships:
  - from: app.orders.customer_id
    to: crm.customers.id
    as: customer

A relationship can cross from one source to another. Fields from different databases come back merged in one reply. A nested join across two databases is not one statement: the engine fetches the parent rows, then runs the child query on the other database.

MongoDB is not sent SQL. The same question is compiled into an aggregation pipeline instead.

APIs

Drop in an OpenAPI spec. Its operations join your tables.

YAML
sources:
  - name: billing_api
    kind: api
    specs_dir: config/specs
    specs:
      stripe:
        base_url: "https://api.stripe.com"
        auth:
          scheme: bearer
          token: ${STRIPE_TOKEN}
        joins:
          listInvoices:
            parent_table: customers
            parent_column: stripe_customer_id
            param: customer
            expose_as: invoices

Now customers has invoices, and they come from Stripe. Supported GET operations become joins, single records or lists that sit beside database fields in the same query. Operations that change something are skipped unless you expose them, and then they wait for a person’s approval.

Files

A bucket is a table.

YAML
sources:
  - name: documents
    kind: file
    backend: s3
    bucket: app-documents
    prefix: tenants/${account_id}
    presign_ttl: 15m
    capabilities:
      files.list: true
      files.read: true
      files.write: false

Local disk, S3 and GCS all work the same way. Every file table has the same columns: key, size, content_type, etag, modified_at, url and data. A contract, a policy document or an export can be found and read by the same agent that reads the accounts table.

Source code

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, and which symbol owns that reference, through the same interface as everything else. It is evidence from source code without handing a model a shell.

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

Same rules everywhere

One set of access rules, whichever system answers.

Whatever the source, a query passes through the same checks before it reaches the backend: who is asking, what that source is allowed to do, and what their role may see. A source marked read-only stays read-only. Your rules, your approval covers this.

In the docs

Go deeper.