At the time of writing, Artie is a team of 17. Every one of us works alongside Hermes, an open-source AI agent harness from @NousResearch. It runs on a single physical machine in Germany, has a different personality for each team, and dreams at night.
This is how it got that way.

It started as one engineer's WhatsApp contact

A few months ago, one of our engineers (Ani, @anirudhsriramzz) was running Hermes for himself. Just a personal setup, and he talked to it over WhatsApp.
Around the same time, Robin, our CTO, came back from a hackathon where a friend had shown him a whole roster of agents running their work. The question he brought back was simple: how do we make that available to everyone at Artie, and not only the engineers?
We looked at OpenClaw first. It's good. But it was easy to watch an agent wander off and do something nobody asked for, and we wanted guardrails before we wanted scale. So we picked Hermes and started thinking about what the guardrails should be.

A brain with blinders

The way we think about it: every lab has shipped a brain. You can ask it anything and it will answer. Ask it the same thing five times and you'll get five answers, all plausible, all shaped differently.
That's fine for a chat window. It's a problem when you want the brain to do a job. If a sales engineer asks for a risk read on 25 open customer threads, they need the same format every time so they can act on it, compare weeks, and trust the thing.
Racehorses wear blinders so they run the track instead of looking at the crowd. Skills and tools are the blinders. The harness is how you strap them on. Hermes, Codex, Claude Code and the rest are all versions of the same idea: a way to decide what the model is allowed to do and how its output should look.
Once we thought of it that way, the project stopped being 'set up a chatbot' and became 'build the blinders for each job at Artie.'

A $60 server in Germany runs all of it

Robin and Ani set up the first Hermes in about three hours one weekend. We rented the cheapest plan on Railway, booted Hermes with one default profile, and let the engineering team at it.
Within five days we were hitting Railway's usage limits over and over. Every alert was a prompt to upgrade. That was the first real lesson: the moment a team actually adopts an agent, the bill stops looking like a side project.
Our production infrastructure runs on AWS and stays there. But this was an internal sandbox for agents, not customer infrastructure, and we wanted to see how cheap we could make it. We found Hetzner (@Hetzner_Online), a German hosting company, and bought a physical machine for $60 a year. Every Hermes at Artie runs on that box today.
We're a scrappy company. The whole question of AI at Artie has been: how do we make the team as AI-native as possible without setting money on fire? The Hetzner box was the first answer.

What we actually wanted

With a machine that could take the load, we sat down and decided what Hermes was for. Two goals.
Everyone gets a sidekick. Engineers, sales, ops, marketing, design. A junior version of yourself that helps you do more, rather than a thing that replaces you. The fear in the industry is that agents take the job. Our experience is the opposite: when everyone has one, everyone ships faster and takes on work they couldn't before.
A human is always in the loop. Hermes can do whatever it's instructed to do. Before anything lands in production, in the docs, or in front of a customer, a person reviews it.

People spike, so agents should too

Nobody on a team of 17 is good at only one thing. But everyone spikes somewhere. We hire for the spike.
So we asked why our agents should be any different. A junior engineer working on marketing copy is a waste. A junior marketer in the codebase is worse. We modeled the agents the way we think about people: give each one a domain, a personality, and access to the things that domain needs.
That gave us a family of Hermes profiles, one per team.
Hermes Plan and Hermes Code belong to engineering. Plan is for the tech lead: figure out whether we do A then B, or A and B in parallel and C later, and write it down. Plan dispatches the work to a Kanban board. Code picks up the tickets and executes in the background against our existing codebase, opens PRs, and waits. A human reviews the PR, and only then does it merge to master. One task finishing kicks off the next one in the plan.
The side effect nobody predicted: most of engineering's time is now spent on the plan. Historically people lived in the code and the execution. Now they live in the system design and the review, and Hermes Code handles the middle.
Hermes Sales preps before a discovery call. It researches the prospect, figures out their existing stack, and pulls current context on the deal. Because it also has our docs and our engineering knowledge, it can go a step further: if a prospect tells us they're moving data with a particular tool, Hermes can tell the rep where that tool tends to break, say on schema drift, before the call even starts.
Hermes Design and Hermes Code together let marketing design, build, and ship landing pages without pulling in an engineer. Our marketing site is on Next.js and we no longer use a CMS. Design works inside the existing component system, checks whether a component already exists before inventing one, and hands off to Code for implementation.
Hermes BizOps handles the recurring operational work: pipeline reviews, reconciliation, tracker updates, finding the exceptions that need a human.
And there's a default profile for everything that doesn't fit.
Most of us talk to these through Slack. Some use Hermes desktop. Either way, the whole thing shifted from reactive to proactive: the agents already have the codebase, the docs, the CRM, and the internet, so they can answer from everywhere instead of waiting to be fed context.

Skills, versioned like code, from day one

The profiles are personalities. Skills are what make them competent.
A skill is a reusable procedure for a real class of work: what to check first, which sources are authoritative, what the output looks like, how to verify it. We wrote our own from the first week and put them in a Git repo. Every Hermes reads from there. When a skill changes, it's a commit, with history, that every profile picks up.
We were deliberate about not writing too many. There are a million ways to make AI work for you and most of the internet will tell you to build a 24/7 factory of autonomous agents. If you had infinite tokens, sure. We don't. An agent flipping through hundreds of skills to decide which one to use burns tokens on the deciding. So we cut everything that wasn't obviously worth its cost, and we keep cutting.
The rule we ended up with: if the value is obvious, the cost is justified. If the value is vague, it doesn't get built.

Hermes dreams

Hermes has a cron system. You can give it a task and a cadence and it runs on its own.
Inspired by Anthropic's work on agent memory, we used it to copy something humans do. During REM sleep, your brain sorts the day. Some things get promoted into long-term memory. Some get dropped. A year where you moved cities and travelled constantly is memorable because nothing repeated.
So every night, when no one is using it, each Hermes dreams. It reviews what it did that day, decides what was useful and what wasn't, promotes the useful parts into memory and demotes the rest. Then it sends our engineer a report. The report says things like: I did this wrong, I did that wrong, I've corrected it, I've stored the correction, and I've forgotten the habit that caused it.
Over weeks, each profile gets more opinionated about what it should and shouldn't be doing for its team. We didn't program the opinions. They came from the dreaming.

Why we run our own harness

People ask why we don't just use Cursor, or Codex, or Claude Code.
We could, and technically we could move the workloads tomorrow. But because we run and operate Hermes ourselves, the model underneath can be anyone's. If one lab raises prices next week, we switch. Our profiles are stable enough now that swapping the model doesn't break them. On a Monday we might be on an Anthropic model; if the pricing moves, we might be on OpenAI by Friday.
The second reason is features. If Cursor doesn't support the authentication you need, or keeps making the same mistake in your codebase, you file a ticket and wait. When Hermes needs something, we build it. Hermes is part of Artie, wired into our systems the way any internal tool is, instead of something we bolted on and hope keeps working.
AI engineering is expensive right now because the token economics haven't settled. One day running this stuff will be close to free. Until then, owning the harness is how we stay in control of the bill.

Where it is today, and what's next

Hermes is maybe 85 to 90 percent of the way there. It does real work every day. The first pass isn't always the best pass.
So we're investing in evals. Every time Hermes gets a question and produces an answer, we want to know what took time, which skills it called, which tools failed and why. We're self-hosting Arize Phoenix, which is open source, so we get this without buying another tool. Traces from Hermes go into Phoenix, and Phoenix tells us: this task called five skills and two tools, this tool took the longest, this one failed, here's why.
Underneath that we run telemetry through Datadog: tokens spent, success rate per task, alerts to on-call if a Hermes goes down or the memory store fills up. Every task runs in a sandbox, and we built our own pruning system that cleans the sandboxes out daily.
The point of all of it is that we no longer have to guess whether a change made Hermes better. We change a skill, we get a report. If it's better, it stays. If it's worse, we revert.
We also wrote documentation into the Hermes server itself: what's in your config, what you're allowed to do, what the data means. Any Hermes can read it. Which means we could spin up a Hermes whose only job is to read the eval data and improve the other profiles.
It's basically Hermes Coach. It coaches Hermes.
Seventeen people, one German server, a family of agents that go to sleep every night and wake up a little sharper. We built it because we're small and wanted to ship like we weren't.