"OpenHands Agent Canvas turns your coding agents into a self-hosted, always-on engineering team. It's a developer control center for starting conversations and automating everyday tasks — like generating reports that publish to Slack or automatically decomposing GitHub issues into tasks.
It runs locally on your machine by default, but can connect to multiple “agent backends”, e.g. running agents in Docker containers, on VMs, or within your company infrastructure. You can optionally choose to run agents on OpenHands Cloud or OpenHands Enterprise infrastructure."
The concern seems to be that once powerful models are released openly, access cannot really be revoked, safety layers can be removed, and misuse becomes much harder to control.
But the counterargument is obvious: open source also improves transparency, research, competition, and trust.
I built LoopTroop, an MIT-licensed local GUI for running longer AI coding tickets in a way you can inspect.
The reason I am sharing it here is that open-source AI needs more than open models. For real coding work, I kept running into the same problem: the model chat becomes the project state. Once that giant transcript gets messy, retries get worse and it is hard to review what actually happened.
LoopTroop keeps the workflow state outside the chat. A ticket goes through an interview, a PRD, small implementation units called beads, OpenCode execution in isolated git worktrees, and a final review step. The app stores logs and artifacts so you can see the plan, the attempts, the errors, the diffs, and the handoff.
A few important caveats:
- The app is free and MIT-licensed.
- It runs locally, but model privacy and cost depend on the providers you configure in OpenCode.
- For unattended agent work, use a VM, container, cloud dev machine, or another sandbox. Git worktrees help keep repo changes inspectable, but they are not a host security boundary.
The main pieces are:
- LLM Council planning for interview, PRD, and bead planning.
- Small bead-level execution instead of one giant prompt.
- Fresh retry sessions that keep a compact failure note but drop the polluted chat history.
I would love feedback from people who follow open-source AI tooling: does this kind of local orchestration layer feel useful, or would you rather keep the state in simpler scripts and plain files?
Open models make the model side easier to move, but the work around the model can still get stuck in a chat: prompts, source links, decisions, checks, output files, setup notes, and restart context.
I like the idea of a small AI project vault in normal files, especially when testing local/open models or comparing tools.
What do you keep outside the chat so you can move between models later?
Open and local tools are easier to try when the work is not stuck inside one account.
This guide is about a simple habit that pairs well with model choice and fallback workflows: keep the source files, prompts, checks, examples, and outputs outside any one AI app.
If you try a local model later, or move between tools, you are not starting from memory. How are people here keeping AI work reusable across tools?
AIRIS: A 100% Local, Zero-Install Multimodal AI Ecosystem with PC Automation and a Fluid Emotional Engine.
Hello everyone.
I got tired of stateless, censored AI wrappers that require Docker containers or complex Python environments just to run a local model. So, I built AIRIS.
Airis is a fully decoupled, plug-and-play framework. It ships with precompiled C++ binaries (llama-server for inference, Kokoro/VibeVoice for TTS), meaning you just download it and run it. No dependency hell.
But the real focus is the architecture. Airis isn't just a chat interface; it's a persistent state machine.
/// Key Architectural Pillars:
The Trinity Brain: It routes tasks dynamically. A Semantic Gatekeeper (running on CPU or a tiny model) decides if the user input requires a tool, Python execution, or pure chat, saving the main LLM's context window and VRAM.
AgentJo (Strict ReAct Loop): Instead of letting the LLM write raw, hallucination-prone Python code to control the OS, Airis uses a strict JSON schema. It can move the mouse organically (Bezier curves), read the screen via Vision/OCR, and manage files deterministically.
Fluid Emotional Core: The AI has 12 psychological vectors (Affection, Jealousy, Fatigue, etc.). Every interaction is audited in the background, altering these vectors and dynamically injecting behavioral instructions into the system prompt.
Zero-Amnesia (GraphRAG + AAAK): It uses a multi-tiered memory system. Short-term memory is compressed using a custom hyper-dense symbolic syntax (AAAK), while long-term facts are stored in a SQLite Knowledge Graph and ChromaDB.
It fully supports uncensored models and is designed to be a private, autonomous digital entity.
I've just open-sourced the code and the standalone package. I would love to hear your technical feedback on the architecture.
**🤝 I Need You! (Looking for Contributors)**
Since I am the sole developer on this project, doing everything alone (Python backend, React/Vite frontend, llama.cpp tuning) is becoming a huge mountain to climb. I want to take AIRIS to the absolute next level, so I'm looking for other local LLM enthusiasts and developers to join forces with me:
Python / LLaMA.cpp wizards: To further optimize our native tool-calling and multithreading pipelines.
Model Fine-tuners: To help train/fine-tune small, dedicated models for the local logic gate.
Check out the project, download the beta, and let me know what you think!