Seed4j is a hexagonal architecture framework that stays deliberately silent on business logic. You define the core domain rules, seed4j enforces the boundaries.
That intentional silence is a feature for human developers. But it's a problem for AI agents that need to understand where they're allowed to write code and what architectural patterns they should follow.
The solution, according to this proposal from the seed4j team, is three layers that make the framework AI-native without changing its human-facing design.
Power - Tools for Agents
The first layer is an MCP server that exposes seed4j's structure as tools an AI agent can call. Need to create a new service in the domain layer? There's a tool for that. Need to wire up a port-adapter boundary? Another tool.
This is the mechanical layer - giving agents the actual operations they can perform within the architecture. Instead of generating code from scratch and hoping it fits the framework's patterns, the agent calls structured tools that guarantee compliance.
It's the same principle as giving a developer a CLI instead of asking them to hand-edit config files. Fewer ways to break things, clearer success paths.
Wisdom - Documentation That Explains Boundaries
The second layer is AI-oriented documentation that explains what the architectural boundaries mean and why they exist. Not just what the framework does, but the thinking behind it.
This is where seed4j's silence becomes a teaching opportunity. The framework doesn't dictate business logic, but the documentation can explain why that separation matters. It can teach an agent that domain logic belongs inside the core, not in the adapters. That ports define contracts, not implementations.
Human developers learn this through experience and code reviews. AI agents need it written down explicitly, structured for their consumption patterns.
Courage - Multi-Stage Workflow Skills
The third layer is workflow skills that guide agents through complex, multi-stage tasks. Creating a new feature isn't a single operation. It's defining domain entities, implementing business rules, creating ports, building adapters, wiring everything together, writing tests.
Workflow skills encode that sequence, so an agent knows not just what tools to call, but in what order, with what dependencies, and how to validate each step before moving to the next.
This is the layer that turns seed4j from a set of tools into a coherent development environment for AI agents. It's the difference between giving someone a toolbox and teaching them how to build a house.
Why This Pattern Matters
This three-layer approach - tools, knowledge, workflows - is a pattern that extends beyond seed4j. It's a model for making any framework AI-native without rewriting it for AI consumption.
Most frameworks were designed for human developers. Making them legible to AI doesn't mean dumbing them down or removing constraints. It means adding the layer that explains the constraints and provides structured ways to work within them.
The genius of this approach is that it keeps seed4j's intentional silence intact. The framework still doesn't dictate business logic. But the AI layer explains why that matters and helps agents respect the boundary.
For builders working with AI-assisted development, this is a glimpse of how tools will evolve. Not by removing structure, but by making structure more legible to both human and machine collaborators.