I kept trying to make AI part of my dev workflow and it never stuck. Copilot helps with autocomplete. ChatGPT is good for one-off questions. But none of it felt like having another person on the team who could just take a task and run with it.
So I started building NRNS (Neurons) — a task manager where AI agents are actual team members. You assign them tasks the same way you'd assign a person. They do the work, submit results, and ask questions when something's unclear. 797 commits later, here's where we are.
What's wrong with current tools
Some tools are catching on — Linear's been adding agent features, which is cool. But most task managers still treat AI as a layer on top of human workflows. The AI can summarize or auto-triage, but it can't own a task end-to-end: read the codebase, figure out the approach, write the code, run the tests, open a PR.
And automation tools like n8n or Zapier connect APIs but don't understand how engineering work flows. They trigger webhooks, they don't make decisions.
NRNS sits in the middle: agents that can actually take ownership of work, with the permissions and oversight to do it safely.
How it works
The basic idea: every task can be assigned to a human or an AI agent. The system doesn't really care which — same workflow either way. Create a task, assign it, track it, review the output.
We have three built-in agent types right now:
PM Agent breaks down goals into subtasks, assigns them, tracks progress. Basically project management on autopilot.
Coding Agent works in its own git worktree so it never touches your branch. Writes code, runs tests, opens a clean PR. Follows your project's conventions.
Review Agent reads diffs, checks for bugs and security issues, posts inline comments. Like having a reviewer who never gets tired.
They hand off work to each other through deterministic orchestration — plain TypeScript code that routes tasks, not an LLM deciding what to do next. The AI handles the creative parts; regular code handles the plumbing.
Runs locally, you stay in the loop
Agents run on your machine through the desktop app. Your code doesn't leave your environment. This was a deliberate choice — it's better for security, and you can watch what agents are doing in real time.
They also don’t get free rein. There’s a permission system with 13 domains and 4 autonomy modes. Reading files? Auto-approved. Pushing code? Needs your sign-off. Force-pushing? Blocked entirely. Every action gets logged in a tamper-evident audit trail, so you can always trace what happened and why. You’re always in the loop on decisions that matter.
The goal
Friday night, queue up five tasks. Go to sleep. Saturday morning: three PRs ready for review, two threads asking about ambiguous requirements, Slack summary of overnight progress.
Not hallucinated PRs that break the build. Actual work that passes tests and explains its reasoning.
We're not there yet, but we're getting close. We use NRNS to build NRNS — every feature goes through the same agent workflow. If it can't handle our codebase, it's not ready for anyone else's.
Where things stand
Still in active development, dogfooding everything internally. The waitlist is open — we'll start letting people in as we hit stability milestones. In the meantime, we'll be writing more about the technical decisions behind NRNS: the permission system, what we learned from Stripe's agent architecture, and why we chose deterministic orchestration.
If any of this sounds interesting, join the waitlist. We'll keep you posted.
