![](/sites/default/files/media/image/2026-09/Blog%20Graphic-Thought%20Leadership-What%20Acquia%20Learned%20from%20Its%20Personalization%20Test.svg) Image ![Martin Anderson Clutz](/sites/default/files/styles/post_content_attribution_headshot/public/media/image/2026-09/Blue_0.png?h=07bda73c&itok=idUbO5Km) [Martin Anderson-Clutz](/people/acquians/martin-anderson-clutz) Senior Product Marketing Manager, Drupal Acquia ## Collection [Drupal](/blog/series/drupal) Drupal # Intelligent Layouts: Drupal Canvas AI and the Context Layer Published: September 17, 2026 Last Updated: September 18, 2026 11 minute read [Share this blog post on LinkedIn ](https://www.linkedin.com/sharing/share-offsite/?url=https://www.acquia.com/markdownify/node/61456) [Share this blog post on Twitter ]() [Share this blog post via Email ]() Drupal Canvas AI shifts content platforms from reading to writing, using governed context layers to help enterprise AI agents automate safely. ![](/sites/default/files/media/image/2026-09/Blog%20Graphic-Thought%20Leadership-What%20Acquia%20Learned%20from%20Its%20Personalization%20Test.svg) ## Collection : [Drupal](/blog/series/drupal) *What changes when an agent stops reading your content and starts writing it.* For the last two years, the conversation about AI and content has mostly been about reading. Retrieval, summarization, a chatbot that answers a question from your knowledge base. That problem is largely solved, and it is solved almost everywhere. Any serious platform can find a relevant paragraph and hand it back. The shift that actually changes the job of a content platform is quieter. Agents have moved from "answer my question" to "do the work." They are no longer only reading your content. They are starting to write it, assembling pages and populating components and publishing the result. The category we have called content management for twenty years was built for the first job. It was never asked to do the second. ### **Where the Real Cost Lands** At this point a fair objection turns up: is this not exactly why we keep a human in the loop? It is. Any content platform worth running in an enterprise keeps a person between the agent and the published page. A system that lets an agent push unreviewed work straight to production is not showing you the risk of agentic content. It is showing you that it was never built for the enterprise to begin with. So the risk worth talking about is not the rogue page. Review catches that. The risk is waste. A read and a write still fail in opposite directions, and the cost is what separates them. When a retrieval system returns a weak answer, one person spends a moment sorting it out and moves on. When an agent produces a weak write, a layout that misses the brand or a component wired to the wrong relationship or a draft that ignored a business rule, someone has to notice it, correct it, and often send it back to be generated again. Every one of those steps costs the reviewer's time and burns the tokens that produced the work in the first place. That cost lands on the exact person the agent was supposed to help. The promise of agentic content is leverage, so the specialist spends their time on judgment instead of assembly. A guessing agent quietly reverses the trade. Rather than assembling the page themselves, the reviewer now inspects a draft they did not write. They hunt for the places it went wrong and explain what to change. That is not leverage. It is rework wearing the costume of automation, and it scales the wrong way, because an agent that guesses does not guess once. It guesses across every draft, at machine volume. This is why context is the whole game. A human in the loop is cheap when the work in front of them is already right, and expensive when it is not. Give the agent structured, governed context and the review step becomes a quick yes. Hand it flat fields and hope, and the review step becomes the job you were trying to automate, now done twice. ### **Every Generation Answered to a Different Consumer** It helps to look at what actually changed, because the content platform has served three different consumers over its life. **Content Management System** **Headless and Composable** **Agentic Content Platform** **Primary consumer** A person in a browser A front end serving a person Software that acts **Content flows** Outward, to one presentation Outward, to many presentations In both directions **How editorial judgment is applied** By hand, page by page By hand, page by page Encoded as context up front, confirmed at review **Measure of success** Editorial autonomy Reuse across channels Safe, accountable machine action For most of that history, judgment stayed with the editor. The system stored content and rendered it, while a person decided what was true, what was on-brand, and what was ready to publish. Headless moved content to more places, but it did not move that responsibility. A human still stood between the content and the world. Agentic content management changes that. The agent now does the assembly the editor used to do, which means the judgment the editor brought to the work has to come from somewhere. A platform that carries it, with the business rules and the content relationships and the standards for what good looks like, hands the reviewer a draft that already reflects those things. A platform that cannot leaves every one of those calls for the person to supply by hand, one draft at a time. The judgment does not disappear. It moves back onto the reviewer the agent was supposed to free. ### **The Distinction the Category Is Missing** Here is the line most tooling blurs, and the reason so many agentic demos fall apart the moment they meet a real enterprise. Content is not context. Content is what you publish: the page, the article, the product description, the campaign. Context is everything an agent draws on to produce that content safely. Your brand voice. Your content model. Your business rules, your reference material, and the relationships that connect all of it. Context is what turns a vague prompt into a result the organization would actually stand behind. Most systems collapse the two. They hand an agent a set of flat fields and hope it infers the rest: the tone, the relationships, the governance that always lived in the editor's head. Guessing works beautifully in a demo and breaks in production, because the fields never carried the context to begin with. The agent was handed the output and asked to reconstruct the reasoning behind it. Treating context as a governed layer of its own, with clear owners, review, version history, and scope, is what separates an agent that produces a plausible draft from one an enterprise can trust to publish. The prompt gets simpler. The result gets more accountable. The organization decides in advance what the agent is allowed to know and do. ### **What Structure Actually Buys You** Here the shape of the underlying system stops being an implementation detail and becomes the whole question. An agent that writes needs things the read era never demanded. It needs to see the page as a structure it can reason about, with components, order, and resolved values, rather than a wall of markup it has to pattern-match. It needs to work inside the governance that already exists, the roles and permissions and workflows the organization spent years getting right, instead of routing around them. And it needs its output to land in a reviewable state, with a record of who initiated the work and what produced it, so a person can still say yes or no before anyone sees it. Structured context is what makes that review a quick confirmation rather than a second round of work. None of that can be added after the fact. A platform that stores content as flat, disconnected fields cannot suddenly expose relationships it never modeled. A platform with shallow governance cannot suddenly supervise an agent it was never designed to hold. These are properties of the foundation. Either the structured content and the mature governance are already there, or you are trying to pour a footing under a building that already stands. For years, careful content modeling and granular governance were treated as overhead, the slow and unglamorous work that held teams back. The agentic era inverts that. The same rigor is now what lets a team move quickly and safely at once, because it is exactly what an agent needs in order to act without guessing. Image ![A female editor inspects the results of a layout being generated, informed by granular context](/sites/default/files/styles/wysiwyg_full_width_desktop/public/media/image/2026-09/Gemini_Generated_Image_50n47v50n47v50n4.jpeg?h=e7a42042&itok=yp9Ekn0O) ### **Where This Gets Real: Drupal Canvas** Plenty of tools can turn a prompt into a layout now. That trick is becoming table stakes, and it is the wrong thing to be dazzled by. The real question is whether the layout that comes back is on-brand, relevant, usable on the devices your audience actually reaches for, and built on terms you control. The answer depends on the foundation under the prompt, and that is what [Drupal Canvas](https://www.drupal.org/project/canvas) is designed around. Four differences show up the moment you move past the demo. The first is how layouts get built. Canvas assembles them from Twig-based single-directory components, React-based code components, and Drupal blocks, so you work with the component technologies your team already knows rather than adopting one proprietary format wholesale. The second is where the context comes from. Because Canvas can ground its work in the Context Control Center, the agent is not inventing your brand from a prompt. It is working from the voice, content model, business rules, and relationships your organization has already curated and approved. That is the difference between a layout that is merely plausible and one that is on-brand and relevant. The third is the model underneath. Through a provider-agnostic AI layer, Canvas is not wired to a single vendor's model. You use the one that suits the task in front of you, and you change your mind later as the field moves, without re-platforming to chase whatever shipped this quarter. The fourth is where the output can go. Coupled or decoupled, you manage the content once and render it across the front ends and devices your audience uses, so a traditional site and a headless build stay open to you from the same system. Any one of these helps on its own. Together they are the distance between generating a layout and producing one you can put into production: on-brand because it is grounded in your context, usable anywhere because the output is ambidextrous, and built with whatever model best fits the work. ### **The Engine Behind It: The Drupal AI Initiative** None of this is a single product feature or a one-vendor bet. It comes out of the Drupal AI Initiative, the funded and coordinated effort in the Drupal community to make the platform both a great place to build with AI and a safe place for agents to act. That initiative is the engine behind the capabilities that put Drupal in front on the things that matter here: structured content an agent can reason about, governance it has to respect, a provider-agnostic model layer, and the freedom to publish coupled or decoupled. The work runs on two fronts. One brings common AI features directly into Drupal so they operate together instead of as disconnected add-ons. The other makes Drupal legible and callable to agents and tools working from outside, measured against an Agent Readiness scorecard that keeps the progress honest. Because it is happening in the open, on standards-based foundations, the improvements compound for everyone building on Drupal rather than accruing to one company. The [Context Control Center](https://www.drupal.org/project/ai_context) is a good marker of the pace. It turns the context an agent can draw on into a governed content entity, with ownership, workflow, revisions, translations, and scope, and its first stable release is expected in the days ahead. That moves the grounding layer from promising to production, which is the exact piece most platforms are still treating as a roadmap. If you want to see where this is heading, DrupalCon Rotterdam has two AI Summits dedicated to it. I will be presenting at the [AI Dev Summit](https://events.drupal.org/rotterdam2026/ai-dev-summit), and my colleague Scott Falconer will present at the [Enterprise AI Summit](https://summit.enterprisedrupal.eu/schedule.html), one track for the people building with these tools and one for the people who have to answer for them in production. ### **Design It In, Do Not Patch It On** Faced with a fast-moving category, the tempting move is to wait for a winner and buy in later. The trouble is that the properties that matter here do not arrive as an upgrade. Structured content, relationship-aware data, a governed context layer, model choice, and the freedom to render coupled or decoupled are either in the foundation or they are not. So the question for a content team is not which AI feature to switch on. It is harder and more useful than that. When an agent stops reading your content and starts writing it, does your platform still carry the judgment that used to live with your editors? Content answers to a person. Context is what lets software act in their place. The teams that see the difference, and that build on a foundation treating context, structure, and governance as first-class concerns, are the ones who will let agents do real work while keeping a hand on what ships. Image ![Martin Anderson Clutz](/sites/default/files/styles/post_content_attribution_headshot/public/media/image/2026-09/Blue_0.png?h=07bda73c&itok=idUbO5Km) [Martin Anderson-Clutz](/people/acquians/martin-anderson-clutz) Senior Product Marketing Manager, Drupal Acquia [Share this blog post on LinkedIn ](https://www.linkedin.com/sharing/share-offsite/?url=https://www.acquia.com/markdownify/node/61456) [Share this blog post on Twitter ]() [Share this blog post via Email ]() ## Keep Reading [View More Resources](/resources) [Image ![](/sites/default/files/styles/card_tablet/public/media/image/2026-09/Social%20Thumbnail%20Webinars%20High%20Res%201%20%5BVectorized%5D.png?h=3c2a25c5&itok=hB4jFObO) Webinar September 24, 2025 ###### Drupal Canvas: The Next Chapter in Site Building Go beyond the basics and see how to deliver exceptional digital experiences faster, with less code, and more control. Watch webinar Drupal ](/events/webinars/drupal-canvas-next-chapter-site-building) [Asset reference ![](https://acquia.widen.net/content/sfxv3kxwce/web/Content%20Trends%20in%20the%20Era%20of%20AI%20Webinar-Resource%20Card.png?crop=yes&w=400&h=200&itok=svdXB9bl) Webinar September 15, 2026 ###### Drupal Canvas and Agentic Content Management Drupal Canvas, real production questions, and why structured, governed context is what the agentic AI era actually needs. Watch webinar ](/events/webinars/drupal-canvas-and-agentic-content-management-what-enterprise-teams-need-know) [Image ![](/sites/default/files/media/image/2026-09/Frame%201321314280.svg) Blog Article 9 min ###### Two Keynotes, One Question: Building Through Disruption at GovCon Two Drupal GovCon keynotes on building through disruption: the courage to lead change, and the care to keep people from being left behind. Read article Drupal Drupal ](/blog/two-keynotes-one-question-building-through-disruption-drupal-govcon)