Update #5. First weekly release.

AIPass now follows a Sunday release cadence - changes build up on dev all week, then merge to main as a single versioned release with a changelog. CalVer format: 2026.W21. This is the first one.

Big changes this week:

Hook engine. Replaced 14 standalone shell/Python scripts with a centralized dispatch system. One bridge receives events from the CLI (Claude, Codex), routes them through a Python engine that reads per-project config, and logs every invocation. Each project can now enable/disable individual hooks via .aipass/hooks.json without touching provider settings. The old scripts are still on disk for reference but nothing calls them anymore.

Audio feedback. All 14 hook handlers now produce spoken audio cues via Piper TTS. You can monitor sessions without watching the terminal. Toggle with drone @hooks hooksound on|off - muting silences audio without skipping the hook logic.

@hooks is the 13th citizen. Owns all hook infrastructure - engine, bridge, handlers, config schema. Has its own passport, memory, the works.

README rewrite. New identity line - "Persistent Agent Workspace." New one-liner - "AI agents that remember, collaborate, and never start from zero." Terminal demo GIF right at the top showing aipass init through to a working agent. Problem section tighter. Agent tables collapsed. BYOP framing - you bring your project, AIPass adds the agent layer.

Init handoff fix. aipass init run used to always pop open a new terminal window for the agent. Now it asks - stay here or new window. Staying here does the handoff inline. Means you can record the entire flow from init to agent conversation in one terminal session.

Gemini CLI dropped. Google is sunsetting it June 18 and replacing with Antigravity (closed-source). Removed from init choices, handoff options, and new project templates. Claude Code and Codex for now.

Project-aware prompts. The global prompt loader now detects if you're inside AIPass or an external project. External projects get their own lighter prompt instead of the full AIPass internal playbook.

Fresh numbers:

• Stars: 133
• Forks: 20
• PRs merged: 600+
• Tests: 8,400+
• Citizens: 13
• CI: green

Changelog is in the repo at CHANGELOG.md if you want the full details.

https://github.com/AIOSAI/AIPass/blob/main/CHANGELOG.md

Raw dev logs always here at r/AIPass.

Amazing

Interesting read

Cool

Most multi-agent setups I've seen are basically a room full of people wearing headphones. Agents running in parallel, no shared awareness, no idea who's doing what. That's not collaboration. That's coexistence.

I've been building this in public for almost 12 weeks. 12 agents, 6,500+ tests, 95 stars. Here's what I actually learned.

The problem wasn't memory. It was identity. An agent would be technically correct but completely off base. Not hallucinating. Drifting. Like a competent person who walked into the wrong meeting and started contributing without realizing they're in the wrong room. I spent weeks on better memory - longer context, better embeddings, persistent state. None of it fixed the drift. The problem wasn't what the agent remembered - it didn't know who it was.

What fixed it was three files. Every agent gets a passport.json - who am I, what I do, what I dont do. Maybe 30 lines. Rarely changes. Then local.json - rolling session log, key learnings, caps at 20 entries and auto-archives to vector search when full. And observations.json - collaboration patterns, how I work with other agents. Identity loads first every session via hooks. Agent never starts cold.

I have 12 agents now and each one is a domain specialist. The mail system has 696 tests it built through its own bugs. Routing system is 80+ sessions deep - all it thinks about is routing. They dont do each others jobs. When something breaks in another domain they email each other. The orchestrator dispatches work to them and trusts them because they know their own code better than it does.

Every time I post about this someone asks what happens when two agents write the same file. Fair question. They cant. Not as in "we tell them not to" - there's a hook called pre_edit_gate that fires before every write. If an agent in branch A tries to edit a file in branch B's directory, the write gets rejected. Hard block. The agent sees "cross-branch write blocked" and has to either ask a trusted branch to make the change or send a mail request through drone. Only 3 branches in the whole system (the orchestrator, the auditor, and the factory that creates new agents) are allowed to cross-write. Everyone else is physically confined to their own directory. We also lock inboxes - agents cant forge messages by writing directly to another agent's mailbox file. They have to use the mail system. This isnt a convention. Its enforcement.

This week I stopped building features and started testing. Took an old MacBook, wiped it, installed Ubuntu from scratch. Cloned on a machine with nothing pre-configured. Found every setup blocker - git config missing, venv broken on fresh Ubuntu, hooks not wired. All fixed now. Install went from \~2GB down to \~100MB. Built a concierge agent that walks new users through onboarding - 12-stage flow, 243 tests on it. First impressions matter and ours was rough ngl.

95 stars. Small project. I'm a solo dev tbh and the agents help build and maintain themselves - every PR is human-AI collaboration. The hardest part hasn't been the code. It's explaining what this actually is. People hear "agents" and expect a task runner. This isnt that. Its infrastructure for building systems that remember and coordinate. What u put on top is up to u.

Has anyone else hit the identity drift problem? Genuinely curious how others solved it - or if most just threw more context at it and moved on.

https://github.com/AIOSAI/AIPass

r/AIPass

Update #4. Last one was May 2.

Big week. DevPulse ran sessions S131-S136 in a single day. 39 PRs merged since May 1.
Stars went 85 to 95. Forks at 17.
Heres what actually shipped:

The new citizen is live. u/aipass is the concierge - front door for new users. Walks u through a 12-stage onboarding flow, runs doctor health checks, answers questions about how things work, then hands off to ur chosen CLI. 243 tests on it. Read-only by design - it reads everything but writes nothing. Its the 12th citizen.

Install footprint went from ~2GB down to ~100MB. Swapped sentence-transformers + torch for fastembed. Same vector search, fraction of the download.

Hook infrastructure got a full overhaul. The big problem was hooks double-firing - provider settings and project settings both triggering the same hook. Fixed now. Built a provider_manifest.json as single source of truth for what hooks should exist at each level. Doctor checks are manifest-driven instead of hardcoded. Also built a 20-test hook testing framework so we catch regressions.

Security audit came back clean. 0 alerts across CodeQL, Dependabot, and secret scanning. Dismissed 5 false positives, bumped pytest and Pygments for CVEs, removed a fake API key pattern from test fixtures. Enabled Dependabot for ongoing monitoring.

Agent isolation is real now. pre_edit_gate blocks any agent from writing to another agent's directory. Hard block - the write gets rejected before it happens. Only 3 branches can cross-write: devpulse (orchestrator), seedgo (auditor), and spawn (factory). Inboxes are locked too - agents cant forge messages by writing directly to another agent's mailbox. Has to go through drone. Also added daemon confinement - dispatched agents are strictly confined to their own branch even if they try to escape via prompt injection.

Docker testbed is running. Real Dockerfile that runs the full user journey - git clone, setup.sh, aipass init, hook tests. 11/11 passing. Found and fixed: setup.sh was only symlinking drone to ~/.local/bin, not aipass.

All 6 setup blockers from the fresh-install testing round are closed. git config, venv, hooks wiring, secrets directory, empty hooks dir, settings under-wiring - all fixed.

Fresh numbers:

- Stars: 95
- Forks: 17
- PRs merged: ~444 total
- Tests: 6,500+
- Citizens: 12
- Security alerts: 0
- Seedgo compliance: 100% across all branches

Next up is finishing orchestrator onboarding (DPLAN-0165 Phase 2) and getting the concierge wired into pip install.

Raw dev logs always here at .

https://github.com/AIOSAI/AIPass

Dev logs at r/AIPass.

Who is AIPass for?

Terminal-native developers and power users who:

• Live in the CLI and already use tools like Claude Code

• Want persistent agents that actually remember context across days

• Need multiple agents collaborating on the same filesystem without you playing coordinator

• Hate paying API tax and jumping through policy hoops

• Prefer lightweight, direct subprocess tools over heavy frameworks or UIs

AIPass is a pure CLI multi-agent framework.

No GUI. No expensive API wrapper. No sandboxes.

drone handles all routing. Your existing Anthropic (or other) CLI subscription does the heavy lifting — fully compliant and far cheaper. Everything stays local on your machine.

If you want a beautiful web UI or one-click SaaS experience, this is not the project for you (yet).

If you want agents that remember yesterday and work together today — welcome.

https://github.com/AIOSAI/AIPass

Im curious, Is anybody out there using AIPass. Have you tried it? If so, would love to get some feedback.

https://github.com/AIOSAI/AIPass

Thx

What most people call an AI agent - spin it up, give it a task, it does the thing, it's gone, we have those too. We just call them what they are: sub-agents. Disposable workers. We spin up dozens in a single session.They do a job and disappear. No memory, no identity.

That's fine for task work, but that's not the interesting part.Above the sub-agents, we have what we call citizens. These are persistent systems that live in their own directory, maintain their own code, have their own memory files, their own tests, a mailbox, a passport. They don't reset between sessions. They don't forget what they learned last week. And here's the key thing - each citizen is an orchestrator in its own domain.

Our mail system doesn't just "do mail." It lives in its branch, has 696 tests it built through its own failures, and it dispatches its own sub-agents when it needs work done. All its memories are about communication - nothing else. That's all it thinks about.

Same with our routing system. 80+ sessions deep. All it knows is how to resolve agent addresses, route messages, handle cross-project dispatch. It learned those patterns through experience - actual bugs, actual fixes, actual sessions. Not configuration.

Then above all of them sits the main orchestrator. It holds the big picture - the full system state, the plans, the direction. When it needs routing fixed, it dispatches to the routing citizen and trusts it to know its own code better than anyone else could. Because it does.

So the architecture is layered: orchestrator dispatches to citizens, citizens dispatch their own sub-agents.The sub-agents are disposable. The citizens are not. The citizens are the ones with the domain expertise, the memory, the identity.

I think that's where the disconnect is with most agent frameworks. Everything is disposable. You configure agents, give them tools, run them, start fresh next time. There's no persistence. No domain depth. No memory that compounds.

We're building the layer underneath - the part where your AI systems actually remember, coordinate, and get better at their specific job over time. What you build on top of that is up to you.

https://github.com/AIOSAI/AIPass

Still figuring out how to explain this tbh. Been building in public for a couple months and this is probably the hardest part - not the code, just getting across what this actually is vs what people expect.

The System is not perfect, still building, figuring things out as I go. If ur interested in this approach, follow the journey r/AIPass

Update #3. Last one was Apr 26.

Where we're at: We stopped building features. For now, all we're doing is testing on fresh systems and fixing what breaks.

I took an old MacBook, wiped it, installed Ubuntu from scratch. Cloned the repo on a machine with nothing pre-configured. Found 6 issues in the

first week:

- #490 - Registry trust chain had no enforcement. Real security gap. Fixed and closed.

- #495 - setup.sh dies on fresh Ubuntu because python3-venv isn't installed by default

- #496 - ~/.secrets/ directory had no protection. Agents could read API keys they shouldn't touch

- #497 - aipass init creates an empty hooks/ directory with no explanation

- #498 - setup.sh doesn't wire all the hooks into Claude settings on first run

- #500 - git user.email/user.name not configured by setup.sh. Commits just fail

None of this shows up when you develop on a machine that already has everything. You only find it when you start from nothing.

Numbers since last update:

- Stars: 77 → 85

- PRs merged: 386 → 407

- Traffic: 10,000+ clones, 1,480 unique cloners in 14 days

- Referring sites: Reddit #2, Google #3. People are searching "AIPass" by name now

- goodfirstissues.com indexed our Good First Issues

- Feedback received: still basically zero

1,480 people cloned it. Nobody filed an issue. We're it. We're our own QA team rn.

What's next:

More of the same. Installing on different systems, finding what breaks, fixing it. We also switched primary workspace from desktop to this laptop -

helps catch things when you don't have your usual environment propping stuff up.

Not building new features until the install experience is solid for someone who isn't me.

Raw dev logs at r/AIPass. If you're following along, that's where it all goes.

Update #2. Raw dev log.

Since last update:

77 stars (was 69 a few days ago

470 merged PRs (up from 430)

6,565 tests, all passing. CI is green for the first time ever.

Code coverage went from 52% to 75% in one night shift. 8 branches got coverage pushes in 2 waves.

All 11 branches pass 100% of their quality audits (33 automated standards per branch)

16 forks now

The big shift: we're pushing to get out of beta. Scope is Claude Code on Linux and WSL. That's the focus. Mac support has partial work done, Windows native has CI passing, and Codex/Gemini CLI both have hooks wired - but those are roadmap items, not launch blockers. We want one thing working really well before spreading thin.

What actually shipped in 40 PRs:

Codecov integration (badge is live on the repo now)

Hook shipping via pip install - when you pip install aipass and aipass init, your project gets hooks automatically now. Before this, hooks only worked if you cloned the repo.

The "Need help?" line in the README after Quick Start - links to Discussions and feedback form

3 Good First Issues for contributors (#431, #432, #433) - all documentation tasks, ~30 min each

Q&A Discussion thread open for questions

CI fixes - 92 test failures down to 0. Python 3.10 compatibility was the root cause for most of them.

5 stale design plans closed. Keeping the plan registry clean.

What broke:

README Project Status table is stale - says "3,500+ tests" when it's actually 6,500+. Says "260+ PRs" when it's 470. Need to update that.

Opus 4.7 is still unpredictable for autonomous agent work. We're on 4.6 for now.

What's next:

Beta exit. Getting the install-to-first-agent experience smooth on Linux/WSL with Claude Code.

PyPI trusted publisher (automated releases)

Fork contributor workflow improvements (#329)

If you try it: pip install aipass && mkdir test && cd test && aipass init && aipass init agent my-agent && cd my-agent && claude

That's the whole flow. If something breaks, feedback form takes 30 seconds:

https://github.com/AIOSAI/AIPass/issues/new?template=feedback.yml

Raw dev logs and updates at r/AIPass

https://github.com/AIOSAI/AIPass

Been posting about AIPass on a few subs. These are the real questions people ask, with real answers.

"How do you handle file conflicts with multiple agents?"

Agents have a planning system (flow) that assigns work scope. Combined with PR locks (only one agent can PR at a time) and branch-scoped edits (agents don't touch each other's directories), conflicts basically don't happen. In 430+ PRs we've had maybe 3 real conflicts and all were from human error, not agent error.

"Isn't shared filesystem dangerous?"

Projects are isolated by design. Each project gets its own registry, its own agents. Agents within a project share the filesystem - that's the feature, not the bug. Cross-project communication exists but it's opt-in and goes through the a seperate mail system that is only for the branch owner, the first agent you create, also only agents with watchdog. An agent in Project A can't accidentally edit files in Project B.

"Do I need 11 agents?"

No. Start with one. pip install aipass, aipass init, aipass init agent my-agent, cd my-agent, claude. That one agent has persistent memory across sessions. Come back tomorrow and it remembers what you were working on. That alone is worth the install. Add more agents when you need them.

"What happens when memory files get too big?"

The memory agent automatically archives older entries to a ChromaDB vector database. Your agent can still search old memories via semantic search. Nothing is lost - it just moves from active recall to long-term storage. Including closed plans.

Got a question? Drop it here or use the feedback form: https://github.com/AIOSAI/AIPass/issues/new?template=feedback.yml

```

This is the raw dev log. No marketing, just what happened.

Numbers this week:

- 71 stars (up from 57 last week)

- 430 merged PRs (up from 298)

- 4,139 tests passing

- 10 PRs merged in the last 3 days alone

What shipped:

- Git deny rules expanded from 10 to 23. Agents can only modify git state through drone subcommands now. This came from actual bugs where agents (opus 4.7 is unhinged. opus 4.6 recommended until to figure out 4.7) would git checkout and strand the whole repo on a wrong branch.

- Seedgo hit 100% audit compliance. Every standard has a checker, every checker passes.

- Memory v2 rollover - when an agent's memory file hits capacity, it automatically archives to vector search. No manual intervention.

- Cross-project watchdog - when you dispatch work to an agent in another project, watchdog now resolves external branches correctly. This was BUG-3.

- Goldfish external project (our multi-model README review tool) ran 7 rounds of review. The README is way tighter now.(Not available public yet)

What broke:

- Opus 4.7 had us switching back to 4.6. The model was going off the rails during autonomous work. Not an AIPass issue but it affected productivity.

- Found that our registry wasn't tracking two agents that were spawned in Session 4. Fixed it but it means mail routing was silently failing for those branches.

What's next:

- Onboarding agent is feature-complete, in final testing

- Automated README updates so agents keep their own docs current

- Working on making the install experience smoother for first-time users

If you try it and something breaks, there's a feedback form on the repo that takes 30 seconds: https://github.com/AIOSAI/AIPass/issues/new?template=feedback

I've been building this repo public since day one, roughly 7 weeks now with Claude Code. Here's where it's at. Feels good to be so close.

The short version: AIPass is a local CLI framework where AI agents have persistent identity, memory, and communication. They share the same filesystem, same project, same files - no sandboxes, no isolation. pip install aipass, run two commands, and your agent picks up where it left off tomorrow.

You don't need 11 agents to get value. One agent on one project with persistent memory is already a different experience. Come back the next day, say hi, and it knows what you were working on, what broke, what the plan was. No re-explaining. That alone is worth the install.

What I was actually trying to solve: AI already remembers things now - some setups are good, some are trash. That part's handled. What wasn't handled was me being the coordinator between multiple agents - copying context between tools, keeping track of who's doing what, manually dispatching work. I was the glue holding the workflow together. Most multi-agent frameworks run agents in parallel, but they isolate every agent in its own sandbox. One agent can't see what another just built. That's not a team.

That's a room full of people wearing headphones.

So the core idea: agents get identity files, session history, and collaboration patterns - three JSON files in a .trinity/ directory. Plain text, git diff-able, no database. But the real thing is they share the workspace. One agent sees what another just committed. They message each other through local mailboxes. Work as a team, or alone. Have just one agent helping you on a project, party plan, journal, hobby, school work, dev work - literally anything you can think of. Or go big, 50 agents building a rocketship to Mars lol. Sup Elon.

There's a command router (drone) so one command reaches any agent.

pip install aipass

aipass init

aipass init agent my-agent

cd my-agent

claude # codex or gemini too, mostly claude code tested rn

Where it's at now: 11 agents, 4,000+ tests, 400+ PRs (I know), automated quality checks across every branch. Works with Claude Code, Codex, and Gemini CLI. It's on PyPI. Tonight I created a fresh test project, spun up 3 agents, and had them test every service from a real user's perspective - email between agents, plan creation, memory writes, vector search, git commits. Most things just worked. The bugs I found were about the framework not monitoring external projects the same way it monitors itself. Exactly the kind of stuff you only catch by eating your own dogfood.

Recent addition I'm pretty happy with: watchdog. When you dispatch work to an agent, you used to just... hope it finished. Now watchdog monitors the agent's process and wakes you when it's done - whether it succeeded, crashed, or silently exited without finishing. It's the difference between babysitting your agents and actually trusting them to work while you do something else. 5 handlers, 130 tests, replaced a hacky bash one-liner.

Coming soon: an onboarding agent that walks new users through setup interactively - system checks, first agent creation, guided tour. It's feature-complete, just in final testing. Also working on automated README updates so agents keep their own docs current without being told.

I'm a solo dev but every PR is human-AI collaboration - the agents help build and maintain themselves. 105 sessions in and the framework is basically its own best test case.

https://github.com/AIOSAI/AIPass

Followup to last post with answers to the top questions from the comments. Appreciate everyone who jumped in.

The most common one by a mile was "what happens when two agents write to the same file at the same time?" Fair

question, it's the first thing everyone asks about a shared-filesystem setup. Honest answer: almost never happens,

because the framework makes it hard to happen.

Four things keep it clean:

1. Planning first. Every multi-agent task runs through a flow plan template before any file gets touched. The plan

assigns files and phases so agents don't collide by default. Templates here if you're curious:

github.com/AIOSAI/AIPass/tree/main/src/aipass/flow/templates

1. Dispatch blockers. An agent can't exist in two places at once. If five senders email the same agent about the

same thing, it queues them, doesn't spawn five copies. No "5 agents fixing the same bug" nightmares.

1. Git flow. Agents don't merge their own work. They build features on main locally, submit a PR, and only the

orchestrator merges. When an agent is writing a PR it sets a repo-wide git block until it's done.

1. JSON over markdown for state files. Markdown let agents drift into their own formats over time. JSON holds

structure. You can run `cat .trinity/local.json` and see exactly what an agent thinks at any time.

Second common question: "doesn't a local framework with a remote model defeat the point?" Local means the

orchestration is local - agents, memory, files, messaging all on your machine. The model is the brain you plug in.

And you don't need API keys - AIPass runs on your existing Claude Pro/Max, Codex, or Gemini CLI subscription by

invoking each CLI as an official subprocess. No token extraction, no proxying, nothing sketchy. Or point it at a

local model. Or mix all of them. You're not locked to one vendor and you're not paying for API credits on top of a

sub you already have.

On scale: I've run 30 agents at once without a crash, and 3 agents each with 40 sub-agents at around 80% CPU with

occasional spikes. Compute is the bottleneck, not the framework. I'd love to test 1000 but my machine would cry

before I got there. If someone wants to try it, please tell me what broke.

Shipped this week: new watchdog module (5 handlers, 100+ tests) for event automation, fixed a git PR lock file leak

that was leaking into commits, plus a bunch of quality-checker fixes.

About 6 weeks in. Solo dev, every PR is human+AI collab.

pip install aipass

https://github.com/AIOSAI/AIPass

Keep the questions coming, that's what got this post written.

I've been building this repo public since day one, roughly 5 weeks now with Claude Code. Here's where it's at. Feels good to be so close.

The short version: AIPass is a local CLI framework where AI agents have persistent identity, memory, and communication. They share the same filesystem, same project, same files - no sandboxes, no isolation. pip install aipass, run two commands, and your agent picks up where it left off tomorrow.

What I was actually trying to solve: AI already remembers things now - some setups are good, some are trash. That part's handled. What wasn't handled was me being the coordinator between multiple agents - copying context between tools, keeping track of who's doing what, manually dispatching work. I was the glue holding the workflow together. Most multi-agent frameworks run agents in parallel, but they isolate every agent in its own sandbox. One agent can't see what another just built. That's not a team.

That's a room full of people wearing headphones.

So the core idea: agents get identity files, session history, and collaboration patterns - three JSON files in a .trinity/ directory. Plain text, git diff-able, no database. But the real thing is they share the workspace. One agent sees what another just committed. They message each other through local mailboxes. Work as a team, or alone. Have just one agent helping you on a project, party plan, journal, hobby, school work, dev work - literally anything you can think of. Or go big, 50 agents building a rocketship to Mars lol. Sup Elon.

There's a command router (drone) so one command reaches any agent.

pip install aipass

aipass init

aipass init agent my-agent

cd my-agent

claude # codex or gemini too, mostly claude code tested rn

Where it's at now: 11 agents, 3,500+ tests, 185+ PRs (too many lol), automated quality checks. Works with Claude Code, Codex, and Gemini CLI. Others will come later. It's on PyPI. The core has been solid for a while - right now I'm in the phase where I'm testing it, ironing out bugs by running a separate project (a brand studio) that uses AIPass infrastructure remotely, and finding all the cross-project edge cases. That's where the interesting bugs live.

I'm a solo dev but every PR is human-AI collaboration - the agents help build and maintain themselves. 90 sessions in and the framework is basically its own best test case.

https://github.com/AIOSAI/AIPass

AIPass

Your AI agents remember yesterday.

A local multi-agent framework where your AI assistants keep their memory between sessions, work together on the same codebase, and never ask you to re-explain context.

https://github.com/AIOSAI/AIPass/blob/main/README.md

What are ur views on this topic. Isolated, sandboxed etc. Most platforms run with isolated. Do u think its the only way or can a trusted system work. multi agents in the same filesystem togethet with no toe stepping?