HighX is a TypeScript framework. You write plain typed functions. HighX runs them next to your data, keeps every screen up to date by itself, and gives your AI agents a safe place to work.
Every function is one of three kinds. Each kind says what it is allowed to do — and the runtime enforces it, so mistakes fail loudly instead of corrupting data quietly.
A query reads the database and remembers what it looked at. That memory is what makes live updates work later.
export const listNotes = query({ args: z.object({ accountId: v.id("accounts") }), auth: authed, handler: (ctx, { accountId }) => ctx.db.query("notes") .withIndex("byAccount", { accountId }) .order("desc") .take(20), });
A mutation changes data inside one transaction. It all commits, or none of it does. Network calls are refused here.
export const saveNote = mutation({ args: z.object({ text: z.string().max(10_000) }), auth: authed, handler: (ctx, args) => ctx.db.insert("notes", { accountId: ctx.identity.accountId, text: args.text, at: ctx.clock.now(), }), });
An action calls APIs and models, then saves results by running mutations. Cross-database work is written as explicit steps.
export const enrich = action({ args: z.object({ domain: z.string() }), handler: async (ctx, { domain }) => { const res = await ctx.fetch(`https://ex.com/${domain}`); return ctx.run(saveEnrichment, { domain, value: await res.json(), }); }, });
When a mutation commits, HighX checks which queries touched that data and pushes the new result to every subscriber. You never write refetch code, cache keys, or polling loops.
client → hello · auth · sub · unsub · mutate · action · resume · ping server → welcome · snapshot · patch · stream · error · bye · pong
function Notes({ accountId }) { const notes = useQuery(api.notes.list, { accountId }); return <List rows={notes} />; }
Each tenant gets a private database — a Durable Object with SQLite inside. Shared public data lives separately in D1. The two never commit together, and HighX says so instead of hiding it.
// signup touches global and tenant data, so it is written // as steps — with a cleanup step if something fails. export const signUp = action({ args: signUpArgs, handler: async (ctx, args) => { const user = await ctx.run(createGlobalUser, args); try { const account = await ctx.run(createTenantAccount, { userId: user.id, ...args, }); await ctx.run(createSession, { userId: user.id, accountId: account.id, }); return account; } catch (error) { await ctx.run(markUserProvisioningFailed, { userId: user.id }); throw error; } }, });
An agent is a model plus a set of skills. A harness runs it in a bounded loop. Every step is saved, every tool call is checked, and a human can be put in the loop at any point.
export default defineSkill({ name: "incident-response", version: "1.0.0", instructions: { file: "./instructions.md" }, input: z.object({ incidentId: z.string(), symptoms: z.string() }), output: z.object({ diagnosis: z.string(), reportId: z.string() }), tools: { readLogs, inspectDeployment, rollbackDeployment }, capabilities: ["logs:read", "deployments:read"], policy: { approvalRequiredFor: ["deployments:rollback"] }, });
export const review = workflow({ args: z.object({ accountId: v.id("accounts"), period: z.string() }), handler: async (step, args) => { const snap = await step.run("snapshot:v1", snapshotAccount, args); const result = await step.run("review:v1", runReviewModel, snap); await step.run("publish:v1", publishReview, result); }, });
Every tool promises the world. Here is exactly what HighX guarantees — and what it openly does not.
HighX does not hide Cloudflare behind fog. Each feature uses one service, and its limit is written right next to it. If the platform cannot do something, the build fails — it never silently degrades.
| You need | The limit, in writing |
|---|---|
| tenant data | One tenant = one place that can commit. |
| shared data | Read-only in v1. No live updates. |
| live updates | WebSocket is the required carrier. |
| files | Big uploads use presigned URLs. |
| vectors | Indexes are created before first use. |
| background jobs | Retries and idempotency are explicit. |
| models | Usage is tracked in your own ledger. |
| secrets | Never sent to the browser. |
Read the spec, then build the smallest thing: one query, one mutation, one screen that updates itself. That is the whole idea — everything else is the same pattern repeated.
$ npm create highx@latest $ cd app && highx dev worker ready on :8787 tenant account-do attached schema 4 tables, 6 indexes ok watch highx/**