The platform
Eight pieces. One way to plug them in.
Everything the agent builds for you - the integrations, the logic, the data, the screens - is made of eight kinds of piece, called primitives. Every piece is described the same way, plugs in the same way, and lands in the same audit log. That is why the agent can build your system and run it in the same session. This page is the machinery behind the promise on the front page.
The primitives
Everything you run is made of these eight.
A primitive is a piece the agent can build for you live and use in the same session. There are no others - this is the whole catalogue.
01 · task
Where work happens.
One job, held in one place - the state, the connections, the logic, and the screens it needs. Add the agent and the task gains a builder; remove it and the task still runs.
02 · connection
One doorway to everything.
Stripe, Gmail, Microsoft 365, any API a vendor documents. The agent sets a connection up live: it walks the import, checks the permissions, and uses it in the same session.
03 · codeLibrary
Your rules, as tested code.
Business logic written as typed code and verified against your real systems before anything is committed. Grounded, not guessed.
04 · customData
Tables you own.
Your records in your own database, in tables you approve before they're created - because schemas are hard to change once data is in them. Real rows, real SQL.
05 · app
Screens your team clicks through.
The agent drafts an app, fixes it until it runs cleanly, and saves it. What your team uses today, it built minutes ago - no release, no second tool.
06 · taskStore
Memory you can see.
Everything a task knows lives in one structured, versioned store - not a prompt window. The agent works on it by address; you see the same data as panels, tables, and forms.
07 · schema
One contract for everything.
A single set of definitions describes the data, the screens, the actions, and the gates. The agent sees exactly the actions your team sees, so it can't invent ones that don't exist.
08 · sysConnection
The platform is a piece too.
Users, access, schedules, billing - Panaptic's own controls plug in like any other connection. The agent that runs your work can look after the system that runs it.
Eight pieces is not a limitation. It's the reason everything composes - and the reason the agent never meets a part of your system it can't read.
See what teams build with themThe AI is a piece too
The agent plugs in the way Stripe does.
The AI isn't a sidebar bolted onto the tool. It's a connection you add to a task, next to your payments and your customer table. Because it lives on the same plane as everything it touches, one agent does three jobs: it runs the work, it builds new pieces, and it looks after the system itself.
- It reads the same catalogue of actions your team sees - it can't call anything that doesn't exist
- It's added per task - a task without the agent is just software, and still runs
- You choose the model per organization - and can mix a frontier model for building with a fast one for high-volume work
// same shape, same import, same audit log
On the record
Signed by who took it. Every time.
A person approves an invoice. The agent sorts an email. The scheduler runs the nightly reconcile. All three land in the same log the same way: the actor, the action, the inputs, the moment. Building is recorded like running - when the agent registers a connection, that's a signed action too.
- Every entry maps to a real, defined action - nothing free-form
- Retries are safe: an action that must not fire twice, can't
- The log isn't a feature you switch on - it's the layer everything runs through, and it exports to the observability stack you already run
Included
The infrastructure is already on.
None of this is installed, provisioned, or deployed. Every capability below is there when your organization is - governed by the same actions and the same audit log as everything you build.
scheduler
Scheduled work
Run tasks on a clock - cron or calendar rules - with state that survives between runs. No server to keep alive.
postgres
Your own database
Every organization gets its own PostgreSQL: your tables, real SQL, hard boundaries.
sql
Query anything
Query your tables, join live API responses, or read cold files in a bucket - one language across all three.
documents
Documents & PDFs
Reports render from templates, so a layout lives where you can change it - not buried in code.
blobs
File storage
Durable files with signed links - managed for you, or pointed at your own bucket.
spend
Spending caps
Caps in dollars per person, team, or organization - by task, day, week, or month. One bad run can't blow the budget.
observability
Observability
Logs, traces, and errors for any past run, exportable to the stack you already watch.
models
Model choice
Pick your AI provider per organization - Claude, Gemini, and others - and mix tiers to match the work.
Where your data lives
Typed records by default. A data lake only if you need one.
customData
Your records
CRM rows, cases, invoices, config - typed tables on your own database. Most reporting is a direct query against them; you don't stand up a pipeline to read your own records.
duckdb
Cold files, queried in place
Point a connection at Parquet or CSV files in a bucket and query them where they sit - for the large analytical data that doesn't belong in your operational tables.
Panaptic isn't a data warehouse by default - and it doesn't make you build one just to get an answer.
Begin
Watch it build. Then run it.
Spin up a workspace, describe how your business works, and watch the agent build the pieces and run them - live, in one session - or talk to us about a guided rollout for your team.