Your AI agents forget. Give them memory as tables.
Vilix AI already gives every AI tool you use one shared memory. Tables is the next step: memory structured as tables you define, rows your agents create and maintain, searchable three ways, with each agent getting only the access it needs.
In development. Waitlist members shape what ships first and get early access.
Your agents start every run from zero.
If you run AI agents on a schedule, across tools, or across devices, you know this pain:
- Lost decisions. You decided something three weeks ago. The agent decided the opposite yesterday. Nobody wrote it down where the agent looks.
- Stale vs. current. Your notes say one thing, reality changed, and the agent can't tell which version is true. So it guesses.
- The re-briefing tax. Every session starts with you pasting context, re-explaining the project, re-stating what failed last time. Operators tell us this eats hours a week.
- Scheduled agents running blind. A nightly agent wakes up, has no idea what last night's run did, repeats the same failed approach, and you find out in the morning.
- Context scattered across tools. You plan on your phone, build on your laptop, automate with n8n. Each tool remembers nothing about the others.
Markdown files, Notion pages, and hand-rolled databases were never built for agents to read and write. They go stale, they contradict each other, and no agent knows which one is the truth.
What operators told us.
We've spent the last week in open conversations with dozens of people who run AI agents: scheduled jobs, multi-agent setups, automation operators. We asked about their workflows, their workarounds, and what breaks. The same patterns came up again and again, in their own words.
“What gets lost is never facts, it's decisions.”
One operator running multiple coding agents told us his team decided weeks ago not to touch the URL structure for SEO reasons. A fresh agent session then “cleaned up” the slugs anyway, because nothing in its context said why they looked that way. Facts it can re-derive from the code; the reasoning behind a decision it can't. His workaround: a plain decisions file, one line per decision plus the why, which every agent has to read first. Boring, he said, but it fixed most of it.
“What bites me is losing rejected decisions. The agent retries an approach that already failed, because only the working solution survived the summary. These days I keep an append-only log of what didn't work alongside the plan, and that file is the only thing I trust across sessions.”
“An agent of mine counted the same unchanged thing three separate times in one day, because every run started clean and the previous answer only existed in the last run's output. It was not confused, it simply had no idea it had already asked.”
Everyone's workaround is a markdown file. Every one of them is manual.
The most common setup we found: a few markdown files per project (overview, roadmap, decisions, changelog) pasted into every new session. One operator keeps it under a few hundred lines to avoid re-explaining decisions from six months ago. Another has the agent spit out the updated file and pastes it in by hand.
It works until it doesn't. Files go stale, nobody knows which version is current, and one operator summed up the tax perfectly: after building an elaborate tagged knowledge vault just to feed his agent the right context, he felt like he was working for the tool instead of the other way around.
Some operators already built the database version.
One automation operator got tired of files and wrote his own command-center app with a database backend: agents check tasks out and back in, report status, and he never has to re-explain anything. Another moved everything into one short doc every tool reads on its own, and went from twenty minutes of re-explaining to “read the doc first.”
The pattern: every workaround is reaching for the same thing. Structured, shared, current state that agents read and write themselves, instead of files a human maintains. That is exactly what Tables is.
Memory as tables your agents manage.
Instead of a pile of notes, your agent memory becomes a small set of structured tables. You define the tables and fields. Your agents do the rest through plain conversation: create tables, add rows, update a status, mark a decision superseded.
Every table ships with three kinds of search built in:
- Semantic search. Ask in plain words, find by meaning. “What did we decide about pricing?” finds the row even if it never uses the word pricing.
- Keyword search. Exact matches when you know the term.
- Field filters. Structured queries on what matters. Show me decisions where status is active. Show me failed runs from the last 7 days.
And every change is audited: which agent wrote it, when, and what the previous value was. No more mystery edits. No more “who told the agent that?”
Four steps, no new skills to learn.
Start from a template.
Pick a ready-made table set for your setup: coding agent, automation operator, researcher, founder. Or describe what you need in plain words and your agent builds the tables for you.
Agents maintain it.
When a decision is made, the agent logs it. When a run finishes, the agent writes the receipt: what happened, what failed, what is next. When a decision changes, the agent marks the old row superseded instead of deleting history.
Every agent reads the same truth.
Phone, laptop, scheduled runs, different models: they all query the same tables through the Vilix AI MCP server. No re-briefing. No drift.
You stay in control.
Per-agent permissions decide who can read and write which table. One trusted agent can act as your command center; narrow agents stay narrow.
Start from a template, not a blank page.
Every template is a starting set of tables with fields. Rename, add, or remove anything. These are the five shipping first.
Decisions
Fields: decision (text) | status (active / superseded) | date made | made by (agent or person) | source (link to the conversation) | notes
Example row: “Switched the nightly scrape from API to HTML parsing” | active | 2026-09-10 | research-agent | link | “API rate limits made the old approach fail 3 nights in a row.”
Why it matters: agents stop re-litigating settled questions, and when a decision changes, the old one is marked superseded, never silently overwritten.
Run logs
Fields: run id | agent | started at | finished at | status (success / failed / partial) | summary | errors | next steps
Example row: “run-4821” | nightly-research | 02:00 | 02:41 | failed | “Scrape blocked after page 12” | “HTTP 429, rotating proxy flagged” | “Retry with residential proxy; alert if it fails twice.”
Why it matters: the next run reads the last runs before starting. Failed approaches don't get repeated. You get a morning-readable history instead of a black box.
Conversations
Fields: your message | assistant reply | date | time | agent or tool used
Example row: Full history of a planning session on the phone, continued on the laptop the next morning.
Why it matters: not just extracted facts. The real conversation, revisit-able, across every tool.
Tasks and projects
Fields: title | status (todo / doing / done) | priority | owner agent | project | due
Example row: “Rewrite onboarding email” | doing | high | copy-agent | launch | 2026-10-02
Why it matters: plan on your phone, execute on your laptop, review on a schedule. Every agent sees the same board.
Skills and procedures
Fields: name | steps | last used | version | notes
Example row: “Deploying the marketing site” | 1. push to main, 2. verify live bundle, 3. check analytics | 2026-09-23 | v3 | “Step 2 was added after the stale-bundle incident.”
Why it matters: hard-won procedures stop living in one chat thread and start being reusable everywhere.
What it looks like in practice.
The automation operator
Your nightly research agent reads the run logs table first: last three runs, what failed, what is next. It avoids the blocked approach, finishes clean, and writes its own receipt. A decision made mid-run, like switching data sources, lands in the decisions table as active. Next week, when you ask why the source changed, the answer is one query away, with the agent’s name on it.
The developer across tools
You plan features on your phone with Claude, build on your laptop with Cursor, and run a review agent on a schedule. The tasks table is the shared board. The decisions table holds architecture calls with their reasons. The skills table holds your deploy procedure. No tool needs re-briefing, because none of them is the source of truth. The tables are.
The researcher
Papers, experiments, and findings land in tables with fields like verdict, key finding, and still-valid. Six months later, semantic search answers “what did we conclude about retrieval benchmarks?” from the actual rows, not from your memory of your memory.
The founder
Every company decision goes in the decisions table: pricing changes, positioning calls, hires, kills. Status flips to superseded when you change your mind, with the date and reason preserved. Your future self, your co-founder, and your agents all read the same decision log.
The team with contractors
Your contractor's coding agent gets read/write on one project table and nothing else. Your command-center agent sees everything and can suggest permission changes, which you approve. Least privilege, without a dashboard maze.
Permissions and audit, by design.
Tables are powerful, so access is explicit. Every agent has an identity, and every table has permissions: which agents can read, which can write. Routine narrow grants can happen conversationally; widening access is always logged and needs your approval.
Every write records who made it and when, with the previous value preserved. If an agent writes something wrong, you see exactly what changed and roll it back. Trust comes from provenance, not promises.
Files, documents, and photos.
Tables don't swallow your files. Documents, PDFs, screenshots, and photos stay in file storage. The table holds the link plus a rich description of what the file contains, so files stay searchable by meaning alongside everything else. Whoever saves the file writes the description at save time.
How this compares.
Vs. Markdown files and notes.
Files go stale and contradict each other. Tables have status fields, so current vs. superseded is a query, not a guess. Agents update rows instead of appending to a 400-line doc.
Vs. Notion and wikis.
Built for humans to read, not agents to maintain. No agent identity, no audit trail, no semantic-plus-field search in one place.
Vs. DIY Redis or Postgres.
Powerful, but you build the schema, the search, the permissions, and the agent instructions yourself, then maintain all of it. Tables gives you that stack as a service, managed through conversation.
Vs. ChatGPT or Claude memory.
Tied to one tool. Vilix AI is a hosted MCP server, so the same memory, including tables, follows you across ChatGPT, Claude, Cursor, Codex, and any MCP-compatible tool. One memory, every device, every app.
Building in stages. You set the priority.
We're building in this order, and the waitlist decides the priority within it:
- Structured tables + run logs. Define tables, agent-managed rows, decision and run history.
- Templates + three-way search. Ready-made setups, semantic/keyword/field search.
- Permissions + audit trail. Per-agent access, full change history.
Waitlist members get early access as each stage lands.
Questions, answered.
How is this different from ChatGPT's memory or Claude's memory?
Do my agents need to change? Do I rewrite my prompts?
What happens to my files, PDFs, and images?
How do agents find the right row?
Can I control which agent sees what?
What if a decision changes or two agents disagree?
Which AI tools does it work with?
Is my data private? Can I export or delete it?
When does the tables upgrade ship?
How much will it cost?
I'm an investor. Why does this matter?
Get early access to Tables.
Vilix AI is live today with shared cross-tool memory. Tables is in development, and the waitlist shapes what ships first. Tell us what you need.
P.S. Vilix AI is live today with shared memory across your AI tools. Try it now, and we'll email you the moment tables land.