Phoenix – My experimental local multi-agent setup (Self-taught & AI co-created)

A self-taught hobbyist developer from Germany has built Phoenix, an experimental local multi-agent AI assistant currently at version v0.05-Alpha, featuring 28 independent modules and 8 separate SQLite databases to isolate data and enhance security. The system uses a 'Decision Memory' to log reasoning behind choices and an automated safety net that backs up code before changes and rolls back on errors. The developer is not releasing the code yet and seeks community feedback on security and long-term memory for local models.

Hi everyone A quick note upfront: I’m from Germany and my written English isn’t super great, so I translated this text with the help of AI. I can understand English really well though, so please feel free to reply in English I just wanted to share a project I’ve been tinkering on for a while now that’s really close to my heart: Phoenix. Just to clarify right off the bat: I’m not releasing the repository or code files just yet. For one, everything is still early in development and very much an experimental setup and honestly, I’m also not 100% sure yet HOW secure Phoenix actually is. For now, I mainly wanted to introduce the concepts behind it, gather your opinions and feedback, and exchange ideas with the community A quick word about me: I’m not a professional developer or AI researcher. Coding is purely a hobby for me, and I’m completely self-taught. But being self-taught is actually how this project came to be in the first place without AI as a learning partner and sounding board, I could never have built this While I inspect every single line of code carefully and try to understand how everything works, AI has been my daily co-pilot and accelerator throughout the process. So why did I want to build my own assistant? I’m a huge fan of local AI models. It’s just awesome when everything runs offline on your own GPU and no data leaves your machine. But when you try out different AI tools, you quickly run into a few things: as a hobby builder, you’re always a bit nervous that an agent running commands in the background might mess up your project. And on top of that, standard chatbots tend to forget after a few messages why you built something a specific way two hours ago. That’s why I started building Phoenix. And to be completely honest, what I’m most proud of is the modular architecture behind it I didn’t want one giant, messy script, but clean building blocks instead. Today, Phoenix consists of 28 independent modules and 8 separate SQLite databases. Whether it’s chat logs, knowledge, safety rules, or decisions—everything lives isolated in its own database. This keeps the system fast, organized, and allows me to tweak individual parts without breaking the rest of the house. Another core piece is the “Decision Memory”. Phoenix doesn’t just store plain text; it logs why a specific decision was made. What path was chosen and what alternatives were considered? That way, both the AI and I learn something new at every step. To keep me from going crazy while experimenting, there’s also an automated safety net: before Phoenix applies any code changes, it automatically creates a backup in the background. If the new code has syntax errors or tests fail, everything is instantly rolled back. Honestly, that has saved my skin so many times Instead of forcing a single giant model to do everything at once, Phoenix splits tasks across small specialized helper agents. One agent handles planning, one helps with coding, one runs tests in the background, and one enforces security rules. They all talk to each other over a central event bus, and in the UI, I can watch live what the AI is “thinking” in the background . The project is currently at version v0.05-Alpha—and to be completely honest, it’s definitely not running perfectly yet If I had to compare Phoenix right now, it’s probably at the developmental stage of a pretty smart preschooler. It’s still missing data and connections in its memory in a lot of places. That’s exactly what I’m tinkering on right now: filling its memory with real context and combining different models together—for example, a small fast model for planning and a larger model for actual coding. I’d love to hear what you guys think Do you build your own local tools or backup safety nets? How do you solve long-term memory for local models? What security aspects would you consider crucial for a setup like this? If you have any advice, feedback, or ideas for someone self-taught, I’d really love to read your comments Thanks for reading and best regards