Generování ArchiMate pomocí AI

ArchiMate publishes a relationship table: for every pair of element types, the set of relationships that is permitted between them. It is exhaustive, it is machine-readable, and it is the reason generation is on firmer ground here than anywhere else in modelling. A generator constrained by that table cannot draw a business process realizing a node or an actor accessing a technology service - not because it was well prompted, but because those edges do not exist.

The layers do the second half of the work. Every element belongs to exactly one of business, application, technology and the rest, so "which layer is this in" is a question with an answer, and a model that puts a database in the business layer is visibly wrong to a reader who has never seen your organisation. Free-form boxes and arrows offer no such handle; ArchiMate is a language, and a language can be checked.

ArchiMate defines derivation: a chain of relationships implies a weaker one between its ends. A node serves an application, the application serves a process, so the node serves the process - and the spec allows you to draw that shortcut directly. It is a genuinely useful feature when a view is deliberately coarse, and it is the single most common thing a generator hands back without saying so.

The damage is not notational, it is that the middle disappears. In the figure above, the application doing the work is gone: nobody can see what would break if it were replaced, and nobody can see that it exists at all. A model built out of derived edges reads as an architecture with no applications in it.

The fix is to ask for the hops. "Show every relationship directly, do not derive anything" costs one sentence in the prompt and turns a tidy picture into a model you can reason about. The full mechanism is in ArchiMate relationships.

Two smaller failures round out the list:

1. Layer confusion. Business services and application services get swapped, because the names differ by one word and the distinction is about who the consumer is rather than about what the thing does.
2. Volume.Ask for "the architecture" and you get sixty elements, which is not a model but a list drawn with rectangles. Ask for a viewpoint.

Four things. The first two are the same as for any notation; the last two are what make an ArchiMate prompt different.

1. The viewpoint."A layered view" to start with - it forces every element into a layer and forces the layers to connect, which is where the arguments worth having are.
2. Your own names.The processes and applications as your organisation calls them. A model that invents "Customer Management System" where you say "Siebel" produces a picture nobody recognises.
3. No derivation. One sentence: every relationship direct, nothing collapsed. This is the highest-value line in the prompt.
4. A stopping rule."At most twelve elements", or one business process and everything under it. Without a bound you get the list.

The first line is the one that matters. Every other item on the list is a five-second judgement; a derived relationship standing in for two real ones is the error that survives review, gets published, and is still on a slide two years later with the application it hides still unnamed.

The AI is given the same metamodel the editor enforces, which for ArchiMate means the relationship table itself. An illegal edge is not something the generator is asked politely to avoid - it is not in the set of edges it can emit, and the editor will not accept one afterwards either. What comes back is a model in the repository, not a picture of one: rename an application and the name changes in every view it appears in.

From there it exports to the ArchiMate Exchange format that Archi and BiZZdesign read, to a Sparx .qea file, and to PNG, SVG or Mermaid for a document. That matters more for ArchiMate than for anything else on this site, because enterprise architecture work is judged by people who use a different tool from the one it was made in.

The UML side of the same question - where the rules are looser and the failures are different - is in generating UML with AI.