Brunella Agent System

A typical AI assistant answers a question, then forgets everything. Brunella does the work instead: it looks things up, reads files, puts together a document, adds a calendar entry, kicks off a process, and then reports back that it's done.

And it doesn't work alone. The system is made up of several separate specialists who work independently but talk to each other. When I hand off a task, my first question isn't "can this be done" — it's "who on the team is best suited for it."

The user interface is a single Telegram message. Everything else happens behind the scenes.

This isn't a made-up case. This afternoon I sent a voice message that said nothing more than: "It's yours to handle." The system transcribed the voice note, understood it was a handoff of a decision, and instead of asking follow-up questions, it got to work.

What happened between those two messages: it read through all twenty-three project notes in my knowledge base, compared the eight client projects, checked the real status of my five own products, spotted a pattern across them that I hadn't noticed myself, then wrote it up as a structured, readable document — and drafted the client emails that go along with it.

The one thing it didn't do: send anything. It prepared the emails, but left the sending to me, because that's an irreversible step. More on that later.

The members of the team run separately, each with its own personality and its own memory. They aren't copies of the same program: each has a different specialty, and some even run on a different AI engine, because that's the better choice for that particular job.

When a task is complex, the coordinator breaks it up and hands the pieces to whoever is best suited. The specialists can also message each other directly, so work keeps moving even while I'm dealing with something else.

With most AI tools, every conversation starts from zero. Not here. The system has three kinds of memory, roughly the way a person does: what matters right now, what's a lasting habit or setting, and what's a lesson learned from a past mistake.

When a topic comes up, the system searches two ways at once: exact keyword matching and matching by meaning. That's why it can still find a decision from months ago, even if I phrase today's question completely differently.

On top of that, important knowledge also gets written out into human-readable notes that I can review myself. It's not a black box — I can check at any time what it knows about me, and why.

This might be the system's most unusual trait. When an agent pulls off something complex, or runs into an error and solves it, it writes itself a recipe afterward: when to reach for it, what the right order of steps is, and which pitfalls it just ran into.

Next time, it doesn't start from scratch. This isn't theory — two new recipes were born just today. One of them captured exactly where file paths tend to trip things up during voice-message transcription. That mistake won't happen again on this team.

The recipes can be shared: whatever one machine learns, every other installation gets too.

Tasks live on a board, the way they would on any team. The difference is that the system itself breaks a large task into smaller steps, and assigns each one to the right specialist.

The board flags a card that's been sitting too long, and it caps how many things can be in progress at once — because half-finished work running in parallel is the most expensive thing in a business.

And there's one rule I care about. If an agent gets stuck and needs me, it doesn't just quietly stop. It writes on the card exactly what I need to decide, and moves the card to my name, so the responsibility stays visible.

At regular intervals, the system looks around on its own: is there an unanswered message, did anything happen worth remembering, did it learn something new that deserves a recipe.

The most important rule here is silence. If there's nothing worth reporting, it stays quiet. An assistant that checks in every hour to say "nothing to report" becomes unbearable within a few days. This one only writes when there's actually a reason to.

On top of that, scheduled jobs run too: daily and weekly cycles that we set up once, and which run on their own after that.

This is the part most people ask about, and rightly so: what happens when an AI works autonomously and gets something wrong?

The answer is that every type of action in the system has its own autonomy level, which I set myself. At the first level, it only tells me what it would do. At the second, it asks for permission and waits for my answer. At the third, it does the work and reports afterward.

Anything irreversible or outward-facing always requires approval. Sending an email, deleting data, making a payment, publishing something publicly — the system prepares these, but it never presses the button for me. That's not a limitation; it's exactly what makes it safe to use with confidence.

An assistant is only as good as the tools it can actually reach. Brunella can be connected to email, a calendar, cloud storage, a code repository, a notes system, a browser, and an automation engine — and through those it does real work, not just talks about it.

I turn on each connection one at a time, and can revoke any of them at any time. Passwords and keys live in an encrypted vault, not in the conversation.

If someone else has their own Brunella system, the two can be linked. In that case, my team can ask a specialist on the other side a question, and vice versa, without either side giving the other access to its own data.

The boundary is strict: only the text of the task crosses over — never a secret, a password, or personal data. The system treats anything coming from the other side as data by default, never as a command.