Site Structure and Navigation

Full report

On this page

MiRuntime.com is organized into clear sections (Overview, Architecture, Capabilities, Use Cases, Developers, Trust, etc.) accessible via a consistent top menu. Each page has a distinct H1 and concise content, with subheads and bullet lists that make it skimmable (e.g. “Tool execution is the security boundary” on the Agents + Tools page). The navigation is straightforward, but it could be strengthened by highlighting the active page in the menu and adding contextual breadcrumbs. The Explore sidebar on each page repeats the menu links, which ensures easy access but could be streamlined for mobile view. The Contact page clearly states the site’s scope and audience. To improve UX, consider:

• Menu highlighting: Visually mark the current section in the navigation to orient readers.
• Breadcrumbs or section labels: Show users where they are in the hierarchy (e.g. “Architecture » Runtime Architecture”).
• Mobile friendliness: Verify the menu collapses/expands properly on small screens (the “Menu” toggle is present).

Content Clarity and Audience Fit

The content is technical and assumes a savvy audience (platform architects, engineering/product leaders). Key terms (“agent”, “tool schema”, “memory package”) are defined contextually, and lists break up dense text (e.g. responsibilities of a MIR). Overall tone is concise and professional. To further align with the intended audience:

• Add illustrative examples or scenarios. For instance, after defining “LLM runtime” vs. “Machine Intelligence Runtime”, a short example (like “Consider a legal research assistant: an LLM runtime just generates text, whereas a MIR would securely call a document-search tool, log all actions, and require review before sending a sensitive email”).
• Link to case studies or demos. If available, real-world examples (even hypothetical) of MIR in action would ground the abstract concepts.
• Glossary for jargon. Terms like “adapter routing” or “typed memory” could be briefly explained in a sidebar or tooltip. This helps new readers quickly recall definitions without losing flow.
• Active voice and parallel structure. Much of the content already uses clear lists (e.g. schema validation, permission checks). Ensure consistency in formatting (for example, the Implementation checklist on Developers uses code-style lines, which is fine but could be formatted as regular bullet points for better readability).

Technical Accuracy and Completeness

The site’s concepts align with current research on AI runtime governance. For example, MiRuntime’s definition of a runtime layer beyond model inference matches academic proposals of an “execution-time layer” that observes and enforces policies during model execution. Key points of correctness include:

• Separation of roles. The site correctly emphasizes that the model should not handle all responsibilities (policy, memory, I/O) by itself. This is supported by recent work showing the importance of an external control plane for LLMs.
• Tool safety. The outline of schema validation, permission checks, and approval gates is sound. External sources (e.g. OpenLegion) note that “the LLM never executes anything; it only requests. The runtime enforces schema validation, ACL checks… before any execution.”. MiRuntime already reflects this best practice.
• Memory management. The breakdown into short-term, project, user, and prohibited memory is sensible. In line with this, an AI orchestration expert warns that “if you treat memory as ‘a pile of text we append to forever,’ you do not get intelligence, you get entropy.”. The site could cite or paraphrase this to underscore why typed memory is crucial.

However, some areas could be expanded or clarified:

• Add citations or links to standards. The site already lists references (NIST AI RMF, ONNX Runtime) but doesn’t hyperlink them in the content. Where statements touch on risk management (e.g. “memory should expire” or “evidence trails for compliance”), linking to NIST guidance or other frameworks would strengthen credibility. For example, NIST’s AI RMF emphasizes traceable logs and audit trails, which aligns with the “evidence-first output” approach.
• Relate to existing tools. Since readers are advanced, mentioning current agent frameworks (LangChain, LlamaIndex, etc.) could help. For example, note that many agent libraries now support JSON schemas for tools, but MiRuntime advocates pushing even more governance around them.
• Concretize abstract principles. The Architecture and Flow sections list layers and steps. Adding a small diagram (even a simple block diagram of the 7 layers) would make this more accessible. Citations from research (e.g. “active memory management and policy enforcement”) could be footnoted to back up the layered model.

SEO and Accessibility Improvements

From an SEO perspective, the site uses clear headings and repeats key phrases (“Machine Intelligence Runtime”). Still, it could use more meta and semantic optimization:

• Meta descriptions and titles. Ensure each page has a unique <title> and <meta name="description"> summarizing its content. For example, the “What Is MIR?” page could have a description like “Learn how Machine Intelligence Runtime extends LLM inference with tool control, memory, policies, and evidence”. This helps search engines and social previews.
• Heading structure. Most pages have one H1 and logical subheads (H2/H3). This is good for both readability and SEO. On the Runtime Architecture page, consider turning numbered layer titles (“1 Application Layer”) into real subheads (H2 or H3) for better crawlability.
• Linking. Internally link related pages (e.g. link “local-first principles” to the Local-First page; link Agents + Tools to Memory + Evidence when talking about evidence trails). External links to authoritative content (whitepapers or docs) can improve trust, but ensure they open in a new tab.

On accessibility:

• Skip link & ARIA. The “Skip to content” link is present, which is good. Ensure it’s visible when focused.
• Contrast and fonts. The site text seems simple; verify sufficient color contrast (especially if there are any colored highlights or buttons).
• Tables and lists. The Use Cases page has a two-column comparison (LLM vs MIR) under “Where MIR is overkill”. Currently it’s formatted as text, which can confuse screen readers. It should be a proper HTML table or two parallel lists. For example, use a <table> with headings “Simple LLM Runtime” vs “Machine Intelligence Runtime” to make this comparison clear. The same applies to the Concern/Runtime Response section on Local-First – ensure it’s semantic (e.g. a <table> or list).
• Links and buttons. Check that the “Email MiRuntime” link and “Chat” (if any) have descriptive text. For instance, screen-readers benefit if the email link reads “Email MiRuntime at [address]” rather than just “Email MiRuntime.”

Prioritized Recommendations and Roadmap

1. Format comparison tables properly. The “Use Cases” page’s LLM-vs-MIR list should be a two-column table or paired lists for clarity and accessibility. Similarly, ensure any concern/response or checklist is semantic. Impact: High – improves readability and a11y.

1. Complete the Privacy page. The current Privacy content is a placeholder. A real privacy policy (or a note that user data isn’t collected) is essential before launch. Impact: Critical – compliance.

1. Add examples and diagrams. Enhance conceptual pages with visuals. For instance, a simple diagram of the 7-layer architecture or the agent loop would aid understanding. Even one illustrative flow (user request → runtime steps) will break up text. Impact: Medium – aids comprehension.

1. Strengthen references and links. Where possible, link statements to external sources. E.g. linking “repeats best practices” to NIST AI RMF or the ARMO “enforceability ladder” blog can show real-world relevance. If there are specific standards (like ISO/IEC, GDPR for data privacy), note alignment. Impact: Medium – builds authority.

1. Enhance Developer Guidance. The Developers page has good principles and a checklist. It could include minimal code snippets or pseudocode (e.g. how to call a tool with schema) or a small example of a “RuntimeCapabilities” class. Even a sample JSON tool schema (as illustration from OpenLegion) could make it more concrete. Impact: Medium – makes content actionable.

1. Improve SEO basics. Review page <title> and <meta> tags. Incorporate key terms naturally (they already are in headings). Add “alt” text to any logos/icons (we saw none in text, but ensure none are empty). Add “lang” attribute (en-US) to HTML. Impact: Low to Medium – aids discoverability.

1. Accessibility audit. Beyond tables, verify that all text has sufficient contrast, links have ARIA labels if needed, and forms (if any) have labels. Since the site is mostly static text, focus on structure (headings, lists) and the contrast of any UI elements. Impact: Medium – ensures inclusivity.

1. Add a Glossary or FAQ. If space allows, a brief glossary of terms (agent, prompt drift, AIBOM, etc.) or an FAQ could help newcomers. Alternatively, use tooltips for uncommon terms. Impact: Low – helpful for readers.

1. Link the evidence trail section to relevant tools. The “Memory and Evidence” page lists evidence items (logs, approvals). Suggest linking terms like “prompt logs”, “traceability” to industry articles (e.g. Snowflake’s AI traceability guide) or to documentation (like Cognite, Metaculus, etc.). This contextualizes why each item matters. Impact: Low – deeper context.

1. Enable user feedback. Consider a blog or updates section (if not present) to show this is an evolving framework. The Contact page invites discussion topics, but a comments section or forum link could engage the audience. Impact: Low – ongoing engagement.

Implementing these steps (in roughly the order above) will make MiRuntime.com more informative, user-friendly, and aligned with best practices. The result will be clearer messaging for the target audience and a site that both educates and enables trust through concrete examples and solid UX.

Sources: The site’s own content is used to identify current strengths and gaps. External sources on AI runtime and governance support the suggested enhancements.