Describe the outcome. Pulse guarantees it.
One spec object per page — server data, state, mutations, and view, co-located in plain JS. Streaming SSR, security headers, and production caching are enforced by the framework, not left to configuration.
Designed for AI agents. Production-quality architecture.
How it works
Write a spec
Everything for a page lives in one object: server data, state, mutations, view. One format, no conventions to learn.
Validate automatically
The schema enforces a single, correct structure. Either the spec is valid, or it’s rejected — no ambiguity, no runtime surprises.
Ship with it built in
Streaming SSR, security headers, and immutable caching come from the framework — not your config. Follow the spec, and the results follow.
Everything in one object
Server data, state, mutations, and view are co-located. No split files. No hidden conventions. The spec is the page.
export default {
route: '/dashboard',
meta: {
title: 'Dashboard — My App',
styles: ['/app.css'],
},
server: {
data: async (ctx) => {
const user = await db.users.find(ctx.cookies.userId)
return { user, stats: await db.stats.forUser(user.id) }
},
},
state: { filter: 'all' },
mutations: {
setFilter: (state, event) => ({ filter: event.target.value }),
},
view: (state, server) => `
<main id="main-content">
<h1>Hello, ${server.data.user.name}</h1>
<select data-event="change:setFilter">
<option value="all">All time</option>
<option value="week">This week</option>
</select>
<p>${server.data.stats[state.filter].total} requests</p>
</main>
`,
}
Designed for AI agents. Enforced by the framework.
Traditional frameworks were built for humans — multiple valid patterns, optional decisions, enough surface area for output to drift. Pulse is different.
AI + existing frameworks
- Multiple valid patterns per page — the agent picks one, the next picks another.
- Security headers, SSR config, and caching are optional decisions the agent can miss.
- Output drifts over time as different agents make different choices.
- Reviewing AI output requires knowing every pattern it could have used.
Pulse + AI enforces structure
- One spec format per page.
- Architecture enforces SSR, security, and caching.
- Agents fill in the contract, never off-pattern.
- Reading AI output means reading one JS object — nothing hidden.
Constraints enforced. Not recommended.
Pulse enforces constraints and correctness out of the box; other frameworks leave it to the developer.
| Pulse | Next.js / Remix | SvelteKit | |
|---|---|---|---|
| Ways to write a page | One — the spec schema | App Router, Pages Router, RSC, client components, loaders… | +page.svelte, +page.server.js, load(), form actions… |
| Agent-readable structure | One JS object per page | Files, folders, magic exports spread across dirs | Files, folders, Svelte syntax |
| SSR out of the box | Streaming SSR, zero config | Yes, but client hydration adds JS overhead on every page | Yes, but requires an adapter and client runtime on every page |
| Client JS shipped | 3.5 kB brotli (shared runtime, first visit) | 50-200 kB+ depending on features | ~15 kB brotli |
| Security headers | On every response, built in | Manual middleware or plugin | Manual hooks setup |
| CLS | Targets 0.00 — shell renders before data arrives | Depends on implementation | Depends on implementation |
| Runtime dependencies | Zero — pure Node.js HTTP | React, 50+ transitive packages | Svelte runtime + adapters |
| Production build step | None — node server.js is production |
Required — next build |
Required — vite build |
Performance by design
Pulse does not offer performance as an option — it enforces it structurally. A high Lighthouse score is the baseline. There is nothing to configure because there is nothing to get wrong.
- Fast LCP by design. The shell renders and streams instantly. Deferred segments arrive as data resolves — no blocking, no flash.
- 3.5 kB of JS on first visit. The shared runtime is brotli-compressed and cached across all navigations. Subsequent pages cost 0.35–0.5 kB.
- Zero CLS. The shell occupies the correct layout before data arrives. No placeholder juggling, no layout shift.
-
Immutable bundle caching.
Production bundles are content-hashed and served with
immutable, max-age=31536000. Browsers cache them forever — deploys are instant for returning visitors.
Safe by design
Security is not a plugin or a checklist in Pulse — it is part of the response pipeline. Every page ships the headers most frameworks leave to the developer to remember.
-
Security headers on every response.
X-Frame-Options,X-Content-Type-Options,Referrer-Policy,Permissions-Policy,Cross-Origin-Opener-Policy— all set automatically, including on 404 and 500 pages. -
Declarative state constraints.
constraintsenforce min/max bounds on state after every mutation. The value can never go out of range regardless of what the client sends. - Co-located validation. Validation rules live next to the state they guard. The agent can see what is being validated and why, in one place.
-
Guard before data.
The
guardfunction runs before any server fetcher executes — authentication and authorisation checks cannot be accidentally bypassed.
Nothing to configure
No bundler config. No framework boilerplate. No runtime dependencies to install, audit, or upgrade. Pulse eliminates the category of problems that come from misconfiguration.
-
Zero runtime dependencies.
The server is pure Node.js HTTP. No Express, no Fastify, no React. Nothing to add to
package.jsonto run a production server. -
No production build step.
node server.jsis production. The build step is only needed to generate content-hashed client bundles — the server runs without it in dev. - esbuild only in development. The one dev dependency that compiles client bundles is esbuild. Fast, no plugins to configure, never part of the production runtime.
- No framework upgrades breaking your app. Because the spec is a plain JS object with no framework imports in page files, there is no framework API surface to break across versions.
Performance you can measure.
Report generated 25 Mar 2026, 18:35 · measured from a real Pulse build
The spec is the contract.
Your agent fills it in.
- Writes the spec
- Validates against the schema
- Checks Lighthouse — desktop and mobile
- Runs the tests
- Ships production quality
MIT licensed and available now. Production quality is not the goal. It is the starting point.