Skip to content
BranchesTags

Repository files navigation

ellmos-ai.github.io Banner

ellmos-ai.github.io — Interactive Public Maps of the ellmos Ecosystem

Official public web portal, interactive module circuit diagrams, bundle recipes, skill directory, and visual stack composer for the modular ellmos AI framework.

Version 0.1.3 CI Status Tests 31 Passed Python 3.10+ Platforms Web UI Privacy: Zero-Egress Security: Non-Elevation Security SLA Code Style: Ruff Ecosystem: ellmos-ai Umbrella: open-bricks LLM Ready Last Checked Notice: Attribution License: MIT

English · Deutsch · Live Site

Note

For AI agent context, automated crawler schemas, and architectural invariants, see llms.txt. All deployed web pages execute 100% offline inside the client's browser with zero external telemetry, zero tracking, and zero third-party CDNs.

Quick Navigation

1. Features & Core Capabilities

Live at https://ellmos-ai.github.io

ellmos-ai.github.io serves as the public graphical surface of the ellmos modular construction kit. It translates internal module registries, composition recipes, and AI agent skills into human- and machine-readable static web experiences:

  1. Module Circuit Map (index.html): Visual, categorized circuit diagram illustrating how modules (MCP servers, proxies, runners, tools) connect and exchange information.
  2. Bundle Recipes (bundles.html): Interactive walkthrough of 13 curated deployment recipes, detailing required and optional components for specific agent profiles.
  3. Skill Library (skills.html): Searchable, live catalog of public agent skills (SKILL.md) with built-in viewer and clipboard integration.
  4. Stack Composer (stack-composer.html): Interactive visual assembly tool enabling developers to compose valid module stacks with live rule enforcement and export to standard stack.v2.json.
  5. Zero-Egress Static Privacy: Pure HTML5/CSS3/Vanilla JS execution in the user's browser with 0 external requests and 0 third-party CDNs.
  6. Bilingual Navigation Parity: Symmetrical documentation and reciprocal HTML anchor aliases across English and German.

2. System Architecture & Topology

The ellmos-ai.github.io static delivery architecture bridges local development repositories, canonical skill catalogs, automated leak gates, and GitHub Pages CDN edge delivery:

  • Surface Layer (Browser Client): Renders static DOM, handles client-side filtering, theme switching (dark/light), and stack composition entirely in local memory.
  • Artifact Layer (Static Web Applications): Self-contained HTML/CSS/JS bundles (index.html, bundles.html, skills.html, stack-composer.html, .nojekyll) with zero server-side state.
  • Maintainer Layer (_tools/pages_maintainer.py): Deterministic runner executing on 7-day windows anchored to Mondays, verifying skill parity and enforcing fail-closed leak gates.
  • Security Isolation Layer: Validates that no draft or private modules (vis:"priv", vis:"cand") leak into public artifacts.
  • Upstream Data Sources: Consumes canonical approved excerpts from .SKILLS registries and module configuration schemas.

3. Target Personas & Discoverability

ellmos-ai.github.io is engineered to solve concrete workflow bottlenecks for four key audiences:

[PERSONA-01] Autonomous AI Agent Architects & Operators

  • Role: AI Infrastructure Engineers, Multi-Agent Swarm Designers (Gemini, Claude Code, Codex).
  • Pain Point: Fragmented, out-of-date agent skill registries and lack of standardized JSON stack declarations for autonomous workers.
  • Solution: Centralized, machine-readable llms.txt, validated SKILL.md library viewer, and exportable stack.v2.json schema definitions.
  • Typical Workflow: Consult llms.txt -> search skills.html for domain skills -> assemble stack in stack-composer.html -> export stack.v2.json -> deploy to agent runner.
  • High-Intent Search Queries:
    • "modular AI agent stack composer"
    • "machine-readable agent skills repository"
    • "MCP server ecosystem interactive map"
    • "standardized agent recipe stack.v2.json"

[PERSONA-02] Modular System Engineers & Developers

  • Role: Backend & Tooling Engineers building decoupled AI extensions and MCP servers.
  • Pain Point: Difficulty visualizing how disparate tools, proxies, and executors fit together in an agent runtime.
  • Solution: Visual circuit map with domain clustering, input/output port definitions, and clear module categorization.
  • Typical Workflow: Open index.html -> filter by functional cluster (e.g., Code & Development) -> inspect module tooltips -> verify compatibility.
  • High-Intent Search Queries:
    • "visual MCP server dependency diagram"
    • "modular AI tooling circuit map"
    • "open-bricks agent architecture map"
    • "local-first AI agent module registry"

[PERSONA-03] Prompt Engineers & AI Workflow Designers

  • Role: Prompt Engineers, AI Team Leads, and Domain Specialists authoring specialized agent capabilities.
  • Pain Point: Hunting through git repositories to find copyable, compliant agent system instructions and tool definitions.
  • Solution: Interactive skills.html with real-time text search, category tabs, formatted markdown preview, and one-click copy to clipboard.
  • Typical Workflow: Browse skills.html -> filter by category -> preview instructions -> click Copy Markdown -> paste into system prompt.
  • High-Intent Search Queries:
    • "agent skill library markdown browser"
    • "curated system prompt bundle recipes"
    • "offline AI agent skill catalog"
    • "copyable SKILL.md template directory"

[PERSONA-04] Security & Compliance Officers

  • Role: Information Security Auditors, Privacy Officers, and Enterprise Compliance Architects.
  • Pain Point: Third-party SaaS tools transmitting intellectual property, browsing habits, or stack blueprints to cloud analytics.
  • Solution: 100% zero-egress guarantee (INV-STATIC-01), client-side DOM processing, fail-closed leak-gates (INV-LEAK-02), and unprivileged user-mode execution (INV-RUNAS-04).
  • Typical Workflow: Review SECURITY.md and THIRD_PARTY_LICENSES.md -> audit network tab in DevTools -> verify 0 external requests.
  • High-Intent Search Queries:
    • "zero egress static agent architecture visualizer"
    • "privacy preserving local-first AI documentation"
    • "fail-closed leak gate static site generator"
    • "air-gapped compatible AI tool catalog"

4. Comparative Matrix vs. Alternatives

The following matrix contrasts ellmos-ai.github.io with traditional developer portals and AI registries across 10 architectural dimensions mapped directly to runtime invariants:

Comparative Dimension Runtime Invariant ellmos-ai.github.io Cloud API / Agent Hubs (e.g. HuggingFace, LangSmith) Static Doc Generators (e.g. Docusaurus, MkDocs) Heavy Dynamic SPAs (e.g. Next.js on Vercel) Unstructured GitHub README Collections
1. Network Egress & Telemetry INV-STATIC-01 100% Zero-Egress (0 CDNs, 0 analytics, 0 cookies) Heavy tracking, session cookies, external API telemetry Often includes Google Analytics, web fonts, CDNs Dynamic API calls, server-side logs, cookies Minimal, but lacks interactive tooling
2. Leak Prevention & Visibility Gates INV-LEAK-02 Fail-Closed Leak-Gates (strict vis:priv/vis:cand check) Manual publishing or public-by-default exposure No native leak-gate; relies on manual file exclusion Dependent on complex backend ACLs and middleware Prone to accidental commits of private drafts
3. Catalog & Skill Synchronization INV-CATALOG-03 Exact Canonical Parity (synchronized with .SKILLS) Central cloud database drift vs local files Static markdown drift unless manually regenerated Database sync lag or disconnected API stubs Frequent desynchronization and broken links
4. Execution Privilege Mode INV-RUNAS-04 Unprivileged User Mode (RunAsInvoker, 0 admin rights) Cloud container root / elevated server runtimes Standard CLI, but often requires global npm packages Requires Node.js server daemons and root containers None (raw git text)
5. Maintenance Cadence INV-WINDOW-05 Deterministic 7-Day Window (anchored to Mondays) Ad-hoc or continuous trigger churn Manual rebuilds on every documentation typo Automated CI/CD webhooks with frequent rebuilds Irregular, untracked manual edits
6. Atomic Git History INV-DIFF-06 Atomic Content Commits (commits only on content diff) Opaque database revisions Empty commits or timestamp churn common Frequent automated deployment commits High noise of minor documentation commits
7. Multi-Agent Concurrency INV-LOCK-07 Fail-Closed Lock Protocol (LOCK.pages-maintainer.txt) Database row-locks or optimistic concurrency No concurrency protection for local multi-agent runs Distributed Redis locks or database locking Prone to merge conflicts across agent swarms
8. Multi-OS CI Validation INV-OS-08 Triple OS Matrix (Ubuntu, Windows, macOS; Py 3.10-3.13) Typically Linux-only cloud container builds Often tested on single OS platform Tested on Linux runner environments Rarely tested with automated test suites
9. Offline Client Autonomy INV-CLIENT-09 100% Pure Client-Side JS (full functionality offline) Breaks completely without internet connectivity Readable offline, but search often needs server index Breaks without active backend server Readable offline, but zero interactive features
10. Security & Triage SLA INV-SLA-10 Binding 48h Response / 5d Triage SLA (SECURITY.md) Standard enterprise ticket queues or best-effort Open-source best-effort, no formal SLA Platform provider SLA, not repository-specific No defined security commitments

5. Dual Mermaid Diagrams

Architecture Topology Diagram

flowchart TB
    subgraph Client["1. Browser Client & Surface Layer"]
        UI["Web Browser Client<br/>(Desktop, Tablet, Mobile)"]
        Theme["Theme & Local State<br/>(Dark / Light Mode, Pure Vanilla JS)"]
        Offline["100% Client-Side Engine<br/>(Zero External Requests, Zero CDNs)"]
    end

    subgraph Pages["2. Public Interactive Web Applications"]
        P1["index.html<br/>Module Circuit Map"]
        P2["bundles.html<br/>13 Curated Bundle Recipes"]
        P3["skills.html<br/>Public Skill Library Viewer"]
        P4["stack-composer.html<br/>Interactive Stack Composer"]
    end

    subgraph Maintainer["3. Automated Maintenance Layer"]
        PM["_tools/pages_maintainer.py<br/>(Deterministic Windowed Runner)"]
        State["_tools/.state/<br/>(Window Bounds & Run Evidence)"]
        DiffCheck["Atomic Diff Verification<br/>(Content Change Commit Gate)"]
    end

    subgraph Security["4. Security & Leak-Gate Isolation"]
        LG["Fail-Closed Leak-Gates<br/>(Block vis:priv & vis:cand)"]
        CatCheck["Canonical Skill Parity<br/>(Verify Counts vs .SKILLS Registry)"]
        Invoker["Non-Elevation Gate<br/>(RunAsInvoker User Mode)"]
    end

    subgraph Upstream["5. Canonical Upstream Sources"]
        Cat["Private Module Catalogs<br/>(Approved Public Excerpts Only)"]
        SkillsReg[".SKILLS Canonical Directory<br/>(Markdown Skill Documents)"]
        GitRepo["Git Repository HEAD<br/>(Branch main)"]
    end

    UI --> Theme
    Theme --> Offline
    Offline --> Pages
    P1 --> UI
    P2 --> UI
    P3 --> UI
    P4 --> UI

    PM --> State
    PM --> Security
    Security --> Upstream
    Security --> LG
    Security --> CatCheck
    Security --> Invoker
    PM --> DiffCheck
    DiffCheck --> Pages
    DiffCheck --> GitRepo
Loading

Maintenance & Publication Lifecycle Sequence

sequenceDiagram
    autonumber
    actor Admin as Maintainer / Automation
    participant Runner as pages_maintainer.py
    participant Guard as Lock & Window Gate
    participant Catalog as Upstream Module Catalog
    participant Leak as Fail-Closed Leak Gate
    participant Artifacts as Site Artifacts (HTML)
    participant Tests as Pytest & Ruff Gates
    participant Git as Git Repository / Pages CDN
    actor User as Web Browser User

    Admin->>Runner: Trigger Maintenance Cycle (--check / --run)
    Runner->>Guard: Verify 7-Day Window & Claim Atomic Lock
    Guard-->>Runner: Window Validated & Lock Granted
    Runner->>Catalog: Read Module Catalogs & .SKILLS Inventory
    Runner->>Leak: Scan Generated HTML for vis:priv / vis:cand
    alt Leak Detected or Skill Count Mismatch
        Leak-->>Runner: Fail-Closed Violation Detected
        Runner-->>Admin: Immediate Abort (0 Artifacts Modified)
    else Leak Free & Parity Verified
        Leak-->>Runner: Verification Passed (100% Clean)
        Runner->>Artifacts: Write Updated index, bundles, skills, stack-composer
        Runner->>Tests: Run Pytest & Ruff Static Analysis
        Tests-->>Runner: All Tests Passed (100% Green)
        alt Generated Content Changed from HEAD
            Runner->>Git: Create Atomic Git Commit & Push
            Git-->>Admin: Pushed Clean Revision to origin/main
        else Content Identical to HEAD
            Runner-->>Admin: Idempotent No-Op (0 Commits Generated)
        end
        Runner->>Guard: Release Atomic Lock
    end

    User->>Git: Request https://ellmos-ai.github.io
    Git-->>User: Deliver Self-Contained Static HTML/CSS/JS
    User->>User: Client-Side Interactive Filtering & Stack Assembly
Loading

6. Governance & Runtime Invariants

The project strictly guarantees 10 operational and architectural invariants:

Invariant ID Guarantee Specification & Implementation Details Security & Operational Benefit
INV-STATIC-01 100% Static & Zero Network Egress All deployed pages (index.html, bundles.html, skills.html, stack-composer.html) are self-contained static HTML/CSS/JavaScript documents. Zero external telemetry, zero tracking scripts, zero user analytics, and zero external third-party CDN dependencies. Complete user confidentiality; client browsing patterns and composed stacks never leave the user's device.
INV-LEAK-02 Fail-Closed Leak-Gates The maintainer suite (_tools/pages_maintainer.py) strictly validates public site artifacts against canonical catalogs before publication. Private module identifiers and non-public visibility markers (vis:"priv", vis:"cand") trigger an immediate fail-closed abort. Absolute prevention of unintended intellectual property or internal architecture exposure.
INV-CATALOG-03 Canonical Catalog Parity Skill catalog counts and module inventories must strictly match canonical .SKILLS and module registry definitions. Any discrepancy halts the generation process. Guarantees public documentation remains 100% synchronized with actual framework capabilities.
INV-RUNAS-04 Local-First & Non-Elevation (User Mode) All build and maintenance scripts run completely unprivileged in standard user space (RunAsInvoker). Administrator or root privileges are never requested, required, or assumed. Safe, least-privilege operation preventing privilege escalation risks across developer workstations and CI runners.
INV-WINDOW-05 Deterministic 7-Day Window Cadence Automated site maintenance is strictly bounded by deterministic 7-day windows anchored to Mondays, synchronized with system-auditor evidence runs. Predictable maintenance intervals without uncontrolled churn or erratic micro-commits.
INV-DIFF-06 Atomic Content-Change Commits Git commits are generated exclusively when verified, leak-free site content has actually changed from HEAD, preventing noisy empty commits. Clean, meaningful commit history with zero ghost revisions or timestamp-only drift.
INV-LOCK-07 Fail-Closed Lock Discipline Repository and workspace lock semantics (LOCK.pages-maintainer.txt, canonical LOCK rules) are enforced to ensure atomic runs and eliminate race conditions across multi-agent environments. Zero file corruption or conflicting simultaneous generator executions across autonomous agent swarms.
INV-OS-08 Multi-OS Platform Parity & Smoke Integrity Automated GitHub Actions CI workflow runs on ubuntu-latest, windows-latest, and macos-latest across Python 3.10-3.13 with bytecode compilation gates and Ruff linter. Seamless cross-platform reliability for all maintainer scripts and verification fixtures.
INV-CLIENT-09 Pure Client-Side Static Execution Dark/light theme toggles, circuit map filtering, bundle recipe inspection, and stack composer logic run 100% in client-side JavaScript without backend servers or server-side state. Ultra-fast page response times, zero server infrastructure costs, and resilient offline utility.
INV-SLA-10 48h Response & 5-Day Triage SLA Mandatory 48-hour response SLA for initial vulnerability acknowledgment and 5 business days for complete triage assessment. Predictable, enterprise-grade security response and responsible vulnerability disclosure process.

7. Interactive Web Applications Matrix

Page File Primary Features Target Audience Privacy & Execution
Module Circuit Map index.html Visual diagram of functional ecosystem clusters, module search, purpose tooltips, bilingual descriptions. Developers, Architects, AI Agents 100% client-side rendering, zero telemetry
Bundle Recipes bundles.html 13 pre-composed ecosystem recipes, component breakdown, module tiers (required / optional). System Integrators, Teams Pure static tables, instant offline filter
Skill Library skills.html Direct reader for public SKILL.md documents, categorized listing, copy-to-clipboard markdown. Prompt Engineers, Agents Local DOM reader, zero external APIs
Stack Composer stack-composer.html Visual drag-and-drop stack builder, real-time compatibility rule validation, export to stack.v2.json. Framework Engineers, DevOps In-browser JSON generation & download

8. Module Circuit Map Deep Dive

The Module Circuit Map (index.html) provides an architectural view of the entire ellmos ecosystem:

  • Interactive Categorization: Groups modules into Infrastructure, Proxies & Routing, Execution Engines, Developer Tooling, and Data Transit.
  • Port Compatibility Visualizer: Highlights communication channels between client tools and MCP servers.
  • Instant Search & Filter: Real-time filtering by module name, keyword, or language without server-side processing.
  • Theme Persistence: Dark and light themes toggled via pure CSS variables with zero tracking cookies.

9. Curated Bundle Recipes

The Bundle Recipes page (bundles.html) documents 13 deployment recipes:

  • Component Tiers: Distinguishes between foundational core components and domain-specific optional additions.
  • Recipe Manifest: Defines recipes for Autonomous Coding, Deep Research, Documentation Auditing, and Data Synchronization.
  • Deterministic Stacks: Guarantees reproducible, conflict-free configurations across different agent runtimes.

10. Public Skill Library Viewer

The Skill Library (skills.html) surfaces public agent capabilities:

  • Categorized Index: Organizes skills into Development, Infrastructure, Utilities, Research, and Education.
  • Inline Markdown Renderer: Live viewer displaying complete SKILL.md instructions directly in the browser.
  • Clipboard Integration: One-click action to copy raw markdown into autonomous agent instruction contexts.

11. Interactive Stack Composer Canvas

The Stack Composer (stack-composer.html) offers a visual interface for custom agent environments:

  • Drag-and-Drop Assembly: Intuitive canvas to add, remove, and connect ecosystem modules.
  • Live Rule Validation: Real-time constraint checking preventing conflicting module combinations.
  • Standardized Export: Generates validated stack.v2.json files ready for deployment to agent runners and local daemons.

12. Pages Maintainer Automation & Leak-Gates

The repository includes a dedicated maintenance tool (_tools/pages_maintainer.py) enforcing leak gates and atomic updates:

# Preflight check without making modifications
$env:PYTHONIOENCODING='utf-8'
python _tools/pages_maintainer.py --check

# Execute generation and verify site artifacts
python _tools/pages_maintainer.py --run

# Execute generation and push verified changes to origin/main
python _tools/pages_maintainer.py --run --push

Fallback automation instructions and scheduling hand-off guidelines are documented in _tools/FALLBACK-AUTOMATION.md.

13. Verification, Testing & Quality Gates

The repository enforces automated contract validation via Pytest and Ruff linting:

# Run Ruff static code analysis
$env:PYTHONIOENCODING='utf-8'
python -m ruff check .

# Verify Python bytecode integrity
python -m compileall -q _tools tests

# Execute complete automated test suite
python -m pytest -ra -v

Verification covers:

  • CI workflow configuration and multi-OS matrix (INV-OS-08)
  • PEP 621 metadata completeness and extended URLs
  • Symmetrical 18-point bilingual navigation parity and reciprocal HTML anchors
  • Target Personas [PERSONA-01] through [PERSONA-04] and comparative matrix
  • Static site artifact existence, leak-gate invariant enforcement (INV-LEAK-02)
  • SBOM licensing integrity (THIRD_PARTY_LICENSES.md)
  • LLM reference integrity (llms.txt) and changelog synchronization

14. Sibling Ecosystem & Cross-Project Topology

ellmos-ai.github.io visually surfaces and interconnects the broader tooling ecosystem across ellmos-ai, dev-bricks, file-bricks, doc-bricks, and open-bricks:

Tool Repository Focus & Role in Ecosystem
coma ellmos-ai/coma Multi-Agent Job Board & Provider Routing Bridge
clutch ellmos-ai/clutch Provider-neutral routing for single tasks
MarbleRun ellmos-ai/MarbleRun Sequential agent loops & chain execution
policy-registry ellmos-ai/policy-registry Policy governance & capability permission authority
system-explorer ellmos-ai/system-explorer System-wide topology & stack inspection
sqlite-transit-sync ellmos-ai/sqlite-transit-sync Secure SQLite snapshot & sync pipeline
workflowhooker ellmos-ai/workflowhooker Workflow hooking & lifecycle event interceptor
memoryhooker ellmos-ai/memoryhooker Agent memory injection & provenance tracking
swarm_ai ellmos-ai/swarm_ai LLM swarm intelligence & consensus voting toolkit
ellmos-filecommander-mcp ellmos-ai/ellmos-filecommander-mcp Local-First FileCommander MCP Server
ellmos-codecommander-mcp ellmos-ai/ellmos-codecommander-mcp Local-First CodeCommander MCP Server
ellmos-controlcenter-mcp ellmos-ai/ellmos-controlcenter-mcp Unified AI Tools & Profiles Control Center MCP
DevCenter dev-bricks/DevCenter Developer workstation hub & process control
CodeBox dev-bricks/CodeBox Multi-language code runner & plugin platform
ProFiler file-bricks/ProFiler Local-First file analysis & privacy traffic light
open-bricks open-bricks/open-bricks Umbrella open-source developer tooling ecosystem

15. Third-Party Licenses & Open-Source Auditing

The web applications deployed in ellmos-ai.github.io use 100% native HTML5, modern CSS, and Vanilla JavaScript with zero third-party runtime dependencies. All development and maintenance dependencies are strictly permissively licensed:

  • Python Standard Library: PSFL-2.0
  • pytest: MIT License
  • Ruff: MIT / Apache-2.0

For full license texts, compliance details, and the complete inventory, see THIRD_PARTY_LICENSES.md.

16. Machine-Readable LLM Context & Agent Protocol

Autonomous agents and LLM scrapers can query llms.txt for structured metadata, schema contracts, invariant declarations, and tool definitions. The document adheres to modern LLM scraper conventions and serves as the single source of truth for automated agent orchestration.

17. Changelog & Project History

Detailed release notes and historical milestones are tracked in accordance with Keep a Changelog standards in CHANGELOG.md.

18. Security Policy & Statutory Notice

ellmos-ai.github.io guarantees 100% zero-egress static execution. For full security disclosures, vulnerability reporting procedures, supported versions, and our binding 48-hour response / 5-day triage SLA, please refer to SECURITY.md.

Distributed under the terms of the MIT License — see LICENSE and NOTICE for details. Project marketing, keywords, and discoverability records are maintained in MARKETING-LOG.txt.

About

Interactive maps of the ellmos-ai ecosystem: module circuit map, skill library, stack composer

ellmos-ai.github.io

Topics

agentic-workflowsai-agentsdocumentationecosystem-overviewellmos-aigithub-pagesinteractive-mapmcpmcp-serversopen-bricksskill-librarystack-composerzero-egress

Resources

Readme
MIT license

Code of conduct

Code of conduct

Contributing

Contributing

Security policy

Security policy
Activity
Custom properties

Stars

1 star

Watchers

0 watching

Forks

0 forks
Report repository

Releases

Packages

Contributors

Languages