claude-emporium
🏛 [UNDER CONSTRUCTION] A (roman) claude plugin marketplace
Stars: 522
Claude Emporium is a Roman-themed plugin marketplace for Claude Code, offering six plugins that wrap standalone MCP servers with automation hooks, commands, and skills. The plugins include Praetorian for context guard, Historian for session memory, Oracle for tool discovery, Gladiator for continuous learning, Vigil for file recovery, and Orator for prompt rhetoric. Each plugin self-configures on install, and the MCP servers handle the actual work. The plugins coordinate automatically when multiple are installed, enhancing behaviors and synergy. The tool is designed with zero overhead, no external API calls, no background processes, and no databases, making it efficient and lightweight for users.
README:
install plugins synergy architecture contributing
roma victrix
Six plugins that wrap standalone MCP servers with automation hooks, commands, and skills. No code duplication: plugins tell claude when to act, MCPs handle how.
╔═╤═══════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╤═╗
║ │ │ ║
║ │ PLUGINS │ ║
║ │ │ ║
║ │ ┌────────────────────┐ ┌────────────────────┐ ┌────────────────────┐ ┌────────────────────┐ ┌────────────────────┐ ┌────────────────────┐ │ ║
║ │ │ PRAETORIAN │ │ HISTORIAN │ │ ORACLE │ │ GLADIATOR │ │ VIGIL │ │ ORATOR │ │ ║
║ │ │ context guard │ │ session memory │ │ tool discovery │ │ learn & adapt │ │ file recovery │ │ prompt rhetoric │ │ ║
║ │ ├────────────────────┤ ├────────────────────┤ ├────────────────────┤ ├────────────────────┤ ├────────────────────┤ ├────────────────────┤ │ ║
║ │ │ hooks │ │ hooks │ │ hooks │ │ hooks │ │ hooks │ │ hooks │ │ ║
║ │ │ · pre-plan │ │ · pre-websearch │ │ · pre-plan │ │ · post-error │ │ · pre-bash │ │ · pre-task │ │ ║
║ │ │ · pre-compact │ │ · pre-plan │ │ · post-error │ │ · stop │ │ │ │ │ │ ║
║ │ │ · post-research │ │ · pre-task │ │ │ │ │ │ commands │ │ commands │ │ ║
║ │ │ · subagent-stop │ │ · post-error │ │ commands │ │ commands │ │ · /save-vigil │ │ · /reprompt- │ │ ║
║ │ │ │ │ │ │ · /search-oracle │ │ · /review- │ │ · /restore-vigil │ │ orator │ │ ║
║ │ │ commands │ │ commands │ │ │ │ gladiator │ │ │ │ │ │ ║
║ │ │ · /compact- │ │ · /search- │ │ │ │ │ │ │ │ │ │ ║
║ │ │ praetorian │ │ historian │ │ │ │ │ │ │ │ │ │ ║
║ │ │ · /restore- │ │ │ │ │ │ │ │ │ │ │ │ ║
║ │ │ praetorian │ │ │ │ │ │ │ │ │ │ │ │ ║
║ │ └────────────────────┘ └────────────────────┘ └────────────────────┘ └────────────────────┘ └────────────────────┘ └────────────────────┘ │ ║
║ │ │ │ │ │ │ │ │ ║
║ │ ▼ ▼ ▼ ▼ ▼ ▼ │ ║
║ │ │ ║
║ │ ┌────────────────────┐ ┌────────────────────┐ ┌────────────────────┐ ┌────────────────────┐ ┌────────────────────┐ ┌────────────────────┐ │ ║
║ │ │ praetorian-mcp │ │ historian-mcp │ │ oracle-mcp │ │ gladiator-mcp │ │ vigil-mcp │ │ orator-mcp │ │ ║
║ │ ├────────────────────┤ ├────────────────────┤ ├────────────────────┤ ├────────────────────┤ ├────────────────────┤ ├────────────────────┤ │ ║
║ │ │ save_context │ │ search_convos │ │ search │ │ observe │ │ vigil_save │ │ orator_optimize │ │ ║
║ │ │ · snapshot before │ │ · full-text across │ │ · query 17 sources │ │ · record patterns │ │ · named checkpoint │ │ · score 7 dims │ │ ║
║ │ │ compaction │ │ all sessions │ │ in parallel │ │ │ │ │ │ · apply 8 techs │ │ ║
║ │ │ │ │ │ │ │ │ reflect │ │ vigil_list │ │ · restructure │ │ ║
║ │ │ restore_context │ │ get_error_solns │ │ browse │ │ · cluster and │ │ · show checkpoints │ │ │ │ ║
║ │ │ · load previous │ │ · how errors were │ │ · by category or │ │ recommend │ │ │ │ ── ── ── ── ── │ │ ║
║ │ │ session state │ │ resolved │ │ popularity │ │ │ │ vigil_diff │ │ dimensions: │ │ ║
║ │ │ │ │ │ │ │ │ ── ── ── ── ── │ │ · preview changes │ │ clarity │ │ ║
║ │ │ search_compactns │ │ find_similar │ │ sources │ │ storage: │ │ │ │ specificity │ │ ║
║ │ │ · find past saves │ │ · related past │ │ · list registries │ │ .claude/ │ │ vigil_restore │ │ structure │ │ ║
║ │ │ │ │ questions │ │ and status │ │ gladiator/ │ │ · restore files │ │ context │ │ ║
║ │ │ list_compactions │ │ │ │ │ │ │ │ │ │ examples │ │ ║
║ │ │ · browse recent │ │ find_file_context │ │ ── ── ── ── ── │ │ │ │ vigil_delete │ │ constraints │ │ ║
║ │ │ snapshots │ │ · track changes │ │ smithery · glama │ │ │ │ · remove checkpoint│ │ tone │ │ ║
║ │ │ │ │ │ │ npm · github │ │ │ │ │ │ │ │ ║
║ │ │ ── ── ── ── ── │ │ find_tool_pattns │ │ awesome-mcp │ │ │ │ ── ── ── ── ── │ │ ── ── ── ── ── │ │ ║
║ │ │ storage: │ │ · agent workflows │ │ mcp-registry │ │ │ │ storage: │ │ in-memory │ │ ║
║ │ │ .claude/ │ │ │ │ + 11 more │ │ │ │ .claude/ │ │ zero storage │ │ ║
║ │ │ praetorian/ │ │ search_plans │ │ │ │ │ │ vigil/ │ │ │ │ ║
║ │ │ │ │ · past plans │ │ in-memory cache │ │ │ │ │ │ │ │ ║
║ │ │ │ │ │ │ zero storage │ │ │ │ │ │ │ │ ║
║ │ │ │ │ list_recent │ │ │ │ │ │ │ │ │ │ ║
║ │ │ │ │ · recent sessions │ │ │ │ │ │ │ │ │ │ ║
║ │ └────────────────────┘ └────────────────────┘ └────────────────────┘ └────────────────────┘ └────────────────────┘ └────────────────────┘ │ ║
║ │ │ ║
║ │ MCP SERVERS │ ║
╚═╧═══════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╧═╝
Each plugin self-configures on install. MCP servers, hooks, commands, skills, and sibling detection all register automatically. All hooks default to enabled. See configuration to disable specific hooks or tune behavior.
Requirements:
Marketplace:
# Add this marketplace
/plugin marketplace add Vvkmnn/claude-emporiumPlugins:
# Each registers its MCP server, skills, hooks, settings, and detects siblings automatically
/plugin install claude-praetorian@claude-emporium
/plugin install claude-historian@claude-emporium
/plugin install claude-oracle@claude-emporium
/plugin install claude-gladiator@claude-emporium
/plugin install claude-vigil@claude-emporium
/plugin install claude-orator@claude-emporiumMCP servers:
# NOT REQUIRED: Each plugin will install their MCP server by themself
# However, you can choose to install just the MCP servers if you like
# Standalone has no hooks or synergy, but each ships with an optionally installable skill
# claude mcp add praetorian -- npx claude-praetorian-mcp # https://github.com/Vvkmnn/claude-praetorian-mcp
# claude mcp add historian -- npx claude-historian-mcp # https://github.com/Vvkmnn/claude-historian-mcp
# claude mcp add oracle -- npx claude-oracle-mcp # https://github.com/Vvkmnn/claude-oracle-mcp
# claude mcp add gladiator -- npx claude-gladiator-mcp # https://github.com/Vvkmnn/claude-gladiator-mcp
# claude mcp add vigil -- npx claude-vigil-mcp # https://github.com/Vvkmnn/claude-vigil-mcp
# claude mcp add orator -- npx claude-orator-mcp # https://github.com/Vvkmnn/claude-orator-mcpContext Guard. Saves and restores valuable context before compaction, after research, and when subagents complete.
mcp: claude-praetorian-mcp (storage at .claude/praetorian/)
commands:
-
/compact-praetorian· save insights after research, decisions, or subagent work -
/restore-praetorian· load relevant past compactions at session start
tools:
-
praetorian_compact· save structured context: research, decisions, flow analysis -
praetorian_restore· search or list recent compactions by query or type
hooks:
-
PreToolUseonEnterPlanMode· lists prior compactions before planning -
PreCompacton*· saves context before compaction resets it -
PostToolUseonWebFetch/WebSearch· prompts to compact research findings -
SubagentStopon*· prompts to compact subagent results
Session searcher. Checks past sessions before you do redundant research, planning, or debugging to find solutions or insights we can recycle.
mcp: claude-historian-mcp (9 search tools across conversations, errors, files, plans)
commands:
-
/search-historian· search past sessions for solutions, patterns, or context
tools:
-
search_conversations· search conversation history, .claude files, and tasks -
find_file_context· find all conversations related to a specific file -
find_similar_queries· find previous similar questions with enhanced matching -
get_error_solutions· find solutions for specific errors -
list_recent_sessions· browse recent sessions with activity summaries -
extract_compact_summary· get intelligent summary of a session with key insights -
find_tool_patterns· analyze tool usage patterns and workflows -
search_plans· search plan files for past approaches and decisions -
search_config· search .claude config files for guidance and patterns
hooks:
-
PreToolUseonWebSearch/WebFetch· checks history before web research -
PreToolUseonEnterPlanMode· searches past plans before planning -
PreToolUseonTask· checks tool patterns before launching agents -
PostToolUseonBash· suggests error solutions after failures
Tool recommender. Searches 17 sources in parallel to find relevant skills, plugins, and MCP servers.
mcp: claude-oracle-mcp (smithery, glama, npm, github, awesome-mcp-servers, and more)
commands:
-
/search-oracle· search all sources for skills, plugins, or MCP servers
tools:
-
search· search by query with optional type and semantic filters -
browse· browse by category or popularity -
sources· show available data sources and their status
hooks:
-
PreToolUseonEnterPlanMode· searches for relevant tools before planning -
PostToolUseonBash· searches for tools that solve errors
Continuous learner. Observes tool failures and prompts reflection at session end to evolve rules, hooks, and skills incrementally.
mcp: claude-gladiator-mcp (storage at .claude/gladiator/)
commands:
-
/review-gladiator· review and cluster observations into actionable patterns
tools:
-
gladiator_observe· record a pattern worth learning from, deduplicates by hash -
gladiator_reflect· query and cluster observations with recommendations
hooks:
-
PostToolUseonBash/Edit/Write· observes failure patterns (silent on success) -
Stopon*· prompts reflection if unprocessed observations exist
Quick saver. Saves checkpoints before dangerous operations, diffs changes, restores files safely to augment /rewind.
mcp: claude-vigil-mcp (storage at .claude/vigil/)
commands:
-
/save-vigil· create a named checkpoint of tracked files -
/restore-vigil· restore files from a previous checkpoint
tools:
-
vigil_save· save a named checkpoint with optional description -
vigil_list· list checkpoints, drill into one for file details -
vigil_diff· diff current files against a checkpoint -
vigil_restore· restore files from a checkpoint -
vigil_delete· delete a checkpoint or all checkpoints
hooks:
-
PreToolUseonBash· auto-quicksaves before destructive commands (rm, mv, etc.)
Prompt coach. Deterministically scores and restructures prompts using Anthropic best practices. No LLM calls, no network, in-memory only.
mcp: claude-orator-mcp (in-memory, zero storage)
commands:
-
/reprompt-orator· score and optimize a prompt with detailed feedback
tools:
-
orator_optimize· analyze and optimize a prompt, returns score metrics and applied techniques
hooks:
-
PreToolUseonTask· suggests optimization for under-specified subagent prompts
Each plugin is a thin wrapper. hooks inject prompts that trigger MCP tools at high-impact moments. plugins contain no business logic: they tell claude when to search, save, or restore. the MCP servers handle the actual work.
claude-emporium/
├── .claude-plugin/
│ ├── marketplace.json plugin registry (6 plugins)
│ └── plugin.json root manifest
│
├── plugins/
│ ├── claude-praetorian/ context guard → praetorian-mcp
│ │ ├── .claude-plugin/plugin.json declares praetorian MCP server
│ │ ├── hooks/
│ │ │ ├── hooks.json hook event bindings
│ │ │ ├── post-research.js compact after WebSearch/WebFetch
│ │ │ ├── post-subagent.js compact after Task completes
│ │ │ ├── pre-compact.js remind to compact before context reset
│ │ │ └── pre-plan.js list prior compactions before planning
│ │ ├── commands/
│ │ │ ├── compact-praetorian.md /compact
│ │ │ └── restore-praetorian.md /compact-status
│ │ ├── skills/claude-praetorian/SKILL.md
│ │ └── README.md
│ │
│ ├── claude-historian/ session memory → historian-mcp
│ │ ├── .claude-plugin/plugin.json declares historian MCP server
│ │ ├── hooks/
│ │ │ ├── hooks.json
│ │ │ ├── pre-websearch.js check history before web research
│ │ │ ├── pre-planning.js search past plans before planning
│ │ │ ├── pre-task.js check tool patterns before agents
│ │ │ └── post-error.js suggest past error solutions
│ │ ├── commands/search-historian.md /history
│ │ ├── skills/claude-historian/SKILL.md
│ │ └── README.md
│ │
│ ├── claude-oracle/ tool discovery → oracle-mcp
│ │ ├── .claude-plugin/plugin.json declares oracle MCP server
│ │ ├── hooks/
│ │ │ ├── hooks.json
│ │ │ ├── pre-planning.js search registries before planning
│ │ │ └── post-error.js find tools that solve errors
│ │ ├── commands/search-oracle.md /discover
│ │ ├── skills/claude-oracle/SKILL.md
│ │ └── README.md
│ │
│ ├── claude-gladiator/ learn & adapt → gladiator-mcp
│ │ ├── .claude-plugin/plugin.json declares gladiator MCP server
│ │ ├── hooks/
│ │ │ ├── hooks.json
│ │ │ ├── stop.js prompt reflection at session end
│ │ │ └── post-error.js observe failure patterns
│ │ ├── commands/review-gladiator.md /observe · /reflect
│ │ ├── skills/claude-gladiator/SKILL.md
│ │ └── README.md
│ │
│ ├── claude-vigil/ file recovery → vigil-mcp
│ │ ├── .claude-plugin/plugin.json declares vigil MCP server
│ │ ├── hooks/
│ │ │ ├── hooks.json
│ │ │ └── pre-bash.js quicksave before rm/reset/checkout
│ │ ├── commands/
│ │ │ ├── save-vigil.md /save
│ │ │ └── restore-vigil.md /restore · /snapshots
│ │ ├── skills/claude-vigil/SKILL.md
│ │ └── README.md
│ │
│ ├── claude-orator/ prompt rhetoric → orator-mcp
│ │ ├── .claude-plugin/plugin.json declares orator MCP server
│ │ ├── hooks/
│ │ │ ├── hooks.json
│ │ │ └── pre-task.js optimize prompts before subagents
│ │ ├── commands/reprompt-orator.md /optimize
│ │ ├── skills/claude-orator/SKILL.md
│ │ └── README.md
│ │
│ └── shared/
│ └── utils.js loadSettings · siblings · readStdin · emit
│
├── mcp/
│ └── .mcp.json all 6 MCP servers (standalone install)
│
├── logo/ plugin SVG icons
├── .github/ issue templates · PR template · CI workflows
├── scripts/readme.py README generation
└── README.md
each plugin.json declares its MCP server:
{ "mcpServers": { "praetorian": { "command": "npx", "args": ["claude-praetorian-mcp"] } } }
each hook script follows the same pattern:
readStdin() → loadSettings() → siblings() → emit(<system-reminder>)
runtime storage:
project/.claude/praetorian/ context snapshots
project/.claude/gladiator/ observations + reflections
project/.claude/vigil/ file checkpoints
~/.claude/settings.json enabledPlugins (auto) · claude-emporium (manual)
zero overhead, by design:
- no external API calls. no network requests from hooks or plugins
- no background processes. hooks run inline and exit (~1ms each)
- no databases. praetorian, gladiator, and vigil store to project-local dirs (
.claude/). oracle, historian, and orator compute in-memory with TTL caching - no dependencies beyond Node.js (ships with Claude Code)
- all hook scripts are pure Node.js, single-purpose, and stateless
- built for claude, by claude
Sibling detection: /plugin install adds each plugin to enabledPlugins in ~/.claude/settings.json. Hooks read this to detect siblings and coordinate automatically. For example, historian's pre-research hook will note "praetorian will compact this" when both are installed, and oracle's error hook will mention "historian can search past solutions" if historian is present. This is what sibling detection looks like:
Hook settings: every hook checks a boolean setting before running. All default to true. To disable any hook, add overrides under the claude-emporium key in ~/.claude/settings.json:
// ~/.claude/settings.json
{
"claude-emporium": {
"suggest_siblings": false, // stop suggesting uninstalled emporium plugins
"claude-praetorian": {
"auto_compact_research": false, // don't prompt to compact after WebFetch/WebSearch
"auto_compact_subagent": false, // don't prompt to compact after subagent completes
"check_compactions_before_plan": false, // don't list prior compactions before planning
"remind_compact": false, // don't remind to compact before context reset
},
"claude-historian": {
"search_before_web": false, // don't check history before web research
"search_before_plan": false, // don't search past plans before planning
"search_before_task": false, // don't check tool patterns before launching agents
"search_after_error": false, // don't suggest error solutions after failures
},
"claude-oracle": {
"search_before_plan": false, // don't search for relevant tools before planning
"search_after_error": false, // don't search for tools that solve errors
},
"claude-gladiator": {
"observe_after_failure": false, // don't record failure patterns
"reflect_before_stop": false, // don't prompt reflection at session end
},
"claude-vigil": {
"auto_quicksave": false, // don't quicksave before destructive commands
},
"claude-orator": {
"optimize_subagent_prompts": false, // don't suggest prompt optimization before Task
},
},
}Only include the settings you want to change. Omitted keys keep their defaults (true). The full defaults are defined in shared/utils.js.
Each plugin works standalone. when multiple are installed, they detect siblings at runtime and coordinate, usually without any extra configuration.
%%{init: {'theme': 'base', 'htmlLabels': true, 'themeVariables': {'primaryColor': '#f5f5f5', 'primaryTextColor': '#1a1a1a', 'primaryBorderColor': '#cccccc', 'lineColor': '#555555', 'edgeLabelBackground': '#f0f0f0', 'fontSize': '16px'}, 'flowchart': {'nodeSpacing': 80, 'rankSpacing': 70, 'curve': 'basis', 'padding': 20}}}%%
flowchart TD
P["⚜️<br/>PRAETORIAN<br/>context guard"]:::gold
H["📜<br/>HISTORIAN<br/>session memory"]:::scroll
V["🏺<br/>VIGIL<br/>file recovery"]:::amphora
O["🔮<br/>ORACLE<br/>tool discovery"]:::crystal
G["⚔️<br/>GLADIATOR<br/>learn & adapt"]:::steel
R["🪶<br/>ORATOR<br/>prompt rhetoric"]:::quill
P ----|" plans & context "| H
V ----|" quicksave "| P
P ----|" compactions "| O
H ----|" solutions + tools "| O
O ----|" error tools "| G
H ----|" past solutions "| G
R ----|" scored prompts "| H
R ----|" compact results "| P
R ----|" find tools "| O
R ----|" observe techniques "| G
R ----|" checkpoint "| V
classDef gold fill:#fff8e1,stroke:#f9a825,stroke-width:2px,color:#5d4037
classDef scroll fill:#fff3e0,stroke:#ef6c00,stroke-width:2px,color:#4e342e
classDef amphora fill:#fbe9e7,stroke:#e64a19,stroke-width:2px,color:#bf360c
classDef crystal fill:#f3e5f5,stroke:#8e24aa,stroke-width:2px,color:#4a148c
classDef steel fill:#eceff1,stroke:#546e7a,stroke-width:2px,color:#263238
classDef quill fill:#efebe9,stroke:#795548,stroke-width:2px,color:#3e2723Enhanced behaviors when siblings are detected:
| event | plugin | alone | with siblings |
|---|---|---|---|
| plan | ⚜️ praetorian | lists prior compactions | + 📜 past plans, 🔮 finds tools |
| plan | 📜 historian | searches past plans | + 🔮 also searches for tools |
| plan | 🔮 oracle | searches 17 registries | + 📜 past plans, ⚜️ compactions |
| compact | ⚜️ praetorian | snapshots context | + 🔮 discoveries included |
| error | 📜 historian | searches past solutions | + 🔮 finds tools for this error class |
| error | 🔮 oracle | searches for error-solving tools | + 📜 checks past solutions |
| error | ⚔️ gladiator | observes failure pattern | + 📜 enriches with past solutions |
| research | 📜 historian | checks history first | + ⚜️ compacts findings after |
| subagent | ⚜️ praetorian | prompts to compact results | + ⚔️ observes subagent outcome patterns |
| task | 📜 historian | checks tool patterns | + 🔮 suggests tools for the task |
| task | 🪶 orator | optimizes vague prompts | + 📜 searches past scored prompts |
| stop | ⚔️ gladiator | prompts reflection | + 📜 and 🔮 deepen analysis |
| bash | 🏺 vigil | quicksaves before destructive | + ⚜️ preserves context alongside |
Detection is automatic via one fs.readFileSync call (~1ms), and falls back gracefully to solo mode if settings are missing or siblings are not dedicated.
Bug fixes, improvements, and documentation PRs are welcome, as are inspirations for new plugins and MCPs that could improve synergy and coverage. See CONTRIBUTING.md for full guidelines.
-
Issues: use the issue templates. Bug reports, feature requests, and plugin ideas each have their own form, but please check open issues for duplicates first.
-
PRs: Fork, branch, and follow the PR template. Good contributions include better hook triggers, bug fixes, documentation, and performance improvements, and any novelties that improve experience or perforamnce.
- New plugins: Please Open a plugin idea issue; always looking for plugins that have clear trigger events, often wrap specific MCPs, or provide obvious synergy with their sibling plugins. Above all, always looking to solve a concrete user pain for other Claude users.
-
plugin not triggering? Verify the mcp server is running:
claude mcp list -
mcp not found? Install via npm:
claude mcp add <name> -- npx <package> -
hook errors? Check that node.js is available and
CLAUDE_PLUGIN_ROOTis set.
MIT
The Consummation of Empire — Thomas Cole, 1836
"alea iacta est" | the die is cast
— Julius Caesar, crossing the Rubicon
For Tasks:
Click tags to check more tools for each tasksFor Jobs:
Alternative AI tools for claude-emporium
Similar Open Source Tools
claude-emporium
Claude Emporium is a Roman-themed plugin marketplace for Claude Code, offering six plugins that wrap standalone MCP servers with automation hooks, commands, and skills. The plugins include Praetorian for context guard, Historian for session memory, Oracle for tool discovery, Gladiator for continuous learning, Vigil for file recovery, and Orator for prompt rhetoric. Each plugin self-configures on install, and the MCP servers handle the actual work. The plugins coordinate automatically when multiple are installed, enhancing behaviors and synergy. The tool is designed with zero overhead, no external API calls, no background processes, and no databases, making it efficient and lightweight for users.
boxlite
BoxLite is an embedded, lightweight micro-VM runtime designed for AI agents running OCI containers with hardware-level isolation. It is built for high concurrency with no daemon required, offering features like lightweight VMs, high concurrency, hardware isolation, embeddability, and OCI compatibility. Users can spin up 'Boxes' to run containers for AI agent sandboxes and multi-tenant code execution scenarios where Docker alone is insufficient and full VM infrastructure is too heavy. BoxLite supports Python, Node.js, and Rust with quick start guides for each, along with features like CPU/memory limits, storage options, networking capabilities, security layers, and image registry configuration. The tool provides SDKs for Python and Node.js, with Go support coming soon. It offers detailed documentation, examples, and architecture insights for users to understand how BoxLite works under the hood.
bumpgen
bumpgen is a tool designed to automatically upgrade TypeScript / TSX dependencies and make necessary code changes to handle any breaking issues that may arise. It uses an abstract syntax tree to analyze code relationships, type definitions for external methods, and a plan graph DAG to execute changes in the correct order. The tool is currently limited to TypeScript and TSX but plans to support other strongly typed languages in the future. It aims to simplify the process of upgrading dependencies and handling code changes caused by updates.
chronicle
Chronicle is a self-hostable AI system that captures audio/video data from OMI devices and other sources to generate memories, action items, and contextual insights about conversations and daily interactions. It includes a mobile app for OMI devices, backend services with AI features, a web dashboard for conversation and memory management, and optional services like speaker recognition and offline ASR. The project aims to provide a system that records personal spoken context and visual context to generate memories, action items, and enable home automation.
Zen-Ai-Pentest
Zen-AI-Pentest is a professional AI-powered penetration testing framework designed for security professionals, bug bounty hunters, and enterprise security teams. It combines cutting-edge language models with 20+ integrated security tools, offering comprehensive security assessments. The framework is security-first with multiple safety controls, extensible with a plugin system, cloud-native for deployment on AWS, Azure, or GCP, and production-ready with CI/CD, monitoring, and support. It features autonomous AI agents, risk analysis, exploit validation, benchmarking, CI/CD integration, AI persona system, subdomain scanning, and multi-cloud & virtualization support.
vibium
Vibium is a browser automation infrastructure designed for AI agents, providing a single binary that manages browser lifecycle, WebDriver BiDi protocol, and an MCP server. It offers zero configuration, AI-native capabilities, and is lightweight with no runtime dependencies. It is suitable for AI agents, test automation, and any tasks requiring browser interaction.
aio-coding-hub
AIO Coding Hub is a local AI CLI unified gateway that allows requests from Claude Code, Codex, and Gemini CLI to go through a single entry point. It solves the pain points of configuring base URLs and API keys for each CLI, provides intelligent failover in case of upstream instability, offers full observability with trace tracking and usage statistics, enables easy switching of providers with a single toggle, and ensures security and privacy through local data storage and encrypted API keys. The tool features a unified gateway proxy supporting multiple CLI tools, intelligent routing and fault tolerance, observability with request tracing and usage statistics, channel validation with multi-dimensional templates, and security and privacy measures like local data storage and encrypted API keys.
detour
Detour is an autonomous collision-avoidance system designed to run on-board satellites using NVIDIA's Nemotron LLM on the ASUS Ascent GX10. It utilizes a multi-agent LangGraph pipeline to detect debris threats, assess risk, plan maneuvers, validate safety constraints, and execute avoidance burns locally with zero ground-station latency. The system consists of key components such as Agent Pipeline, Physics Engine, Satellite Model, Tool Wrappers, API, Frontend, and Ascent GX10 Setup. The tool aims to provide fast and autonomous decision-making capabilities to prevent collisions in Low Earth Orbit (LEO) by leveraging edge AI technology.
AgentX
AgentX is a next-generation open-source AI agent development framework and runtime platform. It provides an event-driven runtime with a simple framework and minimal UI. The platform is ready-to-use and offers features like multi-user support, session persistence, real-time streaming, and Docker readiness. Users can build AI Agent applications with event-driven architecture using TypeScript for server-side (Node.js) and client-side (Browser/React) development. AgentX also includes comprehensive documentation, core concepts, guides, API references, and various packages for different functionalities. The architecture follows an event-driven design with layered components for server-side and client-side interactions.
memsearch
Memsearch is a tool that allows users to give their AI agents persistent memory in a few lines of code. It enables users to write memories as markdown and search them semantically. Inspired by OpenClaw's markdown-first memory architecture, Memsearch is pluggable into any agent framework. The tool offers features like smart deduplication, live sync, and a ready-made Claude Code plugin for building agent memory.
aiohomematic
AIO Homematic (hahomematic) is a lightweight Python 3 library for controlling and monitoring HomeMatic and HomematicIP devices, with support for third-party devices/gateways. It automatically creates entities for device parameters, offers custom entity classes for complex behavior, and includes features like caching paramsets for faster restarts. Designed to integrate with Home Assistant, it requires specific firmware versions for HomematicIP devices. The public API is defined in modules like central, client, model, exceptions, and const, with example usage provided. Useful links include changelog, data point definitions, troubleshooting, and developer resources for architecture, data flow, model extension, and Home Assistant lifecycle.
observers
Observers is a lightweight library for AI observability that provides support for various generative AI APIs and storage backends. It allows users to track interactions with AI models and sync observations to different storage systems. The library supports OpenAI, Hugging Face transformers, AISuite, Litellm, and Docling for document parsing and export. Users can configure different stores such as Hugging Face Datasets, DuckDB, Argilla, and OpenTelemetry to manage and query their observations. Observers is designed to enhance AI model monitoring and observability in a user-friendly manner.
auto-paper-digest
Auto Paper Digest (APD) is a tool designed to automatically fetch cutting-edge AI research papers, download PDFs, generate video explanations, and publish them on platforms like HuggingFace, Douyin, and portal websites. It provides functionalities such as fetching papers from Hugging Face, downloading PDFs from arXiv, generating videos using NotebookLM, automatic publishing to HuggingFace Dataset, automatic publishing to Douyin, and hosting videos on a Gradio portal website. The tool also supports resuming interrupted tasks, persistent login states for Google and Douyin, and a structured workflow divided into three phases: Upload, Download, and Publish.
osmedeus
Osmedeus is a security-focused declarative orchestration engine that simplifies complex workflow automation into auditable YAML definitions. It provides powerful automation capabilities without compromising infrastructure integrity and safety. With features like declarative YAML workflows, multiple runners, event-driven triggers, template engine, utility functions, REST API server, distributed execution, notifications, cloud storage, AI integration, SAST integration, language detection, and preset installations, Osmedeus offers a comprehensive solution for security automation tasks.
huf
HUF is an AI-native engine designed to centralize intelligence and execution into a single engine, enabling AI to operate inside real business systems. It offers multi-provider AI connectivity, intelligent tools, knowledge grounding, event-driven execution, visual workflow builder, full auditability, and cost control. HUF can be used as AI infrastructure for products, internal intelligence platform, automation & orchestration engine, embedded AI layer for SaaS, and enterprise AI control plane. Core capabilities include agent system, knowledge management, trigger system, visual flow builder, and observability. The tech stack includes Frappe Framework, Python 3.10+, LiteLLM, SQLite FTS5, React 18, TypeScript, Tailwind CSS, and MariaDB.
forge-orchestrator
Forge Orchestrator is a Rust CLI tool designed to coordinate and manage multiple AI tools seamlessly. It acts as a senior tech lead, preventing conflicts, capturing knowledge, and ensuring work aligns with specifications. With features like file locking, knowledge capture, and unified state management, Forge enhances collaboration and efficiency among AI tools. The tool offers a pluggable brain for intelligent decision-making and includes a Model Context Protocol server for real-time integration with AI tools. Forge is not a replacement for AI tools but a facilitator for making them work together effectively.
For similar tasks
claude-emporium
Claude Emporium is a Roman-themed plugin marketplace for Claude Code, offering six plugins that wrap standalone MCP servers with automation hooks, commands, and skills. The plugins include Praetorian for context guard, Historian for session memory, Oracle for tool discovery, Gladiator for continuous learning, Vigil for file recovery, and Orator for prompt rhetoric. Each plugin self-configures on install, and the MCP servers handle the actual work. The plugins coordinate automatically when multiple are installed, enhancing behaviors and synergy. The tool is designed with zero overhead, no external API calls, no background processes, and no databases, making it efficient and lightweight for users.
termax
Termax is an LLM agent in your terminal that converts natural language to commands. It is featured by: - Personalized Experience: Optimize the command generation with RAG. - Various LLMs Support: OpenAI GPT, Anthropic Claude, Google Gemini, Mistral AI, and more. - Shell Extensions: Plugin with popular shells like `zsh`, `bash` and `fish`. - Cross Platform: Able to run on Windows, macOS, and Linux.
AIHub
AIHub is a client that integrates the capabilities of multiple large models, allowing users to quickly and easily build their own personalized AI assistants. It supports custom plugins for endless possibilities. The tool provides powerful AI capabilities, rich configuration options, customization of AI assistants for text and image conversations, AI drawing, installation of custom plugins, personal knowledge base building, AI calendar generation, support for AI mini programs, and ongoing development of additional features. Users can download the application package from the release section, resolve issues related to macOS app installation, and contribute ideas by submitting issues. The project development involves installation, development, and building processes for different operating systems.
HyperChat
HyperChat is an open Chat client that utilizes various LLM APIs to enhance the Chat experience and offer productivity tools through the MCP protocol. It supports multiple LLMs like OpenAI, Claude, Qwen, Deepseek, GLM, Ollama. The platform includes a built-in MCP plugin market for easy installation and also allows manual installation of third-party MCPs. Features include Windows and MacOS support, resource support, tools support, English and Chinese language support, built-in MCP client 'hypertools', 'fetch' + 'search', Bot support, Artifacts rendering, KaTeX for mathematical formulas, WebDAV synchronization, and a MCP plugin market. Future plans include permission pop-up, scheduled tasks support, Projects + RAG support, tools implementation by LLM, and a local shell + nodejs + js on web runtime environment.
anyquery
Anyquery is a SQL query engine built on SQLite that allows users to run SQL queries on various data sources like files, databases, and apps. It can connect to LLMs to access data and act as a MySQL server for running queries. The tool is extensible through plugins and supports various installation methods like Homebrew, APT, YUM/DNF, Scoop, Winget, and Chocolatey.
mdserve
Markdown preview server for AI coding agents. mdserve is a tool that allows AI agents to write markdown and see it rendered live in the browser. It features zero configuration, single binary installation, instant live reload via WebSocket, ephemeral sessions, and agent-friendly content support. It is not a documentation site generator, static site server, or general-purpose markdown authoring tool. mdserve is designed for AI coding agents to produce content like tables, diagrams, and code blocks.
zai-coding-plugins
Z.ai Coding Plugins Marketplace is a collection of plugins designed to enhance coding productivity and provide GLM Coding Plan related services for Claude Code. It includes plugins for querying quota and usage statistics, submitting case feedback and bug reports. Users can easily install and manage these plugins within Claude Code to streamline their coding workflow. The marketplace requires Node.js 18 or higher and the Claude Code CLI for installation. Contributions are welcome under the Apache License 2.0.
agent-sdk-go
Agent Go SDK is a powerful Go framework for building production-ready AI agents that seamlessly integrates memory management, tool execution, multi-LLM support, and enterprise features into a flexible, extensible architecture. It offers core capabilities like multi-model intelligence, modular tool ecosystem, advanced memory management, and MCP integration. The SDK is enterprise-ready with built-in guardrails, complete observability, and support for enterprise multi-tenancy. It provides a structured task framework, declarative configuration, and zero-effort bootstrapping for development experience. The SDK supports environment variables for configuration and includes features like creating agents with YAML configuration, auto-generating agent configurations, using MCP servers with an agent, and CLI tool for headless usage.
For similar jobs
aiscript
AiScript is a lightweight scripting language that runs on JavaScript. It supports arrays, objects, and functions as first-class citizens, and is easy to write without the need for semicolons or commas. AiScript runs in a secure sandbox environment, preventing infinite loops from freezing the host. It also allows for easy provision of variables and functions from the host.
askui
AskUI is a reliable, automated end-to-end automation tool that only depends on what is shown on your screen instead of the technology or platform you are running on.
bots
The 'bots' repository is a collection of guides, tools, and example bots for programming bots to play video games. It provides resources on running bots live, installing the BotLab client, debugging bots, testing bots in simulated environments, and more. The repository also includes example bots for games like EVE Online, Tribal Wars 2, and Elvenar. Users can learn about developing bots for specific games, syntax of the Elm programming language, and tools for memory reading development. Additionally, there are guides on bot programming, contributing to BotLab, and exploring Elm syntax and core library.
ain
Ain is a terminal HTTP API client designed for scripting input and processing output via pipes. It allows flexible organization of APIs using files and folders, supports shell-scripts and executables for common tasks, handles url-encoding, and enables sharing the resulting curl, wget, or httpie command-line. Users can put things that change in environment variables or .env-files, and pipe the API output for further processing. Ain targets users who work with many APIs using a simple file format and uses curl, wget, or httpie to make the actual calls.
LaVague
LaVague is an open-source Large Action Model framework that uses advanced AI techniques to compile natural language instructions into browser automation code. It leverages Selenium or Playwright for browser actions. Users can interact with LaVague through an interactive Gradio interface to automate web interactions. The tool requires an OpenAI API key for default examples and offers a Playwright integration guide. Contributors can help by working on outlined tasks, submitting PRs, and engaging with the community on Discord. The project roadmap is available to track progress, but users should exercise caution when executing LLM-generated code using 'exec'.
robocorp
Robocorp is a platform that allows users to create, deploy, and operate Python automations and AI actions. It provides an easy way to extend the capabilities of AI agents, assistants, and copilots with custom actions written in Python. Users can create and deploy tools, skills, loaders, and plugins that securely connect any AI Assistant platform to their data and applications. The Robocorp Action Server makes Python scripts compatible with ChatGPT and LangChain by automatically creating and exposing an API based on function declaration, type hints, and docstrings. It simplifies the process of developing and deploying AI actions, enabling users to interact with AI frameworks effortlessly.
Open-Interface
Open Interface is a self-driving software that automates computer tasks by sending user requests to a language model backend (e.g., GPT-4V) and simulating keyboard and mouse inputs to execute the steps. It course-corrects by sending current screenshots to the language models. The tool supports MacOS, Linux, and Windows, and requires setting up the OpenAI API key for access to GPT-4V. It can automate tasks like creating meal plans, setting up custom language model backends, and more. Open Interface is currently not efficient in accurate spatial reasoning, tracking itself in tabular contexts, and navigating complex GUI-rich applications. Future improvements aim to enhance the tool's capabilities with better models trained on video walkthroughs. The tool is cost-effective, with user requests priced between $0.05 - $0.20, and offers features like interrupting the app and primary display visibility in multi-monitor setups.
AI-Case-Sorter-CS7.1
AI-Case-Sorter-CS7.1 is a project focused on building a case sorter using machine vision and machine learning AI to sort cases by headstamp. The repository includes Arduino code and 3D models necessary for the project.