Kernaro Assist is an extension panel inside the Enterprise Architect desktop client that brings natural language capabilities to the architect’s modeling and governance workflow. It is not a standalone platform, it lives inside EA where architects work. Kernaro Assist operates in four capability domains: Core Modeling (create and modify elements using natural language), Model Chat (query and analyze the model in plain English), event-driven governance agents (triggered by EA Broadcast Events), and validation checks (MDG compliance, naming conventions, required tagged values). Kernaro Assist is currently in beta, developed by Sparx Systems with no published general availability timeline. This is a real limitation, the roadmap and feature stability are determined by Sparx Systems, not your organization. However, Sparx Services is an active beta participant. We use Kernaro Assist with real clients on real models, contribute field feedback to Sparx Systems, and integrate it into practice development work. Frame this as active architect participation, not as weakness. The guidance we provide based on hands-on beta usage is genuine.
The critical distinction is between the tool and the capability. Kernaro Assist is the tool, it provides natural language modeling functions inside EA. The Amplify service develops the practice capability, it integrates natural language modeling into your architecture governance, review standards, and workflow so that productivity gains compound across the team. Architects using Kernaro Assist in isolation gain some efficiency. Architects in an Amplify practice where natural language modeling is woven into standards and processes gain a measurable discipline shift. This is why Amplify, not the license alone, is the vehicle for meaningful Kernaro Assist adoption.
Core Modeling: Natural Language Element Creation
Instead of clicking through EA dialogs to create and configure elements, architects type natural language prompts. “Create an Application Component called Customer Portal with stereotype ‘WebApplication’, set it to business-critical, and add a note: ‘Supports online customer onboarding.'” Kernaro Assist processes the prompt and creates the properly configured element in the model. This is not autocomplete or code generation, it’s a directed instruction that understands your MDG stereotypes, tagged values, and property structure.
For documentation-heavy modeling sessions (where descriptive text and tagged values matter as much as the structure), natural language prompt speeds significantly outpace manual dialog-based entry. A junior architect documenting 40 new components takes half the time when describing in natural language vs. clicking properties individually.
Model Chat: Query and Analysis in Plain English
Architects can ask questions of the model in natural language. “What Application Components in this package have no assigned owner?” Kernaro Assist queries the model and returns a list. “Show me all infrastructure elements supporting this capability.” “Which business processes are mapped to the customer onboarding capability?” “What data entities are created or consumed by this application?” These are queries that would traditionally require navigation, filtering, or searching through relationships manually.
Model Chat is particularly valuable during architecture reviews and documentation work. Instead of architects manually searching to answer stakeholder questions, they ask Kernaro Assist and get an instant view of the model state.
Event-Driven Governance Agents
Governance rules can trigger automatically when architects perform actions in EA. When a new Application Component element is created, a governance agent fires that checks required tagged values (Owner, CriticalityLevel, BusinessCapability). If a required tagged value is missing, the agent prompts the architect to add it before continuing. When an Infrastructure element is created with a deprecated technology stereotype, an agent flags it for review.
This is governance in the workflow, not governance in a separate review cycle. It reduces the friction of compliance and makes MDG standards visible to architects at the moment they matter, during model creation, rather than weeks later during a review meeting.
Validation Checks: MDG Compliance and Standards
Kernaro Assist runs checks against your MDG definition and organizational standards. It validates that elements use approved stereotypes, that required relationships are present, that naming conventions are followed, and that critical properties are populated. These checks can run on-demand (architect triggers them manually) or continuously (runs in background as the architect works).
Unlike manual validation done in periodic review cycles, continuous validation keeps architects aligned to standards in real time. It surfaces problems while they can be fixed easily rather than after significant modeling has occurred.
Accelerating Capture and Documentation
An architecture team is documenting a 200-application portfolio for the first time. Architects have rich descriptions and business context for each application. Using Kernaro Assist, they prompt natural language descriptions, let it create basic elements and tagged values, then refine and review. The capture cycle that would take 4-6 weeks of manual entry takes 2-3 weeks with Kernaro Assist handling basic element creation and population.
Junior Architect Onboarding
A junior architect new to the organization asks Kernaro Assist questions about the existing model. “What applications are we responsible for on the AWS platform?” “Show me the technology roadmap for this business capability.” “What is the owner structure for the customer-facing systems?” Model Chat reduces ramp-up time and gives junior architects self-service access to model context instead of constant interruptions to senior architects.
Governance Enforcement in Workflow
An architecture team has strong standards requiring Owner and BusinessCapability tags on all Application Components. Without governance automation, they complete quarterly reviews finding 30-50 elements missing tags, triggering rework. With Kernaro Assist agents triggering on element creation, architects are prompted to add required tags immediately. Quarterly reviews surface no governance violations, they shift from correctional to strategic.
Rapid Model Querying
During an architecture review meeting, a stakeholder asks “Which of our systems depend on this database?” In the old workflow, an architect leaves the meeting, queries the model, and comes back with an answer 10 minutes later. With Kernaro Assist Model Chat, the architect types the question in the meeting and gets the answer in 10 seconds. The meeting continues with better information.
Documentation Consistency
An architecture team is improving application documentation. Kernaro Assist can query all Application Components, identify those missing owner descriptions, and help architects draft descriptions en masse rather than one-by-one. Consistency improves because the assistant provides a uniform template.
Kernaro Assist concentrates value with architects who spend significant time on capture, documentation, governance, and model querying work.
| Persona | Why they benefit | Typical impact |
|---|---|---|
| EA Architect | Direct daily productivity in modeling workflow. Natural language prompts reduce dialog clicking. Model Chat answers questions about the model instantly. | 20-40% time savings on element creation and documentation; varies by documentation intensity |
| Junior/Developing Architect | Reduced friction during ramp-up. Model Chat provides self-service context instead of constant questions to senior architects. Governance agents prevent mistakes. | Faster model understanding; reduced need for mentoring questions; fewer governance violations during ramp-up |
| Architecture Manager / Governance Lead | Event-driven agents reduce review overhead. Continuous governance checking surfaces violations immediately rather than in quarterly cycles. Visibility into team compliance. | 15-30% reduction in governance review time; earlier error detection; better governance posture |
| Large Documentation Initiatives | Capture and documentation of large model populations (200+ elements) accelerated by natural language prompts. Consistency across large populations. | 30-50% reduction in documentation cycle time for portfolio assessment work |
| Less value for | Architects whose bottleneck is stakeholder engagement, business case development, or strategic roadmapping (different capabilities, Connect addresses those). Teams with small models (under 50 elements). Organizations with informal governance. |
Lowest-Friction AI Integration for Architect Productivity
Kernaro Assist works where architects already work, inside the EA client, with no context switching to external tools or platforms. If the bottleneck in your architecture practice is capture, documentation, governance, or model querying, Kernaro Assist addresses it directly.
Governance Automation Shifts Work from Reactive to Preventive
Event-driven governance agents fire in the workflow (element creation) rather than in review cycles weeks later. This surfaces governance violations immediately when they’re easy to fix, not after significant downstream modeling. The ROI is not just time saved but quality improved: fewer elements land in the model out of compliance; fewer rework cycles occur.
Active Beta Participation with Real Product Momentum
Kernaro Assist is in beta, feature stability is not guaranteed. However, Sparx Systems is actively developing it with a published roadmap. Sparx Services is an active participant in the beta program. We use Kernaro Assist with real clients, contribute feedback to the product team, and learn field patterns that inform practice development. This is not experimental software that might disappear; it’s a real product with momentum and architect participation.
Model Chat Accelerates Analysis and Decision-Making
In meetings, during reviews, during design sessions, architects can ask the model questions and get instant answers. “What elements depend on this?” “Which applications use this technology?” “Is this data entity redundant?” Questions that used to send architects off to query are answered in real time.
Natural Language Interface Reduces Learning Curve
Architects don’t need to learn EA API syntax, query languages, or reporting tools. They describe what they want in plain English. This lowers the bar for junior architects and architects from non-EA backgrounds to work productively with the model.
Beta Status: Feature Stability Is Not Guaranteed
Kernaro Assist is in active development. Sparx Systems determines the feature roadmap, deprecation policy, and upgrade path. You are not in control of these decisions. Feature changes or removals could require process adaptation. This is a real constraint that requires transparent acknowledgment. If your organization requires production-grade stability guarantees on all tools, Kernaro Assist may not fit until GA.
Value Is Concentrated in Specific Work Categories
Kernaro Assist’s productivity gains are concentrated in capture, documentation, governance, and model analysis work. If your architecture team’s bottleneck is stakeholder engagement, business case development, or strategic roadmapping, Kernaro Assist alone doesn’t address that. Connect (Kernaro AI Hub) addresses stakeholder engagement. Different services address different bottlenecks. Misalignment between tool capability and practice bottleneck yields low ROI.
Practice Capability Development Required
The tool alone doesn’t change how architects work. Kernaro Assist operating on informal models or governance frameworks doesn’t improve either. For meaningful adoption, the Amplify service is needed, to embed natural language modeling into team standards, to design governance agents matching your MDG, to establish quality baselines so that tool output is automatically compliant. Organizations treating Kernaro Assist as a point tool without practice development typically see lower adoption and ROI than organizations using Amplify to integrate it into workflow.
Repository Governance Must Be Sufficiently Defined
Kernaro Assist generates outputs (elements, tagged values, descriptions) using your MDG Technology definition as the model. If your MDG is undefined, informal, or inconsistently applied, Kernaro Assist outputs reflect that inconsistency. “Create an Application Component with the appropriate tags for a legacy system” works if you have a clear definition of what “legacy system” means in your MDG. If your organization has three different approaches to tagging legacy systems, Kernaro Assist can’t know which to apply. This doesn’t make Kernaro Assist unsuitable; it means governance clarity is a prerequisite.
Enterprise Architect Desktop Client
Kernaro Assist License
MDG Technology Definition
EA Repository
Note on EA GraphLink
EA GraphLink is NOT required for basic Kernaro Assist functions (Core Modeling, Model Chat, agents, validation). GraphLink is required if you’re also deploying Kernaro AI Hub or integrating with external tools via MCP. If Kernaro Assist is your only AI feature, GraphLink deployment is not necessary.
The Amplify service establishes baseline metrics across four time categories for each architect. These metrics become the foundation for measuring Kernaro Assist ROI:
Time Category Breakdown (typical across practices, before capability development):
Current Baseline Observation: Across Sparx Services practices, architect time allocation is typically 70-80% on the first three categories combined (operational work), less than 30% on stakeholder engagement (strategic work).
Kernaro Assist Productivity Impact: Natural language modeling, Model Chat, and governance agents reduce time spent in Categories 1 and 2 by typically 20-40% (varies by documentation intensity and governance structure). For a 5-person architecture team:
Amplify Target: After capability development, the goal is to shift the team from 70/30 operational/strategic toward 50/50. This requires not just Kernaro Assist productivity but also practice restructuring, eliminating unnecessary review cycles, automating governance, and creating space for strategic work. Kernaro Assist is one component of this shift; Amplify orchestrates the full transformation.
Manual Modeling via EA Client
The baseline: architects use EA dialogs to create elements, manually navigate relationships, run periodic governance reviews. No tool cost. limited productivity. Suitable only for small practices or low-velocity modeling.
Sparx EA API and Scripting
Architects or technical specialists write scripts (JScript or other languages) that bulk-create or modify elements. Much more powerful than manual entry for large populations, but requires scripting expertise. High initial investment in script development; reusable for future initiatives. Best suited for one-time large bulk operations rather than ongoing capture work.
MCP Integration with Claude (via EA GraphLink)
If EA GraphLink is deployed, Claude can be integrated as a more powerful reasoning engine for model analysis. Claude can answer complex architecture questions across the repository with more sophisticated reasoning than Kernaro Assist Model Chat. Pros: powerful for analysis and decision support; Claude has broader context. Cons: requires GraphLink deployment; data leaves the environment; slower response than in-EA Model Chat; requires API credentials.
Other In-Tool AI Assistants
Generic AI assistants in EA or similar tools (if available from other vendors). Kernaro Assist is purpose-built for EA, it understands MDG stereotypes, ArchiMate, EA structure natively. Generic assistants lack this domain knowledge.
Is Kernaro Assist stable enough to use on live models?
Kernaro Assist is in beta. Its features and API surface may change based on Sparx Systems product development decisions. You can use it on live models, architects in production are using it now. However, you should plan for the possibility of feature changes, deprecations, or API adjustments. The Amplify service manages this through practice design that remains stable even as the underlying tool changes. Our recommendation: use Kernaro Assist in production, but version your governance rules and workflow patterns in Amplify so that changes to Kernaro Assist trigger targeted updates rather than wholesale retraining.
Does Kernaro Assist require EA GraphLink?
No. Kernaro Assist operates inside the EA client against the local repository connection. It does not require EA GraphLink. GraphLink is only required if you’re deploying Kernaro AI Hub (stakeholder portal) or integrating with external tools via MCP. If Kernaro Assist is your only AI feature, you don’t need GraphLink.
What is the difference between Kernaro Assist and Kernaro AI Hub?
Kernaro Assist is an in-EA extension for architects. Kernaro AI Hub is a browser-based portal for stakeholders. Assist helps architects model faster and govern better. Hub helps stakeholders query the repository without architect involvement. They serve completely different users and don’t overlap in purpose. Some organizations deploy both; others choose one based on which bottleneck is most pressing.
How does the event-driven agent feature work?
EA Broadcast Events fire when certain actions occur in the client (element creation, property change, relationship creation, etc.). You define agents that listen for these events and trigger governance checks or automated actions. For example: “When an Application Component is created, fire an agent that checks Owner and CriticalityLevel tags; if missing, prompt the architect to add them.” Agents can be designed through Kernaro Assist configuration or through EA’s standard broadcast mechanism, depending on complexity.
What does the Amplify service add if I already have Kernaro Assist?
Kernaro Assist is the tool. Amplify is the practice development program. The tool alone gives architects faster element creation and Model Chat querying. Amplify integrates Kernaro Assist into governance, workflow, and team standards. It designs governance agents matching your MDG, establishes quality baselines, coaches architects on natural language modeling patterns, measures baseline metrics, and orchestrates the shift from 70% operational time to 50% operational/50% strategic. Without Amplify, Kernaro Assist is a point productivity tool. With Amplify, it becomes a practice transformation vehicle.
Is Kernaro Assist going to stay in beta, or is there a GA timeline?
Sparx Systems has not published a GA timeline for Kernaro Assist. We are active beta participants and have visibility into the product roadmap, but the timeline is their decision, not ours. Expect 12-24 months to GA based on typical Sparx product development cycles, but this is not a public commitment. The beta status is a real constraint that should factor into your adoption decision if your organization requires production-grade stability.
Can Kernaro Assist access the whole repository or just the current model?
Kernaro Assist operates on the active model in the EA client at the time you use it. For Model Chat queries, you’re querying the elements and relationships in the current model and its sub-packages. You can’t query across the entire repository from Kernaro Assist, you need to have the relevant models loaded. If you need repository-wide querying, Kernaro AI Hub (connected to EA GraphLink) is better suited.
What happens if Kernaro Assist creates elements that don’t match my MDG?
Kernaro Assist uses your MDG Technology definition to guide element creation. If you have a well-defined MDG with clear stereotypes and tags, Kernaro Assist outputs comply automatically. If your MDG is vague or Kernaro Assist interprets an ambiguous natural language prompt in an unintended way, non-compliant elements can be created. This is why MDG clarity and event-driven validation agents are important, agents running immediately after element creation catch mismatches while they’re easy to fix. In Amplify practice, governance agents are considered a required control when using Kernaro Assist.
Kernaro Assist is deployed and integrated into practice through the Amplify service. Amplify includes hands-on coaching, governance design, process adaptation, metric baselines, and practice measurement. Amplify is the vehicle for meaningful Kernaro Assist adoption.
If you already have Kernaro Assist licenses and want to develop practice capability around them, Amplify is the engagement.
If you have not yet purchased Kernaro Assist licenses and want to understand readiness before committing, start with Discover to assess your repository governance and architecture practice maturity.
Contact the Sparx Services team to discuss your Kernaro Assist adoption timeline and Amplify program design.
Related reading:
Talk to a Sparx Services architect about where your organization is on the journey and what the next stage looks like.