The platform that writes its own integrations, code, and apps.
Panaptic is a self-authoring, agent-native business operating system. Describe how your business works, and the agent builds the pieces to run it — connections to your systems, typed code libraries that hold your logic, apps your team clicks through, Custom Data schemas that own your records — then wires them into tasks. Build-time and run-time are the same environment: the agent that authors a primitive is the same agent that operates it, against the same typed catalogue, in one audit log.
Eight primitives the agent builds and runs.
Each primitive is a typed connection the agent can author live and operate the same session. Together they cover everything from a manual workspace to a fully autonomous agent — and the AI reads them all the same way it reads Stripe.
Tasks
The surface the agent builds onto and runs from. A task holds state, imports connections, runs operations, and renders UI. There is no separate "agent task" — add the agent connection and the same task gains a builder; remove it and the task still runs.
Connections
One primitive for everything. A connection is a configured, typed, credentialed instance of an integration — Stripe, M365, Google Workspace, any OpenAPI/GraphQL/HTTP/A2A. The agent authors new connections live: it walks the import, validates scopes, then registers and uses them in the same session.
Code libraries
Your business logic as typed TypeScript operations, authored live inside the platform. The agent writes them through a gated 6-phase workflow — verifying against real API responses before it commits a typed contract — so the code that runs your logic is grounded, not guessed.
Custom Data
Tables you own, defined in JSON Schema, on per-org PostgreSQL with JSONB — auto CRUD plus raw SQL. The agent drafts the schema in a scratchpad, previews it for you, and only creates the namespace once you confirm, because schemas are hard to change after data is written.
Apps
The apps your team clicks through — React + Mantine, compiled live and reactive to task state. The agent drafts a widget inline and self-heals it through compile and runtime errors before saving, so what your team uses today the agent built minutes ago, with no PR and no deploy.
Task Store
A normalised, typed, path-addressable, version-tracked store — the agent's persistent memory and your live workspace at once. State lives in a queryable store, not crammed into a prompt window. The agent navigates and writes to specific paths; you see the same elements as panels, tables, and forms.
Schemas
JSON Schema is the contract for inputs, outputs, UI rendering, the agent's operation catalogue, confirmation gates, and the audit trail. Because the agent sees the exact operation list humans see, it can't invent operations that don't exist — and the same type system spans code, data, UI, and AI.
System connections
Panaptic's own surface, callable like any integration — sysTask, sysUser, sysOrg, sysAccess, sysBoard, sysUsage, sysRag, sysFlags. So the agent that runs your work can also build and administer it: provision teammates, set access, schedule tasks, manage billing. No separate admin console, no second API.
AI is a connection
The agent imports the same way Stripe does — and builds the rest.
In Panaptic the AI agent isn't a chat sidebar bolted onto your tool. It's a typed connection you import into a task, alongside your CRM, your Custom Data tables, and your code libraries. Because it lives on the same plane as everything it touches, it does three jobs most assistants can't: it operates the work, it authors new connections, code libraries, apps, and Custom Data schemas, and it administers users, access, schedules, and billing. The same agent that triages support tickets can scaffold a new code library, provision a teammate, and put the task on a board — all in one session, all typed, all audited.
- ✓ Imported per task, alongside any other connection
- ✓ Operates, authors, and administers — same plane, same typed catalogue
- ✓ Reads the exact operation list humans see, so it can't hallucinate ops
- ✓ Per-org choice of model (Claude, Gemini, others) — even mix a frontier model for building with a cheap one for high-volume work; tools, not chains
// Connections panel — agents and external systems are equal citizens
stripe → Stripe API runtime
gmail → Gmail runtime
outlookMail → Outlook Mail runtime
customers → Custom Data table runtime
billingTools → Code library utility
quoteApp → App ui
sysAgent → Task Agent utility
sysTask → Panaptic tasks system
sysUser → Panaptic users system
// Same shape, same import flow, same audit log.
// Every action signed by actor — human, agent, or system
action.actor → user:ricky@panaptic.ai
action.operation → approve_invoice
action.input → { invoice_id: "inv_4823" }
action.timestamp → 2026-05-04T10:23:41Z
action.actor → agent:sysAgent
action.operation → categorise_email
action.confidence → 0.94
action.gate → autonomous
action.actor → system:scheduler
action.operation → run_billing_reconcile
action.trigger → cron:daily_0200
Audit by construction
Every action — built or run — is signed by who took it.
User, agent, or system: every action lands in the same audit log with the actor, the operation, the inputs, and the moment it happened. Authoring is captured the same way operating is — when the agent registers a connection or commits a tile, that's a signed action too. Provenance isn't a feature you switch on or a tier you upgrade to. The audit log is the kernel, and it exports to whatever you already run.
- ✓ Provenance is the kernel, not a logging plugin
- ✓ Schema-typed entries — every action maps to a real operation
- ✓ Replay-safe — non-idempotent ops can't fire twice on retry
- ✓ OpenTelemetry (OTLP) export to GCP, Datadog, Honeycomb, or Grafana
Autonomy is a dial
Build it once. Run it at any level of autonomy.
Whatever the agent builds, you run at the level of control you choose. Manual: a human drives and the agent assists when asked — zero AI credits. CoPilot: the agent proposes and a human approves at confirmation gates. Autonomous: the agent executes and you audit afterwards. Under the hood it's one mechanism: any destructive, costly, or customer-facing operation can be marked to stage instead of fire — it pauses, a Confirm button appears, and nothing happens until a human clicks Execute. Same task definition, same data, same UI — only the dial moves. Start manual to learn the workflow, then move along the dial as trust grows, without rebuilding anything.
Batteries included
The infrastructure an operating system needs — already on tap.
You don't install, provision, or deploy any of this. Every durable capability is a typed connection already in the catalogue, governed by the same schemas and the same audit log as everything you build.
Scheduler
Cron, RRULE, or interval work with durable cross-run state — no server to run.
Per-org Postgres
Your Custom Data tables on an isolated database, with live CRUD and real SQL.
Three SQL surfaces
Query across your data tables, join live API responses in-process, or read cold Parquet/CSV in a bucket.
Documents & PDFs
Typst and templated rendering, so a report's layout lives in a template, not buried in code.
Blob storage
Durable files with signed URLs — fully managed or bring-your-own bucket.
Spend governance
Per-user, team, or org USD caps by task, day, week, or month — one bad run can't blow the budget.
Observability
Logs, traces, and errors for any past run, exported over OpenTelemetry to your stack.
Model choice
Per-org LLM provider — mix a frontier tier for building with a cheap tier for high-volume work.
Where your data lives
Typed records by default. A data lake only when you actually need one.
Custom Data — your records
Typed JSON-Schema tables on your per-org PostgreSQL, with live CRUD and real SQL — your CRM rows, cases, invoices, config. Most reporting is a direct query against these tables; you don't stand up a pipeline to read your own records.
DuckDB connection — cold data
Point it at Parquet or CSV sitting in a bucket and query the files in place. For large or external analytical data that doesn't belong in your operational tables — added only when you actually have it.
Panaptic isn't a data warehouse by default — and it doesn't make you build one just to get an answer.
Watch the agent build, then run it.
Spin up a workspace, describe how your business works, and let the agent author the connections, libraries, and apps to run it — live, in one session.