AI-native Drupal knowledge

Turn any Drupal module into an agent-ready skill

Drupal Context reverse-engineers contrib modules into structured, AI-consumable knowledge — then compiles that knowledge into focused, versioned skills your agents load on demand. No guessing, no hallucinated APIs.

See how it works Explore the pipeline

Contrib maintainer? Help us review generated skills and docs

Read-only explorers
Parallel analysis
Grounded in real source

drupal-context — agent session

$ discover-drupal-module webform

→ spawning 4 explorers in parallel…

✓ entities · plugins · services

✓ hooks · events · routes

✓ configuration · permissions

✓ extension-points · ai-integration

wrote storage/webform/6.2.0/discover/ (11 files)

$ generate-module-skill webform

→ resolved drupal/webform 6.2.0

wrote ai/skills/boost-webform/SKILL.md + references/

✓ skill ready — agents can now build on Webform

Why Drupal Context

Agents that actually understand your modules

A contrib module is thousands of lines of plugins, services, hooks, and config schema. Drupal Context distills all of it into knowledge an AI agent can act on — accurately.

Deep module analysis

Every entity, plugin type, service, hook, event, route, permission, and extension point — captured as structured Markdown, one file per category.

Grounded, never guessed

Read-only explorer agents cite real source files. If the code does not state it, it does not get written — so agents build on facts, not hallucinated APIs.

Skills agents actually use

The output is a focused SKILL.md plus lazy-loaded references, pinned to the exact release installed on your site and loaded only when an agent needs it.

Why it pays off

Less context burned, fewer wrong turns

A documented module returned as context changes the economics of every agent run. Your agents stop reading source to understand a module, stop guessing at APIs that have moved on, and start building on knowledge pinned to the exact release you ship.

Spend tokens building, not reading

The module arrives pre-documented as context. Agents no longer crawl thousands of lines of plugins, services, and hooks just to figure out how it works — that analysis is already done, so each run starts informed instead of paying to re-derive it.

Lower token cost per task

Knowledge that stays current

Models are frozen at their training cutoff and never see the API changes that landed afterward. Drupal Context is regenerated against the release on your site, so agents always work from the module's real, up-to-date surface — not a stale memory of an old version.

Pinned to the installed release

Not dependent on a strong model

When the knowledge is injected up front, the agent does not have to be brilliant to be right. Even smaller or cheaper models — and agents with no prior exposure to the module — make the correct calls, because the facts they need are in front of them.

Levels up weaker agents

Get it right the first time

With current, grounded documentation, agents stop banging their heads against APIs that no longer exist. Fewer dead ends, fewer retries on methods that were removed releases ago — just accurate implementations against the API as it is today.

Fewer retries and dead ends

The pipeline

From module source to a usable skill

Two skills run back to back. The first reads the module and writes down what it found; the second turns those findings into something other agents can pick up and use.

Module source

webform 6.2.0

Explorer agents

read-only · parallel

discover/*.md

11 categories

boost-{module}

SKILL.md + references

Stage one

Discover the module

An orchestrator spawns a team of read-only explorer subagents in parallel. Each is handed a disjoint set of analysis categories, reads only the module source on disk, and returns structured Markdown — it never writes files and never invents APIs.

Disjoint categories per agent — no overlap, full coverage
The orchestrator persists each block to a category file
Submodules each get their own condensed analysis

storage/{module}/{ref}/discover/*.md

Stage two

Generate the skill

The generator reads the discovery files, resolves the version actually installed from composer.lock, and writes a second-order skill: a focused SKILL.md for orientation plus lazy-loaded references for the deep detail.

SKILL.md carries only the orientation and the 80% path
Deep topics split into references, loaded only on demand
Every snippet is grounded in identifiers from discovery

ai/skills/boost-{module}/SKILL.md

Inside discovery

Eleven angles on a single module

Each explorer agent owns one or more of these categories. Together they reconstruct the whole API surface — the parts an agent needs to use, configure, extend, and theme the module.

Entities

entities.md

Entity types, fields, formatters, widgets.

Plugins

plugins.md

Plugin types defined and implementations shipped.

Services

services.md

Service IDs, tags, and what each one does.

Configuration

configuration.md

Config objects, key settings, defaults, UI.

Permissions

permissions.md

Each permission and what it guards.

Routes

routes.md

Paths, controllers, access, menu and task links.

Hooks

hooks.md

Hooks defined in the API and hooks implemented.

Events

events.md

Events dispatched and their subscribers.

Extension points

extension-points.md

Every way another module can hook in or extend.

AI integration

ai-integration.md

Code-level guidance and non-obvious gotchas.

Submodules

submodules/*.md

One condensed analysis per shippable submodule.

Summary

summary.md

Key facts: purpose, package, version, deps.

The output

A skill built for lazy loading

The generated boost-{module} skill is small on purpose. The orientation layer stays in context every time; the heavy detail waits in references until an agent decides it needs it.

SKILL.md — orientation: Summary, key-facts table, when to use it, the single most common usage pattern, and a routing table to the references.
A mandatory install guard: Every generated skill makes the consuming agent confirm the module is enabled before it touches anything on the site.
references/*.md — depth on demand: One file per non-trivial topic — use, configure, extend, theme, events — each with a runnable, grounded example.
Pinned to your release: The skill names the exact installed version; re-running for a new release overwrites it in place.

ai/skills/boost-webform/

SKILL.md — orientation + the 80% path

references/

use.md — render & use on a site

configure.md — config, UI, permissions

extend.md — hooks, services, plugins

theme.md — templates & preprocess

events.md — dispatched & subscribable

Loaded only when an agent needs it

Built with maintainer expertise

For contrib maintainers

Help every agent build on knowledge you trust

AI-generated skills and documentation are only as strong as the maintainers who review them. Your module expertise helps agents across the ecosystem work with accurate, release-pinned context — and makes our community stronger together.

How to get started

Sign in with GitLab

Use your Drupal.org GitLab account to log in.

Open your profile

See every module on the site where you are listed as maintainer.

Browse your modules

Visit any module details, doc, or skill page for a project you maintain.

Review and improve

Click Review to validate generated skills and documentation.

analysis categories per module

stage pipeline: discover then generate

100%

grounded in real source, zero guesses

1:1

versioned skill per installed release

Give your agents real Drupal fluency

Discover a module once. Generate a skill your whole agent fleet can build on — accurately, on every site that has it installed.

Discover a module Review the pipeline