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.
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.
Your systems
Postgres · Snowflake · MySQL · APIs · Files · Code
DeepORG
- Discover
- Connect
- Run
- Check
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.
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: customerA 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.
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: invoicesNow 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.
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: falseLocal 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.
users.email used?query {
gj_code(where: {
name: { eq: "users.email" }
kind: { eq: "db_ref" }
}) {
path
symbol_name
}
}kind=filekind=symbolkind=db_refkind=docSame 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.
- Database support: the matrix, engine by engine.
- Multiple databases: how cross-database queries run.
- OpenAPI: remote APIs as joinable fields.
- Files and uploads and CodeSQL.
- MongoDB and sources.