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
Not feature lists. The actual things you do every day.
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
The little things that add up.
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.
Why we built this for engineers, not just users.
Most SaaS platforms have a developer experience that feels like an afterthought — minimal API docs, opaque error messages, "configure in our UI" instead of "configure as code." Aeion was built by engineers who got tired of platforms that didn't respect their workflow. CollectionConfig is code, not a JSON blob in a UI. Migrations are SQL files you can review. Errors include `requestId` for traceability. The API surface is documented in OpenAPI + MCP spec + actual code. Your senior engineer should be able to read this platform on day one and know how to extend it.
Built for the engineer, not around them.
CollectionConfig is code you review in a PR, not a JSON blob buried in a UI — TypeScript types flow from schema through routes, services, and React components with no `as any` at the boundaries. `createServiceLogger` attaches tenant, request, and trace context to every log line automatically, and every error carries a `requestId` for tracing. A new collection ships with 5 REST endpoints, 5 MCP tools, and an auto-rendered admin screen the moment it's registered — the boilerplate a senior engineer would otherwise spend a sprint building.
TypeScript 6 strict · Bun 1.3+ · React 19
45+ vertical modules · 89 MCP tools · 47 AI skills
REST + GraphQL + MCP + WebMCP for every collection
Hot reload, structured logs, distributed tracing
30+ query operators · sparse fieldsets · cursor pagination
Drizzle SQL transparency · Drizzle Studio GUI
Forge MCP for agentic workflows
Open architecture · standard exports · no walled garden
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.
Try it locally in 5 minutes.
Clone, install, run. Hit /admin, click around, build a custom collection. The platform a senior engineer would build for themselves.