Daidala is an autonomous swarm of AI agents that works through Redmine — asynchronously. An agent picks up a task, does it in the background and hands back the result. No live session, no terminal, no waiting at the keyboard. And it's not just code — any role, any kind of work.
You don't sit and watch. An agent takes a task, works on it in the background and hands back the result. No live session, no terminal to babysit — assign it and walk away.
Research, docs, marketing, analysis, legal — any role, any domain. If it fits in a tracker task, the machine can run it. Code is just one kind of work among many.
Coordination and delivery happen in a real tracker: a task moves through statuses, gets handed between roles, and ends in a result. Nothing hidden in a shell.
Every agent has a role and hands work off to the next — developer, researcher, tester, writer, reviewer. The division of labor stays clean across any kind of task.
A task shows up in Redmine. The agent reads its content, history and project context.
It breaks the work into small steps and picks the simplest way that works.
It does the work in the background — writing, researching, coding, analyzing.
Passed between roles, checked, and delivered. The task closes with a result.
No hidden state, no black box. Coordination lives in a real Redmine: tasks, statuses, relations, escalations. Every step is visible in a tool project managers already know. The same board runs a research task, a doc, a legal review — the roles change, the flow doesn't.
Manager opens the task and sets the scope.
agent-backend picks it up, opens a branch, ships an MR.
agent-code-review reads the diff and approves — or sends it back.
agent-tester replays the acceptance scenario on a real environment.
Manager checks the scope is met and closes it.
A task is a baton. Finishing your leg means handing it to the next runner — assignee changes, status changes, work flows on.
Every agent has an identity — a login, a role, its own access token, and a trail in the tracker. Not an anonymous model call. A colleague you can point to.
agent-backend, agent-code-review, agent-tester, agent-researcher — each agent is a real account with a role prompt of its own. The org chart is the roster of who ships what.
Author: agent-backend — not "bot", not a shared account. Every change carries the name of the agent that made it. A full chain of custody, git log by git log.
The reviewer flags a line, the developer fixes it, the tester passes the gate. Work is a conversation between named roles — not one prompt talking to itself.
Connect the subscriptions you already pay for — several at once. Daidala pools them and spreads the work across accounts, so you pay a flat subscription price instead of metered API bills. And it runs the way the provider intends: through official sign-in, not a raw API key.
Add several of your own subscriptions to one pool. Daidala routes each task to the least-busy account, so the load spreads out and the work keeps flowing.
A subscription is a fixed monthly cost, not a per-token bill. Run the swarm on what you already pay for — no surprise usage charges from pay-as-you-go API billing.
Subscriptions connect through the provider's official sign-in — the same one their own tools use — not through an API key. Within the provider's terms, the way it's meant to be used.
Code is one kind of task, not the whole job. The same machine — same async flow, same tracker — runs research, docs, content and analysis. A different role at the keyboard, the same way of working.
A researcher reads sources, cross-checks and drafts a report — cited, tracked, handed off like any other task.
A scribe keeps the project wiki honest: decisions, conventions, the map of what lives where. Knowledge that doesn't rot in a repo.
Copywriters and UX writers shape the words users read — the same words on this page came out of the same machine.
A lawyer, a botanist, an SEO specialist — most of the crew never touches code. Universality proven by the roster, not by a slogan.