AppsAutessaDB

$ autessadb · database for AI apps

The database for AI apps that knows who is asking.

AutessaDB is the database for apps and AI agents: typed tables with built-in vector search, a columnar data lake for SQL over billions of rows, row-level security and column masking, and triggers that run tools and agents. Every person, agent, app and API key sees only the rows and columns it is allowed to.

Use it out of the box, then shape it to how your company works. No separate vector store, no separate warehouse, no security re-written in every client.

customersviewing as: sales_westSAMPLE
row rule: region IN $CURRENT_USER_TEAMStax_id: masked · last 4credit_limit: hidden
idnameregiontax_idnotes ◆
1042Harbor Freight Co.west•••• 4821Asked about renewal pricing
1043Larkspur Clinicwest•••• 0937Wants SSO for staff
1044filtered by row ruleeast——
1051Pine & Tide Foodswest•••• 5560Price increase concerns
1052filtered by row rulecentral——

◆ semantic search · notes

“customers worried about cost”

#1051 Pine & Tide0.86#1042 Harbor Freight0.79

⚡ trigger · on UPDATE

when status changed to at_risk

invoke agent RetentionAgent with @@{notes}

Same rules for:peopleagentsscriptsappsAPI keys

-- what is autessadb?

A managed database built for AI agents and the apps around them

AutessaDB is Autessa's system of record. It looks like a friendly table editor, but underneath it is a relational database on PostgreSQL with semantic (vector) search, row-level and column-level security, event-driven triggers and an access log, plus a columnar data lake for analytical SQL over large data. It is the database behind Autessa agents, tools, Drives and custom apps.

tablesTyped relational tables, from Short Text to Audio
vectorsSemantic search as a column setting
data lakeColumnar storage and SQL for billions of rows
securityRow rules and masks on every caller and query

-- what makes it different

One table. Three viewers. Zero extra code.

Most stacks bolt a vector database, an auth layer and a queue onto a plain database, then re-implement permissions in every client. In AutessaDB, the row rule, the column mask, the semantic index and the trigger all live on the table, so an agent, a portal visitor and an admin can share one source of truth safely.

customers · id 1042financeSAMPLE
Finance adminSees: all 1,284 rowstax_id94-1234821credit_limit$250,000
customers · id 1042salesSAMPLE
Sales rep (west)Sees: 312 rows · region = westtax_id•••• 4821credit_limithidden
customers · id 1042customerSAMPLE
Customer portal visitorSees: 1 row · their own accounttax_id••••••credit_limithidden

Computed columns

A computed column runs a short script over the row after each write and stores the answer, recomputing only when the columns it depends on change.

Read more →

Append-only tables

Append-only tables are write-once: rows can be added and read but never changed or removed, and the setting can be turned on but never off.

Read more →

Knowledge bases

Drag files or whole folders into a knowledge base and they are indexed for semantic search, with a Create Agent shortcut for a ready-made search agent.

Read more →

Semantic (vector) search

Mark a column for semantic search and every write is indexed in the background, enriched by AI, and searchable by meaning next to ordinary filters.

Read more →

File and audio search

File columns get an auto-written notes companion and audio columns get a transcript, so documents and calls are searchable like text.

Read more →

Database tools for AI agents

Ready-made tools give agents insert, update, delete, query, aggregate, semantic query, general search, Drive and data lake access to your tables.

Read more →

DB Copilot

Describe the data you need and the DB Copilot proposes tables and schema changes as cards you apply or reject, and answers questions about your data.

Read more →

Row-level security

Row rules decide which rows each caller sees, with placeholders for the current user, teams, roles and app visitors, and edit checks for changes.

Read more →

Column masking and hidden columns

Per role, a column is visible, masked (fully redacted, last four, or a consistent code) or hidden, and masked columns are stored encrypted.

Read more →

Plus more that only AutessaDB does. See every feature →

-- autessadb - columnar · the data lake

A columnar data lake, built into your database

Load events, logs, sales history and exports by the billion, then ask questions in SQL, in plain language or through an agent. Lakehouse-style columnar storage, partitions and archive tiers, on the same platform as your relational tables and Drive, under the same security on every query.

load
CSV & Parquetupload · in parts
Server-fetched fileslarge sources
AutessaDB tablesload-from-table
Apps & scriptsappend rows
AutessaDB - ColumnarSAMPLE
event_id
event_date
region
user_id
amount
payload
hot · queryablearchive · Parquet · restore
partitionssemantic layerretention
on every query:row rulesmasked columnshidden columns
ask
SQL WorkbenchANSI SQL · estimates
Askquestion → SQL
Data agentsdescribe · query · result
App dashboardsread-only queries

Explore the data lake and analytics →

-- product tour

Everything a database for AI apps needs, on one table

The main areas of the product, each with its own topic and deep-dive pages.

01 · tables and data modeling

Spreadsheet-simple tables with real types

Create a table in a three-step wizard, in chat with the DB Copilot, or in one CLI call. Typed columns cover text, numbers, selects and media, and every row carries an id and timestamps.
  • Foreign keys and join queries
  • Computed columns written in AutessaScript
  • Append-only tables for ledgers and audit data
  • Knowledge bases for drag-and-drop document search
Explore tables and data modeling →
support_tickets8 columnsSAMPLE
idINTEGERsystem
subjectSHORT_TEXTrequired
bodyLONG_TEXTsemantic
prioritySINGLE_SELECTp1 · p2 · p3
labelsMULTI_SELECT
screenshotIMAGE
call_audioAUDIOtranscribed
created_atDATETIMEsystem

02 · semantic search and AI

Vector search is a column setting

Mark a text, file or audio column for semantic search and every write is enriched by AI and indexed in the background. The same table answers questions by meaning and by filter.
  • Notes for every file and transcripts for every recording
  • Ready-made AutessaDB tool types for agents
  • DB Copilot designs schemas you approve
Explore semantic search and ai →
call_notes · Semantic Searchcolumn: summarySAMPLE
which calls mention pricing complaints?
#7712Customer said the new tier feels too expensive for a team of four0.88
#7690Asked whether annual billing lowers the per-seat cost0.81
#7655Comparing us with a cheaper tool before renewal0.74
Enriched on write: summary · key facts · likely questions. Filter alongside: status = 'open'.

03 · row-level security and access

Row rules and column masks for every caller

Security roles decide which rows each person, agent, app or API key sees and which columns are visible, masked or hidden. Edit checks stop anyone moving a row outside their own view.
  • Placeholders for users, teams, roles and app visitors
  • Encrypted masked columns with logged reveals
  • A row-level access log with a chain check
Explore row-level security and access →
Role · Regional sales → table policy: customerswriteCheck: SAME_AS_READSAMPLE

Row filter

regionIN$CURRENT_USER_TEAMS
archivedEQUALSfalse
calleracting asrows visible
persondana@ (team west)312
agentruns as dana@312
API keyown role: reporting1,284
public app visitor$CURRENT_USER_ID unset0

04 · triggers and pipelines

Rows that start work

Triggers fire on insert, update or delete and run a tool, an agent, a multi-agent or a write to another table. Chain them and every pipeline stage is a table you can open.
  • Column-change conditions such as Became Non-Null
  • Impact analysis with cycle warnings
  • Execution history with before and after rows
Explore triggers and pipelines →
stage 1intake⚡ INSERT → ExtractText tool
stage 2documents⚡ text non-null → ReviewAgent
stage 3reviewed⚡ verdict = ok → copy to published
analyze-trigger-impact · intake INSERTstatic · nothing runsSAMPLE
matched triggers   3
tables touched     intake, documents, reviewed, published
tools / agents     ExtractText, ReviewAgent
detectedCycles     1  severity: WARNING
  documents → reviewed → documents (verdict = redo)

05 · data lake and analytics

SQL over billions of rows

The columnar data lake stores events, logs and history and answers analytical ANSI SQL as fast asynchronous jobs. A semantic layer of measures and verified queries keeps every answer consistent, from people and agents alike.
  • CSV and Parquet bulk loads, plus loads from tables
  • Estimates before you run
  • Retention and archive tiers for long-kept data
Explore data lake and analytics →
SQL WorkbenchScans ~1.2 GBSAMPLE
SELECT region, date_trunc('month', order_date) AS month,
       SUM(net_amount) AS revenue
FROM order_lines
WHERE order_date >= DATE '2026-01-01'
GROUP BY 1, 2 ORDER BY 2, 1
regionmonthrevenue
NA2026-012,411,093.20
EMEA2026-011,502,118.45
APAC2026-01612,077.40
Download CSVDownload ParquetSave as verified query

06 · files, apps and operations

The backbone for files and apps

Drives are AutessaDB tables of files, and custom apps keep both their data and their sign-in users in AutessaDB, with each visitor scoped to their own rows.
  • Per-visitor row rules for client portals
  • Drives with grep, search, push and pull
  • Soft delete with 14 days to restore
Explore files, apps and operations →
Client Portal · My orderssigned in: kim@harbor.exampleSAMPLE
orderstatustotal
5531shipped1,240.00
5540open86.00
Only Harbor Freight’s rows. The app asks for orders; the database applies the visitor’s rule.
Role · Portal customers → ordersSAMPLE
assigned to: CUSTOM_APP  Client Portal
row rule:    account_id EQUALS $CURRENT_CUSTOMAPP_USER.account_id
writeCheck:  SAME_AS_READ

-- for developers

REST API, CLI, SDK and agent tools over the same tables

Every operation in the builder is also an API call, a CLI command and an SDK method, and all of them pass through the same row and column security.

Insert a typed row (CLI)bash
autessa autessadb query insert --tableId ayXduiaLeFKh --values '{
  "task":   { "columnType": "SHORT_TEXT",    "textValue": "Write the CLI docs" },
  "status": { "columnType": "SINGLE_SELECT", "textValue": "doing" }
}'
Read a table (REST API)bash
curl https://api.autessa.com/clients/autessadb/get-data?resourceId=V1StGXR8Z5 \
  -H "Authorization: your_api_key" \
  -H "Content-Type: application/json"
Query the data lake (CLI)sql
autessa analytics query "
  SELECT region, SUM(net_amount) AS revenue
  FROM order_lines
  WHERE order_date >= DATE '2026-01-01'
  GROUP BY region ORDER BY revenue DESC"
Give an agent vector search (tool config)json
{
  "toolType": "AUTESSADB_SEMANTIC_QUERY",
  "tableId": "V1StGXR8Z5",
  "query": "@@{SEARCH_QUERY}",
  "columnName": "document_text",
  "limit": 10,
  "scoreThreshold": 0.5
}

-- schema of the product

Every topic and feature

Every topic has a page of its own, and every feature a deep dive.

-- how it works

How do you build on AutessaDB?

  1. step_1

    Model

    Create typed tables by hand, in chat, or from the CLI. Mark the columns that should be searchable by meaning.

  2. step_2

    Secure

    Share the table, then add a security role: a row rule, an edit check and masked or hidden columns.

  3. step_3

    Connect

    Give agents AutessaDB tools, build an app on the tables, or call the REST API, CLI and SDK.

  4. step_4

    Automate

    Add triggers that run tools and agents when rows change, and bulk-load events and history into the data lake for SQL.

-- use cases

What teams build on AutessaDB

Use cases by role and industry →

RAG and AI search

Knowledge bases and vectorized columns ground agents in your documents, calls and records.

Client portals

Apps where each customer signs in and sees only their own rows.

Operational records

Tickets, orders, intake and case files that people and agents both work on.

Ledgers and audit trails

Append-only tables plus an access log for data that must not change.

Document pipelines

Intake, extract, review and publish as trigger-chained tables.

Data lake reporting

Call records, events and sales history in the data lake, with SQL, Ask and data agents.

-- integrations

Built into the rest of Autessa

Agents and tools read and write tables, custom apps use them as their backend, Drives are built on them, and the REST API, CLI and SDK reach them from anywhere.

See integrations →

-- security

Security that lives in the data

Row rules, edit checks, encrypted masked columns, hidden columns, sharing levels, an access log and soft delete apply to every caller. Autessa's security documentation is in the Trust Center.

How AutessaDB protects data →

-- compare

Evaluating AutessaDB against other databases?

Fair, factual comparisons with the tools teams most often look at next to AutessaDB.

Building the whole stack? See the AI-native runtime and the Builder Platform, where you build apps, scripts and workflows on your tables. Capture any of those workflows automatically with Autessa Autodocs: do it once in the browser and get a step-by-step guide and a replayable workflow.

-- faq

Questions about AutessaDB

What is AutessaDB?

AutessaDB is the database for apps and AI agents. You create typed tables, query them with filters, joins and aggregates, search them by meaning, protect them with row-level security and column masking, and automate them with triggers. Its columnar data lake holds billions of rows for SQL analytics, all from the builder, the REST API, the Autessa CLI or the AutessaScript SDK.

Does AutessaDB work out of the box?

Yes. Create a table, drop in a file or start a data lake load, and it works the same day, with sharing, security and agent tools ready. Then you shape it to how your company works: your own columns, row rules and masks, triggers that run your tools and agents, a semantic layer in your own business terms, and apps built on your tables.

Does AutessaDB include a data lake?

Yes. AutessaDB - Columnar is a data lake built into AutessaDB, with lakehouse-style columnar storage for millions to billions of rows such as events, logs, sales history and exports from other systems. You bulk-load CSV and Parquet files or existing tables, partition by date, query with analytical SQL, ask in plain language, and give agents tools to answer data questions, with the same sharing and row and column security as every other table.

Can AI agents answer questions about my data with SQL?

Yes. One action creates three tools for the tables you pick: describe the tables, run a query, and read the result. An agent with them looks up what the tables contain, prefers your verified queries, filters on partition columns, and pages through long results, seeing only what the person or key it runs as may see.

Does AutessaDB have vector search?

Yes. Mark a Short Text, Long Text, File or Audio column for semantic search and every insert and update is embedded in the background, with no separate pipeline or re-index job. An AI step also enriches each value with a summary, key facts and likely questions, so search matches meaning, and it works next to ordinary filters on the same table.

Does AutessaDB support row-level security?

Yes. Security roles carry a row rule per table, written as a filter with placeholders such as $CURRENT_USER_ID, $CURRENT_USER_TEAMS or $CURRENT_CUSTOMAPP_USER_ID, plus an edit check for changes. The same rules apply to every caller, whether a person, an agent, a script, an app or an API key.

Can AI agents read and write AutessaDB tables?

Yes. Ready-made AutessaDB tools let agents insert, update, delete, query, aggregate, run semantic search, browse Drives and query the data lake with SQL. Agents act as the person or key they run as, so they see only the rows and columns that identity is allowed to see, and their writes fire triggers like any other write.

How do database triggers work in AutessaDB?

A trigger fires on INSERT, UPDATE or DELETE of a row, optionally only when specific columns change in a specific way, and runs a tool, an agent, a multi-agent or a write to another table. Row values pass in as @@{column} and @@{old.column}, and every firing is recorded with the row before and after and the response. Agents can also call or email a customer when a row changes, following your instructions.

Can I query AutessaDB with SQL?

Yes. The data lake answers read-only ANSI SQL, with joins, common table expressions, subqueries, unions and window functions, in the SQL Workbench, the CLI, the API, custom apps and agents. Relational tables use structured queries (filters, joins and aggregates), which is what lets them carry triggers and semantic search per row.

How do I protect sensitive columns?

Mark a text column masked to store it encrypted, then decide per security role whether the column is visible, masked or hidden. Masked shows a full redaction, the last four characters or a consistent code; hidden removes the column entirely; and every reveal of a masked value is recorded in the access log.

Is there an API and CLI for AutessaDB?

Yes. The REST API lives at https://api.autessa.com/clients/autessadb with per-table API key permissions, the Autessa CLI has an autessadb namespace covering tables, queries, triggers, roles, the access log, Drives and analytics, and scripts use the autessa.autessadb SDK. All three apply the same row and column security as the web app.

When should I use a relational table and when the data lake?

Use a relational table for records people and agents read and change one at a time, with triggers, semantic search and row edits. Use the data lake for data that arrives in batches and is read in aggregate, such as events, logs and history, queried with SQL over millions to billions of rows. Both share the same sharing levels and row and column security, and you can load a relational table into the data lake in one step.

Can I make a table that can never be edited?

Yes. An append-only table accepts inserts and reads but refuses every update and delete. The setting is a one-way latch: it can be turned on but never off, computed columns are not allowed on it, and removing a column is refused because it would destroy history.

Where can I read about AutessaDB security and compliance?

The AutessaDB security page explains row rules, masking, sharing levels and the access log, and the Autessa Trust Center at trust.autessa.com has Autessa's security documentation and compliance reports.

$ autessa autessadb tables create

Give your agents a database that keeps them in bounds.

Use it out of the box: create a table or load the data lake, write one row rule, and every person, agent and app sees exactly what it should. Then shape it to how your company works.

Read the AutessaDB guide or install the CLI.

100% customizable, code and all

Make AutessaDB fully your own.

Use it out of the box, then change anything. Ask Autobot, Autessa’s AI builder, for a new field, screen, report, workflow or agent and it builds it into your copy of the app. Or open the code and edit it yourself. Nothing is locked: the app, its data and its code are yours.

Start free and make it yours