The Machineforce runs AI agents with accountability built in: each one has a role, someone it answers to, and limits it can’t go past.
The front door. One sign-in for every Machineforce app, and it puts each person where they belong: their own Machineforce, their organization’s, or both.
A first sign-in is a first day: it sets the person up before it lets them in.
Where AI agents are run. Every agent has a role, someone it answers to, and limits it can’t go past. Operators approve what needs approving, and agents learn on the job from the corrections they get.
When it matters, Control hands the decision to the lab’s own chip*, so the limits hold even if the software around it doesn’t. Everywhere else, Control enforces the same rules in software.
People sign in once, through Launch, and land in the right workspace: their own, their organization’s, or both.
Control is where the rules live: who each agent answers to, what it may do, what needs a yes first, what it has learned, and the record of everything it did.
Agents do the work in the tools and data they were given. When the stakes are high, the lab’s own chip sits on the path.
Every action an agent proposes is checked against three things: is this its job, is it within its limits, and does it need someone to say yes first.
The answer is one of three: it goes ahead, it waits for the boss, or it is refused with a reason the operator can read.
Whatever the answer, it is recorded.
Agents get better the way new staff do: by being corrected. An operator marks a reply right, wrong or “adjust”, and one tap turns a correction into a proposed rule.
The agent’s boss signs it off or sends it back. Approved rules become steps in the agent’s procedure, and the agent cites them by name next time.
No retraining. Every rule shows why it exists, whether it is working, and what changed.
Authority is something a person gives, so a person can take it away. When a boss revokes an agent’s authority in Control, its next action is refused — 203 ms later, measured on the live system.
It works the other way too: an agent that claims authority it was never given is halted anyway. What counts is the role Control gave it.
Control keeps the facts needed to answer “who let this happen, and why?” — for every decision, every approval, every learned rule and every sign-in.
Decisions that matter go to a ledger where each entry is linked to the one before it, so a record can’t be quietly changed after the fact.
What Control records is about the work agents do and who authorized it. How it is stored is shared under NDA.
The same rules can run in three places. In software, inside Control, they protect people and today’s systems from agents that overstep, and that is how the Machineforce runs in production.
But software trusts the machine it runs on. If that machine is compromised, the limits go with it. So the checker should never run on the hardware it is checking: on its own box with no AI on it, or as a chip.
That is what autonomous robots, drones and vehicles need, because a wrong action moves something. The CEU on its own box runs on the bench today, on an FPGA board; the chip is a design.*
For the actions that matter most, Control turns an agent’s role and limits into a signed permission, and the lab’s CEU chip* makes the call.
An allowed action comes back with the chip’s own signed receipt, which goes into Control’s record. A refused one stays refused, even if the software around the chip fails.
On a bench board today: Control’s own software asked the chip directly, and every answer matched.
Launch and Control are in production. Learning on the job and each operator’s own workspace are rolling out, and the hardware link is on the bench.
What an agent must never do, written down before it is built.
Every rule backed by tests, including the refusals.
Our own release pipeline checks each build before it goes live.
The same checks, run against the live system. This is where Control is now.
The decisions that matter, made by the chip. On the bench today.
From going live, through the tests that matter, to the chip. Filter by part, and sort newest or oldest first; each part’s lane grows toward its newest milestone.
What it means for you: The corrections you give an agent become rules your manager can approve, and the agent follows them from then on.
What it means for you: You start each day in your own workspace, with a daily paper tuned to you.
What it means for you: For high-stakes actions, a hardware check stands behind the software, and it fails safe.
What it means for you: You teach an agent the way you’d teach a new hire, by correcting it once, instead of waiting for it to be retrained.
What it means for you: If an agent needs to stop, it stops on its very next action, not after a sync or a restart.
What it means for you: The limits you set in Control are the ones the hardware enforces.
What it means for you: Adding a rule can only make an agent safer; no rule can accidentally give it more power.
What it means for you: One sign-in takes you to every Machineforce app and the right workspace.
Results in plain language are on Findings; the chip is on Silicon.
* The CEU and MPU are designs. They run today as FPGA prototypes and have not been fabricated. Machineforce Control enforces the same rules in software today.
The Machineforce is in use with early customers. To see it or try it, visit machineforce.one or contact the lab. How it is built is shared under NDA.