The 6 euro brain

I run my entire AI development workflow from a 6 euro/month OVH VPS. Ubuntu. Claude Code connects via SSH. Full root access. Persistent processes. Nothing disappears when I close a browser tab.

This is not a tutorial. This is a setup I have been iterating on for months. Some parts work great. Some are still ideas on a whiteboard. I am sharing it because I think more people should build their own version of this.

The VPS

Why a 6 euro box instead of a cloud IDE or a managed platform?

Full root access. PostgreSQL always running. MCP servers always available. Custom services in the background. Total control over the environment. Claude Code connects via SSH and has the same experience as if it were sitting at the machine.

The cost is irrelevant. What matters is that I own the infrastructure. I can install anything, run anything, break anything. When I close my laptop, the database is still there. The memory system is still indexing. The context files are still on disk.

Cloud IDEs give you convenience. A VPS gives you control. I chose control.

The agents

I have 25+ specialized agents configured in Claude Code. They are all the same model underneath. The system prompt is what makes them different. And that difference matters more than you would expect.

They fall into two layers.

Business and strategy layer

startup-cmo-landing-page handles positioning, messaging, and landing page strategy. When I need to figure out how to present a product, this is who I talk to.

market-research-analyst does competitive analysis, ICP definition, and market sizing. Before I write a single line of code, I want to know who the buyer is and what alternatives exist.

finance-partner coaches on budgeting strategy and investment planning. It remembers constraints across sessions because of the memory layer.

career-coach helps with career strategy, interview prep, and positioning. Useful when you are navigating a job search and need someone to pressure-test your thinking.

Coding team

solution-architect is the lead. System design, API contracts, data flow. Sits at the top of the technical hierarchy. Validates every architectural decision before implementation starts.

technical-pm is the bridge between business and technical. Takes business requirements and splits them into structured JSON specs. Coordinates between the CEO/marketing side and the implementation side.

python-react-coder implements everything. Flask + React + PostgreSQL. Knows the stack conventions, the folder structure, the coding philosophy.

ai-engineer handles LLM workflows, RAG pipelines, scoring algorithms, fine-tuning strategy, and model selection. This is the agent I use most on AI-heavy projects.

ui does visual design and layout. Follows a Neo-Brutalism design system we defined. Thinks in components, spacing, and hierarchy.

qa-debug-engineer reviews code, hunts bugs, writes tests. Gets triggered after implementation is done. Can run in parallel with other work.

devops-engineer handles CI/CD, Docker, deployment, and infrastructure decisions. The one who makes sure things actually run in production.

How they coordinate

The typical flow for a new feature: technical-pm specs it, solution-architect designs it, python-react-coder builds it, qa-debug-engineer reviews it.

For a landing page: market-research-analyst feeds into startup-cmo who feeds into technical-pm who hands specs to the coding team.

The solution-architect validates everything architectural. Nothing gets built without a design review.

This is not some orchestration framework. There is no agent-to-agent communication protocol. I am the orchestrator. I decide which agent to engage, I pass context between them, I make the final calls. The system works because the prompts are specific enough that each agent stays in its lane.

The memory layer

This is the part that changed everything.

The VPS runs PostgreSQL with pgvector. A custom MCP server exposes five tools to Claude Code:

• recall : hybrid vector + full-text search across all stored memories
• remember : store a new memory with category, tags, and importance score (1-10)
• forget : soft-delete a memory by ID
• list_memories : browse recent memories, optionally filtered by category
• memory_stats : get counts by category

Categories are simple: decision, fact, preference, project, person, technical, general.

The practical effect: my coaching agent remembers career goals from months ago. My finance agent remembers budget constraints. My project agents remember the architectural decisions we already made and why we made them.

Without memory, every session starts from zero. With memory, sessions build on each other. That is the difference between using AI as a tool and using it as a team member with institutional knowledge.

The memory system is not perfect. Retrieval quality depends on how well I tagged things. Sometimes irrelevant memories surface. Sometimes important ones do not. But even imperfect memory beats no memory by a wide margin.

The modes

I have different “modes” activated by keywords. Each mode loads specific context files and system prompts, then the session follows that behavior.

Coach mode is the one I use most outside of coding. Business strategy, personal life management, goal setting. It uses a TCC (cognitive behavioral) framework. Because of the memory layer, it remembers decisions and commitments from previous sessions. It holds me accountable.

Learning mode is the one that surprised me. More on that below.

Then project-specific modes for each active project. Each one loads the project’s README, agent structure, and context files. Switching modes is like switching which team member I am talking to. Same underlying model. Completely different conversation.

Learning mode

This deserves its own section because it changed how I study.

Learning mode turns Claude Code into a personal tutor. It adapts to my existing knowledge. Concise, concrete, example-driven. If I already know something, it skips ahead. If I am confused, it tries a different angle rather than repeating the same explanation.

The key feature: it generates Jupyter notebooks in Andrew Ng’s style. Theory section explaining the concept, then coding exercises with # YOUR CODE HERE placeholders, then assert tests to verify my answers. I learn by implementing, not by reading.

I have three active learning tracks right now: neural networks to LoRA implementation (understanding the math, then building it from scratch), GCP cloud architecture, and Python manual reps (solving problems without copilot, building back the muscle memory).

The memory system tracks progress across sessions. When I start a new learning session, the tutor knows where I left off, what I struggled with, and what I already understand. It picks up where we stopped. No re-explaining.

This is the mode I did not expect to use as much as I do. It turns out that a tutor who knows your background, adapts to your pace, and generates hands-on exercises on demand is genuinely useful. Not as a replacement for courses or books. As a complement that fills the gaps between them.

What is next

The system works. But it is missing something.

I want agents that can self-evaluate. The idea: a skill (slash command in Claude Code) that lets an agent review its own accumulated outcomes. Did the specs I wrote lead to clean implementations? Did the architectures I designed survive contact with reality? Did my landing page copy convert?

Based on that evaluation, the agent would suggest improvements to its own system prompt. A feedback loop. Auto-improve.

I have not built this yet. The skills system is still being designed. The hard part is making it reliable. An agent that confidently makes itself worse is more dangerous than one that stays static.

But the direction is clear. The system should get better at its job over time without me manually rewriting prompts every few weeks.

The honest version

This is not a polished product. It is a personal setup that grew organically over months of daily use. Some agents are battle-tested. Some I wrote last week and have barely used. The memory system has rough edges. The mode switching is just keyword matching and file loading.

But it works. I ship features faster. I make fewer architectural mistakes. I have context that persists across sessions and projects. And the whole thing runs on a box that costs less than a coffee.

That is the point. You do not need a platform. You do not need a framework. You need a VPS, good system prompts, and a memory layer. The rest is iteration.