I'll admit I spent a stupid amount of time chasing weights.
A new set drops. The leaderboard shuffles. People argue parameter counts like they're horsepower stickers. I tell myself this one will fix the sluggish feeling in my stack, swap it in, and wait for the work to get easier.
I run a local box with an RTX 5090. Hermes for agent loops. OpenCode and Cursor when I'm in the code. Antigravity when I want to talk the architecture out loud before anyone touches a file. For a long time I treated every stall as a model limitation. Too small. Too dumb. Wrong family.
The stall was how the environment was feeding context into the model.
The model is an engine sitting in a shop
Raw reasoning is cheap. Work happens in the surrounding gear.
The model provides reasoning and token generation. That is the engine. Sit that engine in a vacuum and you have a brain with no hands, no memory, and no door into your files.
What decides whether you get real work done is the harness: the environment around the engine. Memory. Tools. Access to the system you live in. Swap engines all day and you will still crawl if the shop around them is a mess.
If you mainly pick models off a chart, this is easy to miss. Picking a brain for the job still matters. So does whether that brain even fits the card. Neither one saves you if every chat window is dragging a filing cabinet through the door before you type hello.
Four layers, or you start from scratch in every window
MCP, skills, hard storage, working memory. Miss one and the stack feels cursed.
If you want a setup that works across tools without a five-prompt recap every time you open a window, you have to wire four distinct layers. Not four vendors. Four jobs.
I learned this the slow way: one layer missing, and the whole thing feels like the model is "bad at my repo."
MCP: the universal plugs
One port. Database, folder, API. Same query from every UI.
Before MCP, if you wanted an environment to talk to a local database, a file tree, or a custom API, you wrote glue. Then you wrote it again for the next interface. Cursor got one adapter. The chat app got another. The agent loop got a third, slightly different, slightly broken.
MCP turns that into plug-and-play ports. You spin up a server that exposes the data or the tool. An autonomous loop and a chat window query it the same way. The model gets hands and eyes without a bespoke script per app.
Think USB-C, not a drawer of proprietary bricks. The win is that the harness stops caring which window you opened.
Skills: packaged mini-prompts you stop rewriting
A skill is a battle-tested prompt, not a mini-app.
A skill is not some standalone product. It is a highly specific mini-prompt you already paid for in time.
You used to retype (or hunt through old chats for) three hundred words on how you want a payload parsed, how an endpoint must look, how you name migrations. You save that as a discrete skill. When you need it, the harness pulls that template and injects it next to the ask.
That is functional modularity for prompts. The good ones are boring on purpose: they encode the rule you got tired of repeating. The bad ones are someone else's entire operating manual, stuffed into a folder you marked global because it felt prepared.
Obsidian: hard storage on disk
The harness should not guess last month's schema.
Your harness should not be reconstructing architecture decisions from vibes, or from a chat that fell out of the context window three weeks ago.
Obsidian is the persistent, structured source of truth on disk. Canonical specs. Schemas. Decisions. Plain Markdown. When the harness needs a hard fact, it pulls from the vault instead of asking the model to remember.
RAG here is not a buzzword. It is the difference between "the API probably uses userId" and the note that says it uses account_id because you already burned an afternoon on that. The model stays grounded in artifacts you wrote, not in a probability-shaped guess about your stack.
Mem0: working memory that survives the window
RAG is the project. Mem0 is you, and what you are in the middle of.
RAG tells the system what the spec is. Mem0 tells the system who you are and what you are doing right now.
It sits as an episodic layer across sessions. Preferences. Working context. Constraints you should not have to restate: this project only, don't touch prod, don't invent numbers. Because it runs independently of whichever UI is open, it is the bridge across the toolchain.
I used to treat that as a nice-to-have. Then I watched myself spend the first five prompts of every Cursor session re-explaining a pipeline I had already designed in another window. That is amnesia you installed by keeping memory inside the chat.
The portable brain, on a real Tuesday
Design in Antigravity. Spec in the vault. Execute in Cursor or Hermes.
No single interface covers a real engineering day.
Antigravity is fast conversational ideation and high-level planning. You talk the shape of a data pipeline out loud, poke holes, rename the stages until the story holds.
Hermes and OpenCode take the multi-step loops: the overnight "go do the thing" work, the agent that can keep walking while you are in another window.
Cursor is where you live when the work is the diff. Write, refactor, argue with the file in front of you.
Because Mem0 carries the user context and Obsidian stores the technical output, the brain gets portable. You flesh out the pipeline in Antigravity. The spec lands in the vault. You open Cursor, or you kick a task in Hermes, and the context is already there.
You don't spend the first five prompts teaching the room who you are.
That is the whole point of the four layers. Not a prettier chat. A shop the engine can walk into without a tour.
The trap: you marked the skill pack global
A 345-skill pack marked global sits on every hello.
Once the system is up, it feels frictionless. Then you discover skill packs.
You're not grabbing a single skill for Python linting. You're grabbing ecosystems. The GSuite pack. The Cursor pack. The Claude pack. The Claude pack alone has 345 skills stuffed into its .md.
The instinct is to mark them Global. Be ready for anything, in every chat, in every agent run. You did the work of installing a hardware store. Why wouldn't you leave the lights on?
On a 5090, that looks like this.
The interface death spiral. That 345-skill pack is now sitting in the baseline. Every chat UI you open has to drag a massive static context through initialization. Time-to-first-token spikes. The card is suddenly busy starting a conversation in Antigravity or Cursor. Fans up. You have not typed a word.
Context window flooding. You burn thousands of tokens before the first character of your ask. The model is processing a manual of unrelated instructions on every turn. You paid for an engine and then parked a library in the intake.
Attention dilution. Large models lose the plot when you hand them competing rulebooks at once. Format SQL. Write Python. Manage Google Calendar. Parse logs. All in the same breath. The one instruction you care about has to fight for space with 344 cousins. Strict following falls off a cliff, and you blame the weights.
I did this. It feels like productivity. It is hoarding with extra steps.
The fix is a router, not a bigger GPU
Lean baseline. Load a skill when something asks for it.
The fix is not a new card, and it is not hunting a new model. Treat the harness like a smart router.
Keep the baseline context window lean. Load skills dynamically. Inject them when you call them: a trigger, a slash command, an agent framework that requested that tool. Leave the rest on disk.
Same instinct as putting a traffic director in front of cheap vs expensive models. You already know grocery-run questions should not hit a frontier brain. Skill packs are the same tax, on the way in. A screwdriver does not require the entire hardware store in the prompt.
Stop treating productivity as a model-selection problem. Build a clean, modular harness. Decouple memory from the interface. Keep the window lean.
What we're not doing tonight
No "best model of 2026." No 5090 shopping list.
Stay on whatever model is working if that is all you have energy for. Seriously. This idea can wait on the shelf.
We're not ranking engines. We're not turning your notes app into a religion. The move is smaller: notice what you stuff into the first turn, and stop stuffing it.
What's next
One global pack off. Then see if the card still feels slow.
If a pack is marked global "just in case," turn that off. Keep the four layers. Call the skill when you need the skill.
If you are still choosing a brain for the job, use the model picker. If the question is whether the card can hold the weights and the context you are about to dump into them, that is what the VRAM calculator is for. If you want the cheap chats to stay on the machine, run locally and let a router sort the rest.
The leaderboard will move again next week. The shop around the engine is the part you can own.