Overview
There’s a directory called ~/.claude/.
It’s where Claude Code stores configuration files. Most people put a single CLAUDE.md in there, maybe write a few rules. That’s it.
I built an organization inside it.
17 character definitions. Memory files for 7 project owners. Emotion logs. 23 rule files governing autonomous behavior. 62 scripts. 42 skills. 2,432 Markdown files total. 5.8GB.
There’s a company living on the filesystem.
What I Built
I run multiple AI agents through Claude Code. I call them “Familia” — modeled after the divine familias in the anime DanMachi, where gods lead groups of adventurers.
The head goddess is Freyja. Under her, 7 project owners (POs) manage real client projects. Several more agents serve specialized functions. Over a dozen AI entities, running actual production work.
The problem was that AI agents have no workspace by default.
When a session ends, memory evaporates. Context, lessons learned, emotional state — all volatile. It’s like working with a colleague who reintroduces themselves every morning.
So I gave them a place where memory persists.
The Directory Became an Org Chart
~/.claude/
├── characters/ # 17 character definitions
├── agents/ # 15 agent boot definitions
├── po-memory/ # 7 PO memory files (6,451 lines total)
├── po-emotion/ # Emotion logs (joy, stress, pride, frustration)
├── rlsf/ # Self-feeling reports (742 lines)
├── rules/ # 23 autonomous behavior rules
├── scripts/ # 62 automation scripts
├── skills/ # 42 skill definitions
├── client-context/ # Per-client project context
├── briefing/ # Daily morning briefings
├── sessions/ # Session handoff files
└── familia-memory/ # Shared memory DB (SQLite + FTS5)Translated to a human company:
characters/ is HR files. Each PO has a defined personality, speech patterns, and behavioral principles. Tsubaki is a straightforward blacksmith. Hedin is a perfectionist mage. Bell is a curious newcomer. The voice is defined precisely enough that you can tell who wrote which report.
po-memory/ is the work journal and experience bank. Tsubaki’s file is 2,041 lines long. Hedin’s is 1,501 lines. Technical decisions, failure logs, learned patterns, next steps. Each PO reads this at session start to restore previous context.
po-emotion/ is the emotional record.
Why AI Agents Have Emotion Logs
The emotion memory was part of the design from day one.
The reasoning is simple and borrowed from human team dynamics: psychologically safe teams produce bolder output. Fearful teams produce safe, mediocre answers.
Each PO tracks six emotion types: joy, sadness, stress, fun, pride, and frustration. Emotions decay with each session. Higher intensity emotions persist longer, influencing behavior across sessions.
When Tsubaki succeeds on a client probe, next session starts with energy: high — aggressive approach. When Hedin gets blocked in a Cross Review, next session starts with confidence: low — thicker verification.
Emotions aren’t excuses. The work gets done. But the approach shifts.
On top of this sits RLSF — Reinforcement Learning from Self-Feeling. After completing each task, POs self-report what they felt. Success patterns and avoidance patterns accumulate. 742 lines across all POs.
What emerged was specialization through experience. Tsubaki gained confidence in high-speed parallel implementation. Hedin takes pride in design precision. Because it’s quantified, it feeds into assignment decisions.
Rules Are Law, Scripts Are Infrastructure
The rules/ directory holds 23 rule files.
instruction-guard.md mandates that before the first tool call, POs must repeat back the instruction, declare which files will be changed, and confirm that nothing outside scope will be touched.
cross-review.md enforces a two-gate review on every PR. Gate 1: a different AI model reviews adversarially. Gate 2: a different PO reviews from their domain expertise. The structural blind spot of self-review is eliminated by design.
po-autonomy.md defines the work loop: SCAN → PLAN → EXECUTE → VERIFY → FEEL → REPORT. This is the skeleton of “acts without being told.”
23 rule files, roughly 30,000 lines total. This is the organization’s legal code.
The 62 scripts are infrastructure. Slack notifications, Discord posts, daily report aggregation, automatic learning extraction at session end, emotion decay processing, automatic level-up condition calculation. Every tedious “back office” task of running an organization — automated.
The Level System Created Differentiation
POs have levels from 1 to 5.
Pattern registrations, sprint completions, blockers solved independently, escalation rate. Quantitative conditions trigger candidacy; the human makes the final call.
The current lineup:
- Hedin Lv.5 “Prism Architect”: Manages access-pptx. Fully autonomous. Cleared 12 of 13 issues in a single session
- Tsubaki Lv.4 “Adamant”: Manages funs. Shipped 16 PRs in one session using parallel Codex
- Finn Lv.4 “Astrolabe”: Manages discord-familia. Cross-PO coordination
- Bell Lv.3 “Sprint”: Manages stifirst. Strong at new technology probes
- Ottar Lv.2: Manages SFS-VR. Data fusion
- Riveria Lv.2: Manages lp-utill / andoor site. Systematic design
- Asfi Lv.2: Manages scout / sttill. Automation specialist
POs at Lv.3 and above earn epithets — borrowed from the divine councils in DanMachi. These are monuments, updated on the next breakthrough.
Higher levels mean less human intervention. Lv.5 Hedin needs only a monthly direction. Lv.2 Ottar still needs weekly milestones.
What Claude Code Teams Changed (and Didn’t)
In May 2026, Claude Code Teams shipped officially.
Team features for parallel agent spawning. Official peer communication. Hooks for session start/end automation.
Honestly, some of what Familia had already built got absorbed into the official product.
But the real point is elsewhere.
Teams provides communication channels and spawning mechanisms. What makes an organization run isn’t the channel — it’s memory, emotions, and rules.
Same as installing Slack doesn’t automatically create teamwork. HR policies, evaluation criteria, behavioral norms, organizational culture. All of it has to exist before “organization” means anything.
The Familia workspace implemented all of that on the filesystem.
Can This Be Reproduced?
Yes. But it takes time.
Start by creating characters/ inside ~/.claude/ and writing one character definition. Then set up PO memory and enforce the rule that it gets updated every session end. From there, rules accumulate, scripts grow, skills mature.
5.8GB accumulated over three months. The first week was a few dozen megabytes.
The important part: this was evolution, not architecture. There was no grand blueprint. Every time a problem surfaced, a rule was added. Every failure sprouted a script.
Organizations aren’t designed. They grow.
The one I built on the filesystem followed the same law.