+
State changes produce patches
Events enter the runtime. State changes. Derived computations update. Views refresh. Long-running processes continue.
BYATLOX/RUNTIME
The reactive runtimefor agentic applications.
Describe the application once in Atlox. The runtime turns state, events, derived data, views, agents, workflows, storage, realtime sync, and deployment into one reactive graph.
appstateagentsworkflowdeploy
$ atlox deploy support.at --graphgraphDatabases, queues, cache, agents, workflows, and pages share one runtime model.
That means fewer disconnected contracts across storage, client state, realtime sync, background jobs, agent memory, and deployment.
You write semantics
The code says what the application means.
state
events
derived data
agents
routes and views
durable or cached data
Atlox owns mechanics
The runtime builds the moving parts.
persistence
migrations
patch propagation
client cache
websocket delivery
queues and processors
The problem
Modern apps are assembled from too many separate systems.
An AI agent can wire those pieces together, but it still has to manage all their contracts. Atlox changes the target.
frontend framework
backend framework
database
auth
queue
cache
search
vector database
realtime transport
agent framework
workflow engine
deployment platform
Atlox gives the agent one typed semantic target.
The database model, event model, derived data model, UI model, workflow model, and deployment model are not separate guesses.
+
Agents are graph nodes
Agents can subscribe to streams, keep memory, emit patches, and be queried like other application state.
+
Workflow runtime is app runtime
Product workflows, agent workflows, data pipelines, and realtime UI share one reactive model.
+
Uniform dataflow
Database rows, browser state, queues, search results, vector matches, agent memory, and external streams use one model.
+
Shorter loop for agents
Agents produce an Atlox application. You can validate it, explain it, run it, and deploy it.
+
Typed app matches production
You can diff it, explain it, roll it back, and ask which route, query, event, or agent changes a view.
Agents are not sidecars in Atlox.
An agent is a stateful workflow node inside the same graph as data, events, reducers, derives, routes, views, workflows, and deployments.
Agent memory
Agents can keep memory and expose it as state that can be queried, derived, searched, rendered, and persisted.
Stream processing
Agents subscribe to streams, produce outputs, and emit patches through the same runtime model as data.
Joined output
Agent output can be joined with product state, filtered by confidence, cached for clients, and used by workflows.
One model
Agent workflows and product workflows use one reactive graph instead of separate orchestration stacks.
Application source
The code is the deployment contract.
Declare the state, events, derived data, and pages once. Atlox uses the same source to build storage, client cache, patch streams, hydration, and deployment.
app SupportDeskstore appDb at server using sqlite durablestore clientDb at client using atlox ephemeralstate tickets: Map<Id, Ticket> in appDb = {} reduce {on TicketCreated as e:tickets[e.id] = Ticket(status: "open", title: e.title)}derive openTickets in clientDb =tickets.values().filter(ticket => ticket.status == "open")route "/tickets" {view = <TicketList tickets={openTickets} />}State changes
Inputs become durable application state.
Describe how each input changes the application model. Atlox persists the change and sends the resulting updates to every dependent part of the system.
state tickets: Map<Id, Ticket> in appDb = {} reduce {on TicketCreated as e:tickets[e.id] = Ticket(id: e.id,customerId: e.customerId,title: e.title,status: "open",priority: e.priority)on TicketClosed as e:tickets[e.id].status = "closed"}Derived data
Derived data is a node, not cache convention.
The same graph relation can be filtered, sorted, joined, watched, cached, rendered, searched, and deployed.
derive openTickets in clientDb =tickets.values().filter(ticket => ticket.status == "open").sortBy(ticket => ticket.priority)derive openTicketsWithCustomers in clientDb =openTickets.values().join(customers.values(),ticket.customerId == customer.id)derive urgentTickets in clientDb =openTicketsWithCustomers.values().filter(row => row.ticket.priority > 7)Live pages
Pages stay connected to the data they show.
Declare what a page reads. Atlox keeps it current as the underlying data changes, without hand-written sync code or client cache wiring.
route "/tickets" {view =<main><h1>Open tickets</h1><section>{ for ticket in openTickets }<article><span>{ticket.title}</span><span>{ticket.priority}</span></article>{/for}</section></main>}Atlox gives the app one runtime model.
State changes, agent work, workflow steps, client updates, cache, sync, and deployment all follow from the same code.
Alternative to Lovable and Replit
They generate ordinary projects. Atlox gives agents a typed runtime target they can actually change and run.
Alternative to Convex
Convex makes backend queries reactive. Atlox makes state, UI, agents, and delivery update together.
Alternative to Supabase
Supabase is centered on Postgres. Atlox is centered on semantic data capabilities.
Alternative to Vercel
Vercel deploys web output. Atlox deploys code, data shape, routes, agents, and workflows together.
Alternative to Ably
Ably keeps messages live. Atlox keeps derived data and client delivery live from declared dependencies.
Alternative to Mastra
Mastra gives agent and workflow primitives. Atlox lets agents read, write, and react inside the same runtime model.
Alternative to React and Svelte
React and Svelte focus on components. Atlox compiles application intent.
Alternative to Kubernetes
Kubernetes deploys infrastructure objects. Atlox deploys the semantic application, not infrastructure wiring.
Semantic infrastructure
Describe meaning. Let the runtime choose mechanics.
Durable data, cached query, searchable data, vector-searchable data, realtime graph, analytics stream, agent memory, and workflow state are graph capabilities.
durable data
cached query
searchable data
vector search
realtime graph
analytics stream
agent memory
workflow state
edge cache
Ship infrastructure from application intent.
Atlox lets the application describe storage, queues, cache, search, realtime delivery, agents, workflows, and deployment in one model, then turns that model into the runtime pieces needed to run it.
One-file deployment
Paste the program. Deploy the application. Templates and examples become real products.
Marketplace capabilities
Install a component, workflow, data model, agent, or complete application with its graph semantics.
Atomic deployment
A new event type, migration, derived index, route, workflow, and generated client contract are one graph version.
That is Atlox
Write the application. Run the system.
Let agents, data, UI, workflows, and infrastructure share the same runtime model.