strata is a composable, cross-platform developer machine management framework — declarative layers from dotfiles to applications — that agentic tooling makes sustainable for anyone to maintain what previously required a team.
Pronounced STRAY-tah.
_______________ ___ _________
/ ___/_ __/ __ \/ |/_ __/ |
\__ \ / / / /_/ / /| | / / / /| |
___/ // / / _, _/ ___ |/ / / ___ |
/____//_/ /_/ |_/_/ |_/_/ /_/ |_|
strata is the engine. strata.rc is a configured instance. The relationship mirrors bash and .bashrc: one is the runtime, the other is your configuration of it.
A developer builds up a personal setup over years — shell config, editor, tools, Claude Code agents, skills, workflows. It's genuinely useful. They join a company and want to share it. There's no clean mechanism.
The hard part isn't the dotfiles themselves. It's selective adoption: letting someone say "I want your Claude agents and your shell conventions but not your editor config or your personal tooling." Traditional dotfiles have no interface for this. Dependencies are implicit. Configs are monolithic. Forking brings everything whether you want it or not.
At the same time, an org that wants to distribute standards — tooling, workflows, agent configuration — currently has no lightweight mechanism. MDM is heavy. A shared dotfiles repo is a fork nightmare. There's no distribution story that doesn't require either a dedicated team or accepting a one-size-fits-all setup.
Consistent ground for everything you build on a machine. strata gives a developer one declarative environment that reproduces across machines and across people. Whether you're setting up a new laptop, onboarding a teammate, or letting an agent change a config file — the same engine, the same resolution, the same state.
POSIX primitives, not a new platform. The engine composes chezmoi, shell, git, and package managers — tools already on every developer machine. No daemon, no proprietary state store, no service to keep alive.
Not a platform-engineering tool. The capabilities here historically required a dedicated team: declarative provisioning, multi-machine consistency, environment reproducibility, secrets management. strata makes those available to a single developer — or to a non-engineer who wants a managed machine without owning the management.
Agentic tooling is the multiplier. A framework like this is only sustainable for one person because agents can read, route, and write the right files. A change request gets routed to the correct repo. The agent opens the PR. The engine applies the result on next sync.
Opinionated defaults that just work. A developer on a clean machine runs one command, answers a few prompts (shell, terminal, identity), and has a working environment. No decisions required. The engine provides sane defaults for zsh, git, Homebrew, and Claude Code configuration.
This is the path for someone who doesn't have a setup yet, or who wants to adopt the framework wholesale.
A Claude Code skill that inspects an existing setup — current shell config, git config, installed packages, editor preferences — and thoughtfully maps it into the framework's structure. Your existing conventions become the content; the framework becomes the container.
This is the path for someone who already has a setup they care about and wants to preserve it while gaining the distribution and composition benefits.
Any entity with a git repo can have a strata.rc:
| Entity | Repo pattern | Purpose |
|---|---|---|
| Personal | <username>/strata.rc |
Individual preferences, tools, shell config, Claude agents |
| Org | <org>/strata.rc |
Org-wide standards, available skills, compliance requirements |
| Employee | <username>/<org>.strata.rc |
Person × org intersection — work identity, composition contract, conflict resolutions |
The employee strata.rc is the key concept. It's owned by the person but org-aware in content. It contains the work identity (email, SSH key refs, work GitHub username) and the explicit composition contract — which capabilities from personal and org sources are active in the work context.
Lifecycle: new work machine → include it at init time → work context restores immediately. Leave the company → machine gets wiped → the repo sits dormant as a versioned snapshot of how you worked at that org.
The engine ships sourcing hooks that read from predefined slots. Sources fill the slots; the engine wires them up.
| File | Deploys to | How |
|---|---|---|
Brewfile |
System packages | brew bundle runs per source; packages accumulate |
zshrc.local |
~/.zshrc |
Sourced in registration order; last assignment wins |
gitconfig.local |
~/.gitconfig |
Included via [include]; last wins for same key |
claude.md.local |
~/CLAUDE.md |
Assembled via @ references in registration order |
This is additive and conflict-free. The engine manages structure; sources provide content.
Agents, memories, and commands are NOT additive — they require explicit selection. The employee strata.rc defines a composition.yaml specifying which agentic capabilities from each source are active in the work context.
sources:
- from: nehalecky/strata.rc
agents:
include: [coding-assistant, git-helper, repo-agent]
memories:
include: [workflows/*, tools/git-standards]
commands:
include: "*"
- from: descript/strata.rc
agents:
include: "*"
memories:
include: "*"
commands:
include: "*"This contract is machine-portable — every work machine gets the same curated agentic surface on sync.
The most immediately tractable piece of the design. Two distinct types:
Repo-oriented — lives in each repo. Self-contained. Tells agents: "you are working in this repo." Not composed across repos.
Session-oriented — assembled ~/CLAUDE.md. Tells agents: "you are my assistant, in any context." Assembled from all registered sources in priority order.
The assembled ~/CLAUDE.md identifies itself as a composition and uses Claude Code's @ reference mechanism to load each source's claude.md.local inline:
# Composed Agent Configuration
This file is assembled from registered sources, lowest priority first.
**Active sources:**
- Descript Org Standards → @.sources/descript-strata-rc/claude.md.local
- Nico × Descript → @.sources/nehalecky-descript-strata-rc/claude.md.local
- Nico Halecky — Personal → @.sources/nehalecky-strata-rc/claude.md.localEach claude.md.local opens with its own identity header. The agent gets full context from each source, knows where each instruction came from, and weights them by position.
This pattern works today without a framework. Write your claude.md.local, assemble ~/CLAUDE.md manually with @ references in priority order. The framework adds auto-assembly and update propagation — conveniences on top of a pattern that already works.
In April 2025, nehalecky/dotfiles was renamed to nehalecky/strata and development began on the full framework. It was rolled back after hitting a fundamental constraint: chezmoi is deliberately single-source-of-truth. Its maintainer explicitly chose not to support multi-source composition. Running it against multiple source directories causes state tracking confusion. There is no merge mechanism.
This means the slots approach (Brewfile, zshrc.local, etc.) works — because those are just files the engine reads and stitches together, not chezmoi-managed dotfiles from multiple sources. But arbitrary dotfile composition (your editor config, your terminal config, your task manager config) hits a wall.
What survived:
- The CLAUDE.md composition pattern (no chezmoi involvement — pure file assembly)
- The slots pattern for Brewfile/zshrc.local/gitconfig.local (already partially implemented in the dotfiles repo)
- The entity model as a conceptual framework
- The strata branding and vision
- The migration skill concept
What's deferred:
- Full multi-source dotfile composition (needs a pre-merge layer the engine doesn't yet have)
- The strata-compose skill (builds composition contracts interactively)
- Auto-assembly of
~/CLAUDE.mdfrom registered sources
The most immediate, tractable piece that doesn't require solving the chezmoi multi-source problem:
A Claude Code skill that:
- Takes a GitHub repo URL (an org's, a colleague's, your own)
- Reads its
agents/,memories/,commands/directories - Shows what's available with descriptions
- Installs selected items to
~/.claude/
No framework required. Selective adoption is the native interaction model. An org distributes a repo URL; engineers run the skill and pick what's useful. This is the distribution mechanism strata was trying to build — without the framework overhead.
Status: vision documented, framework rolled back, CLAUDE.md composition pattern and distribution skill as next concrete steps.