AI-Native · Self-Hosted · Enterprise-Grade
AI builds your business systems. Your team governs every change. Your infrastructure runs it all.
Megapodes turns natural language into validated configuration — never generated code — interpreted by a fixed, tested runtime. A local LLM via Ollama means zero external AI API calls, and a human approval gate stands in front of every change. Built for systems of record, on your infrastructure.
What is Megapodes?
A platform where AI proposes, your organization approves, and a fixed runtime executes.
Megapodes turns natural language into validated configuration — never generated code — interpreted by a fixed, tested runtime. A local LLM via Ollama means zero external AI API calls, and a human approval gate stands in front of every change. Built for systems of record, on your infrastructure.
Validated Configuration, Not Code
The AI emits validated configuration — never executable code — so it cannot inject arbitrary logic into your system. Every proposal passes Zod schema validation, business-rule checks, and a migration dry-run before you see it, and nothing is applied until you approve it.
A Platform, Not a Prototype
A microkernel plugin architecture with kernel registries for field types, blocks, workflow nodes, auth providers, data-source drivers, and AI tools. Built-in capabilities are themselves plugins, so the platform extends without forks — and integrates with existing PostgreSQL, MySQL, and REST sources as first-class citizens.
Governance by Construction
Authorization is enforced in three server-side layers — role ACL, forced PostgreSQL Row-Level Security, field-level masking in SQL — and denials fail closed. Every gated mutation and AI action lands in an append-only audit log with the actor identified: human, AI builder, or AI Employee.
One AI plane builds the system. Another operates within it. The boundary is enforced.
The build-time AI agent defines application structure under human approval. Runtime AI Employees work inside the running application, bound by the same permissions as human users. AI Employees are hard-denied the build surface server-side — the boundary between the two planes is enforced in the platform and tested adversarially.
Build-Time AI Agent
Orchestrated by LangGraph over a local LLM via Ollama, the build-time agent converts natural language into an ordered task plan and emits each artifact — collections, relations, pages, workflows, permissions — as schema-validated metadata. Nothing is applied without your approval.
- Converts requests into an ordered, per-artifact task plan
- Every artifact passes Zod schema and business-rule validation
- Migration dry-run before any proposal reaches you
- Large builds grouped into one changeset; destructive items individually confirmed
- Transactional apply and append-only audit log after approval
Runtime AI Employees
AI Employees operate inside the running application with role-bound, data-only tools: read, summarize, extract, classify, fill forms, and answer questions. They inherit the same permissions as the human user they assist — PostgreSQL Row-Level Security applies to them identically — and they can never touch application structure.
- Data-only tools: read, summarize, extract, classify, fill_form, answer
- RAG over pgvector knowledge bases, with cited sources
- Embeddable beside blocks, as workflow nodes, or in an inbox
- Every action recorded in the audit log with actor_type ai_employee
- Hard-denied the build surface server-side
A governed pipeline from intent to production
Every AI-proposed change moves through the same pipeline: emitted as validated configuration, dry-run against your data, approved by a human, and applied transactionally with a full audit trail. Governance is the product — the gate is the point.
Describe
State the system you need in natural language. The build-time AI agent converts it into an ordered task plan.
Validate
Metadata passes schema validation, business rules and migration dry-runs before approval.
Approve
Every proposal is reviewed before deployment. Destructive actions require explicit confirmation.
Deploy
Approved changes are deployed transactionally with audit logs, versioning and rollback.
"Build me a CRM" — planned, validated, and held for your approval.
The build-time AI agent defines application structure under human approval. Runtime AI Employees work inside the running application, bound by the same permissions as human users. AI Employees are hard-denied the build surface server-side — the boundary between the two planes is enforced in the platform and tested adversarially.
Plans collections, relations, roles, pages, and workflows
Emits schema-validated artifacts — never executable code
Repair loop corrects invalid output, then escalates to you
Resumes builds cleanly after interruption
Approval gate cannot be bypassed — including by prompt injection.
// You: Build me a CRM
✦ AI: Planning 5 tasks...
1. collections (customers, deals, products)
2. relations (deals→customers, deals→products)
3. roles (admin, sales_rep, read_only)
4. pages (/customers, /deals, /dashboard)
5. workflows (deal_stage_changed)
// Each task: emit → validate → dry-run
✓ collection customers (6 fields) — validated
✓ collection deals (8 fields) — validated
✓ relation deals→customers — validated
✓ roles + permissions (3 roles) — validated
✓ pages + blocks (3 pages) — validated
✓ workflow deal_stage_changed — validated
✦ 14 changes awaiting approval.
[ Review changeset → ]
Built for systems of record
From integrating existing data to promoting configuration through environments, Megapodes provides the platform primitives that business-critical systems require.
First-Class External Data
Introspect external PostgreSQL and MySQL databases and connect REST APIs as isolated, first-class data sources — never materialized. Credentials are protected with envelope encryption and never persisted in plaintext or logged; REST sources sit behind SSRF guards and outbound allow-lists.
Workflow Engine
Build automations with a visual workflow builder: notifications, record updates, external calls over HMAC-signed webhooks, approval steps, and AI Employee nodes. Workflow JavaScript runs sandboxed — no network, filesystem, or process access — and any run can be replayed for inspection.
Three-Layer Authorization
Role ACL, forced PostgreSQL Row-Level Security — the application role can never bypass RLS — and field-level masking applied in SQL. The build-time agent and AI Employees are subject to the same enforcement as human users, and every denial fails closed.
Signed Environment Promotion
Export application configuration as a versioned, signed bundle and promote it dev → test → prod. Import runs a diff and dry-run, waits for approval, then applies idempotently. Secrets are excluded and rekeyed per environment — never carried in the bundle.
Microkernel Plugin Architecture
Kernel registries accept new field types, block types, workflow nodes, auth providers, data-source drivers, and AI tools. Plugins are npm packages with a manifest and lifecycle — and built-in capabilities are themselves plugins, so the core stays small and stable.
Knowledge Bases & MCP
Ground both AI planes in your own documents via pgvector knowledge bases with cited sources. An MCP (Model Context Protocol) Streamable-HTTP endpoint lets external coding agents build applications through typed tools — subject to the same validation and approval gate.
Sovereign by construction
Every component — application server, PostgreSQL, Redis, object storage, and the Ollama-served local LLM — deploys inside your network with Docker. AI inference makes zero external API calls, and there is no cloud fallback to fail open into: if the local model is unavailable, the platform fails closed. Regulated, defense, and data-residency-bound environments can run Megapodes fully disconnected.
Local AI, Fail-Closed
Chat and embedding models run completely on your infrastructure through Ollama. No prompts, documents or records are ever sent to external AI services.
Air-Gap Capable
Signed configuration bundles allow applications to move safely across disconnected environments with validation, diff checking and approval.
Isolation & Erasure
Schema-per-app isolation, secure backups and architecture designed to support GDPR and DPDP compliance requirements.
Security enforced in the database, not promised in the UI
The AI proposes; it cannot apply. Authorization is enforced server-side in three layers, every denial fails closed, and every gated mutation is recorded with its actor. Governance is not a feature flag — it is how the platform is constructed.
Row-Level Security
Forced PostgreSQL RLS on every query — the application role can never bypass it — plus role ACL above and field-level masking below.
Approval Gates
Every AI proposal is validated, dry-run, and held for human approval. Applied transactionally and recorded in an append-only audit log.
Fail-Closed
Denied operations return 403 and stop. AI features fail closed: if the local model is unavailable, AI-assisted operations stop while the application continues under normal manual operation.
Hardened Foundation
argon2id hashing, short-lived rotating JWTs, OIDC-ready, optional MFA, envelope-encrypted credentials, TLS + HSTS, SBOM at build.
AI Governance, Ready for Review
Megapodes is built for organizations that must account for how AI touches their systems and data — including teams preparing for the EU AI Act's transparency, human-oversight, and record-keeping expectations.
Human oversight is structural: every AI-proposed change passes a human approval gate before it takes effect. Traceability is structural: an append-only audit log records every gated mutation and AI action with its actor — human, AI Builder, or AI Employee. Scope is structural: the AI emits validated configuration, never executable code, while runtime AI Employees inherit only the permissions of the user they assist.
How Megapodes compares
An honest comparison against the categories enterprises evaluate: self-hosted low-code, AI app builders, and enterprise low-code suites.
| Capability | Megapodes | Self-hosted Low-Code (Retool, Appsmith, Budibase) |
AI App Builders (Lovable, Bolt) |
Enterprise Low-Code (Power Apps) |
|---|---|---|---|---|
| Local AI (works air-gapped) | Local LLM via Ollama — zero external AI calls | App self-hosts — AI features still call cloud LLMs | Cloud LLMs only | Copilot runs in Microsoft's cloud |
| Human approval gate on every AI change | Enforced — validated, dry-run, then approved | Edits apply directly; review is process, not platform | AI writes and applies code directly | Governance via admin policies, not per-change gates |
| AI output is validated configuration, not code | Schema-validated metadata; a fixed runtime executes it | Apps mix low-code with custom JS and SQL | AI generates executable code | Declarative core plus formulas, code components, connectors |
| Database-enforced Row-Level Security | Forced PostgreSQL RLS — app role cannot bypass it | Typically application-layer permissions | Depends on whatever backend the AI generates | Dataverse security roles enforced at the service layer |
| Flat licensing — no per-seat fees | Flat platform license — unlimited users self-hosted | Paid tiers are typically per-user | Subscription and usage-credit pricing | Per-user licensing |
| Signed environment promotion (dev → test → prod) | Signed bundles with diff, dry-run, and approval | Export/import or Git sync, without signing | Cloud deploys; promotion is redeployment | Managed solutions; unsigned, admin-managed |
Frequently asked questions
What Megapodes is, how the governed build pipeline works, and how it is deployed and licensed.
What is Megapodes?
How does the AI build process work?
The build-time AI agent (LangGraph orchestration over a local LLM via Ollama) converts your request into an ordered task plan, then emits each artifact — collections, fields, relations, pages, workflows, ACL — as declarative metadata. Every artifact passes Zod schema validation, business-rule validation, and a migration dry-run before it reaches you. You review the full changeset, with destructive items individually confirmed and the data at risk named, and only after your approval is the change applied transactionally and written to the append-only audit log.
Is Megapodes self-hosted?
Yes. Megapodes deploys with Docker on your infrastructure: PostgreSQL 18 with pgvector, Redis, MinIO or S3-compatible object storage, and Ollama serving the local LLM. There are zero external AI API calls — inference happens on your hardware, and if the local model is unavailable the platform fails closed rather than silently falling back to a cloud provider. Your data never leaves your network.
What is the difference between build-time AI and runtime AI Employees?
The build-time AI agent defines and changes application structure — collections, pages, workflows, permissions — and every one of its proposals must pass validation and human approval before it is applied. Runtime AI Employees operate inside the running application with role-bound, data-only tools: read, summarize, extract, classify, fill forms, and answer questions, always constrained by PostgreSQL Row-Level Security to the data the current user is authorized to see. AI Employees are hard-denied the build surface server-side; the boundary between the two planes is enforced in the platform and tested adversarially.
How does Megapodes handle security and tenant isolation?
Authorization is enforced server-side in three layers: role-based ACL, forced PostgreSQL Row-Level Security (the application role can never bypass RLS), and field-level masking applied in SQL. Denials fail closed with a 403. Each application lives in its own PostgreSQL schema with per-app backup, restore, and erasure. Passwords use argon2id, sessions use short-lived rotating JWTs with OIDC support, external-source credentials are protected by envelope encryption and never persisted in plaintext or logged, and every gated mutation and AI action is recorded in an append-only audit log with the actor identified as human, AI builder, or AI Employee.
Can I extend Megapodes with plugins?
Yes. Megapodes has a microkernel plugin architecture: kernel registries accept new field types, block types, workflow nodes, auth providers, data-source drivers, and AI tools. Plugins are npm packages with a manifest and an install, enable, disable, remove lifecycle — and the built-in capabilities are themselves plugins, so extensions are first-class rather than bolted on. There is also an MCP (Model Context Protocol) endpoint, so external coding agents can build applications through typed tools.
What tech stack does Megapodes use?
Node.js 22 LTS with TypeScript and Fastify 5 on the server; PostgreSQL 18 with pgvector; Redis for cache coordination and BullMQ queues; MinIO or S3 for object storage; React 18 with Ant Design 5 in the Studio; LangChain and LangGraph for AI orchestration over a local LLM served by Ollama; Zod for schema validation of every AI-emitted artifact; and the MCP SDK for the Model Context Protocol endpoint. The platform ships as licensed, self-hostable commercial software.
Can Megapodes connect to my existing databases?
Yes. External PostgreSQL and MySQL databases are introspected and mapped as first-class isolated data sources, and REST APIs connect the same way — external data is never materialized into the platform’s own tables. Credentials are protected with envelope encryption and never logged, REST sources are constrained by SSRF guards and outbound allow-lists, and each external source carries its own access controls, separate from native application data.
Does Megapodes work air-gapped?
Yes. Megapodes is designed to run in fully disconnected environments. Every component — the application server, PostgreSQL, Redis, object storage, and the Ollama-served local LLM — deploys inside your network with no outbound dependency. AI inference makes zero external API calls, and the platform fails closed rather than reaching for a cloud fallback. Environment promotion between dev, test, and prod uses signed, versioned configuration bundles that can be carried across the air gap, verified, diffed, and applied after approval.
How is Megapodes licensed and priced for enterprises?
Megapodes is a commercial platform with flat licensing. A free 30-day evaluation license covers the full platform on your infrastructure or ours, with guided pilot support. A managed Cloud plan for small teams is $49 per month. Enterprise Self-Hosted is a custom flat platform license — no per-seat metering, with unlimited users and applications — covering on-prem, private cloud, or air-gapped deployment, SSO/OIDC integration, an MSA/DPA, named support, and procurement and security-review assistance. Uptime commitments are defined as a custom SLA in your enterprise agreement.
Bring governed AI to your business systems
See the full pipeline — from natural language to validated configuration, human approval, and signed promotion to production — on infrastructure you control.
Self-hosted — your data never leaves your network · Every change human-approved and audit-logged · SSO/OIDC available · We support your security review
The governed AI application platform. A local AI builds business systems as validated configuration, every change is human-approved, and it all runs on your infrastructure.