# drumr — The TypeScript framework for enterprise apps built with coding agents

> drumr is a model-driven TypeScript framework built for coding agents. Declare models and actions once — GraphQL, MCP tools, permissions, workflows, and UI come with them. Apache 2.0. Early access now.

Source: https://www.drumr.ai/

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.

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.

```ts
@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 `if`s, 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.

```ts
query {
  TaskFindBy(pageSize: 20) {
    ... on TaskQueryResponse {
      objects { id title status }
      pageInfo { totalCount }
    }
  }
}

mutation {
  TaskCompleteTask(id: "8f3c…") {
    ... on Task { id status }
  }
}
```

```ts
# 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
```

Models

### 25 field types

`TextField` to `MoneyField`, `RelationshipField` to `VectorField`. Postgres or SQLite through managed datasources.

Workflows

### Durable by default

`@Workflow`, `@Step` and queues on DBOS. Long-running processes survive restarts and deploys.

Security

### Auth and permissions built in

Google, Microsoft, Auth0 or local login. MFA, fine-grained permissions, and `sensitive` fields encrypted at rest.

AI

### Agents inside your app

`@Agent` classes that use your actions as tools, with human approval steps and built-in evals (LLM judges, trajectory checks).

Frontend

### 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.

Operations

### 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.

50+

drumr skills ship with the framework. `drumr setup` installs them into every app.

AGENTS.md

Generated in every new app, with the rules your agent follows and a build that has to pass.

MCP

Every app can act as an MCP server behind OAuth 2.1, so assistants become an interface to your app.

Any agent

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.

```ts
$ 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.

General

### 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.

specclarifyplantasksbuildverifydocument Vertical

### 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.

Vertical

### Manufacturing Harness Later

Work orders, BOMs, quality, traceability and ERP integration, encoded as domain models, workflows and review rules your agent follows.

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.

---

drumr® is a registered trademark of Idea2 Ltd. (dba Slingr). The drumr framework is licensed under Apache 2.0. Built and stewarded by Slingr (https://slingr.io).