The Platform a Senior Engineer Would Build.
TypeScript 6 strict mode, Bun 1.3+ runtime, Hono on Web Standards, Drizzle with transparent SQL, hot reload everywhere. 89 native MCP tools. 47 module-specific AI skills you can call from your code. WebMCP for in-browser AI tool execution under user RBAC. Forge MCP for agent project management. No proprietary DSL, no walled-garden framework, no "platform engineer" required to onboard. The boring stuff is boring on purpose; the interesting stuff is genuinely interesting.
The Developer Experience That Wins You Over
Type-Safe From Schema to UI
Define a CollectionConfig. Drizzle generates the SQL. Zod schemas validate I/O. TypeScript types flow through routes, services, and React components. No `as any` at boundaries. No runtime surprises.
REST + GraphQL + MCP, All Free
Every collection auto-generates 5 REST endpoints (list/read/create/update/delete) AND 5 MCP tools AND optionally GraphQL fields. One CollectionConfig, three API surfaces. Sparse fieldsets, cursor pagination, 30+ filter operators native.
89 Native MCP Tools
Call AeionClaw from your code via the MCP protocol. Cross-tenant queries, AI invocations, collection CRUD, file ops, notifications — all exposed as typed tools. Build agentic features without writing tool-call boilerplate. Read MCP →
WebMCP In Your Components
Use `useAeionTool` hook in any React component to expose context-specific browser tools to AI agents. Tools run under the user's JWT — no service-account keys in the LLM. Read WebMCP →
Hot Reload Everywhere
Module code, frontend components, even cron jobs hot-reload during `bun run dev`. No restart, no losing state, no waiting on a Vite optimize pass.
Distributed Lock + Event Bus Built In
Redis-backed locks, ULID-keyed event envelopes, idempotency tokens, dedicated tenant-fairness queues. Don't reinvent the boring concurrency primitives.
The Aegis Time Machine For Mistakes
Per-document version history undoes any miskey. Bulk-undo via the Temporal DB rolls back AI-generated batch edits. Continuous PITR (~30s RPO) for "I just dropped prod" moments. Read Aegis →
Forge MCP for Agentic Workflows
Your AI agents can read/write tickets, comments, sprints, knowledge base via Forge — the agent project management layer. Session handoffs persist across agent restarts. Read Forge →
What Your First Day on Aeion Looks Like
Real walkthrough from signup to your first custom feature.
The API Surface — REST, GraphQL, MCP, WebMCP
Every Aeion collection gets every API surface for free.
DX Wins You Notice Within a Week
Bun startup under a second
your local dev cycle feels instant instead of "go get coffee while it boots."
Drizzle Studio
a GUI on your schema for ad-hoc queries while you're debugging — no separate DB client to open.
Forge MCP
your AI assistant can read your project's tickets and state directly, without a screen-share to explain context.
Hot reload that preserves state
refresh-less iteration — you don't lose your form state or your app state every time you save a file.
Strict TypeScript everywhere
your IDE catches the bug before runtime does, not after a customer does.
Direct, tree-shakeable imports
`import { X } from "@aeion/types/schema"` instead of a barrel import that pulls in the whole package — faster builds, smaller bundles.
`createServiceLogger` by default
every log line carries tenant, request, and trace context automatically — no manual context-threading through every function call.
`safeParseOrRespond`
Zod validation and the HTTP error response in one helper, so input validation isn't boilerplate you rewrite on every route.
`createModuleRouter`
typed Hono context everywhere — no `(c as any)` casts, ever.
`playwright-cli` E2E patterns
documented, working examples instead of a blank test file and a guess.
What You'd Build vs What's Already Built
The 12 platform features every serious SaaS needs, where each lives in Aeion.
Developer questions
Yes — `BringYourOwnModel` adapters via the AdapterRegistry pattern. Provide an OpenAI-compatible baseURL or implement the `AIProvider` interface. Self-hosted Ollama, vLLM, custom inference servers all supported.
Aeion ships: (a) `bun run` scripts for dev/test/deploy (b) Direct TypeScript imports from `@aeion/core` + `@aeion/types` (c) REST API + MCP catalog for external clients (d) Forge MCP for AI agent integrations No separate JavaScript SDK because the platform itself runs on TS — you import directly.
Fully. Define your own `CollectionConfig`, add custom field types via the field registry, override hooks (beforeChange, afterRead, beforeDelete, etc.), inject access functions, register module-specific routes. The kernel API surface is documented at `/docs/architecture/`.
Yes — testcontainers fixtures for Postgres + Redis, testbench helpers for mocking AI providers, Vitest + jsdom for admin UI tests, Playwright for E2E. The `withRealQueue` fixture lets you write integration tests against real BullMQ + Redis.
Drizzle-Kit generates SQL diffs from schema changes. `bun run db:migrate:generate` produces a migration file you review; `bun run db:migrate:push` applies it. A pre-destructive guardrail refuses to run any migration that would silently drop non-empty tables — built specifically so a schema mistake can't destroy production data (see Aegis).
Hono runs on Node, Cloudflare Workers, Deno, Bun. The Aeion kernel currently targets Bun (1.3+); ports to Node or Workers are possible but not officially supported. Bun is fast enough that we haven't needed to port.
Every module ships with its own focused test suite — unit tests, integration tests against real Postgres + Redis via testcontainers, Vitest + jsdom for admin UI, and Playwright for end-to-end flows. CI runs the full suite plus module-doc validation on every commit. Type-checking runs at module granularity, so day-to-day development gets fast feedback without waiting on a full-platform build.
Yes — Aeion's API is REST + MCP. Your Next.js / Nuxt / SvelteKit / Astro / custom-vanilla frontend can call the API directly. The bundled admin console and marketing site are optional — swap in your own frontend entirely if you prefer.
Turborepo runs per-package type-checking, so you only pay the compile cost for the module you're actually touching — typically well under 30 seconds. Your IDE's language server scopes to your active project instead of the whole platform. We optimized specifically so day-to-day development never waits on a full-platform compile; the full cross-platform check is a CI concern, not a local one.