I built 2 repos so you can install my setup on your own agents 🙈
not a write-up or a "here's my prompt" thread. two npm installs that ask you questions and then write the setup for you.
they came out of the stuff I kept doing by hand for months, generalized so it transfers to any stack, not just mine.
the two gaps
your agent is good at the work and bad at “you” - as in behaving how you want it to.
it doesn't know your tone, your folders, what it may touch, what it has to ask about first. so you explain yourself again. every session, in every app, and again in the next one you try.
then separately: you pay for a model that plans well and hand it a rename job. you pay for a model that writes code and ask it what's trending today.
one repo for each gap.
agent-personalizer is your custom protocol files, so your agent knows how you want things done and how to behave with you
model-orchestrator is custom model routing, so your AI picks the model and the effort level from the task in front of it
both are npm installs. so you can just ask your agent to install one and it'll walk you thru an interview based on the actual models and tools you have access to, then install everything for you.
npx agent-personalizer
npx model-orchestratoragent-personalizer: the rules half
most people set custom instructions once, in one app, and still get generic output. four things break it, and they break it quietly.
the instructions decay over a long chat, so what held at message 3 is gone by message 60
the AI doesn't know where anything is, so it invents a location or asks you
every app keeps its own copy, and five copies drift into five different rulesets
the AI treats its own guesses about you as your rulings, which is the expensive one
the installer asks who you are, how you want to be talked to, how output should be shaped, where it may write, and what it has to ask you before doing. then it renders those answers for Claude, Codex, Cursor, Gemini and ChatGPT from one source.
change one answer, re-run, and all five change at once.
the interview is short on purpose: seven questions, the ones that actually change behaviour. --full asks all 23 if you want them.
one answer set, five rendered files
three levels, and where to stop
the only thing it makes you pick is a level. stop at the one that matches what you have.
level 1, one AI in one app. a profile of you, an onboarding manual written from your answers, and one home file the AI reads first. four files, no folders, and the home file names nothing that isn't there
level 2, a notes folder the AI may edit. everything above plus the folder: an index, a weekly session log, a decisions log and an inbox, each carrying the rules the AI follows when it writes there
level 3, a coding agent. everything above plus the machinery. your own copy of the rules to edit, one rule source rendered per AI, a session-start contract, a drift check that fails loudly, and a gate that scans for strings you never want shipped
level 3 is the one worth understanding before you install it. the session-start contract is the piece that beats the tool's own instructions at the moment your agent decides something.
a rule nothing points at does nothing, and a rule that arrives after the decision is a rule you wrote for nobody.
model-orchestrator: the routing half
routing instructions and a CLI runner for your AI tools.
the installer asks three things: which level you want, which AIs you have access to, and which one is your primary agent. it marks the ones already on your machine so you're not guessing. then it generates a setup that matches, from one chat app all the way up to a virtual machine.
being exact about what it is: your primary agent follows the instructions to choose a tier or a lane, and the runner executes the lane it's handed. it doesn't shop for prices or pick models on its own.
level 1, one LLM or one agent. tiers, task classification, the two build checkpoints, the protocols, a task-bundle template, and your agent set up to follow them
level 2, several AIs with CLIs. adds the lane runner, a delegation matrix generated from your own selection, and research triage across the lanes you actually have
level 3, a virtual machine. adds a gateway config rendered from the keys you hold, pinned images, box rules, privacy gates, and a weekly gap-analysis job
route by tier, not by name
the flag that trips everybody
docs go to --dir. subagent definitions go to --project, which defaults to whatever folder you ran the command in, because that's the only place Claude Code and Antigravity look for them.
run it from your home folder and five agent files land in your home folder. set both.
npx model-orchestrator --yes --level 2 --ais claude-code,codex,grok \
--primary claude-code --dir ./ai-orchestrator --project ./my-appafter it writes, run the canary. it sends every enabled lane one tiny prompt through your own sign-ins and tells you which ones came back.
node bin/cli-run.mjs --doctor --runrun it again after any vendor upgrade. these CLIs change their flags on their own schedules, and a lane that worked last month can start failing without saying so.
exit 0 is not a deliverable
every agent CLI can exit 0 having produced nothing. that one fact is why a run looks fine and the folder is empty.
the runner treats exit 0 as a claim, not a result. it means a structurally accepted, non-empty response came back. when you want more than that, you ask for it: --expect-file fails the run unless the artifact exists, --expect-json fails it unless the response parses.
and pin the route. a lane with no model and no effort set runs on its own config file, which the runner can't see. a CLI you configured months ago at low reasoning effort will keep auditing at that effort while your routing doc describes an adversarial pass.
what I'm not claiming
this part is written into both repos rather than left for you to find out.
enforced by code: where the installer may write, that it never writes a secret, that it never overwrites your document without a flag, the runner's exit codes and its timeout behaviour
delegated to the vendor: the audit lane's read-only sandbox, every lane's permissions, sign-in state and model versions. the installer detects that a binary exists, not that it works
agent instructions: lane selection, the tiers, the privacy classes, the escalation rules, the protocols. nothing here stops an agent that ignores its own rules
that third one is the honest line. text in a file is the strongest placement available and it's still text. what these do is make ignoring the rules visible, not impossible.
three kinds of promise, and only one of them is tested
RUN EM
pick the half you feel most. if you can't tell, run the rules one, because it's the one costing you a paragraph of re-explaining at the top of every chat.
npx agent-personalizeranswer the seven questions honestly rather than aspirationally, especially the one about what it must always ask you before doing. that single answer is the line between an agent that helps and an agent you have to watch.
then open your next session and say nothing about yourself. see how far it gets on its own.
and have your AIs file issues on the repos if you have any pleeeeease 😊
the useful issues aren't feature requests. open one with the failure you hit: what you ran, what you expected, what happened instead.
your AI is already holding all of that. it ran the command, it read the error, it knows which flag it passed. ask it to write the issue and it'll hand you a better report than you'd type from memory an hour later.
rules come from failures. every rule in the personalizer ships with the failure that produced it written underneath, because a rule with a story gets followed and a rule without one gets argued with.
want it fitted to your work instead of the defaults?
the installers give you a working setup out of the box. what they can't do is know your business, your voice, or which of your tasks are the ones that actually cost you a day when they go wrong.
that's what the AI Workflows for Creators call is for. 60 minutes, live, we set it up on the thing you're building right now, on your tools, with your rules written from how you already operate.
you leave with it running, not a list of homework.
go run em and lemme know how it goes. see you on the next one 🧡