Intake
Ideas arrive as plain language, by a file or a chat command. Each becomes a goal with a stated "done when", reviewed by a person before it is active.
In Development
Artemis
An estate that builds what you ask it to.
Direction is human. Labour is machine. Nothing counts until a machine can check it.
Artemis is a long-running project to turn a small, self-hosted computing estate into a self-directing engineering team. You describe an outcome in a sentence. Artemis works out who should act, what to change, where it lives and why it matters, then plans the work, carries it out on its own hardware with its own models, proves the result, and tells you what it did and why.
Humans set direction and approve the few things that deserve a human decision. The machine does the labour. This page is the top-down view; it leaves out the operating details on purpose.
What it is for
Not a script. Not a chat. A loop that never stops.
Most automation runs a fixed script. Most "AI agents" run one conversation and forget it. Artemis is neither. It reads the goals it has been given, breaks them into tasks, assigns each task to the cheapest worker that can do it, checks the work mechanically before anyone sees it, lands it, measures what happened, and feeds the lesson back into the next round. Over time it should need the humans less, not because it hides its work, but because its record of being right grows.
-
Direction is human; labour is machine.
People decide what to pursue and sign the rules the system runs under. The system does not activate its own goals or widen its own permissions.
-
Nothing counts until a machine can check it.
A change is done when a test goes green that was first proven to go red. Where no mechanical check exists yet, the system asks rather than guesses, and the ceiling rises only when a new check is built.
-
Sovereign by default.
The models that do the work run on hardware we own. Confidential material never leaves the premises and never touches a third-party model. A separate, sealed lane exists for work under contract, and it does not open until a rehearsal proves it cannot leak.
How it is put together
A nervous system with named regions.
Each is a real component with a job, and each is small enough to understand on its own.
Planning
A planner reads active goals and the current state of each project, selects the next milestone, and writes small, verifiable tasks with explicit success criteria.
Execution tiers
Work is routed to the least expensive capable worker first: local open-weight models on our own GPUs for most tasks, stronger models only when a task has failed locally and only within a budget.
Review gate
Every task specification is read by a reviewer that can approve, fix, or refuse. Refusal exists for one question only: should this run at all.
Verification
Each task carries a mechanical check. If it does not pass in a clean environment, the task is not done.
Landing
Passing work is merged under rules that depend on how much damage a mistake in that project could do. Low-risk projects land automatically and report afterwards; high-risk ones ask first.
Measurement
Every attempt, pass, retry and escalation is recorded, so the system can tell which tiers earn their keep and where its own estimates are wrong.
Learning and memory
Outcomes become lessons; lessons become changes to the rules and the prompts; the map of the estate regenerates itself so the planner is never working from a stale picture.
Compute pool
The system decides which model runs on which cards for which task, leasing and releasing capacity rather than pinning one model to one card forever.
Human channel
Alerts, approvals, digests and questions flow through one chat server with a small set of commands. Decisions that need two people need two presses. Messages carry names, identifiers and links, never the work itself.
Boundary
What may leave the network is declared and proven, not assumed. The sealed lane for contract work has its own storage, its own models and no route out.
Where it stands
The foundation is in place and running.
- The human channel is live, with two-person approval proven end to end on real requests.
- The free, local execution tier is in service on a stable model alias, so the cost of most work is electricity.
- The review gate is live and has demonstrated a refusal on a planted unsafe task.
- A health check watches the pieces that have broken before and reports once, not hourly.
- The first fourteen operating rules are written down, signed by both operators, and version-controlled; the system reads them, it does not merely remember them.
- A confidentiality class for client material is signed into the data charter, with the handling rules that make the sealed lane meaningful. Building that lane is the current work.
What comes next, in order
- 1
Finish the sealed lane
And its leak rehearsal.
- 2
Connect intake
So an idea typed in chat becomes a reviewed goal without a human relaying it.
- 3
Close the loop
From measurement to learning, so lessons change behaviour without a person editing a prompt.
- 4
Widen the autonomy ceiling
One proven check at a time.
Why build it this way
The usual failure of autonomous systems is not that they do too little. It is that they do the wrong thing confidently, and nobody can tell afterwards why. Artemis is built around the opposite bet: every action leaves a record a person can audit, every rule it follows was written by a person and can be read, and every increase in its freedom is paid for with a new way to prove it right.
Slower to start. Far easier to trust.
Following the work
Progress notes will appear on this page as milestones land. The project is private while it is being built; the ideas are not, and we are glad to talk about them.
[email protected]