Built for agents. Built for humans.

An AI backend
platform for
human developers.

Database, filesystem, routing, cron, debugger, build pipeline, AI copilot — one engine. Every knob exposed to your agent via MCP. Drop a Kanban card, split it into tasks, ship a feature.

70+
MCP tools
1 JAR
everything inside
0
cold starts
Postgres WebDAV MCP Scripts Kanban Agents Ingress Cron Builder AI Copilot
// what is diesel

A self-hosted backend
an LLM can actually drive.

DieselEngine is a single-binary backend that bundles PostgreSQL-backed tables, a virtual filesystem, HTTP + WebSocket routing, a GraalVM JavaScript runtime, cron jobs, a Chrome-DevTools debugger, a frontend build pipeline, and an AI copilot with code completion.

Then it does the thing nobody else does: it exposes every one of those capabilities as a Model Context Protocol tool. file_write, ingress_create, database_query, build_deploy, debugger_step_over — all callable by any LLM.

Humans write scripts, chat with the agent, and design systems. Agents ship features, ask clarifying questions, and split big ideas into tasks. They share the same filesystem, the same database, the same running process — no handoff, no glue.

Drop a Kanban card. Split it into tasks. Get deployed endpoints.

DieselEngine // one JAR
Postgres + JSONB
Virtual FS
MCP Server
GraalVM JS
Ingress (HTTP/WS)
Cron + Startup
Agent Loop
Kanban + Split
Build Pipeline
AI Copilot
Humans · scripts, SQL, JSX
LLM agents · via MCP
Your editor · over WebDAV
// the special parts

Everything your agent needs. Nothing it doesn't.

It is not a BaaS. It is not a low-code builder. It is not an IDE plugin. It's the runtime your agent works inside.

MCP-native, end-to-end

70+ tools cover files, trees, SQL, ingress, scripts, debugger, cron, kanban, build pipeline, and more. Any MCP-capable LLM operates the whole platform — no custom SDKs, no glue code.

Kanban → Agent pipeline

Flip a column into agent mode, give it a system prompt, and every card dropped there becomes a task. An agent picks it up, runs tools, commits, and moves the card to Done. You watch it happen live.

In-process everything

Postgres pool, virtual FS, JS runtime, cron with a visual expression builder, startup scripts, and the autonomous agent loop share one JVM. No cold starts. No edge-function latency. No vendor dashboard.

Your filesystem, three ways

One virtual filesystem, visible via REST, MCP, and a built-in WebDAV server. Mount it in Finder, Explorer, or VSCode and edit your scripts like any other folder — agents and humans share the same tree.

Real JS, real debugger

ES2023 modules on GraalVM with a Chrome DevTools Protocol adapter. Breakpoints, step-in, step-out, eval — all driven by MCP. Agents can debug the code they just wrote.

Self-hosted, one engine

Your data, your runtime, your agents — on your own hardware. MCP live at /mcp, bearer-token gated, ready for any OpenAI-compatible client. No vendor lock-in, no egress fees, no surprises.

Split cards into tasks

Right-click any Kanban card and let the agent decompose a vague idea into concrete sub-tasks. Parent-child relationships are tracked automatically — the board becomes your project plan without you writing one.

Agent Chat panel

A floating, resizable chat overlay lives in the corner of the IDE. Talk to the agent, see MCP tool calls expand inline, review structured Q&A — all without leaving the editor. Context follows the conversation.

?

Structured Agent Q&A

When the agent needs clarification it asks structured questions — single-select, multi-select, yes/no, free text — rendered as interactive controls. No more guessing intent from a wall of prose.

Frontend build pipeline

Scaffold, build, and deploy Vue, React, or Svelte projects. The builder sidecar runs npm in a sandbox, publishes the dist to your virtual FS, and auto-registers the ingress. Two MCP calls: build_deploy + build_wait.

Built-in CLI

A command line inside the IDE. Run scripts, query tables, manage ingress rules, trigger agent runs — all from a shell-like interface with auto-complete and command history.

AI code completion

Fill-in-the-middle AI completion in the Monaco editor. Context-aware suggestions powered by your configured LLM. Write the function signature, the copilot writes the body.

// live demo

Drop a card. Split it. Watch features ship.

This is what actually happens when you drop a card into a Diesel column wired to an agent. Watch the fourth card get split into sub-tasks automatically. Autoplays once, then it's yours — drag any card into Working.

Backlog 4
Planned 0
Working agent 0
Done 0
agent // run idle
$ waiting for a card to arrive in `Working`…
// compared

Other tools look good until you read the row labels.

Nobody else wires the whole backend to the LLM. Not Supabase. Not Retool. Not n8n. Not Replit Agent. Not Firebase.

Capability diesel.rocks Supabase Retool n8n Replit Agent Firebase
MCP-native admin surface (every capability = an LLM tool) ~
Self-hosted, single binary ~~
Built-in autonomous agent loop (server-side, persistent) ~
Kanban cards trigger agent runs on drop
Real JS runtime with Chrome DevTools debugger ~
PostgreSQL + JSONB + raw SQL in same process
Built-in WebDAV — mount the filesystem in your editor
Native WebSocket rooms with per-connection JS context ~~
Cron + startup scripts in the same runtime ~
No cold starts, no vendor lock-in ~
AI card splitting (idea → sub-tasks on Kanban)
Structured agent Q&A (interactive clarification) ~
Built-in frontend build pipeline (scaffold → deploy)
In-editor AI code completion
first-class ~ partial / limited not available
vs. Supabase

Supabase gives you Postgres + edge functions. Diesel gives you Postgres, a filesystem, in-process JS, cron, an agent loop, and — the thing that matters — an LLM-drivable control plane.

vs. n8n

n8n draws boxes between nodes. Diesel runs your ES-module JavaScript next to your database, with a real debugger, and lets an agent rewire the whole graph through MCP.

vs. Replit Agent

Replit's agent edits files in an IDE. Diesel's agent edits files in a live, running server — changes go on-air instantly. The server is the workspace.

// show me the code

Real scripts. Real MCP calls. Nothing hidden.

POST /mcp · tools/call
{
  "name": "ingress_create",
  "arguments": {
    "type":       "HTTP_GET",
    "route":      "/api/hello",
    "script_uuid": "a1b2c3d4-…"
  }
}
// → 200 OK, route is live at http://localhost/backend/api/hello
// request an instance

Want a Diesel instance?

Tell us what you want to build. We'll spin one up for you — wired, mounted, and ready for your agents.

Private, dedicated instance
70+ tools out of the box
60+ tools out of the box