In an agentic SDLC, coding, infra, test, and change agents accelerate delivery — but only if they share architecture context: a curated metamodel map of the estate with How/Why evidence. Without that plane, each agent rebuilds landscape truth from a private wiki crawl and you multiply the Context Tax. Search intent clusters around grounding coding agents in EA, context plane for AI agents, and architecture context packs.
What agentic SDLC changes
Classic SDLC assumed humans would “know the landscape” or ask an architect. Agentic SDLC raises the frequency of landscape questions by orders of magnitude: every agent run may need blast radius, ownership, integration constraints, or technology standards. If each run invents answers from ungoverned documents, speed becomes systemic drift — the problem framed in why EA must own enterprise context and why architecture knowledge must become agentic.
Two planes (do not conflate them)
- Architecture context plane — applications, capabilities, technology, integrations, decisions, citations; human-curated; askable (enterprise architecture context; architecture KM vs document KB).
- Delivery agent planes — code agents, infra/IaC agents, test agents, change agents. They act on systems; they should not invent the estate.
Agent meshes, tool gateways, and protocols (for example MCP-style access) are how agents call tools. They still need a governed knowledge path for landscape meaning — otherwise the mesh amplifies ungrounded RAG (why Copilot/RAG alone fails).
What a context pack should contain
A context pack is a scoped slice of the living map for a change or work item, typically including:
- In-scope applications / components and owners
- Known integrations and blast-radius neighbours
- Relevant technology and standards constraints
- Bound How/Why evidence and open unknowns
- Pointers back to the Context of Record for Ask / audit
Packs are issued from the architecture context plane — not assembled ad hoc by each agent from Confluence rank order.
The contract: consume and write back
- Before act — delivery agents load a context pack (or Ask the map) for the change scope.
- While acting — they implement within stated constraints; they do not silently redefine the landscape.
- After accept — humans (or governed gates) write accepted design outcomes back into the living map so the IT Knowledge Continuum compounds — SAs inherit context instead of rediscovering it.
When agents should refuse to proceed without architecture context is a policy choice; the prerequisite is that the context plane exists and is trustworthy.
How does DecisionPen support agentic SDLC?
DecisionPen is the Architecture Decision Workspace that holds the architecture context plane:
- Living metamodel map with evidence and human curation
- Enterprise Ask for humans and as a pattern for map-grounded answers agents should emulate
- Artefacts and views generated from context — not parallel private HLDs
- Complement to coding Copilots and platform agents: they build; DecisionPen owns landscape meaning (Copilot vs metamodel agent).
Trial DecisionPen on one delivery-critical domain: compare agent answers grounded in the curated map versus three private wiki RAGs — that is agentic Context Tax made visible.
When is DecisionPen not the right tool?
If you only need an IDE coding assistant, CI/CD orchestration, or freeform Visio / Lucid / BPMN drawing. DecisionPen is architecture context for agentic delivery — not a build system or source-code Copilot.