{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-njbrake--agent-of-empires","slug":"njbrake--agent-of-empires","name":"agent-of-empires","type":"agent","url":"http://www.agent-of-empires.com/","page_url":"https://unfragile.ai/njbrake--agent-of-empires","categories":["ai-agents","code-editors"],"tags":["ai-coding","claude","claude-code","cli","codex","cursor","factory-droid-cli","gemini","gemini-cli","github-copilot-cli","hermes-agent","llm","mistral-vibe","opencode","orchestrator","pi","terminal","tmux","vibe","vibe-coding"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github-njbrake--agent-of-empires__cap_0","uri":"capability://automation.workflow.tmux.backed.multi.agent.session.orchestration","name":"tmux-backed multi-agent session orchestration","description":"Creates and manages isolated tmux sessions for AI coding agents (Claude Code, OpenCode, Mistral Vibe, Gemini CLI, etc.) through a Rust-based wrapper that abstracts tmux complexity. Each session is assigned a unique 8-character UUID and human-readable title, with lifecycle management (attach/detach/kill) exposed via CLI and TUI. The system maintains session state in persistent storage keyed by profile, enabling recovery and resumption across terminal restarts.","intents":["I need to run multiple AI coding agents in parallel without managing tmux sessions manually","I want to switch between different agent sessions quickly from a single interface","I need to persist agent sessions across SSH disconnections and terminal restarts","I want to organize my agent sessions hierarchically by project or context"],"best_for":["developers managing 3+ concurrent AI coding agents","teams using Claude Code, OpenCode, or other CLI-based agents","solo developers prototyping with multiple LLM providers simultaneously"],"limitations":["Linux and macOS only — no Windows support","Requires tmux to be installed and functional on the host system","Session state persists only within a single profile — cross-profile session sharing requires manual worktree setup","Status detection relies on process introspection and may miss agents in unusual terminal states"],"requires":["tmux 2.6+","Rust 1.70+ (for building from source)","Linux or macOS operating system","At least one AI coding agent CLI installed (Claude Code, OpenCode, Gemini CLI, etc.)"],"input_types":["session metadata (title, agent type, working directory)","configuration YAML (profile settings, worktree paths, Docker sandbox config)"],"output_types":["tmux session identifiers","session status (Running, Waiting, Idle)","structured session list with hierarchy"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-njbrake--agent-of-empires__cap_1","uri":"capability://memory.knowledge.profile.isolated.workspace.management","name":"profile-isolated workspace management","description":"Maintains multiple independent profiles (contexts) where each profile has its own session storage, worktree configuration, and Docker sandbox settings. Profiles are stored in a configuration directory and loaded on-demand, enabling developers to switch between completely isolated workspaces (e.g., 'project-a', 'project-b', 'experimentation') without session collision. The Storage system (src/session/storage.rs) provides profile-keyed persistence with automatic directory creation and cleanup.","intents":["I want to keep sessions for different projects completely isolated so they don't interfere","I need to switch between different development contexts without losing session state","I want to use different agent configurations for different projects","I need to maintain separate Docker sandbox configurations per project"],"best_for":["developers juggling multiple concurrent projects with different agent setups","teams with project-specific agent configurations and isolation requirements","researchers running parallel experiments with different agent configurations"],"limitations":["No built-in profile synchronization — profiles are local to a machine","Profile switching requires explicit CLI command; no automatic context detection","Session data is not encrypted — sensitive credentials in profiles should be managed via environment variables","No profile merging or inheritance — each profile is completely independent"],"requires":["Write access to ~/.config/agent-of-empires/ or configured profile directory","YAML-compatible configuration files","Rust 1.70+ (for building)"],"input_types":["profile name (string)","YAML configuration with worktree paths, sandbox settings, agent defaults"],"output_types":["profile metadata","session list scoped to active profile","configuration validation results"],"categories":["memory-knowledge","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-njbrake--agent-of-empires__cap_10","uri":"capability://tool.use.integration.multi.agent.provider.support.with.agent.specific.configuration","name":"multi-agent provider support with agent-specific configuration","description":"Supports multiple AI coding agent providers (Claude Code, OpenCode, Mistral Vibe, Codex CLI, Gemini CLI, Pi.dev, GitHub Copilot CLI, Factory Droid Coding) with agent-specific configuration and status detection patterns. Each agent type has a profile in AGENTS.md defining its CLI invocation, output patterns for status detection, and configuration requirements. The system abstracts agent differences, allowing users to create sessions for any supported agent without learning provider-specific details.","intents":["I want to use multiple AI coding agents without learning each one's CLI syntax","I need to switch between different agents for different tasks","I want to run agents from different providers in parallel","I need status detection to work correctly for each agent type"],"best_for":["developers evaluating multiple AI coding agents","teams using heterogeneous agent stacks","researchers comparing agent performance across providers"],"limitations":["Adding support for new agents requires modifying AGENTS.md and status detection code","Agent CLI must be installed on the host; no built-in agent provisioning","Status detection patterns are heuristic-based; may fail for agents with non-standard output","No automatic agent version detection or compatibility checking","Agent-specific features (e.g., streaming output) may not be fully supported"],"requires":["Agent CLI installed and in PATH (e.g., claude-code, opencode, mistral-vibe, etc.)","Agent API keys or authentication configured (typically via environment variables)","Agent-specific configuration in profile (if required)"],"input_types":["agent type (Claude Code, OpenCode, Mistral Vibe, etc.)","agent-specific configuration (API keys, model selection, etc.)"],"output_types":["session with agent-specific environment and CLI invocation","agent status (Running, Waiting, Idle) based on provider-specific patterns"],"categories":["tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-njbrake--agent-of-empires__cap_11","uri":"capability://memory.knowledge.persistent.session.recovery.and.state.restoration","name":"persistent session recovery and state restoration","description":"Persists session metadata (title, agent type, working directory, group membership, parent-child relationships) to disk in profile-scoped storage, enabling sessions to survive terminal restarts, SSH disconnections, and system reboots. When aoe is restarted, it reads session metadata from storage and can reattach to existing tmux sessions or recreate them if they were lost. The system maintains a session index for fast lookup and supports session cleanup (removing orphaned metadata for deleted sessions).","intents":["I want my sessions to survive a system reboot or SSH disconnection","I need to resume a session I created earlier without recreating it","I want to see all my sessions even after closing and reopening the terminal","I need to clean up orphaned session metadata when sessions are deleted"],"best_for":["developers running long-lived sessions across multiple days","teams with unreliable network connections (mobile, remote)","researchers running experiments that must survive system restarts"],"limitations":["Session metadata is stored in plain text; no encryption for sensitive data","If the tmux session is killed externally (e.g., tmux kill-server), metadata becomes orphaned","No automatic garbage collection of orphaned metadata; requires manual cleanup","Session state is not fully captured; only metadata is persisted (not terminal history or output)","Restoring a session requires the same tmux and agent CLIs to be available"],"requires":["Write access to profile storage directory (~/.config/agent-of-empires/ or configured path)","Persistent filesystem (not in-memory /tmp)","tmux session (for session recovery)"],"input_types":["session metadata (title, agent type, working directory, group, parent ID)"],"output_types":["session index (list of all sessions in profile)","session metadata (for recovery)","recovery status (session found, recreated, or orphaned)"],"categories":["memory-knowledge","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-njbrake--agent-of-empires__cap_12","uri":"capability://automation.workflow.configuration.driven.session.templates.and.defaults","name":"configuration-driven session templates and defaults","description":"Allows users to define session templates and default configurations in YAML files (profile configuration, worktree settings, Docker sandbox config, agent defaults). When creating a session, users can reference a template to inherit configuration, reducing repetitive setup. Configuration is hierarchical: global defaults, profile-level defaults, and session-level overrides. The system validates configuration on load and provides helpful error messages for invalid settings.","intents":["I want to define standard session configurations for my team","I need to create sessions with consistent settings without manual configuration","I want to version-control session templates as code","I need to override defaults for specific sessions without changing global config"],"best_for":["teams with standardized session configurations","developers using infrastructure-as-code practices","organizations needing consistent agent setups across projects"],"limitations":["Configuration is static; no dynamic template generation based on environment","No template inheritance or composition; each template is independent","Configuration validation is basic; no schema enforcement beyond YAML syntax","Changes to templates don't automatically update existing sessions","No built-in support for secrets management; credentials must be in environment variables"],"requires":["YAML-compatible configuration files","Write access to profile configuration directory","Valid YAML syntax (no validation of semantic correctness)"],"input_types":["YAML configuration file with worktree, sandbox, agent, and session defaults","template name (string) to reference in session creation"],"output_types":["merged configuration (defaults + overrides)","configuration validation results","session created with template configuration"],"categories":["automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-njbrake--agent-of-empires__cap_2","uri":"capability://planning.reasoning.hierarchical.session.grouping.and.organization","name":"hierarchical session grouping and organization","description":"Organizes sessions into a tree structure (GroupTree in src/session/group_tree.rs) where sessions can be nested under logical groups (e.g., 'frontend', 'backend', 'experiments'). Groups are displayed hierarchically in the TUI and can be collapsed/expanded for navigation. The system supports sub-sessions and parent-child relationships, enabling developers to logically cluster related agent sessions and manage them as units.","intents":["I want to organize my 20+ agent sessions by project component or feature","I need to see a tree view of all my sessions grouped by context","I want to collapse/expand groups to reduce visual clutter in the TUI","I need to understand parent-child relationships between sessions (e.g., a session forked from another)"],"best_for":["developers managing 10+ concurrent sessions across multiple projects","teams with hierarchical project structures (monorepos, microservices)","researchers running experiment trees with parent-child session dependencies"],"limitations":["Group hierarchy is flat in storage — no arbitrary nesting depth optimization","Moving sessions between groups requires manual CLI commands; no drag-and-drop in TUI","Group names are not enforced to be unique; duplicate group names may cause confusion","No group-level operations (e.g., 'kill all sessions in group') — must operate on individual sessions"],"requires":["TUI interface (for visual group navigation) or CLI commands for group management","Profile-scoped storage (groups are profile-local)"],"input_types":["group name (string)","session ID to assign to group","parent session ID (for sub-session relationships)"],"output_types":["hierarchical session tree (JSON or TUI display)","group metadata with member count","parent-child relationship graph"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-njbrake--agent-of-empires__cap_3","uri":"capability://planning.reasoning.automatic.ai.agent.status.detection","name":"automatic ai agent status detection","description":"Monitors tmux session processes to automatically detect and classify agent state as Running, Waiting, or Idle by parsing agent-specific output patterns and process introspection. The status detection implementation (src/session/instance.rs and src/tmux/) analyzes terminal output and process trees to infer whether an agent is actively executing code, waiting for user input, or idle. Status is cached and updated on-demand to avoid expensive polling.","intents":["I want to see at a glance which of my agents are actively working vs waiting for input","I need to identify idle agents that I can safely interrupt or repurpose","I want to avoid attaching to an agent that's in the middle of code execution","I need to monitor agent health and detect stuck or hung processes"],"best_for":["developers managing 5+ concurrent agents and needing quick status visibility","teams using heterogeneous agents (Claude Code, OpenCode, Mistral, Gemini) with different output patterns","researchers monitoring long-running agent experiments"],"limitations":["Status detection is heuristic-based and may misclassify agents with non-standard output","Requires agent CLI to produce recognizable output patterns — custom agents may not be detected","Status is cached and updated on-demand; real-time status requires polling (adds latency)","Cannot detect agent state inside Docker containers without additional instrumentation","No support for detecting agent errors or exceptions — only Running/Waiting/Idle states"],"requires":["tmux session with running agent process","Agent CLI that produces standard output patterns (Claude Code, OpenCode, etc.)","Process introspection capabilities (available on Linux/macOS)"],"input_types":["tmux session ID","agent type (Claude Code, OpenCode, Mistral Vibe, etc.)"],"output_types":["status enum (Running, Waiting, Idle)","last status update timestamp","process tree snapshot"],"categories":["planning-reasoning","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-njbrake--agent-of-empires__cap_4","uri":"capability://automation.workflow.git.worktree.based.parallel.development.isolation","name":"git worktree-based parallel development isolation","description":"Creates and manages Git worktrees for each session, enabling parallel development branches without switching the main working directory. When a session is created with worktree support, the system automatically creates a new worktree at a path derived from a configurable template (e.g., ~/.agent-of-empires/worktrees/{profile}/{session-id}), checks out a specified branch, and cleans up the worktree when the session is destroyed. This allows multiple agents to work on different branches simultaneously without file system conflicts.","intents":["I want each agent to work on a different git branch without switching my main working directory","I need to run multiple agents on the same repo simultaneously without merge conflicts","I want to automatically clean up git worktrees when I'm done with a session","I need to use path templates to organize worktrees by profile and session"],"best_for":["developers using git-based workflows with multiple concurrent agents","teams working on monorepos where agents need isolated branches","researchers running parallel experiments on different code branches"],"limitations":["Requires Git 2.7+ with worktree support","Worktree paths are derived from templates; custom paths require configuration changes","No automatic branch creation — branches must exist before worktree creation","Worktree cleanup is not atomic; partial cleanup may leave orphaned worktrees if the process crashes","No support for worktree locking or conflict detection between sessions"],"requires":["Git 2.7+","Git repository initialized in the working directory","Write access to the worktree base directory (default: ~/.agent-of-empires/worktrees/)","Existing git branches for worktree checkout"],"input_types":["git repository path","branch name to check out","worktree path template (e.g., ~/.agent-of-empires/worktrees/{profile}/{session-id})"],"output_types":["worktree path (string)","checked-out branch name","worktree creation/cleanup status"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-njbrake--agent-of-empires__cap_5","uri":"capability://automation.workflow.docker.sandbox.containerization.with.volume.mounting","name":"docker sandbox containerization with volume mounting","description":"Optionally isolates agent execution inside Docker containers with configurable volume mounts for code directories, authentication files, and other resources. When sandbox mode is enabled (via configuration), sessions are launched inside a Docker container with the specified image, with volumes mounted to provide access to the host's code and credentials. The system manages container lifecycle (creation, attachment, cleanup) and supports custom images and environment variable injection.","intents":["I want to isolate agent execution in a container to prevent accidental host system modifications","I need to provide agents with access to specific host directories without exposing the entire filesystem","I want to use different Docker images for different agents or projects","I need to inject environment variables or secrets into the container without storing them in config files"],"best_for":["teams running untrusted or experimental agents","developers needing strong isolation between agent workspaces","organizations with security policies requiring containerized execution","researchers running agents with different dependency sets"],"limitations":["Requires Docker daemon to be running and accessible","Volume mounts require explicit configuration; no automatic host directory discovery","Status detection inside containers requires additional instrumentation (may not work out-of-the-box)","Container networking is limited to the Docker network; SSH access requires port mapping","Image pulling and container startup add 5-30 seconds of latency per session creation","No built-in support for GPU passthrough or other advanced Docker features"],"requires":["Docker 20.10+","Docker daemon running and accessible to the user","Docker image specified in configuration (can be custom or public)","Volume mount paths configured in profile"],"input_types":["Docker image name/tag","volume mount specifications (host_path:container_path)","environment variables (as key-value pairs)","container working directory"],"output_types":["container ID","container status (running, exited, etc.)","volume mount verification results"],"categories":["automation-workflow","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-njbrake--agent-of-empires__cap_6","uri":"capability://automation.workflow.tui.based.interactive.session.dashboard","name":"tui-based interactive session dashboard","description":"Provides a terminal user interface (TUI) built with a Rust UI framework (likely Ratatui or similar, based on Rust ecosystem conventions) that displays sessions in a hierarchical tree view with real-time status indicators, search/filtering, and interactive controls. The TUI allows users to create, attach, detach, and delete sessions without CLI commands, with keyboard navigation (arrow keys, Enter, etc.) and a preview panel showing session details. The interface is responsive and updates session status on-demand.","intents":["I want a visual dashboard to see all my sessions and their status at a glance","I need to quickly attach to a session without typing CLI commands","I want to search and filter sessions by name or group","I need to create new sessions interactively without memorizing CLI syntax"],"best_for":["developers preferring visual interfaces over CLI commands","teams with 10+ concurrent sessions needing quick navigation","users on mobile SSH connections where typing is cumbersome","developers new to the tool who benefit from guided workflows"],"limitations":["TUI is terminal-based; no graphical UI for desktop/web (though web interface mentioned in description)","Search/filtering is client-side; no full-text indexing for large session counts","Preview panel shows limited session metadata; detailed logs require attaching to the session","Keyboard navigation may be unfamiliar to users accustomed to mouse-driven interfaces","TUI rendering adds ~50-100ms latency per update cycle"],"requires":["Terminal emulator with 256-color support (or 24-bit color for better rendering)","Terminal width of at least 80 columns (120+ recommended for full feature visibility)","Rust 1.70+ (for building from source)"],"input_types":["keyboard input (arrow keys, Enter, letters for search)","session metadata from storage"],"output_types":["rendered TUI display (ANSI escape codes)","session selection (for attach/delete operations)","search query results"],"categories":["automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-njbrake--agent-of-empires__cap_7","uri":"capability://automation.workflow.cli.command.interface.for.session.and.worktree.operations","name":"cli command interface for session and worktree operations","description":"Exposes core session and worktree operations through a command-line interface with subcommands like 'aoe add' (create session), 'aoe session' (manage sessions), 'aoe worktree' (manage worktrees), and others. Each command accepts flags and arguments for configuration (e.g., --agent-type, --branch, --group), with help text and validation. The CLI is the primary interface for scripting and automation, complementing the TUI for interactive use.","intents":["I want to create sessions programmatically from scripts or CI/CD pipelines","I need to manage sessions via command-line for automation and batch operations","I want to integrate aoe into shell aliases and custom workflows","I need to version-control session configurations as code"],"best_for":["developers automating session creation in scripts or CI/CD","teams building custom workflows on top of aoe","users preferring command-line interfaces over interactive UIs","systems integrating aoe into larger toolchains"],"limitations":["CLI output is not machine-parseable by default (no JSON output option mentioned)","No batch operations (e.g., 'create 10 sessions from template') — requires scripting","Flag syntax is not standardized across all commands; inconsistent UX","No command history or undo functionality","Error messages may not be actionable for non-technical users"],"requires":["Rust 1.70+ (for building from source) or pre-built binary","Terminal with shell (bash, zsh, etc.)","Appropriate permissions for tmux, git, and Docker operations"],"input_types":["command name (add, session, worktree, etc.)","flags and arguments (--agent-type, --branch, --group, etc.)","session/group names (strings)"],"output_types":["command execution status (success/error)","session ID or metadata (text output)","error messages with troubleshooting hints"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-njbrake--agent-of-empires__cap_8","uri":"capability://planning.reasoning.session.forking.with.parent.child.relationships","name":"session forking with parent-child relationships","description":"Enables creating new sessions as 'forks' of existing sessions, inheriting configuration (agent type, worktree branch, Docker sandbox settings) while maintaining a parent-child relationship in the session tree. When a session is forked, a new session is created with the same configuration but a new UUID and working directory (via git worktree), and the parent-child relationship is recorded in storage. This allows developers to branch off experiments from a baseline session without manual reconfiguration.","intents":["I want to create a variant of an existing session without manually reconfiguring everything","I need to track which sessions are derived from which baseline sessions","I want to run parallel experiments starting from the same code state","I need to understand the lineage of my sessions for reproducibility"],"best_for":["researchers running experiment trees with shared baselines","developers exploring multiple code variations in parallel","teams needing reproducible session configurations"],"limitations":["Forking creates a new worktree; if the parent worktree is deleted, the child is not automatically cleaned up","Parent-child relationships are stored but not enforced; deleting a parent doesn't cascade to children","Configuration inheritance is shallow; changes to parent config after forking don't propagate to children","No visual diff between parent and child configurations","Forking requires the parent session to exist; cannot fork from a deleted session"],"requires":["Existing parent session in the same profile","Git repository with multiple branches (for worktree isolation)","Write access to worktree base directory"],"input_types":["parent session ID","new session title (optional; defaults to parent title + suffix)","new branch name (optional; defaults to parent branch)"],"output_types":["new session ID","parent-child relationship metadata","forked session configuration"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-njbrake--agent-of-empires__cap_9","uri":"capability://automation.workflow.mobile.ssh.workflow.support","name":"mobile ssh workflow support","description":"Optimizes the TUI and session management for mobile SSH connections by providing a responsive, low-bandwidth interface that works over high-latency, lossy connections. The TUI is designed to minimize redraws and support mobile-friendly keyboard shortcuts (e.g., single-key commands instead of multi-key combinations). Sessions persist across SSH disconnections (via tmux), and the TUI can be resumed without losing state. The system supports SSH key-based authentication and works with standard SSH clients on iOS/Android.","intents":["I want to manage my agents from my phone or tablet over SSH","I need sessions to persist when my SSH connection drops","I want a mobile-friendly interface that doesn't require precise typing","I need to attach to running agents from anywhere without re-creating them"],"best_for":["developers working remotely or on-the-go","teams with distributed members needing mobile access","researchers monitoring long-running agents from mobile devices"],"limitations":["Mobile SSH clients have limited terminal emulation; some TUI features may not render correctly","High-latency connections (>500ms) may cause TUI responsiveness issues","Copy-paste from mobile SSH clients is cumbersome; complex commands are difficult to enter","No native mobile app; requires SSH client (e.g., Termius, iSH on iOS)","Status detection may be delayed over high-latency connections"],"requires":["SSH access to a Linux/macOS machine with aoe installed","Mobile SSH client (e.g., Termius, iSH, JuiceSSH)","Terminal emulator with at least 80-column width"],"input_types":["SSH connection parameters (host, port, username)","keyboard input (single-key commands, arrow keys)"],"output_types":["TUI display optimized for mobile screens","session status and metadata"],"categories":["automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":48,"verified":false,"data_access_risk":"high","permissions":["tmux 2.6+","Rust 1.70+ (for building from source)","Linux or macOS operating system","At least one AI coding agent CLI installed (Claude Code, OpenCode, Gemini CLI, etc.)","Write access to ~/.config/agent-of-empires/ or configured profile directory","YAML-compatible configuration files","Rust 1.70+ (for building)","Agent CLI installed and in PATH (e.g., claude-code, opencode, mistral-vibe, etc.)","Agent API keys or authentication configured (typically via environment variables)","Agent-specific configuration in profile (if required)"],"failure_modes":["Linux and macOS only — no Windows support","Requires tmux to be installed and functional on the host system","Session state persists only within a single profile — cross-profile session sharing requires manual worktree setup","Status detection relies on process introspection and may miss agents in unusual terminal states","No built-in profile synchronization — profiles are local to a machine","Profile switching requires explicit CLI command; no automatic context detection","Session data is not encrypted — sensitive credentials in profiles should be managed via environment variables","No profile merging or inheritance — each profile is completely independent","Adding support for new agents requires modifying AGENTS.md and status detection code","Agent CLI must be installed on the host; no built-in agent provisioning","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.4835488085103586,"quality":0.5,"ecosystem":0.7000000000000001,"match_graph":0.25,"freshness":0.75,"weights":{"adoption":0.25,"quality":0.25,"ecosystem":0.1,"match_graph":0.28,"freshness":0.12}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:22.063Z","last_scraped_at":"2026-05-03T13:58:34.540Z","last_commit":"2026-05-02T03:28:20Z"},"community":{"stars":1911,"forks":157,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=njbrake--agent-of-empires","compare_url":"https://unfragile.ai/compare?artifact=njbrake--agent-of-empires"}},"signature":"q4BTPoR0+o2prZpNfGhEfFfpmcX5TcxxwRjtOQkOAb/MgruW6xxRrqcHQtGR+mN9j20w63f9OENOVvDaYkiQAQ==","signedAt":"2026-06-20T08:06:59.426Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/njbrake--agent-of-empires","artifact":"https://unfragile.ai/njbrake--agent-of-empires","verify":"https://unfragile.ai/api/v1/verify?slug=njbrake--agent-of-empires","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}