deciduous
Decision graph tooling for AI-assisted development - track every choice, query your reasoning
Stars: 86
Deciduous is a decision graph tool for AI-assisted development that helps track and query every decision made during software development. It creates a persistent graph of decisions, goals, and outcomes, allowing users to query past reasoning, see what was tried and rejected, trace outcomes back to goals, and recover context after sessions end. The tool integrates with AI coding assistants and provides a structured way to understand a codebase. It includes features like a Q&A interface, document attachments, multi-user sync, and visualization options for decision graphs.
README:
Decision graph tooling for AI-assisted development. Track every goal, decision, and outcome. Survive context loss. Query your reasoning.
Browse the Live Decision Graph — 1,100+ decisions from building deciduous itself
Interactive Tutorial — Learn the workflow in 15 minutes
Watch the Demo — Full session walkthrough
You're building software with AI assistance. The LLM generates complex code fast. But then:
- Sessions end. Context compacts. The LLM loses memory of what was tried.
- Decisions evaporate. Six months later, no one remembers why you chose approach A over B.
- PRs become incomprehensible. A 50-file diff tells you what changed, not why.
- Onboarding is archaeology. New teammates reverse-engineer decisions from code.
The code tells you what. But decisions tell you why.
Deciduous creates a persistent, queryable graph of every decision made during development. Log decisions in real-time—as they happen—and they survive session boundaries, context compaction, and human memory.
1,174 nodes • 1,024 edges • Real development history from building this tool
Both you and your AI assistant can:
- Query past reasoning before making new decisions
- See what was tried and what was rejected
- Trace any outcome back to the goal that spawned it
- Recover context after sessions end or memory compacts
This isn't documentation written after the fact. It's a real-time record of how software gets built.
Download the latest release for your platform from GitHub Releases:
| Platform | Binary |
|---|---|
| Linux (x86_64) | deciduous-linux-amd64 |
| Linux (ARM64) | deciduous-linux-arm64 |
| macOS (Intel) | deciduous-darwin-amd64 |
| macOS (Apple Silicon) | deciduous-darwin-arm64 |
| Windows | deciduous-windows-amd64.exe |
# Example: Linux/macOS
curl -LO https://github.com/notactuallytreyanastasio/deciduous/releases/latest/download/deciduous-darwin-arm64
chmod +x deciduous-darwin-arm64
sudo mv deciduous-darwin-arm64 /usr/local/bin/deciduouscargo install deciduousgit clone https://github.com/notactuallytreyanastasio/deciduous.git
cd deciduous
cargo build --release
# Binary at target/release/deciduous# Initialize in your project
cd your-project
deciduous init
# Start logging decisions
deciduous add goal "Add user authentication" -c 90
deciduous add decision "Choose auth method" -c 75
deciduous link 1 2 -r "Deciding implementation approach"
# View the graph
deciduous serve # Web viewer at localhost:3000That's it. Your first decision graph is live.
Deciduous integrates with multiple AI coding assistants:
# Claude Code (default)
deciduous init
# OpenCode
deciduous init --opencode
# Windsurf (Codeium)
deciduous init --windsurf
# Multiple assistants
deciduous init --both # Claude Code + OpenCode
deciduous init --windsurf # + Windsurf (auto-creates .windsurf/)
deciduous init --both --windsurf # All three| Assistant | Flag | Integration Files |
|---|---|---|
| Claude Code |
--claude (default) |
.claude/, CLAUDE.md
|
| OpenCode | --opencode |
.opencode/, AGENTS.md
|
| Windsurf | --windsurf |
.windsurf/hooks/, .windsurf/rules/
|
Auto-detection: deciduous update auto-detects which assistants are installed (.claude/, .opencode/, .windsurf/) and updates them all. Windsurf is also auto-detected during init if .windsurf/ already exists.
BEFORE you do something → Log what you're ABOUT to do
AFTER it succeeds/fails → Log the outcome
CONNECT immediately → Link every node to its parent
# Starting a new feature
deciduous add goal "Add rate limiting" -c 90 -p "User asked: add rate limiting to the API"
# Making a choice
deciduous add decision "Choose rate limiter approach" -c 75
deciduous link 1 2 -r "Deciding implementation"
# Considering options
deciduous add option "Redis-based distributed" -c 80
deciduous add option "In-memory sliding window" -c 70
deciduous link 2 3 -r "Option A"
deciduous link 2 4 -r "Option B"
# Implementing the chosen approach
deciduous add action "Implementing Redis rate limiter" -c 85
deciduous link 3 5 --edge-type chosen -r "Scales across instances"
# Recording the outcome
deciduous add outcome "Rate limiting working in prod" -c 95
deciduous link 5 6 -r "Implementation complete"
# Sync for GitHub Pages
deciduous syncWhen context compacts or you start a new session:
deciduous nodes # What decisions exist?
deciduous edges # How are they connected?
deciduous commands # What happened recently?Or open the web viewer and ask a question in plain English:
"What was I working on before the session ended?" "What approach did we take for rate limiting and why?"
The graph remembers what you don't. The Q&A interface lets you ask it.
Deciduous ships with three skills that give your AI assistant structured ways to understand a codebase. These aren't just CLI commands—they're workflows the agent follows to build and query the graph.
Pulse maps the current architecture as a decision tree. No history, no evolution—just the design choices that make the system work today.
Your agent reads the code, identifies the design questions that had to be answered, and logs them:
deciduous add goal "API rate limiting behavior" -c 90
deciduous add decision "What identifies a user for rate limiting?" -c 85
deciduous link 1 2 -r "leads_to"
deciduous add decision "What happens when limit is exceeded?" -c 85
deciduous link 1 3 -r "leads_to"
deciduous add option "Return 429 with Retry-After header" -c 90
deciduous link 3 4 -r "resolved_by"Output: A decision tree of the current model. Use this before making changes to understand what decisions you might affect.
Archaeology takes the conceptual stories from /narratives and structures them as nodes and edges you can traverse. Every PIVOT in a narrative becomes a revisit node that connects the old approach to the new one, with observation nodes capturing why things changed.
# The pivot pattern: old approach → observation → revisit → new approach
deciduous add decision "JWT for all auth" -c 85 --date "2023-01-20"
deciduous add observation "Mobile Safari 4KB cookie limit breaking JWT auth"
deciduous link 2 3 -r "Discovered in production"
deciduous add revisit "Reconsidering auth token strategy"
deciduous link 3 4 -r "Cookie limits forced rethink"
deciduous status 2 superseded
deciduous add decision "Hybrid: JWT for API, sessions for web"
deciduous link 4 5 -r "New approach"After archaeology, you can query: "What did we try before?" (--status superseded), "What led to this decision?" (edges --to <id>), "What are the pivot points?" (--type revisit).
Narratives are the conceptual stories—how a subsystem evolved over time, what pivots happened, and how different parts of the system connect.
## Authentication
> How users prove identity.
**Current state:** JWT for API, sessions for web.
**Evolution:**
1. Started with JWT everywhere
2. **PIVOT:** Mobile hit 4KB cookie limits
3. Added sessions for web, kept JWT for API
**Connects to:** "Rate Limiting"Output: .deciduous/narratives.md with evolution stories that archaeology can transform into graph structure.
The web viewer includes a built-in Q&A interface where you can ask questions about your decision graph and get answers grounded in your actual development history.
POST /api/ask
{
"question": "Why did we switch from JWT to sessions for web auth?",
"context": {
"selected_node_id": 42,
"branch": "main"
}
}
The Q&A system:
- Sends your question + graph context to Claude — it sees the relevant nodes, edges, and narrative context
- Archaeology-aware — when asking from the archaeology view, the agent gets full narrative context including pivots, superseded approaches, and GitHub links
- Stores every interaction — questions and answers are saved with full-text search (FTS5), so you can search past Q&A sessions
-
Searchable history —
GET /api/qa/search?q=authfinds past conversations about authentication decisions
This turns the graph into a conversational interface. Instead of manually traversing nodes, ask: "What was tried before the current approach?" or "What connects the auth system to rate limiting?"
# Browse Q&A history
GET /api/qa?offset=0&limit=20
# Search past questions
GET /api/qa/search?q=rate+limiting&limit=10
# Get a specific interaction
GET /api/qa/42deciduous serve --port 3000Five views:
| View | Purpose |
|---|---|
| Chains | Decision chains by session—see the story of a feature |
| Timeline | Chronological view merged with git commits |
| Graph | Force-directed interactive visualization |
| DAG | Hierarchical goal→decision→outcome flow |
| Archaeology | Narrative-driven exploration with Q&A |
Features: branch filtering, node search, click-to-expand details, Q&A panel, auto-refresh.
| Type | Purpose | Example |
|---|---|---|
goal |
High-level objective | "Add user authentication" |
decision |
Choice point | "Choose auth method" |
option |
Approach considered | "Use JWT tokens" |
action |
Implementation step | "Added JWT middleware" |
outcome |
Result | "Auth working in prod" |
observation |
Discovery or insight | "JWT tokens too large for mobile" |
revisit |
Pivot point—connects old approach to new | "Reconsidering token strategy" |
| Status | Meaning |
|---|---|
active |
Current truth—how things work today |
superseded |
Replaced by a newer approach |
abandoned |
Tried and rejected—dead end |
deciduous status <node_id> superseded
deciduous nodes --status active # Now mode
deciduous nodes --status superseded # What was tried| Type | Meaning |
|---|---|
leads_to |
Natural progression |
chosen |
Selected this option |
rejected |
Did not select (with reason) |
requires |
Dependency |
blocks |
Preventing progress |
enables |
Makes possible |
supersedes |
New approach replaces old (via revisit) |
Attach files to any decision node — architecture diagrams, specs, screenshots, PDFs.
# Attach a diagram to a goal
deciduous doc attach 1 docs/architecture.png -d "System architecture diagram"
# AI-generate a description
deciduous doc attach 1 screenshot.png --ai-describe
# List what's attached
deciduous doc list 1
# Open a document
deciduous doc open 3
# Soft-delete (recoverable)
deciduous doc detach 3
# Clean up orphaned files
deciduous doc gcDocuments are stored in .deciduous/documents/ with content-hash naming for deduplication. The web viewer displays attached documents in the node detail panel. Soft-delete with doc detach; garbage-collect orphaned files with doc gc --dry-run to preview.
Made a mistake? Fix it:
# Remove an edge
deciduous unlink 5 12
# Delete a node (cascades to connected edges)
deciduous delete 42
# Preview before deleting
deciduous delete 42 --dry-runShare decisions across teammates. Each node has a globally unique change_id (UUID):
# Export your branch's decisions
deciduous diff export --branch feature-x -o .deciduous/patches/my-feature.json
# Apply patches from teammates (idempotent)
deciduous diff apply .deciduous/patches/*.json
# Preview before applying
deciduous diff apply --dry-run .deciduous/patches/teammate.json- Create nodes while working
- Export:
deciduous diff export -o .deciduous/patches/my-feature.json - Commit the patch file (not the database)
- PR includes the patch; teammates apply after merge
deciduous init creates workflows that deploy your graph viewer automatically:
deciduous sync # Export to docs/graph-data.json
git add docs/
git pushEnable Pages: Settings > Pages > Source > gh-pages branch
Your graph is live at https://<user>.github.io/<repo>/
When deciduous releases new features, your existing projects can get the latest integration files:
# Check if an update is needed
deciduous check-update
# Update integration files (auto-detects installed assistants)
deciduous updateThe update command auto-detects which assistants are installed and updates them:
| Files | What's Updated |
|---|---|
.claude/commands/*.md |
Slash commands (/decision, /recover, /work, /document, /build-test, /serve-ui, /sync-graph, /decision-graph, /sync) |
.claude/skills/*.md |
Skills (/pulse, /narratives, /archaeology) |
.claude/hooks/*.sh |
Enforcement hooks |
.claude/agents.toml |
Subagent configurations |
CLAUDE.md |
Decision Graph Workflow section (preserves custom content) |
| Files | What's Updated |
|---|---|
.opencode/plugins/*.ts |
TypeScript hooks (pre-edit, post-commit) |
.opencode/opencode.json |
Plugin configuration |
AGENTS.md |
Decision Graph Workflow section |
| Files | What's Updated |
|---|---|
.windsurf/hooks.json |
Cascade hooks configuration |
.windsurf/hooks/*.sh |
Hook scripts (pre-write, post-command) |
.windsurf/rules/deciduous.md |
Always-on rules for Cascade |
Not touched: Settings files, .deciduous/config.toml, docs/ - your configs stay intact.
The check-update command compares .deciduous/.version with the binary version:
$ deciduous check-update
Update available: Integration files are v0.9.4, binary is v0.9.5. Run 'deciduous update'.Add this to your session start routine to catch updates automatically.
Each AI assistant integration includes hooks that enforce the decision graph workflow:
Before the AI can edit files, it must have logged a recent goal or action node (within 15 minutes). This ensures decisions are captured before code is written.
AI tries to edit → Hook checks for recent node → Blocks if missing → AI logs decision → Edit proceeds
After any git commit, the AI is reminded to:
- Create an outcome or action node with
--commit HEAD - Link it to the parent goal/action
This connects your git history to the decision graph.
| Assistant | Pre-Edit Hook | Post-Commit Hook |
|---|---|---|
| Claude Code |
PreToolUse on Edit|Write
|
PostToolUse on Bash (git commit) |
| OpenCode | TypeScript plugin pre-edit
|
TypeScript plugin post-commit
|
| Windsurf | Cascade pre_write_code
|
Cascade post_run_command
|
All hooks use exit code 2 to block actions and provide guidance to the AI.
-
Decisions are the unit of institutional knowledge. Code tells you what, but decisions tell you why. Six months from now, you won't remember why you chose Redis over Postgres for that cache. The graph will.
-
Structured thinking produces better outcomes. The act of logging a decision—naming it, assigning confidence, connecting it to goals—forces you to think it through.
-
Real-time logging beats retroactive documentation. Capture reasoning in the moment. By the time you write post-hoc docs, you've forgotten the options you rejected.
-
Graphs beat documents. Goals spawn decisions, decisions spawn actions, actions produce outcomes. A graph captures these relationships. You can trace any outcome to its origin.
-
Complex PRs tell a story. A 50-file diff is incomprehensible. A decision graph shows the goal, the key decisions, the rejected approaches, and how each change connects to purpose.
-
Context loss is inevitable. Sessions end. Memory compacts. The graph survives.
-
The graph is a shared workspace. Decisions flow between sessions, between humans and AI, between teammates. The graph doesn't care who's typing—it preserves the reasoning.
# Initialize
deciduous init # Initialize with Claude Code (default)
deciduous init --opencode # Initialize with OpenCode
deciduous init --windsurf # Initialize with Windsurf
deciduous init --both # Initialize with Claude Code + OpenCode
deciduous init --both --windsurf # All three assistants
deciduous update # Update tooling (auto-detects installed assistants)
deciduous check-update # Check if update is needed
# Add nodes
deciduous add goal "Title" -c 90
deciduous add decision "Title" -c 75
deciduous add action "Title" -c 85 --commit HEAD # Link to git commit
# Node options
-c, --confidence <0-100> # Confidence level
-p, --prompt "..." # User prompt that triggered this
--prompt-stdin # Read prompt from stdin (multi-line)
-f, --files "a.rs,b.rs" # Associated files
--commit <hash|HEAD> # Link to git commit
--date "YYYY-MM-DD" # Backdate node (for archaeology)
# Connect and disconnect
deciduous link <from> <to> -r "reason"
deciduous unlink <from> <to>
# Delete nodes
deciduous delete <id>
deciduous delete <id> --dry-run
# Query
deciduous nodes # List all nodes
deciduous nodes -b main # Filter by branch
deciduous edges # List connections
deciduous graph # Full graph as JSON
# Visualize
deciduous serve # Web viewer
deciduous dot --png # Generate PNG (requires graphviz)
# Export
deciduous sync # Export to docs/
deciduous writeup -t "Title" # Generate PR writeup
deciduous backup # Create database backup
# Multi-user sync
deciduous diff export -o patch.json
deciduous diff apply patches/*.json
deciduous migrate # Add change_id columns for sync
# Document attachments
deciduous doc attach <node_id> <file> # Attach file to node
deciduous doc attach <node_id> <file> -d "..." # With description
deciduous doc attach <node_id> <file> --ai-describe # AI description
deciduous doc list # List all documents
deciduous doc list <node_id> # Documents for a node
deciduous doc show <id> # Document details
deciduous doc describe <id> "text" # Set description
deciduous doc describe <id> --ai # AI-generate description
deciduous doc open <id> # Open in default app
deciduous doc detach <id> # Soft-delete
deciduous doc gc # Clean orphaned files
deciduous doc gc --dry-run # Preview cleanup
# Shell completion
deciduous completion zsh # Add: source <(deciduous completion zsh)
deciduous completion bash
deciduous completion fishYou, the developer:
- Think through decisions by structuring them
- Remember why you made choices months later
- Review PRs by understanding the decision flow
- Onboard to codebases by reading decision history
- Ask questions about your own project's history and get grounded answers
Your AI assistant:
- Recover context after compaction or session boundaries
- Build on previous reasoning instead of starting fresh
- Leave a queryable trail for future sessions
- Use
/pulseto map current architecture before making changes - Use
/archaeologyto understand why things are the way they are - Use
/documentto generate comprehensive docs with test examples - Use
/decision-graphto build decision graphs from commit history - Use
/syncto synchronize decision graphs across teammates - Ask deep questions via the Q&A interface grounded in actual graph data
- Attach relevant documents (diagrams, screenshots, specs) to decision nodes
Your team:
- Share decision context via patch files
- Review PRs with full visibility into reasoning
- Build institutional knowledge that survives turnover
- Search past Q&A interactions to find answers that were already given
It almost has the word "decision" in it, and they're trees.
For Tasks:
Click tags to check more tools for each tasksFor Jobs:
Alternative AI tools for deciduous
Similar Open Source Tools
deciduous
Deciduous is a decision graph tool for AI-assisted development that helps track and query every decision made during software development. It creates a persistent graph of decisions, goals, and outcomes, allowing users to query past reasoning, see what was tried and rejected, trace outcomes back to goals, and recover context after sessions end. The tool integrates with AI coding assistants and provides a structured way to understand a codebase. It includes features like a Q&A interface, document attachments, multi-user sync, and visualization options for decision graphs.
iloom-cli
iloom is a tool designed to streamline AI-assisted development by focusing on maintaining alignment between human developers and AI agents. It treats context as a first-class concern, persisting AI reasoning in issue comments rather than temporary chats. The tool allows users to collaborate with AI agents in an isolated environment, switch between complex features without losing context, document AI decisions publicly, and capture key insights and lessons learned from AI sessions. iloom is not just a tool for managing git worktrees, but a control plane for maintaining alignment between users and their AI assistants.
skyvern
Skyvern automates browser-based workflows using LLMs and computer vision. It provides a simple API endpoint to fully automate manual workflows, replacing brittle or unreliable automation solutions. Traditional approaches to browser automations required writing custom scripts for websites, often relying on DOM parsing and XPath-based interactions which would break whenever the website layouts changed. Instead of only relying on code-defined XPath interactions, Skyvern adds computer vision and LLMs to the mix to parse items in the viewport in real-time, create a plan for interaction and interact with them. This approach gives us a few advantages: 1. Skyvern can operate on websites it’s never seen before, as it’s able to map visual elements to actions necessary to complete a workflow, without any customized code 2. Skyvern is resistant to website layout changes, as there are no pre-determined XPaths or other selectors our system is looking for while trying to navigate 3. Skyvern leverages LLMs to reason through interactions to ensure we can cover complex situations. Examples include: 1. If you wanted to get an auto insurance quote from Geico, the answer to a common question “Were you eligible to drive at 18?” could be inferred from the driver receiving their license at age 16 2. If you were doing competitor analysis, it’s understanding that an Arnold Palmer 22 oz can at 7/11 is almost definitely the same product as a 23 oz can at Gopuff (even though the sizes are slightly different, which could be a rounding error!) Want to see examples of Skyvern in action? Jump to #real-world-examples-of- skyvern
agenticSeek
AgenticSeek is a voice-enabled AI assistant powered by DeepSeek R1 agents, offering a fully local alternative to cloud-based AI services. It allows users to interact with their filesystem, code in multiple languages, and perform various tasks autonomously. The tool is equipped with memory to remember user preferences and past conversations, and it can divide tasks among multiple agents for efficient execution. AgenticSeek prioritizes privacy by running entirely on the user's hardware without sending data to the cloud.
chatgpt-cli
ChatGPT CLI provides a powerful command-line interface for seamless interaction with ChatGPT models via OpenAI and Azure. It features streaming capabilities, extensive configuration options, and supports various modes like streaming, query, and interactive mode. Users can manage thread-based context, sliding window history, and provide custom context from any source. The CLI also offers model and thread listing, advanced configuration options, and supports GPT-4, GPT-3.5-turbo, and Perplexity's models. Installation is available via Homebrew or direct download, and users can configure settings through default values, a config.yaml file, or environment variables.
metis
Metis is an open-source, AI-driven tool for deep security code review, created by Arm's Product Security Team. It helps engineers detect subtle vulnerabilities, improve secure coding practices, and reduce review fatigue. Metis uses LLMs for semantic understanding and reasoning, RAG for context-aware reviews, and supports multiple languages and vector store backends. It provides a plugin-friendly and extensible architecture, named after the Greek goddess of wisdom, Metis. The tool is designed for large, complex, or legacy codebases where traditional tooling falls short.
langserve
LangServe helps developers deploy `LangChain` runnables and chains as a REST API. This library is integrated with FastAPI and uses pydantic for data validation. In addition, it provides a client that can be used to call into runnables deployed on a server. A JavaScript client is available in LangChain.js.
playword
PlayWord is a tool designed to supercharge web test automation experience with AI. It provides core features such as enabling browser operations and validations using natural language inputs, as well as monitoring interface to record and dry-run test steps. PlayWord supports multiple AI services including Anthropic, Google, and OpenAI, allowing users to select the appropriate provider based on their requirements. The tool also offers features like assertion handling, frame handling, custom variables, test recordings, and an Observer module to track user interactions on web pages. With PlayWord, users can interact with web pages using natural language commands, reducing the need to worry about element locators and providing AI-powered adaptation to UI changes.
can-ai-code
Can AI Code is a self-evaluating interview tool for AI coding models. It includes interview questions written by humans and tests taken by AI, inference scripts for common API providers and CUDA-enabled quantization runtimes, a Docker-based sandbox environment for validating untrusted Python and NodeJS code, and the ability to evaluate the impact of prompting techniques and sampling parameters on large language model (LLM) coding performance. Users can also assess LLM coding performance degradation due to quantization. The tool provides test suites for evaluating LLM coding performance, a webapp for exploring results, and comparison scripts for evaluations. It supports multiple interviewers for API and CUDA runtimes, with detailed instructions on running the tool in different environments. The repository structure includes folders for interviews, prompts, parameters, evaluation scripts, comparison scripts, and more.
consult-llm-mcp
Consult LLM MCP is an MCP server that enables users to consult powerful AI models like GPT-5.2, Gemini 3.0 Pro, and DeepSeek Reasoner for complex problem-solving. It supports multi-turn conversations, direct queries with optional file context, git changes inclusion for code review, comprehensive logging with cost estimation, and various CLI modes for Gemini and Codex. The tool is designed to simplify the process of querying AI models for assistance in resolving coding issues and improving code quality.
runpod-worker-comfy
runpod-worker-comfy is a serverless API tool that allows users to run any ComfyUI workflow to generate an image. Users can provide input images as base64-encoded strings, and the generated image can be returned as a base64-encoded string or uploaded to AWS S3. The tool is built on Ubuntu + NVIDIA CUDA and provides features like built-in checkpoints and VAE models. Users can configure environment variables to upload images to AWS S3 and interact with the RunPod API to generate images. The tool also supports local testing and deployment to Docker hub using Github Actions.
aidermacs
Aidermacs is an AI pair programming tool for Emacs that integrates Aider, a powerful open-source AI pair programming tool. It provides top performance on the SWE Bench, support for multi-file edits, real-time file synchronization, and broad language support. Aidermacs delivers an Emacs-centric experience with features like intelligent model selection, flexible terminal backend support, smarter syntax highlighting, enhanced file management, and streamlined transient menus. It thrives on community involvement, encouraging contributions, issue reporting, idea sharing, and documentation improvement.
llm-vscode
llm-vscode is an extension designed for all things LLM, utilizing llm-ls as its backend. It offers features such as code completion with 'ghost-text' suggestions, the ability to choose models for code generation via HTTP requests, ensuring prompt size fits within the context window, and code attribution checks. Users can configure the backend, suggestion behavior, keybindings, llm-ls settings, and tokenization options. Additionally, the extension supports testing models like Code Llama 13B, Phind/Phind-CodeLlama-34B-v2, and WizardLM/WizardCoder-Python-34B-V1.0. Development involves cloning llm-ls, building it, and setting up the llm-vscode extension for use.
pr-pilot
PR Pilot is an AI-powered tool designed to assist users in their daily workflow by delegating routine work to AI with confidence and predictability. It integrates seamlessly with popular development tools and allows users to interact with it through a Command-Line Interface, Python SDK, REST API, and Smart Workflows. Users can automate tasks such as generating PR titles and descriptions, summarizing and posting issues, and formatting README files. The tool aims to save time and enhance productivity by providing AI-powered solutions for common development tasks.
uLoopMCP
uLoopMCP is a Unity integration tool designed to let AI drive your Unity project forward with minimal human intervention. It provides a 'self-hosted development loop' where an AI can compile, run tests, inspect logs, and fix issues using tools like compile, run-tests, get-logs, and clear-console. It also allows AI to operate the Unity Editor itself—creating objects, calling menu items, inspecting scenes, and refining UI layouts from screenshots via tools like execute-dynamic-code, execute-menu-item, and capture-window. The tool enables AI-driven development loops to run autonomously inside existing Unity projects.
forge
Forge is a powerful open-source tool for building modern web applications. It provides a simple and intuitive interface for developers to quickly scaffold and deploy projects. With Forge, you can easily create custom components, manage dependencies, and streamline your development workflow. Whether you are a beginner or an experienced developer, Forge offers a flexible and efficient solution for your web development needs.
For similar tasks
chunkhound
ChunkHound is a modern tool for transforming your codebase into a searchable knowledge base for AI assistants. It utilizes semantic search via the cAST algorithm and regex search, integrating with AI assistants through the Model Context Protocol (MCP). With features like cAST Algorithm, Multi-Hop Semantic Search, Regex search, and support for 22 languages, ChunkHound offers a local-first approach to code analysis and discovery. It provides intelligent code discovery, universal language support, and real-time indexing capabilities, making it a powerful tool for developers looking to enhance their coding experience.
ApeRAG
ApeRAG is a production-ready platform for Retrieval-Augmented Generation (RAG) that combines Graph RAG, vector search, and full-text search with advanced AI agents. It is ideal for building Knowledge Graphs, Context Engineering, and deploying intelligent AI agents for autonomous search and reasoning across knowledge bases. The platform offers features like advanced index types, intelligent AI agents with MCP support, enhanced Graph RAG with entity normalization, multimodal processing, hybrid retrieval engine, MinerU integration for document parsing, production-grade deployment with Kubernetes, enterprise management features, MCP integration, and developer-friendly tools for customization and contribution.
env-doctor
Env-Doctor is a tool designed to diagnose and fix mismatched CUDA versions between NVIDIA driver, system toolkit, cuDNN, and Python libraries, providing a quick solution to the common frustration in GPU computing. It offers one-command diagnosis, safe install commands, extension library support, AI model compatibility checks, WSL2 GPU support, deep CUDA analysis, container validation, MCP server integration, and CI/CD readiness. The tool helps users identify and resolve environment issues efficiently, ensuring smooth operation of AI libraries on their GPUs.
distill
Distill is a reliability layer for LLM context that provides deterministic deduplication to remove redundancy before reaching the model. It aims to reduce redundant data, lower costs, provide faster responses, and offer more efficient and deterministic results. The tool works by deduplicating, compressing, summarizing, and caching context to ensure reliable outputs. It offers various installation methods, including binary download, Go install, Docker usage, and building from source. Distill can be used for tasks like deduplicating chunks, connecting to vector databases, integrating with AI assistants, analyzing files for duplicates, syncing vectors to Pinecone, querying from the command line, and managing configuration files. The tool supports self-hosting via Docker, Docker Compose, building from source, Fly.io deployment, Render deployment, and Railway integration. Distill also provides monitoring capabilities with Prometheus-compatible metrics, Grafana dashboard, and OpenTelemetry tracing.
doc-scraper
A configurable, concurrent, and resumable web crawler written in Go, specifically designed to scrape technical documentation websites, extract core content, convert it cleanly to Markdown format suitable for ingestion by Large Language Models (LLMs), and save the results locally. The tool is built for LLM training and RAG systems, preserving documentation structure, offering production-ready features like resumable crawls and rate limiting, and using Go's concurrency model for efficient parallel processing. It automates the process of gathering and cleaning web-based documentation for use with Large Language Models, providing a dataset that is text-focused, structured, cleaned, and locally accessible.
deciduous
Deciduous is a decision graph tool for AI-assisted development that helps track and query every decision made during software development. It creates a persistent graph of decisions, goals, and outcomes, allowing users to query past reasoning, see what was tried and rejected, trace outcomes back to goals, and recover context after sessions end. The tool integrates with AI coding assistants and provides a structured way to understand a codebase. It includes features like a Q&A interface, document attachments, multi-user sync, and visualization options for decision graphs.
burr
Burr is a Python library and UI that makes it easy to develop applications that make decisions based on state (chatbots, agents, simulations, etc...). Burr includes a UI that can track/monitor those decisions in real time.
For similar jobs
promptflow
**Prompt flow** is a suite of development tools designed to streamline the end-to-end development cycle of LLM-based AI applications, from ideation, prototyping, testing, evaluation to production deployment and monitoring. It makes prompt engineering much easier and enables you to build LLM apps with production quality.
deepeval
DeepEval is a simple-to-use, open-source LLM evaluation framework specialized for unit testing LLM outputs. It incorporates various metrics such as G-Eval, hallucination, answer relevancy, RAGAS, etc., and runs locally on your machine for evaluation. It provides a wide range of ready-to-use evaluation metrics, allows for creating custom metrics, integrates with any CI/CD environment, and enables benchmarking LLMs on popular benchmarks. DeepEval is designed for evaluating RAG and fine-tuning applications, helping users optimize hyperparameters, prevent prompt drifting, and transition from OpenAI to hosting their own Llama2 with confidence.
MegaDetector
MegaDetector is an AI model that identifies animals, people, and vehicles in camera trap images (which also makes it useful for eliminating blank images). This model is trained on several million images from a variety of ecosystems. MegaDetector is just one of many tools that aims to make conservation biologists more efficient with AI. If you want to learn about other ways to use AI to accelerate camera trap workflows, check out our of the field, affectionately titled "Everything I know about machine learning and camera traps".
leapfrogai
LeapfrogAI is a self-hosted AI platform designed to be deployed in air-gapped resource-constrained environments. It brings sophisticated AI solutions to these environments by hosting all the necessary components of an AI stack, including vector databases, model backends, API, and UI. LeapfrogAI's API closely matches that of OpenAI, allowing tools built for OpenAI/ChatGPT to function seamlessly with a LeapfrogAI backend. It provides several backends for various use cases, including llama-cpp-python, whisper, text-embeddings, and vllm. LeapfrogAI leverages Chainguard's apko to harden base python images, ensuring the latest supported Python versions are used by the other components of the stack. The LeapfrogAI SDK provides a standard set of protobuffs and python utilities for implementing backends and gRPC. LeapfrogAI offers UI options for common use-cases like chat, summarization, and transcription. It can be deployed and run locally via UDS and Kubernetes, built out using Zarf packages. LeapfrogAI is supported by a community of users and contributors, including Defense Unicorns, Beast Code, Chainguard, Exovera, Hypergiant, Pulze, SOSi, United States Navy, United States Air Force, and United States Space Force.
llava-docker
This Docker image for LLaVA (Large Language and Vision Assistant) provides a convenient way to run LLaVA locally or on RunPod. LLaVA is a powerful AI tool that combines natural language processing and computer vision capabilities. With this Docker image, you can easily access LLaVA's functionalities for various tasks, including image captioning, visual question answering, text summarization, and more. The image comes pre-installed with LLaVA v1.2.0, Torch 2.1.2, xformers 0.0.23.post1, and other necessary dependencies. You can customize the model used by setting the MODEL environment variable. The image also includes a Jupyter Lab environment for interactive development and exploration. Overall, this Docker image offers a comprehensive and user-friendly platform for leveraging LLaVA's capabilities.
carrot
The 'carrot' repository on GitHub provides a list of free and user-friendly ChatGPT mirror sites for easy access. The repository includes sponsored sites offering various GPT models and services. Users can find and share sites, report errors, and access stable and recommended sites for ChatGPT usage. The repository also includes a detailed list of ChatGPT sites, their features, and accessibility options, making it a valuable resource for ChatGPT users seeking free and unlimited GPT services.
TrustLLM
TrustLLM is a comprehensive study of trustworthiness in LLMs, including principles for different dimensions of trustworthiness, established benchmark, evaluation, and analysis of trustworthiness for mainstream LLMs, and discussion of open challenges and future directions. Specifically, we first propose a set of principles for trustworthy LLMs that span eight different dimensions. Based on these principles, we further establish a benchmark across six dimensions including truthfulness, safety, fairness, robustness, privacy, and machine ethics. We then present a study evaluating 16 mainstream LLMs in TrustLLM, consisting of over 30 datasets. The document explains how to use the trustllm python package to help you assess the performance of your LLM in trustworthiness more quickly. For more details about TrustLLM, please refer to project website.
AI-YinMei
AI-YinMei is an AI virtual anchor Vtuber development tool (N card version). It supports fastgpt knowledge base chat dialogue, a complete set of solutions for LLM large language models: [fastgpt] + [one-api] + [Xinference], supports docking bilibili live broadcast barrage reply and entering live broadcast welcome speech, supports Microsoft edge-tts speech synthesis, supports Bert-VITS2 speech synthesis, supports GPT-SoVITS speech synthesis, supports expression control Vtuber Studio, supports painting stable-diffusion-webui output OBS live broadcast room, supports painting picture pornography public-NSFW-y-distinguish, supports search and image search service duckduckgo (requires magic Internet access), supports image search service Baidu image search (no magic Internet access), supports AI reply chat box [html plug-in], supports AI singing Auto-Convert-Music, supports playlist [html plug-in], supports dancing function, supports expression video playback, supports head touching action, supports gift smashing action, supports singing automatic start dancing function, chat and singing automatic cycle swing action, supports multi scene switching, background music switching, day and night automatic switching scene, supports open singing and painting, let AI automatically judge the content.