So quick hot take on some Obsidian plugins relating to AI:

For the longest time, I leaned hard on the Copilot extension for when I needed to do things like quick note summaries for time tracking and Slack, but as of late, I’ve started using a few different agents inside my vault via ACP (Agent Control Protocol).

Also… it seems the new v4.0 release is pretty bugged… lame…

So y’all might want to check these out:

Side note: I’m working on a related blog post on tool fatigue / tech exhaustion. Stay tuned.

whiskeyjack96/obsidian-acp

• Old, minimal functionality.

luis85/specorator

• Feels like a meh version of KanDev.

yiiwang118/obsidian-glossa

• Half-baked setup, no ACP.

antigmalabs/ante-obsidian

• Nice, but you need to commit to Ante… which I do love though as a side project.

donivatamazondotcom/obsidian-agent-console

• New kid in town, good ideas, running it for a while, multi-tab, better features.

rait-09/obsidian-agent-client

• OG ACP with Obsidian, still great, has floating chat button.

Intro

So I’ve been using AI Chat for a VERY long time for autocomplete, but I’ve taken a real liking to 💻 term-llm as of late, due to the amount of terminal-specific options, vs 🤖 aichat which always had felt like a “do anything, and do it, okay” tool (I started with aichat for reference).

The biggest issue is that I’ve always wanted just a little more flexibility and options out of it. So over the last week or two, I’ve started comparing them, along with 🛠️ forge (at the recommendation of a friend). I’m including it (forge) here as well, even though it ALSO functions as a full-on ZSH-homed AI agent. Really, you should check it out, outside of the need for terminal autocomplete.

The big driving force behind this post and related research is that I have a strong distaste for closed-source options and baked-in shell AI… I’m looking at you, Warp.

HA! … I stand corrected. … https://www.warp.dev/blog/warp-is-now-open-source

Edit

… Oh wow, I forgot about Fabric… that thing is REAL MVP G.L.U.E. 🖌️

Smaller agents?

Yes, I know you can also use agents like OpenCode and Crush, but both tend to load way too much overhead to be usable in this context. Maybe something like 🐦‍⬛ crow-cli or 🥧 pi might fit better, but I’ve relegated those two to just toying around with on my phone (still very neato tho!). You could also override OpenCode and Crush with minimal configs, but with minimal agents like Pi and Crow, why bother? Just keep separate tools for separate jobs. And don’t get me started where 🪿 goose would even fit in… that thing is so strange… it HONKS for Christ’s sake, and its TUI reads like a SimCity 2000 loading screen 🤣. TBH the whole “batteries included” approach it has is refreshing, in stark contrast to Pi’s absolute minimalism.

Caveat While I know the provider you pick will have one of the biggest influences on the results you get out, if you do have decent system prompts, you should get the results you would expect.

Links

CLI Native

• 
• 
• 
• https://forgecode.dev/

Smaller agents

Config Examples

Anyway 🙄, I still prefer to be able to use whatever app I like when it comes to something like shell autocomplete.

Without further ado, here are some working snippets you should feel free to test out; YMMV. Check what it spits out before you hit ENTER a second time 🫠.

TermLLM

New hotness, testing going well!

_term_llm_zsh() {
    if [[ -n "$BUFFER" ]]; then
        local msg=$BUFFER
        zle -I && zle redisplay
        PROMPT="Be concise. Output only the text needed for a POSIX compatible shell, must work with Bash / ZSH. Only output the command, PLAIN TEXT ONLY."
        BUFFER=$(term-llm ask "$msg" --fast --porcelain --native-search --system-message "$PROMPT")
        zle end-of-line
    fi
}
zle -N _term_llm_zsh
bindkey "^ " _term_llm_zsh # Ctrl+SPACE

AI Chat

Just works…

_aichat_zsh() {
    if [[ -n "$BUFFER" ]]; then
        local _old=$BUFFER
        BUFFER+="⌛"
        zle -I && zle redisplay
        BUFFER=$(aichat -e "$_old")
        zle end-of-line
    fi
}
zle -N _aichat_zsh
bindkey "^x" _aichat_zsh # Ctrl+x

ForgeCode

You may want to just use their native : QUERY_HERE, based shell injection?

_forge_zsh() {
    if [[ -n "$BUFFER" ]]; then
        local _old=$BUFFER
        zle -I && zle redisplay
        local result=$(forge suggest "$_old")
        BUFFER=$result
        zle reset-prompt
        zle end-of-line
    fi
}
zle -N _forge_zsh
bindkey "^f" _forge_zsh # Ctrl+f

Crush

Kinda working?

_crush_zsh() {
    if [[ -n "$BUFFER" ]]; then
        local msg=$BUFFER
        zle -I && zle redisplay
        PROMPT="Be concise. Output only the text needed for a POSIX compatible shell, must work with Bash / ZSH. Only output the command, PLAIN TEXT ONLY."
        BUFFER=$(crush run --quiet "$PROMPT $msg" --small-model 'copilot-proxy/gpt-4o')
        zle end-of-line
    fi
}
zle -N _crush_zsh
bindkey "^q" _crush_zsh

BONUS: Fabric

https://github.com/danielmiessler/Fabric

_fabric_zsh() {
    if [[ -n "$BUFFER" ]]; then
        local msg=$BUFFER
        zle -I && zle redisplay
        PROMPT="Be concise. Output ONLY the PLAIN TEXT command needed for a ZSH shell."
        BUFFER=$(fabric --pattern create_command "$PROMPT - $msg")
        zle end-of-line
    fi
}
zle -N _fabric_zsh
bindkey "^ " _fabric_zsh

Tool breakdown (thanks Gemini…?)

These three tools are all terminal-based AI interfaces, but they target different workflows: ForgeCode is an autonomous coding agent, AIChat is a multi-model shell utility, and term-llm is a terminal-first runtime for agents and tools.

High-Level Comparison

ForgeCode (forgecode.dev)

ForgeCode is designed as a high-performance alternative to tools like Aider or Claude Code. It focuses on deep codebase integration and autonomous execution.

• Workflow: Uses specialized agents:

• muse: Planning and impact analysis.

• forge: Implementation (modifies files, runs tests).

• sage: Internal research agent for codebase navigation.

• Strengths:

• Native Zsh plugin for seamless shell integration.

• High accuracy on terminal-based benchmarks.

• Maintains conversation context when switching between LLMs (e.g., GPT-4 to Claude).

• Infrastructure: Distributed as a Rust binary; very low latency in terminal interactions.

AIChat (sigoden/aichat)

AIChat is an all-in-one utility meant to be the “Swiss Army knife” for LLM interactions in the terminal. It is less about “agents” and more about “versatility.”

• Workflow: Centered around a robust Chat-REPL and shell expansion (-e to explain/run commands).

• Strengths:

• Extensive provider support (OpenAI, Claude, Gemini, Ollama, Groq, Mistral, etc.).

• Role-based prompting: Define custom system prompts for specific tasks (e.g., code reviewer, translator).

• Lightweight RAG: Can index local documents for context-aware chatting.

• Infrastructure: Single Rust binary; highly portable with a simple config.yaml.

term-llm (samSaffron/term-llm)

term-llm functions as a runtime for AI workflows rather than just a chat interface. It emphasizes the Model Context Protocol (MCP) and persistent sessions.

• Workflow: Executing “Jobs” and “Skills” via natural language. It can manage background tasks and complex tool-use sequences.

• Strengths:

• MCP First: Deep integration with MCP servers to fetch data or control local systems.

• Widgets: Support for local web-based widgets that can be served directly from the terminal UI.

• Zen Provider: Offers a “no-key” quickstart option for immediate use.

• Infrastructure: Built in Go; supports Unix domain sockets for widget communication and local automation.

Key Differentiators

• Codebase Management: Use ForgeCode if the goal is to have an agent read a thousand files and implement a complex feature across multiple directories.
• Shell Integration: Use AIChat for day-to-day command-line assistance, such as “How do I grep for this pattern?” or “Summarize this log file.”
• Extensibility & MCP: Use term-llm if you want to build a customized environment where the AI can interact with your local databases, APIs, or custom MCP servers.

All three tools are compatible with Linux environments (Ubuntu/Debian) and work well within multiplexers like Zellij or screen/tmux sessions due to their CLI-first architectures.

Intro

The AI tooling landscape has exploded recently, and it can be overwhelming to sift through the noise. This review covers some tools I’ve found genuinely handy. There’s also a really nice PDF report I’ve attached below, worth a read if you have the time.

AI Tooling Review and Analysis - Markdown

AI Tooling Review and Analysis - PDF

Search Engines

perplexity.ai

Perplexity.ai excels at delivering concise answers with source citations, making it ideal for research and fact-checking. It blew my mind when I first started using it a few month back. It’s magic yo.

Gemini

Google’s Gemini offers a more integrated search experience, blending traditional search results with AI-powered summaries. Its deep integration with other Google services is a significant advantage (if you’re ok with that…). I’d stick with the Pro model, as Flash tends to be good for simpler tasks. The live mode is downright creepy with how real it sounds and responds.

phind.com

Phind works as a great alternative and second source to engines like Gemini and Perplexity. I do wish I used it more, but it’s usually worth a shot if the other two aren’t cutting it.

AI Tools

I’ve also dug through a fair bit a tooling as I often do. I’ve had, of all things, Gemini fill in the gaps below, as I’ve been pretty busy with work. Aichat in particular, I’d say check out out. It’s better then Goose, but the LTM stuff with Pieces is nuts with how it sort of follows you around, taking notes on your work.

LTM (Long-Term Memory) - Pieces

Pieces is a powerful CLI and GUI tool for saving and managing code snippets. Its AI capabilities allow for semantic search and intelligent tagging, making it easy to find and reuse code.

Links & Stats

👉 https://github.com/pieces-app/cli-agent

AI Agent - Goose

Goose is a versatile AI agent designed for automation and task execution. While still under development, its potential for streamlining workflows and automating repetitive tasks is significant.

Links & Stats

👉 https://github.com/block/goose

AI Agent - Aider

aider lets you pair program with LLMs to start a new project or build on your existing codebase. It supports various programming languages and integrates with popular code editors, making it a powerful tool for developers.

Links & Stats

👉 https://github.com/Aider-AI/aider

AI Chat - aichat

aichat provides a convenient CLI for interacting with various large language models. Its simple interface makes it easy to experiment with different models and access their capabilities from the terminal.

Links & Stats

👉 https://github.com/sigoden/aichat

GUI - Jan

Jan offers a clean and intuitive GUI for interacting with LLMs. Its cross-platform compatibility and user-friendly design make it accessible to a wide range of users.

Links & Stats

👉 https://github.com/menloresearch/jan

IDE Plugin - ProxyAI

ProxyAI integrates AI assistance directly into your IDE, providing code completion, generation, and refactoring suggestions. This tight integration can significantly speed up development workflows.

Links & Stats

👉 https://github.com/carlrobertoh/ProxyAI

Model - Qwen2.5-Coder

Qwen2.5-Coder is a specialized language model designed for code generation and understanding. Its performance on coding tasks makes it a valuable tool for developers.

Links & Stats

👉 https://github.com/QwenLM/Qwen2.5-Coder

Honorable Mentions (Local Based)

Running AI tools locally offers benefits in terms of privacy, security, and customization. These options are worth exploring:

Conclusion

The AI tools discussed here represent a powerful and rapidly evolving landscape. By integrating these tools into your workflow, you can significantly enhance your productivity and unlock new possibilities. This is just the beginning, and I’m excited to see what the future holds for AI-powered tooling.

Edit 2026-06-14 01:32 PM

Found this in my drafts, worth adding as a foot note at least

https://www.linkedin.com/pulse/ai-agents-human-anatomy-creative-framework-systems-monisha-sadhukhan-mekke

AI Tooling blog post

flowchart TD

subgraph agent [Agent Orchestrator]
    direction TB
    opencode <--> mcp

    subgraph context_window [Working Memory]
        agent_prompt
        loaded_skills
    end

    opencode <--> context_window
end

agent <--> provider

subgraph provider [Inference Gateway]
    openrouter --> model
    model --> gemma-4-31b-it
end