Use MIRENA’s Entity SEO and Salience workflows when a page needs clearer meaning.
This prompt set helps you define the main entity, map supporting entities, assign attributes, show relationships, improve salience, repair entity drift, plan support pages, and prepare schema-ready entity notes.
Start with source context.
Do not run entity prompts against a loose keyword, sitemap, draft, or page list before MIRENA knows the site, offer, audience, allowed topics, blocked topics, internal link rules, and next workflow stage.
Use the source context template before running this workflow if the project base is not ready yet. Use the Source Context page if you need to understand why source context controls the entity layer.
What This Workflow Does
The Entity SEO and Salience workflow helps MIRENA answer one basic question:
What should this page clearly mean?
A page can include the right keywords and still send weak entity signals. The main entity may be buried. Supporting entities may appear without context. Attributes may be missing. Related concepts may sit too far apart. A draft may mention many concepts but fail to show how they connect.
This workflow fixes that layer before the page moves into briefing, drafting, rewriting, internal links, or schema notes.
Use this workflow when you need to know:
- what the page is mainly about
- which supporting entities belong near the main entity
- which attributes define the main entity
- which relationships the page should explain
- which entities need more prominence
- which entities should be moved, reduced, or removed
- which support pages should exist
- which internal links should support entity meaning
- which markup cues should be held for the approved draft
If the entity layer is weak, the rest of the SEO workflow becomes harder. The MIRENA workflow should still move in order: source context, planning, briefing, drafting or rewriting, internal links, schema notes, and QA.
When to Use Entity SEO and Salience Prompts
Use this prompt set when a page or cluster has weak entity ownership.
That often shows up as:
- unclear page purpose
- weak opening definition
- too many competing concepts
- missing attributes
- missing support entities
- scattered entity placement
- repeated entity mentions without added meaning
- mixed entity identity across pages
- poor internal link anchors
- weak schema-ready notes
- pages that overlap because the entity role is unclear
Entity work is not only for entity pages. It can support topical maps, content briefs, rewrites, documentation pages, product pages, comparison pages, use case pages, and internal link plans.
For example, a content brief should carry a clear primary entity and support entity set before a writer starts. A drafting and rewriting workflow should use entity placement, salience, and context windows to repair weak pages. A topical mapping workflow should use entity maps and support pages to decide which URLs belong in the cluster.
The Fast Path
Run the workflow in this order.
- Define the source context.
- Select the main entity.
- Define the entity.
- Build the entity map.
- Add attributes.
- Map relationships.
- Build the hierarchy.
- Score salience.
- Fix placement.
- Fix proximity and distance.
- Repair context windows.
- Check consistency.
- Find gaps.
- Plan support pages.
- Prepare markup cues after approval.
- Review before handoff.
Do not move into drafting or schema before the entity layer is clear.
Use the Entity Map page when the next step is building the entity model. Use Entity Attributes when the page names the entity but does not explain its defining details. Use Entity Relationships when the page lists concepts but does not show how they connect.
The Entity Optimisation Prompt Pattern
Use short commands.
You do not need to type the full module title. Name the action, name the asset, and ask for the output.
Use this pattern:
text
Run [entity module] on [asset].
Use the source context first.
Return [output].
Route it into [next workflow stage].Examples:
text
Run Entity Map for this cluster.
Use the source context first.
Return the main entity, supporting entities, attributes, relationships, and salience priorities.text
Run Entity Salience on this draft.
Use the source context first.
Return placement fixes, proximity fixes, dilution risks, and priority edits.text
Run Entity Gap Audit on this page set.
Use the source context first.
Return missing entities, missing attributes, weak relationships, and support page ideas.text
Run Entity Markup Cues for this approved draft.
Use the source context first.
Return schema-ready entity notes only.The command should be short, but the context should be strong.
What to Give MIRENA Before Running Entity Optimiser
Start with source context.
Then add the material that fits the task.
For a new page, give MIRENA:
- source context
- page target
- audience
- primary query
- page role
- internal link targets
- target workflow stage
For a draft, give MIRENA:
- source context
- draft text
- page goal
- main query
- desired output
- internal link targets
- known weak points
For a cluster, give MIRENA:
- source context
- sitemap or URL list
- current page roles
- keyword export if available
- internal link map if available
- pages to protect
- pages to merge, refresh, or split
For a schema-ready review, give MIRENA:
- source context
- approved draft
- page type
- entity map
- schema notes if any
- visible FAQ or process sections
- brand and product identity notes
Use the MIRENA input documentation if you need a fuller checklist before starting.
Entity SEO and Salience Modules
The modules below can be run by name inside MIRENA.
Each one has a job. Choose the smallest module that fits the task.
1. Entity SEO
Use this when you need the broad entity layer for a page, cluster, or site section.
Prompt:
text
Run Entity SEO on this page.
Use the source context first.
Return the main entity, support entities, attributes, relationships, salience risks, and next edits.Best for:
- new page planning
- weak drafts
- entity light pages
- topical drift
- rewrite planning
Output should include:
- primary entity
- secondary entities
- support entities
- entity purpose
- entity role in the page
- salience risks
- next workflow stage
Use this before a page moves into an entity-led content brief or a rewrite.
2. Entity Definition
Use this when the page needs a clear definition of the main entity.
Prompt:
text
Run Entity Definition for this page.
Use the source context first.
Return the clearest definition, defining attributes, nearby entities, and terms to avoid.Best for:
- glossary pages
- entity pages
- intro rewrites
- weak explanation pages
- FAQ answer repair
Output should include:
- direct definition
- defining attributes
- exclusions
- nearby concepts
- disambiguation notes
A strong definition should appear early enough to anchor the page. If the main entity is not clear in the opening, run Entity Definition before running salience or rewrite modules.
3. Entity Map
Use this when you need the core entity model before drafting or rewriting.
Prompt:
text
Run Entity Map for this cluster.
Use the source context first.
Return the primary entity, secondary entities, support entities, attributes, relationships, and salience priorities.Best for:
- page briefs
- topical map refinement
- draft repair
- internal link planning
- schema cue planning
Output should include:
- entity hierarchy
- attributes
- relationship map
- salience notes
- page role notes
- internal link notes
The Entity Map workflow is the right step when a page has too many loose concepts and needs a clear semantic model.
4. Entity Attributes
Use this when a page names entities but does not explain what defines them.
Prompt:
text
Run Entity Attributes for this entity.
Use the source context first.
Return defining attributes, functional attributes, audience attributes, and missing attributes.Best for:
- thin definitions
- comparison pages
- product pages
- documentation pages
- support pages
Output should include:
- attribute list
- attribute priority
- missing attributes
- attribute placement notes
- related entities
The Entity Attributes page is the right support asset when the draft mentions an entity but gives readers too little detail to understand it.
5. Entity Salience
Use this when the right entity exists but is not prominent enough.
Prompt:
text
Run Entity Salience on this draft.
Use the source context first.
Return salience scores, placement fixes, dilution risks, and priority edits.Best for:
- weak intros
- unclear H1 or H2s
- entity dilution
- poor snippet targeting
- mixed-topic drafts
Output should include:
- salience score
- entity placement review
- H1 and H2 fixes
- intro fixes
- co-occurrence fixes
- dilution warnings
Run this before the final draft. The goal is to make the primary entity easy to identify, easy to follow, and hard to confuse with nearby concepts.
6. Entity Audit
Use this when you need to inspect a page or cluster before editing.
Prompt:
text
Run Entity Audit on this page set.
Use the source context first.
Return entity gaps, entity conflicts, weak support, drift risks, and priority fixes.Best for:
- existing clusters
- rewrite queues
- content refresh
- old posts
- page consolidation
Output should include:
- entity inventory
- missing entities
- low-value entities
- drift risks
- salience actions
- rewrite priorities
Run this before a large refresh so MIRENA can decide which pages need entity repair, which pages should be merged, and which pages need support links.
7. Entity Placement
Use this when entities appear in the wrong places.
Prompt:
text
Run Entity Placement on this draft.
Use the source context first.
Return where each important entity should appear.Best for:
- weak headings
- buried definitions
- off-topic openings
- poor section structure
- unclear page ownership
Output should include:
- metadata notes
- H1 notes
- H2 and H3 notes
- first 100 word notes
- paragraph placement
- schema cue placement
Entity Placement is useful when the draft contains the right ideas but gives them weak positions.
8. Entity Prioritization
Use this when too many entities compete for attention.
Prompt:
text
Run Entity Prioritization on this entity list.
Use the source context first.
Return primary, secondary, support, optional, and remove groups.Best for:
- crowded briefs
- long entity lists
- SERP imports
- competitor entity sets
- large content hubs
Output should include:
- primary entity
- secondary entities
- support entities
- optional entities
- entities to remove
- reason for each priority
This module prevents an entity list from becoming a content dump. Every entity should have a role.
9. Entity Support Depth
Use this when supporting entities are present but thin.
Prompt:
text
Run Entity Support Depth on this page.
Use the source context first.
Return support entities that need more explanation, examples, attributes, or links.Best for:
- pages that mention concepts without explaining them
- weak support sections
- entity-heavy drafts
- pages with thin context
- documentation pages
Output should include:
- support entity
- current depth
- needed depth
- section recommendation
- link target recommendation
Run this when a page feels shallow even though it mentions many relevant ideas.
10. Entity Support Pages
Use this when the cluster needs more pages to support the main entity.
Prompt:
text
Run Entity Support Pages for this cluster.
Use the source context first.
Return support page ideas, page roles, anchors, and priority.Best for:
- hub pages
- product clusters
- documentation clusters
- comparison clusters
- topical map expansion
Output should include:
- support page title
- support entity
- page role
- parent page
- internal link target
- priority
This module connects entity SEO to site structure. If one page cannot carry all support detail, the cluster may need dedicated support pages.
11. Entity Consistency
Use this when entities shift meaning across a page set.
Prompt:
text
Run Entity Consistency across this page set.
Use the source context first.
Return inconsistent entity use, naming conflicts, attribute conflicts, and fixes.Best for:
- older sites
- multi-author content
- comparison pages
- docs
- product pages
Output should include:
- inconsistent terms
- conflicting definitions
- page locations
- preferred wording
- update notes
Run this before editing a large cluster. It helps stop one entity from being defined three different ways across the site.
12. Entity Conflict Resolution
Use this when entities, terms, or page roles collide.
Prompt:
text
Run Entity Conflict Resolution on this cluster.
Use the source context first.
Return conflicts, source pages, preferred entity roles, and repair actions.Best for:
- cannibalized pages
- mixed-intent pages
- overlapping definitions
- ambiguous terms
- old clusters
Output should include:
- conflict type
- affected pages
- entity role decision
- merge, split, rewrite, or clarify action
- internal link note
This module works well before topical map cleanup because entity conflicts often create page overlap.
13. Entity Gap Audit
Use this when the page or cluster is missing important concepts.
Prompt:
text
Run Entity Gap Audit on this page set.
Use the source context first.
Return missing entities, missing attributes, weak relationships, and support page ideas.Best for:
- competitor gap work
- refresh work
- semantic SEO reviews
- content brief repair
- topical authority repair
Output should include:
- missing entity
- related primary entity
- missing attribute
- page or section target
- priority
- next workflow stage
Use this after an entity audit when the page has clear gaps that need action.
14. Entity Cluster Design
Use this when entities need to become a cluster structure.
Prompt:
text
Run Entity Cluster Design for this topic.
Use the source context first.
Return hub, support pages, entity roles, page roles, and link routes.Best for:
- new clusters
- authority hubs
- product docs
- comparison sets
- semantic SEO clusters
Output should include:
- hub entity
- support entities
- page roles
- link paths
- publishing order
This module turns entity thinking into a site plan. It should connect back to the Topical Maps + Planning workflow when new pages are needed.
15. Entity-Led Sections
Use this when the page structure should be rebuilt around entity logic.
Prompt:
text
Run Entity Sections on this page.
Use the source context first.
Return section order, entity target per section, and support terms.Best for:
- weak outlines
- unclear drafts
- rewrite briefs
- documentation pages
- entity pages
Output should include:
- section heading
- target entity
- supporting entity
- attribute to cover
- internal link target
This module helps make the page easier to read and easier for search systems to parse.
16. Entity-Rich Intro
Use this when the opening does not make the main entity clear.
Prompt:
text
Run Entity Intro on this page.
Use the source context first.
Return a stronger opening answer and entity placement notes.Best for:
- weak intros
- buried answers
- unclear definitions
- low salience pages
- snippet repair
Output should include:
- revised opening
- main entity placement
- support entity placement
- answer block notes
- salience notes
Run this before a snippet rewrite if the page fails to answer the main question early.
17. Entity Context Windows
Use this when entity mentions need better surrounding text.
Prompt:
text
Run Context Windows for these entity mentions.
Use the source context first.
Return better surrounding phrases, attributes, and relationship notes.Best for:
- entity mentions that feel dropped in
- poor co-occurrence
- unclear definitions
- schema-ready notes
- internal link anchors
Output should include:
- entity mention
- current context
- improved context
- attribute to add
- relationship to clarify
Context windows help MIRENA place entities inside meaningful sentences, not as loose terms.
18. Entity Disambiguation
Use this when a term could mean more than one thing.
Prompt:
text
Run Entity Disambiguation on this page.
Use the source context first.
Return ambiguous entities, definitions, exclusions, and wording fixes.Best for:
- overloaded terms
- acronyms
- competitor comparisons
- product names
- broad concepts
Output should include:
- ambiguous entity
- possible meanings
- chosen meaning
- disambiguation copy
- terms to avoid
This module is useful when one term could point to several meanings and the page needs clearer framing.
19. Entity Density vs Clarity
Use this when the page has too many entity mentions or not enough clear explanation.
Prompt:
text
Run Entity Clarity on this draft.
Use the source context first.
Return entities to keep, reduce, explain, move, or remove.Best for:
- entity-stuffed content
- AI drafts
- dense pages
- awkward repetition
- weak readability
Output should include:
- entity density risk
- clarity risk
- keep list
- reduce list
- remove list
- rewrite notes
Entity Clarity keeps the page from turning into a list of terms.
20. Entity Proximity
Use this when related entities and attributes are too far apart.
Prompt:
text
Run Entity Proximity on this section.
Use the source context first.
Return entities that should be closer together and the revised section structure.Best for:
- weak paragraph flow
- poor attribute placement
- confusing definitions
- internal link placement
- salience repair
Output should include:
- entity pair
- attribute pair
- distance issue
- recommended movement
- revised section notes
Entity Proximity is useful when the right concepts appear on the page but are not close enough to reinforce each other.
21. Entity Distance
Use this when the page spreads related concepts too widely.
Prompt:
text
Run Entity Distance on this page.
Use the source context first.
Return distance problems, section moves, and entity grouping fixes.Best for:
- long pages
- scattered support concepts
- weak section grouping
- old posts
- deep documentation pages
Output should include:
- distance issue
- affected entity
- related attribute
- section move
- revised order
Entity Distance is the broader version of Entity Proximity. Use it when the whole page needs better grouping.
22. Entity Hierarchy
Use this when entities need clear priority.
Prompt:
text
Run Entity Hierarchy for this page.
Use the source context first.
Return primary, secondary, support, attribute, and optional entities.Best for:
- page briefs
- entity maps
- cluster planning
- rewrite planning
- schema notes
Output should include:
- hierarchy list
- role for each entity
- placement priority
- section target
- link target
Run Entity Hierarchy before writing a brief. It helps prevent a writer from giving equal weight to every concept.
23. Entity Co-Occurrence
Use this when related entities should appear together more clearly.
Prompt:
text
Run Entity Co-Occurrence on this draft.
Use the source context first.
Return entity pairs that should appear together and where to place them.Best for:
- semantic SEO repair
- low salience pages
- relationship gaps
- schema cue planning
- supporting concept placement
Output should include:
- entity pair
- reason for co-occurrence
- target section
- attribute to add
- internal link note
Co-occurrence helps MIRENA show relationships through nearby language.
24. Entity Relationships
Use this when the page lists entities but does not explain how they connect.
Prompt:
text
Run Entity Relationships for this cluster.
Use the source context first.
Return relationship types, missing links, and section recommendations.Best for:
- semantic SEO pages
- educational pages
- docs
- content briefs
- topical map refinement
Output should include:
- entity A
- entity B
- relationship type
- sentence or section recommendation
- link target
Use the Entity Relationships page when the project needs stronger connections between concepts.
25. Contextual Entity Integration
Use this when entities need to be worked into the draft more naturally.
Prompt:
text
Run Entity Integration on this draft.
Use the source context first.
Return sentence-level and section-level entity placement fixes.Best for:
- draft repair
- awkward entity insertion
- weak content flow
- AI-generated sections
- final QA
Output should include:
- entity to add
- entity to move
- entity to reduce
- revised wording
- section target
This module is useful near the end of a rewrite, when the entity model is known but the copy still feels uneven.
26. Entity Markup Cues
Use this after the draft is approved, before schema is written.
Prompt:
text
Run Entity Markup Cues for this approved draft.
Use the source context first.
Return schema-ready entity notes only.Best for:
- approved drafts
- docs pages
- product pages
- use case pages
- entity pages
Output should include:
- entity type
- schema cue
- attribute cue
- relationship cue
- validation note
This is not final schema. It is the planning layer for schema.
27. Entity Markup
Use this when the page is approved and ready for structured data planning.
Prompt:
text
Run Entity Markup for this approved page.
Use the source context first.
Return JSON-LD planning notes and entity relationship notes.Best for:
- post-approval schema planning
- entity pages
- product pages
- documentation pages
- comparison pages
Output should include:
- schema type
- main entity
- supporting entities
- entity relationships
- sameAs notes
- validation steps
Only run this after the visible page content is stable. Schema should reflect the page, not lead it.
28. sameAs and Entity Identity
Use this when entity identity needs clearer external alignment.
Prompt:
text
Run Entity Identity for this schema plan.
Use the source context first.
Return sameAs candidates, identity risks, and validation notes.Best for:
- brand entities
- people
- software
- organizations
- known concepts
Output should include:
- entity name
- possible sameAs target
- confidence note
- risk note
- schema cue
This module is useful when a brand, product, founder, organization, or known concept needs cleaner identity signals.
29. Entity Identity Across Pages
Use this when the same entity appears across several pages.
Prompt:
text
Run Entity Identity across this page set.
Use the source context first.
Return naming, definition, attribute, and schema consistency fixes.Best for:
- product clusters
- docs
- entity hubs
- comparison pages
- author or organization pages
Output should include:
- entity naming rule
- definition rule
- page conflicts
- fix list
- schema cue
Run this before schema work if a key entity appears across many pages.
30. Knowledge Panel Support
Use this when an entity needs clearer signals for recognition.
Prompt:
text
Run Knowledge Panel Support for this entity.
Use the source context first.
Return description, attributes, relationships, sameAs cues, and support pages.Best for:
- brand pages
- product pages
- author pages
- organization pages
- entity hubs
Output should include:
- entity summary
- attributes
- authority signals
- related entities
- sameAs candidates
- support page suggestions
This module is not a promise of a knowledge panel. It helps prepare cleaner entity signals.
31. Knowledge Panel Entity Support
Use this when a page or cluster should strengthen recognition of a known entity.
Prompt:
text
Run Knowledge Panel Entity Support on this page.
Use the source context first.
Return entity identity fixes, support facts, schema cues, and internal link targets.Best for:
- entity profiles
- software pages
- organization pages
- founder pages
- brand hubs
Output should include:
- identity fixes
- supporting facts
- internal links
- schema cues
- trust notes
This module pairs well with semantic internal linking because entity recognition gets stronger when related pages reinforce the same identity.
32. Schema-Ready Entity Structure
Use this when the draft is ready for schema planning but schema should not be written yet.
Prompt:
text
Run Schema-Ready Entity Structure on this approved draft.
Use the source context first.
Return entity types, attributes, relationships, and schema cues.Best for:
- approved final drafts
- final QA
- schema handoff
- developer handoff
- rich result planning
Output should include:
- main entity
- entity type
- attributes
- relationships
- schema cue
- validation note
Use this as the bridge between entity SEO and schema. The next step should be schema cues, not schema code, unless the draft is already approved.
Which Entity Optimization Module Should You Run First?
Start with the smallest useful action.
If the page has no entity model, run Entity Map.
If the main topic is unclear, run Main Entity Selection or Entity Definition.
If the page already has the right entity but weak placement, run Entity Salience or Entity Placement.
If the cluster has many pages, run Entity Audit before editing.
If the same entity appears across many pages, run Entity Consistency or Entity Identity Across Pages.
If the draft is approved and moving toward schema, run Entity Markup Cues or Schema-Ready Entity Structure.
Common Entity Starting Points
I Have a New Page Idea
Start with source context, then run Entity Definition.
Prompt:
text
Run Entity Definition for this page idea.
Use the source context first.
Return the primary entity, defining attributes, nearby entities, and terms to avoid.Then run Entity Map if the page still needs a stronger structure.
I Have a Draft
Start with source context, then run Entity Salience.
Prompt:
text
Run Entity Salience on this draft.
Use the source context first.
Return entity placement fixes, dilution risks, proximity issues, and priority edits.Then run Entity Integration before final editing.
I Have a Cluster
Start with source context, then run Entity Audit.
Prompt:
text
Run Entity Audit on this cluster.
Use the source context first.
Return entity gaps, conflicts, weak support, drift risks, and priority fixes.Then run Entity Support Pages if the cluster needs more depth.
I Have a Keyword Export
Start with source context, then run Entity Prioritization.
Prompt:
text
Run Entity Prioritization on this keyword export.
Use the source context first.
Return primary, secondary, support, optional, and remove groups.Then run Entity Cluster Design if the keyword export needs to become a page plan.
I Have Competitor Pages
Start with source context, then run Entity Gap Audit.
Prompt:
text
Run Entity Gap Audit on these competitor pages.
Use the source context first.
Return missing entities, missing attributes, relationship gaps, and support page ideas.Then run Information Gain if the page also needs differentiation.
I Have an Approved Draft
Start with source context, then run Entity Markup Cues.
Prompt:
text
Run Entity Markup Cues for this approved draft.
Use the source context first.
Return schema-ready entity notes only.Then run Schema-Ready Entity Structure if the developer or schema workflow needs a cleaner handoff.
Entity Output Review Checklist
Before moving downstream, check the output for:
- source context fit
- one clear primary entity
- clean secondary entity set
- support entities that belong
- clear attributes
- clear relationships
- salience priorities
- entity placement notes
- proximity fixes
- semantic distance fixes
- conflict notes
- gap notes
- support page ideas
- internal link notes
- schema-ready cues
- next workflow stage
Do not move into drafting, rewriting, internal links, or schema if the entity layer is still unclear.
How it Connects to Other MIRENA Workflows
This workflow does not sit alone.
It feeds the rest of the MIRENA system.
A finished entity map can feed a content brief.
A salience audit can feed a drafting and rewriting task.
An entity support page plan can feed topical mapping.
Entity relationships can feed semantic internal linking.
Entity markup cues can feed schema notes after the draft is approved.
The handoff should always say what comes next.
Entity Mistakes to Avoid
Mistake 1: Running Entity Prompts Without Source Context
Do not ask for an entity map before MIRENA knows the site.
The same entity can have different roles on different sites. Source context tells MIRENA which role is correct for this project.
Mistake 2: Treating Entity Lists as Entity Maps
A list of entities is not a map.
An entity map should show hierarchy, attributes, relationships, salience priorities, and page roles.
Mistake 3: Giving Every Entity Equal Weight
Every page needs one main entity.
Secondary and support entities should help the main entity. They should not compete with it.
Mistake 4: Adding Entities Without Explaining Relationships
Entity coverage is weak when concepts are listed without meaning.
Use Entity Relationships or Entity Co-Occurrence when the page needs stronger connections.
Mistake 5: Moving Into Schema Too Early
Schema should follow the approved draft.
Run Entity Markup Cues after approval. Do not write final schema while the page structure is still moving.
Mistake 6: Ignoring Internal Links
Entity SEO should feed internal links.
A page that defines an entity should link to related pages that support, clarify, or extend that entity. Use entity-aware links instead of random related post blocks.
Mistake 7: Leaving Ambiguous Terms Unfixed
If a term can mean several things, run Entity Disambiguation before drafting or schema planning.
Ambiguity weakens the page.
Example Entity Workflow for a New Page
Use this when you are planning a new page from scratch.
text
Run Entity Definition for this page idea.
Use the source context first.
Return the primary entity, defining attributes, nearby entities, and terms to avoid.Then:
text
Run Entity Map for this page.
Use the source context first.
Return primary, secondary, support, attribute, and optional entities.Then:
text
Run Entity Sections on this page.
Use the source context first.
Return section order, entity target per section, and internal link targets.Then route the result into a content brief.
Example Entity Workflow for a Rewrite
Use this when a draft already exists.
text
Run Entity Salience on this draft.
Use the source context first.
Return salience risks, placement fixes, dilution risks, and priority edits.Then:
text
Run Context Windows for the main entity mentions.
Use the source context first.
Return stronger surrounding text and relationship notes.Then:
text
Run Entity Integration on this draft.
Use the source context first.
Return section-level and sentence-level entity fixes.Then route the result into a rewrite.
Example Workflow for a Cluster
Use this when you are reviewing several related pages.
text
Run Entity Audit on this page set.
Use the source context first.
Return entity gaps, conflicts, weak support, drift risks, and priority fixes.Then:
text
Run Entity Consistency across this page set.
Use the source context first.
Return naming, definition, attribute, and schema consistency fixes.Then:
text
Run Entity Support Pages for this cluster.
Use the source context first.
Return support page ideas, page roles, anchors, and priority.Then route the result into topical mapping or internal links.
Example Workflow for Schema Notes
Use this only after the draft is approved.
text
Run Entity Markup Cues for this approved draft.
Use the source context first.
Return schema-ready entity notes only.Then:
text
Run Schema-Ready Entity Structure on this approved draft.
Use the source context first.
Return entity types, attributes, relationships, and validation notes.Then route the result into schema planning.
FAQs About Entity SEO and Salience Prompts in MIRENA
What is the first entity prompt I should run?
Start with Entity Definition if the page idea is unclear.
Start with Entity Map if the page or cluster already has a known topic but needs structure.
Start with Entity Salience if a draft exists and the main entity needs stronger placement.
Do I need source context before running Entity Map?
Yes.
Source context tells MIRENA which entity role fits the site. Without it, the entity map may look complete but still point in the wrong direction.
What is the difference between Entity Map and Entity Salience?
Entity Map defines the structure of entities around a page or cluster.
Entity Salience checks how prominent and clear those entities are inside the content.
Use Entity Map before briefing. Use Entity Salience during draft review or rewrite.
What is the difference between Entity Attributes and Entity Relationships?
Entity Attributes explain what defines an entity.
Entity Relationships explain how one entity connects to another.
A strong page usually needs both.
When should I run Entity Gap Audit?
Run Entity Gap Audit when a page or cluster feels incomplete.
It can find missing entities, missing attributes, weak relationships, and support page ideas.
When should I run Entity Conflict Resolution?
Run Entity Conflict Resolution when pages compete, definitions conflict, or a concept has different meanings across the site.
It helps decide which page owns which entity role.
When should I run Entity Markup Cues?
Run Entity Markup Cues after the draft is approved.
The output should be schema-ready notes, not final schema code.
Can it help with internal links?
Yes.
Entity maps, entity relationships, and support page plans can all feed internal link decisions.
Use to decide which pages should reinforce the same entity, then route the result into semantic internal linking.
Can this help with content briefs?
Yes.
A strong content brief should include the primary entity, support entities, attributes, relationships, and internal link targets.
Run Entity Map before creating an entity-led brief.
Can this help with rewrites?
Yes.
Run Entity Salience, Entity Placement, Entity Context Windows, Entity Distance, or Entity Integration before rewriting a weak page.
Those modules help the rewrite fix meaning, not just wording.
What should I do after?
Move the output into the next workflow stage.
If the page is not written yet, move into a content brief.
If the page already exists, move into drafting and rewriting.
If the draft is approved, move into schema cues.
If the cluster needs support, move into topical mapping or internal links.