forge-orchestrator
Universal coordination engine for AI-powered development — orchestrates Claude Code, Codex CLI, Gemini CLI as a coordinated team
Stars: 75
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.
README:
The tech lead that never sleeps.
Plan work. Assign it to the right AI. Track progress. Prevent conflicts. Capture knowledge. Ship faster.
Quick Start | Why Forge? | MCP Server | Architecture | Contributing
You have Claude Code, Codex CLI, and Gemini CLI installed. They're powerful alone. But when two AI tools edit the same file? Chaos. When nobody remembers why a decision was made last Tuesday? Lost knowledge. When your spec says "build auth" but the AI is refactoring CSS? Drift.
Forge coordinates your AI tools like a senior tech lead coordinates junior developers.
| Without Forge | With Forge |
|---|---|
| AI tools step on each other's files | File locking prevents conflicts automatically |
| "What did we decide about auth?" | Knowledge flywheel captures every decision |
| Manually copy-pasting tasks between tools | One plan, auto-assigned to the best AI tool |
| No idea if work matches the spec | Drift detection catches misalignment early |
| Each AI tool is an island | Unified state via MCP — all tools see the same board |
One-liner (Linux/macOS):
curl -sSL https://raw.githubusercontent.com/nxtg-ai/forge-orchestrator/main/install.sh | shWindows (PowerShell):
Download from latest release, extract forge.exe, and add to PATH.
From source (any platform with Rust):
git clone https://github.com/nxtg-ai/forge-orchestrator.git
cd forge-orchestrator
cargo install --path .# 1. Initialize in any project (must be a git repo)
cd your-project
forge init
# 2. Write a SPEC.md describing what you want to build
# 3. Generate a plan from your spec
forge plan --generate # AI decomposes spec into tasks with dependencies
# 4. See the task board
forge status # Full task table with deps, statuses, agents
# 5. Launch the TUI dashboard (recommended)
forge dashboard # Live multi-agent orchestration with real-time output
# Or run headlessly (CI/CD, SSH, scripting)
forge run # Parallel autonomous execution, no TUI
forge run --dry-run # Preview execution plan without running
forge run --parallel 1 # Sequential mode
# Or run a single task manually
forge run --task T-001 --agent codexAdd to your project's .mcp.json:
{
"mcpServers": {
"forge": {
"type": "stdio",
"command": "forge",
"args": ["mcp", "--project", "."]
}
}
}Restart Claude Code. Now Claude can call forge_get_tasks(), forge_claim_task(), forge_check_drift() — all 9 tools are native.
You write SPEC.md
│
▼
┌──────────────────┐ ┌─────────────────┐
│ forge plan │────▶│ ForgeBrain │ GPT-4.1 decomposes spec
│ --generate │ │ (pluggable LLM) │ into tasks with deps
└──────────────────┘ └─────────────────┘
│
▼
┌──────────────────┐ ┌─────────────────┐
│ forge dashboard │────▶│ Adapters │ Claude, Codex, Gemini
│ (TUI) or │ │ (tool-specific) │ run in parallel with
│ forge run │ │ │ dependency scheduling
│ (headless) │ │ │ + rate limit backoff
└──────────────────┘ └─────────────────┘
│
▼
┌──────────────────┐ ┌─────────────────┐
│ Auto-commit per │◀───▶│ .forge/ │ File-based state
│ task + status │ │ state.json │ MCP live queries
│ forge mcp │ │ tasks/ events/ │ Knowledge flywheel
└──────────────────┘ └─────────────────┘
| Command | What It Does |
|---|---|
forge init |
Scan project, detect AI tools, scaffold .forge/
|
forge plan --generate |
Decompose SPEC.md into tasks using ForgeBrain |
forge status |
Full task table with deps, blocking status, agents |
forge dashboard |
TUI dashboard — live multi-agent orchestration with scrollable panes, shell access, auto-commit |
forge run |
Headless autonomous mode — parallel dependency-aware execution for CI/CD |
forge run --dry-run |
Preview execution plan without running |
forge run --task T-001 --agent claude |
Execute a single task |
forge start |
Sequential orchestration with retry logic |
forge sync |
Reconcile state, render CLAUDE.md/AGENTS.md/GEMINI.md |
forge config brain openai |
Switch to OpenAI-powered brain |
forge mcp |
Start MCP server (stdio) for AI tool integration |
Forge includes a built-in Model Context Protocol server. Any MCP-compatible AI tool can query and update orchestration state in real-time.
| Tool | Description |
|---|---|
forge_get_tasks |
List/filter tasks by status, assignments, dependencies |
forge_claim_task |
Claim a task — locks associated files, prevents conflicts |
forge_complete_task |
Mark done — unlocks files, reveals newly available tasks |
forge_get_state |
Full state: project info, tools, brain config, active locks |
forge_get_plan |
Read the master plan |
forge_capture_knowledge |
Store a learning, decision, or pattern (auto-classified) |
forge_get_knowledge |
Search the knowledge base, generate SKILL.md files |
forge_check_drift |
Compare completed work against SPEC.md vision |
forge_get_health |
5-dimension governance health check (0-100 score) |
forge_set_project |
Switch the active project root for multi-project setups |
Claude Code
Add to .mcp.json in your project root:
{
"mcpServers": {
"forge": {
"type": "stdio",
"command": "forge",
"args": ["mcp", "--project", "."]
}
}
}Claude Code auto-discovers the tools. No plugin needed.
Codex CLI
Forge generates an AGENTS.md file that Codex CLI reads:
forge sync # renders AGENTS.md with current tasks and state
codex --agents-md AGENTS.mdGemini CLI
Forge generates a GEMINI.md context file:
forge sync # renders GEMINI.md
gemini --context GEMINI.md┌─────────────────────────────────────────────────────────────┐
│ CLI (clap) │
│ init | plan | dashboard | run | start | status | sync | mcp│
├─────────────────────────────────────────────────────────────┤
│ TUI Dashboard (ratatui + crossterm) │
│ Task board | Agent panes | Shell panes | Event log │
│ Rate limit backoff | Auto-commit | Key legend │
├─────────────────────────────────────────────────────────────┤
│ ForgeBrain (pluggable) │
│ RuleBasedBrain (free) | OpenAIBrain (gpt-4.1) | ... │
├─────────────────────────────────────────────────────────────┤
│ Core Engine │
│ TaskManager | StateManager | EventLogger | PlanManager │
│ KnowledgeManager | GovernanceChecker │
├─────────────────────────────────────────────────────────────┤
│ MCP Server (JSON-RPC 2.0 / stdio) │
│ 9 tools for real-time AI-tool integration │
├─────────────────────────────────────────────────────────────┤
│ Adapters │
│ ClaudeAdapter | CodexAdapter | GeminiAdapter │
├─────────────────────────────────────────────────────────────┤
│ .forge/ (file-based state) │
│ state.json | tasks/ | knowledge/ | events.jsonl | plan.md │
└─────────────────────────────────────────────────────────────┘
Forge separates deterministic operations (state, locks, events) from intelligent decisions (plan decomposition, drift detection). The deterministic engine runs zero LLM tokens. The brain is pluggable.
| Brain | Cost | Best For |
|---|---|---|
RuleBasedBrain |
Free | Keyword heuristics, offline use |
OpenAIBrain |
Paid | Intelligent plan decomposition, drift detection |
Configure with:
forge config brain openai
forge config brain.model gpt-4.1 # or gpt-5, gpt-5.3-codexRequires OPENAI_API_KEY in environment or .env file.
When an agent claims a task, Forge locks the associated files in state.json. Other agents see the conflict before starting work. Locks are released automatically on task completion.
Agent A claims T-001 → locks: src/auth.rs, src/middleware.rs
Agent B claims T-002 → checks locks → no conflict → proceeds
Agent C claims T-003 → checks locks → CONFLICT on src/auth.rs → blocked
Every interaction can generate intelligence. Forge captures and classifies it automatically:
forge_capture_knowledge("JWT tokens expire after 24h", source: "debugging")
→ auto-classified as "learning"
→ stored in .forge/knowledge/learnings/
→ searchable via forge_get_knowledge
→ aggregated into SKILL.md files
The forge_get_health tool runs a 5-dimension check:
| Dimension | What It Checks |
|---|---|
| Documentation | SPEC.md exists, README present, plan freshness |
| Architecture |
.forge/ integrity, state.json valid, no orphaned locks |
| Task Health | Stale tasks, broken dependencies, failed count, progress |
| Knowledge | Category coverage, SKILL.md generation status |
| Drift | Vision alignment score (0.0-1.0) via ForgeBrain |
Returns a health score out of 100 with actionable findings.
.forge/
├── state.json # Project state, tool inventory, brain config, file locks
├── plan.md # Master plan (human-readable)
├── events.jsonl # Append-only event log
├── tasks/
│ ├── T-001.json # Task definitions with deps, acceptance criteria
│ └── T-001.md # Human-readable task cards
├── results/ # Agent execution results
└── knowledge/
├── decisions/ # Architectural decisions (ADRs)
├── learnings/ # Lessons learned
├── research/ # Research findings
└── patterns/ # Discovered patterns
| Tool | What It Does | What Forge Does Differently |
|---|---|---|
| Claude Squad | Manages Claude terminals | Orchestrates ALL AI tools, not just Claude |
| Claude-Flow | Multi-agent Claude orchestration | Vendor-neutral, not Claude-locked |
| Codex CLI | Headless code execution | Coordinates Codex WITH other tools |
| CCManager | Session management | Task-level orchestration, not sessions |
Forge doesn't replace your AI tools. It makes them work together.
| Metric | Value |
|---|---|
| Language | Rust (2024 edition) |
| Binary size | 4.0 MB (includes TLS) |
| Source lines | ~10,650 |
| Tests | 293 (271 unit + 10 CLI + 12 MCP) |
| External runtime deps | Zero (single binary) |
| MCP tools | 10 |
| Supported AI tools | Claude Code, Codex CLI, Gemini CLI |
# Clone
git clone https://github.com/nxtg-ai/forge-orchestrator.git
cd forge-orchestrator
# Build
cargo build
# Test
cargo test
# Build release (~3 MB binary)
cargo build --release
# Run
./target/release/forge --helpsrc/
├── main.rs # Entry point, CLI dispatch
├── cli/ # Command implementations
│ ├── init.rs # Project initialization
│ ├── plan.rs # Plan generation (uses ForgeBrain)
│ ├── dashboard.rs # TUI dashboard launcher
│ ├── start.rs # Sequential orchestration with retry
│ ├── run.rs # Headless autonomous + single-task execution
│ ├── status.rs # Full task table with dependencies
│ ├── sync.rs # State reconciliation
│ └── config.rs # Brain configuration
├── tui/ # Terminal UI (ratatui + crossterm)
│ ├── app.rs # Dashboard state, scheduler, key handling
│ ├── ui.rs # Layout rendering (task board, agent panes, event log)
│ └── event.rs # Terminal event polling
├── core/ # Core engine
│ ├── state.rs # State management (.forge/state.json)
│ ├── task.rs # Task lifecycle, file locking
│ ├── event.rs # Event logging
│ ├── plan.rs # Plan parsing and templates
│ ├── knowledge.rs # Knowledge capture and retrieval
│ └── governance.rs # Health checks, drift detection
├── brain/ # Pluggable LLM backends
│ ├── rule_based.rs # Free heuristic brain
│ └── openai.rs # Real OpenAI API integration
├── adapters/ # AI tool adapters
│ ├── claude.rs # Claude Code adapter
│ ├── codex.rs # Codex CLI adapter
│ └── gemini.rs # Gemini CLI adapter
├── mcp/ # MCP server
│ ├── server.rs # JSON-RPC 2.0 dispatcher
│ ├── protocol.rs # MCP protocol types
│ └── tools.rs # 9 tool implementations
└── detect/ # AI tool auto-detection
└── mod.rs
Forge is three repos that work together:
| Repo | What it is |
|---|---|
| forge-orchestrator (this repo) | Rust CLI — multi-agent task planning and coordination |
| forge-plugin | Claude Code plugin — 21 commands, 22 agents, 29 skills, 6 hooks |
| forge | Full platform — React dashboard, Infinity Terminal, API server |
The orchestrator plans and coordinates. The plugin adds governance to Claude Code. The dashboard adds visual oversight for teams.
Forge is MIT-licensed and contributions are welcome.
Good first issues:
- Add a
ClaudeBrainimplementation (Claude API for plan decomposition) - Add
forge worktreecommand (git worktree per task for parallel agent isolation) - Add
forge uatcommand (interactive acceptance testing checklist) - Add
forge reportcommand (session summary from events.jsonl) - Embedded interactive agent TUIs (PTY bridge per pane — "Stargate" mode)
Before submitting a PR:
cargo test # All 293 tests must pass
cargo clippy # No warnings
cargo fmt --check # FormattedMIT -- LICENSE
Built by NXTG with Claude Opus 4.6
Star this repo if your AI tools deserve a tech lead.
For Tasks:
Click tags to check more tools for each tasksFor Jobs:
Alternative AI tools for forge-orchestrator
Similar Open Source Tools
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.
jat
JAT is a complete, self-contained environment for agentic development, offering task management, agent orchestration, code editor, git integration, and terminal access all in a single IDE. It allows users to connect various external sources like RSS, Slack, Telegram, and Gmail to create tasks and spawn agents automatically. JAT supports hands-on supervision of agents or autonomous operation. The tool provides features such as multi-agent management, task management, smart question UI, epic swarm for parallel agent spawning, autonomous triggers, task scheduling, error recovery, and a skill marketplace. JAT is designed to be a control tower for managing a swarm of agents, whether actively supervised or running autonomously.
pilot
Pilot is an AI tool designed to streamline the process of handling tickets from GitHub, Linear, Jira, or Asana. It plans the implementation, writes the code, runs tests, and opens a PR for you to review and merge. With features like Autopilot, Epic Decomposition, Self-Review, and more, Pilot aims to automate the ticket handling process and reduce the time spent on prioritizing and completing tasks. It integrates with various platforms, offers intelligence features, and provides real-time visibility through a dashboard. Pilot is free to use, with costs associated with Claude API usage. It is designed for bug fixes, small features, refactoring, tests, docs, and dependency updates, but may not be suitable for large architectural changes or security-critical code.
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.
CoWork-OS
CoWork-OS is an open-source AI assistant platform designed for security-hardened, local-first runtime. It offers 30+ LLM providers, 14 messaging channels, and over 100 built-in skills. Users can create tasks, choose execution modes, monitor real-time execution, and approve actions. The platform emphasizes security, extensibility, and privacy by keeping data and API keys on the user's machine. CoWork-OS is suitable for individuals and teams looking for an independent AI assistant solution with advanced features and customizable workflows.
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.
myclaw
myclaw is a personal AI assistant built on agentsdk-go that offers a CLI agent for single message or interactive REPL mode, full orchestration with channels, cron, and heartbeat, support for various messaging channels like Telegram, Feishu, WeCom, WhatsApp, and a web UI, multi-provider support for Anthropic and OpenAI models, image recognition and document processing, scheduled tasks with JSON persistence, long-term and daily memory storage, custom skill loading, and more. It provides a comprehensive solution for interacting with AI models and managing tasks efficiently.
mesh
MCP Mesh is an open-source control plane for MCP traffic that provides a unified layer for authentication, routing, and observability. It replaces multiple integrations with a single production endpoint, simplifying configuration management. Built for multi-tenant organizations, it offers workspace/project scoping for policies, credentials, and logs. With core capabilities like MeshContext, AccessControl, and OpenTelemetry, it ensures fine-grained RBAC, full tracing, and metrics for tools and workflows. Users can define tools with input/output validation, access control checks, audit logging, and OpenTelemetry traces. The project structure includes apps for full-stack MCP Mesh, encryption, observability, and more, with deployment options ranging from Docker to Kubernetes. The tech stack includes Bun/Node runtime, TypeScript, Hono API, React, Kysely ORM, and Better Auth for OAuth and API keys.
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.
vllm-mlx
vLLM-MLX is a tool that brings native Apple Silicon GPU acceleration to vLLM by integrating Apple's ML framework with unified memory and Metal kernels. It offers optimized LLM inference with KV cache and quantization, vision-language models for multimodal inference, speech-to-text and text-to-speech with native voices, text embeddings for semantic search and RAG, and more. Users can benefit from features like multimodal support for text, image, video, and audio, native GPU acceleration on Apple Silicon, compatibility with OpenAI API, Anthropic Messages API, reasoning models extraction, integration with external tools via Model Context Protocol, memory-efficient caching, and high throughput for multiple concurrent users.
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.
starknet-agentic
Open-source stack for giving AI agents wallets, identity, reputation, and execution rails on Starknet. `starknet-agentic` is a monorepo with Cairo smart contracts for agent wallets, identity, reputation, and validation, TypeScript packages for MCP tools, A2A integration, and payment signing, reusable skills for common Starknet agent capabilities, and examples and docs for integration. It provides contract primitives + runtime tooling in one place for integrating agents. The repo includes various layers such as Agent Frameworks / Apps, Integration + Runtime Layer, Packages / Tooling Layer, Cairo Contract Layer, and Starknet L2. It aims for portability of agent integrations without giving up Starknet strengths, with a cross-chain interop strategy and skills marketplace. The repository layout consists of directories for contracts, packages, skills, examples, docs, and website.
QodeAssist
QodeAssist is an AI-powered coding assistant plugin for Qt Creator, offering intelligent code completion and suggestions for C++ and QML. It leverages large language models like Ollama to enhance coding productivity with context-aware AI assistance directly in the Qt development environment. The plugin supports multiple LLM providers, extensive model-specific templates, and easy configuration for enhanced coding experience.
codemap
Codemap is a project brain tool designed to provide instant architectural context for AI projects without consuming excessive tokens. It offers features such as tree visualization, file filtering, dependency flow analysis, and remote repository support. Codemap can be integrated with Claude for automatic context at session start and supports multi-agent handoff for seamless collaboration between different tools. The tool is powered by ast-grep and supports 18 languages for dependency analysis, making it versatile for various project types.
giztoy
Giztoy is a multi-language framework designed for building AI toys and intelligent applications. It provides a unified abstraction layer that spans from resource-constrained embedded systems to powerful cloud services. With features like native support for ESP32 and other MCUs, cross-platform app development, a unified build system with Bazel, an agent framework for AI agents, audio processing capabilities, support for various Large Language Models, real-time models with WebSocket streaming, secure transport protocols, and multi-language implementations in Go, Rust, Zig, and C/C++, Giztoy serves as a versatile tool for developing AI-powered applications across different platforms and devices.
Shannon
Shannon is a battle-tested infrastructure for AI agents that solves problems at scale, such as runaway costs, non-deterministic failures, and security concerns. It offers features like intelligent caching, deterministic replay of workflows, time-travel debugging, WASI sandboxing, and hot-swapping between LLM providers. Shannon allows users to ship faster with zero configuration multi-agent setup, multiple AI patterns, time-travel debugging, and hot configuration changes. It is production-ready with features like WASI sandbox, token budget control, policy engine (OPA), and multi-tenancy. Shannon helps scale without breaking by reducing costs, being provider agnostic, observable by default, and designed for horizontal scaling with Temporal workflow orchestration.
For similar tasks
AgentBench
AgentBench is a benchmark designed to evaluate Large Language Models (LLMs) as autonomous agents in various environments. It includes 8 distinct environments such as Operating System, Database, Knowledge Graph, Digital Card Game, and Lateral Thinking Puzzles. The tool provides a comprehensive evaluation of LLMs' ability to operate as agents by offering Dev and Test sets for each environment. Users can quickly start using the tool by following the provided steps, configuring the agent, starting task servers, and assigning tasks. AgentBench aims to bridge the gap between LLMs' proficiency as agents and their practical usability.
fabrice-ai
A lightweight, functional, and composable framework for building AI agents that work together to solve complex tasks. Built with TypeScript and designed to be serverless-ready. Fabrice embraces functional programming principles, remains stateless, and stays focused on composability. It provides core concepts like easy teamwork creation, infrastructure-agnosticism, statelessness, and includes all tools and features needed to build AI teams. Agents are specialized workers with specific roles and capabilities, able to call tools and complete tasks. Workflows define how agents collaborate to achieve a goal, with workflow states representing the current state of the workflow. Providers handle requests to the LLM and responses. Tools extend agent capabilities by providing concrete actions they can perform. Execution involves running the workflow to completion, with options for custom execution and BDD testing.
flowdeer-dist
FlowDeer Tree is an AI tool designed for managing complex workflows and facilitating deep thoughts. It provides features such as displaying thinking chains, assigning tasks to AI members, utilizing task conclusions as context, copying and importing AI members in JSON format, adjusting node sequences, calling external APIs as plugins, and customizing default task splitting, execution, summarization, and output rewriting prompts. The tool aims to streamline workflow processes and enhance productivity by leveraging artificial intelligence capabilities.
EpicStaff
EpicStaff is a powerful project management tool designed to streamline team collaboration and task management. It provides a user-friendly interface for creating and assigning tasks, tracking progress, and communicating with team members in real-time. With features such as task prioritization, deadline reminders, and file sharing capabilities, EpicStaff helps teams stay organized and productive. Whether you're working on a small project or managing a large team, EpicStaff is the perfect solution to keep everyone on the same page and ensure project success.
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.
learnhouse
LearnHouse is an open-source platform that allows anyone to easily provide world-class educational content. It supports various content types, including dynamic pages, videos, and documents. The platform is still in early development and should not be used in production environments. However, it offers several features, such as dynamic Notion-like pages, ease of use, multi-organization support, support for uploading videos and documents, course collections, user management, quizzes, course progress tracking, and an AI-powered assistant for teachers and students. LearnHouse is built using various open-source projects, including Next.js, TailwindCSS, Radix UI, Tiptap, FastAPI, YJS, PostgreSQL, LangChain, and React.
tegon
Tegon is an open-source AI-First issue tracking tool designed for engineering teams. It aims to simplify task management by leveraging AI and integrations to automate task creation, prioritize tasks, and enhance bug resolution. Tegon offers features like issues tracking, automatic title generation, AI-generated labels and assignees, custom views, and upcoming features like sprints and task prioritization. It integrates with GitHub, Slack, and Sentry to streamline issue tracking processes. Tegon also plans to introduce AI Agents like PR Agent and Bug Agent to enhance product management and bug resolution. Contributions are welcome, and the product is licensed under the MIT License.
Aidoku
Aidoku is a free and open source manga reading application for iOS and iPadOS. It offers features like ad-free experience, robust WASM source system, online reading through external sources, iCloud sync support, downloads, and tracker support. Users can access the latest ipa from the releases page and join TestFlight via the Aidoku Discord for detailed installation instructions. The project is open to contributions, with planned features and fixes. Translation efforts are welcomed through Weblate for crowd-sourced translations.
For similar jobs
runbooks
Runbooks is a repository that is no longer active. The project has been deprecated in favor of KubeAI, a platform designed to simplify the operationalization of AI on Kubernetes. For more information, please refer to the new repository at https://github.com/substratusai/kubeai.
aiops-modules
AIOps Modules is a collection of reusable Infrastructure as Code (IAC) modules that work with SeedFarmer CLI. The modules are decoupled and can be aggregated using GitOps principles to achieve desired use cases, removing heavy lifting for end users. They must be generic for reuse in Machine Learning and Foundation Model Operations domain, adhering to SeedFarmer Guide structure. The repository includes deployment steps, project manifests, and various modules for SageMaker, Mlflow, FMOps/LLMOps, MWAA, Step Functions, EKS, and example use cases. It also supports Industry Data Framework (IDF) and Autonomous Driving Data Framework (ADDF) Modules.
Awesome-LLMOps
Awesome-LLMOps is a curated list of the best LLMOps tools, providing a comprehensive collection of frameworks and tools for building, deploying, and managing large language models (LLMs) and AI agents. The repository includes a wide range of tools for tasks such as building multimodal AI agents, fine-tuning models, orchestrating applications, evaluating models, and serving models for inference. It covers various aspects of the machine learning operations (MLOps) lifecycle, from training to deployment and observability. The tools listed in this repository cater to the needs of developers, data scientists, and machine learning engineers working with large language models and AI applications.
skyflo
Skyflo.ai is an AI agent designed for Cloud Native operations, providing seamless infrastructure management through natural language interactions. It serves as a safety-first co-pilot with a human-in-the-loop design. The tool offers flexible deployment options for both production and local Kubernetes environments, supporting various LLM providers and self-hosted models. Users can explore the architecture of Skyflo.ai and contribute to its development following the provided guidelines and Code of Conduct. The community engagement includes Discord, Twitter, YouTube, and GitHub Discussions.
AI-CloudOps
AI+CloudOps is a cloud-native operations management platform designed for enterprises. It aims to integrate artificial intelligence technology with cloud-native practices to significantly improve the efficiency and level of operations work. The platform offers features such as AIOps for monitoring data analysis and alerts, multi-dimensional permission management, visual CMDB for resource management, efficient ticketing system, deep integration with Prometheus for real-time monitoring, and unified Kubernetes management for cluster optimization.
kubectl-mcp-server
Control your entire Kubernetes infrastructure through natural language conversations with AI. Talk to your clusters like you talk to a DevOps expert. Debug crashed pods, optimize costs, deploy applications, audit security, manage Helm charts, and visualize dashboards—all through natural language. The tool provides 253 powerful tools, 8 workflow prompts, 8 data resources, and works with all major AI assistants. It offers AI-powered diagnostics, built-in cost optimization, enterprise-ready features, zero learning curve, universal compatibility, visual insights, and production-grade deployment options. From debugging crashed pods to optimizing cluster costs, kubectl-mcp-server is your AI-powered DevOps companion.
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.
Thor
Thor is a powerful AI model management tool designed for unified management and usage of various AI models. It offers features such as user, channel, and token management, data statistics preview, log viewing, system settings, external chat link integration, and Alipay account balance purchase. Thor supports multiple AI models including OpenAI, Kimi, Starfire, Claudia, Zhilu AI, Ollama, Tongyi Qianwen, AzureOpenAI, and Tencent Hybrid models. It also supports various databases like SqlServer, PostgreSql, Sqlite, and MySql, allowing users to choose the appropriate database based on their needs.