drumr: the framework that keeps the beat
Enterprise apps your coding agent gets right.
drumr is the model-driven TypeScript framework built for coding agents. Declare models and actions. drumr supplies the API, MCP tools, permissions, workflows and UI. Less code for your agent to write means less for it to get wrong.
We'll only email you about drumr. No spam, ever.
The framework
Declare it once. drumr does the plumbing.
A model and an action are all it takes for a working, secured, API-exposed feature. drumr sits on Express, TypeORM, Apollo GraphQL and DBOS, so you get a proven stack without wiring it up yourself.
@DataModel({ dataSource: MainDs, managedActions: { api: ['gql', 'mcp'], actions: ['create', 'findById', 'findBy', 'update', 'deleteById'], }, }) export class Task extends BaseDataModel { @UuidField({ primaryKey: true, generated: true, required: true }) id!: string; @TextField({ required: true, minLength: 1, maxLength: 200 }) title!: string; @ChoiceField({ required: true, type: () => TaskStatus }) status: TaskStatus = TaskStatus.Pending; } @Action({ type: 'write', model: Task, api: ['gql', 'mcp'], returns: Task }) export class CompleteTask extends ObjectAction<Task, void, Task> { static preconditions: PreconditionList<Task> = [ { when: { status: { ne: TaskStatus.Done } }, otherwise: 'Task is already completed' }, ]; override async execute(task: Task): Promise<Task> { task.status = TaskStatus.Done; await this.ds.save(task); return task; } }
- Validation and persistence. Field rules are enforced on every write, and the schema and migrations come from the model.
- A GraphQL API and a typed SDK. CRUD, filters and relationships, with no resolvers to write.
- MCP tools.
api: ['mcp']turns the action into a permission-filtered tool your users' assistants can call. - Guards you can read. Preconditions are data, not buried
ifs, and actions run in real database transactions. - UI that follows the model. Tables, forms and views built on Ant Design, or use headless hooks and bring your own.
query { TaskFindBy(pageSize: 20) { ... on TaskQueryResponse { objects { id title status } pageInfo { totalCount } } } } mutation { TaskCompleteTask(id: "8f3c…") { ... on Task { id status } } }
# permission-filtered, behind OAuth 2.1 TaskFindBy search & page tasks TaskFindById fetch one task TaskCreate validated create TaskUpdate validated update TaskDeleteById delete CompleteTask runs the action, preconditions enforced
25 field types
TextField to MoneyField, RelationshipField to VectorField. Postgres or SQLite through managed datasources.
Durable by default
@Workflow, @Step and queues on DBOS. Long-running processes survive restarts and deploys.
Auth and permissions built in
Google, Microsoft, Auth0 or local login. MFA, fine-grained permissions, and sensitive fields encrypted at rest.
Agents inside your app
@Agent classes that use your actions as tools, with human approval steps and built-in evals (LLM judges, trajectory checks).
Use as much as you want
A typed SDK, then headless React hooks, then Ant Design components, then a full scaffold. Stop at any layer.
Production concerns, covered
OpenTelemetry tracing, an audit trail, distributed locks, and keyword, vector and hybrid search.
Built for coding agents
We don't hand-write drumr apps. Neither will you.
A higher level of abstraction means fewer decisions for your agent to get wrong. drumr ships the knowledge along with the code, so Claude Code, Copilot, Cursor or any other agent produces idiomatic, well-structured apps from short prompts, and reviews stay short too.
drumr skills ship with the framework. drumr setup installs them into every app.
Generated in every new app, with the rules your agent follows and a build that has to pass.
Every app can act as an MCP server behind OAuth 2.1, so assistants become an interface to your app.
Skills are plain files in your repo. Claude Code, Copilot, Cursor and others all read them, and you can switch models without switching frameworks.
The CLI · early access
From empty folder to deployed app.
One CLI creates, runs, tests and deploys your app. Local infrastructure runs on Docker Compose, and cloud deploys go to Google Cloud through Pulumi, in your account or ours.
During early access, the CLI and packages go straight to participating teams. Public install from npm comes with the open-source release.
$ drumr create-app field-service $ drumr setup # deps, schema, SDK, agent skills $ drumr infra up # local Postgres & friends $ drumr run $ drumr tests open # local test manager $ drumr cloud deploy # GCP, via Pulumi
Coming soon
The framework gives agents the right abstractions. A harness gives them the right process.
drumr harnesses run your coding agent from spec to shipped feature, following the practices we use to deliver enterprise apps. Bring your own agent and your own model.
drumr Harness Soon
An orchestrator for coding agents building any drumr app. It keeps agents inside the guardrails and turns every feature into a full set of artifacts: code, tests mapped to acceptance criteria, and documentation someone can pick up later.
LIMS Harness Later
The general harness plus laboratory know-how: samples, test plans, results, instruments and audit-ready records, drawn from LIMS apps we've already built.
Manufacturing Harness Later
Work orders, BOMs, quality, traceability and ERP integration, encoded as domain models, workflows and review rules your agent follows.
Harnesses are commercial products. The drumr framework stays Apache 2.0, and the public repository opens alongside the first drumr Harness.
Developer FAQ
The questions you'd ask before betting on it.
What happens when I need logic the framework doesn't cover?
You write TypeScript. Custom @Action classes cover model, object and global operations, and @Service classes with dependency injection hold shared logic. For inbound HTTP there's app.registerWebhook(), and ds.native() gives you the underlying TypeORM query builder. On the frontend you can write fully custom React views, or use the headless hooks and skip the generated UI entirely. The framework handles the standard cases and gets out of the way for the rest.
How do migrations work when several people change models?
They're TypeORM migrations in an explicit chain: each one names the migration it follows. drumr ds migration new scaffolds the next one at the current head, and --from-models drafts the additive changes for you. If two branches both add a migration at the same point, the fork is detected and rejected instead of silently applying both, so you re-point one onto the other. migrate --test runs the whole chain against a throwaway Postgres and compares it with your models. An app won't start while migrations are pending.
What's the testing story?
Jest for unit tests, integration tests against your app's generated typed SDK, and Playwright end-to-end tests with a drumr test kit that knows how to drive drumr screens. drumr tests setup scaffolds all three, and drumr tests open runs a local test manager. The shipped skills teach your agent the same patterns.
Versions and upgrades?
drumr is released continuously with semantic versioning, and breaking changes come with migration guides your agent can follow. During early access we keep apps on the latest version. Longer support for older versions is being defined as part of the commercial offering.
Is it Google Cloud only?
drumr cloud deploy targets Google Cloud today (Cloud Run and Cloud SQL, provisioned with Pulumi), in your account or ours. Every app also ships with a Dockerfile and Docker Compose files, so it runs anywhere Node.js 24 and PostgreSQL run. There's no one-command deploy for other clouds yet.
How tied am I to Ant Design?
Only as much as you choose. The frontend comes in layers. The generated SDK and @drumr/frontend-headless (React hooks) have no Ant Design dependency. The component and runtime layers build on Ant Design 6 for teams who want finished screens fast. Everything is React 19.
Which decorators and databases?
TypeScript legacy decorators (experimentalDecorators and emitDecoratorMetadata, with reflect-metadata), already set up in the generated tsconfig. PostgreSQL is the production database. SQLite works for local development.
Is it open source? When can I install it?
drumr is licensed Apache 2.0. The public repository and public npm packages launch with the first drumr Harness. Until then, early-access teams get the framework and CLI directly. Join the list below.
Early access
Build with drumr before everyone else.
We're adding developers and teams in waves. Leave your email and we'll reach out when there's a spot, with first access to the drumr Harness.
We'll only email you about drumr. No spam, ever.