Hello HN,

I’ve been experimenting with an architecture for long-lived AI-generated applications (CRUD systems, dashboards, workflows). One pattern keeps appearing: the traditional frontend / backend / database model starts to struggle once an LLM can modify the structure of the application.

The issue isn’t first generation.

The issue is evolution of application state and schema over time.

The first version of an AI-generated app usually works. Problems appear during the second or third iteration:

* schema changes silently breaking dashboards * metrics changing meaning across versions * UI components querying incompatible datasets * the model fixing a local issue while violating global invariants

In short: the system drifts.

Most SaaS systems today look like this:

User ↓ Frontend ↓ Backend API ↓ Database

The real semantics of the system end up scattered across API handlers, migrations, background jobs, RBAC logic, UI assumptions and reporting queries. Nothing explicitly defines the meaning of the system or guarantees invariants when the schema evolves.

When an LLM can propose structural changes (entities, workflows, dashboards), a naive architecture looks like:

User ↓ LLM ↓ JSON change ↓ Apply to system

This works for demos but breaks for long-lived systems. “Valid JSON” doesn’t guarantee reference integrity, workflow invariants, permission boundaries, metric semantics or UI binding compatibility.

One approach that seems to stabilize things is separating AI reasoning from deterministic execution.

Instead of mutating the system directly, the LLM proposes an intent plan:

User ↓ LLM ↓ Intent / Plan (IR) ↓ Runtime validation ↓ Deterministic execution

The runtime decides whether the change is valid before anything is applied.

This leads to a deterministic execution layer exposing primitives such as:

Entity Relation State Transition Event Handler Query Mutation Permission

These primitives define the semantic model of the application. The runtime enforces invariants like reference resolution, schema evolution safety, RBAC boundaries and deterministic state transitions.

At that point the application stops looking like APIs and starts looking like an executable semantic graph.

Entities become nodes, relations connect them, events trigger handlers and transitions define allowed state changes. Interfaces (UI, API, LLM, agents) interact with this runtime.

An interesting consequence is that the runtime itself can remain general-purpose infrastructure while the application becomes declarative.

For example a simple CRM could be described as a semantic model:

entities: Contact, Company, Deal relations: Contact→Company, Deal→Company workflows: Deal pipeline (Lead → Qualified → Won/Lost) metrics: pipeline_value, conversion_rate permissions: role policies

The runtime interprets this model and exposes queries, dashboards and workflows.

Runtime (constant)

* semantic model (JSON / DSL) = application

This effectively turns the runtime into a programmable application platform where different SaaS products are just different semantic models running on the same execution layer.

Conceptually this behaves less like a typical backend and more like a domain-specific runtime or application kernel.

In this architecture the LLM doesn’t execute the system directly. It proposes changes to the semantic model, and the runtime validates them before execution.

Curious if others building AI-native infrastructure, agent runtimes or programmable SaaS platforms have explored similar patterns.

IonRouter (YC W26) – High throughput, low cost inference

AI Cluster Runtime: Reproducible Configs for GPU-Accelerated Kubernetes Clusters

NM framework on Karpathy's autoresearch factory

Oops, You Wrote a Database

Engram – A distributed memory system for AI agents, with extensible architecture

Show HN: Mingle – find and connect with people, like LinkedIn but in your chat

Current and former Block workers say AI can't do their jobs

PHP-rnet – a PHP extension that mimics real browser TLS fingerprints

A small CLI for stopping Git worktrees from fighting over ports

Svelte Best Practices

Lowdown can translate Markdown to an mdoc manpage

FSC Age Verification Bill Tracker

Disney+ Teases Creator-Driven Content as It Launches Vertical Video Feature

The FermAI Paradox: Agents Need Their IDE Moment

New F1 regulations take bravery out of the sport, drivers say

Local Agents with Llama.cpp and Pi

Show HN: Aurion OS – A 32-bit GUI operating system written from scratch in C

Ask HN: Rethinking SaaS architecture for AI-native systems

Weak Cyberdefenses Threaten U.S. Tech Dominance

Anthropic invests $100M into the Claude Partner Network

gstack – Garry Tan's Claude Code Setup

The Tao of Kung Fu: The Undiscerning Mind [video]

Is MacBook Neo "The One"? [video]

WebZero – a web server that serves 5k req/SEC on a 2001 Pentium III

'The shine has been taken off': Dubai faces existential threat

Speculative Branching Cache

Valea: An AI-native systems programming language

TrueTime Meetings – open-source video meetings, built for customization

Mapping the Forests with Precision:Introducing Canopy Height Maps

Axiom Raises $200M Series A at a $1.6B Valuation

Show HN: Two AI entities wouldn't write until we discussed their existence