One kernel. Four shared services. No integration layer.
The difference between a suite and an operating system is not the number of products. It is whether the products share a data model or share a login screen. This page states the difference structurally, so you can check it rather than believe it.
Argos Kernel · identity & tenancy · the client graph · the event spine · the audit spine · internal-only, no public ingress
A suite is twelve products that share a login screen. An operating system is twelve products that share a data model.
Everything else on this page is an elaboration of that one sentence. A suite assembled by acquisition has to build an integration layer, because each product arrived with its own idea of what a client is, its own tenancy rules, its own audit table and its own definition of “done.” The integration layer is where the money goes, where the outages come from, and where your data quietly forks into seven versions that disagree with each other by Thursday.
Argos does not have an integration layer, because there is nothing to integrate. Every product is a citizen of one kernel. It does not own a client record — it reads the client record. It does not keep an audit table — it writes to the audit spine. It does not poll a peer for changes — it subscribes to the spine. Four things are solved once, in one place, and every product inherits the answer.
The kernel itself is not a product you log into. It has no public ingress, no console, nothing to sell. It is the part of the platform a customer never sees and every product depends on — which is exactly why it is the first thing we document.
Identity & Tenancy — isolation enforced once, not twenty-seven times.
The most expensive bug in multi-tenant software is a product that got tenancy nearly right. Nearly right means one endpoint, in one product, on one bad afternoon, returns another MSP’s client. The way you avoid that is not vigilance. It is not writing the check twenty-seven times.
A tenant is defined in the kernel and nowhere else. Every citizen resolves the caller’s identity and tenancy from the kernel before it touches a row, and isolation is enforced twice on the way down: scoped in the application layer, then again by row-level security in the database, so a query that forgets its tenant filter returns nothing rather than returning something interesting.
Service accounts are least-privilege and scoped per citizen. A product that only needs to read the client graph is issued a token that can only read the client graph. There is no platform-wide key, because a platform-wide key is a single interesting file on a single interesting server.
You get one tenant model across the whole platform, so “this technician can see this client’s tickets but not their compliance evidence” is one decision, made in one place, that every product obeys — instead of a permissions matrix you have to reconstruct separately in each vendor’s admin panel and re-verify every time one of them ships an update.
When you white-label Argos, your clients live inside your tenant. Your brand, your domain, your relationship. We are the substrate, not the party your client thinks they bought from.
The Client Graph — the same client lives once, not seven times.
Open your current stack and count how many places store “Northside Dental.” The PSA has it. The RMM has it. The documentation tool has it. The backup console, the security portal, the QBR deck generator and the spreadsheet somebody keeps because none of the others agree. Seven records, seven spellings, seven sync jobs, and a permanent low-grade argument about which one is right.
The kernel owns four canonical entities — Client, Contact, Asset, User — and every citizen resolves against them. A ticket does not store a client name; it holds a reference to the client. A compliance control does not store an asset inventory; it reads the asset graph. Change the client’s legal name once and it is correct everywhere, immediately, because there was only ever one copy to change.
External systems attach through platform links rather than duplication: the NinjaRMM device, the directory user, the accounting customer and the Argos client are the same node wearing different identifiers, not four records pretending to be friends.
Reporting stops being reconciliation. When your QBR pulls ticket volume, patch status, posture score and control coverage for one client, all four numbers are keyed to the same node — so the report is a read, not a merge, and nobody has to explain to your client why two of your dashboards disagree about how many endpoints they have.
Onboarding a client is one act. Offboarding is one act. There is no eight-system checklist where the item everyone forgets is the one that leaves a former employee holding live access for a year.
Our real ticket number is higher. We ran on SyncroMSP and Freshdesk before this, and that history didn’t come with us when we left. We can’t prove it, so we don’t count it. That’s why Argos exports everything, any day, at no cost — we’ve been the customer holding the empty box. A shared client graph is worth very little if you can’t take it with you, so you can.
The Event Spine — a write and its announcement commit together, or not at all.
Every integrated stack you have ever used has the same silent failure: the record saved, the webhook didn’t fire, and nothing anywhere is wrong enough to alert on. The ticket exists and the alert never landed. The endpoint was isolated and the compliance log never heard about it. You find out weeks later, in an audit, from an absence.
The spine is a transactional outbox. When a citizen writes a row, it writes the event describing that row inside the same database transaction. Either both land or neither does — there is no window in which the data exists and the announcement was lost. A publisher then drains the outbox to the bus and marks each event delivered.
If the bus is down, nothing is dropped; the outbox simply grows until the bus returns, then drains. If a subscriber is down, it resumes from where it stopped. Delivery is at-least-once and consumers are idempotent, because “exactly once” is a thing people say in architecture diagrams and not a thing distributed systems do.
Cross-product behavior becomes something you can rely on rather than something you re-test after every vendor release. A detection firing in Argos Red opens a ticket in Argos Service with the evidence already attached, records the action in GRC, and updates the asset in the client graph — because all four are reacting to the same event, not to four separate webhooks with four separate retry policies and four separate ways of failing quietly.
And the count is checkable. The number below is not “uptime.” It is emitted events versus events that reached the bus, which is the only version of that statistic that means anything.
The Audit Spine — a log we are not permitted to edit either.
Most audit logs are a table. A table can be updated. Which means the honest description of most audit logs is: a record of what happened, unless somebody with database access preferred a different version. That is not an accusation about any vendor. It is a description of how the storage works, and it applies to us too unless we do something about it.
Every consequential action across the platform is written as a hash-chained record: each entry commits to the one before it, so altering any historical row breaks every hash after it. That makes tampering detectable rather than merely discouraged.
Detectable is not enough on its own, so the database enforces it. Three triggers refuse UPDATE and DELETE on the audit log, and the application role holds INSERT and SELECT only — a live UPDATE returns “ERROR: audit_log is append-only”•. The application cannot rewrite history because the application was never granted the ability to.
Then the chain head leaves our custody entirely. It is anchored into the public Bitcoin blockchain, which means the timestamp is attested by a ledger we do not run, cannot edit, and could not quietly re-mine if we wanted to.
When a client’s auditor, insurer or attorney asks who approved a change, who signed a document, or when an access grant was revoked, the answer is not our screenshot of our dashboard. It is a hash chain whose head was published in a block a stranger can look up without asking us for anything.
This is the mechanism the rest of this company is built on. It is why we can publish a claim ledger and a list of what isn’t finished instead of a logo wall: we get stronger under audit rather than weaker, so we invite it.
# connect as the application role and attempt to rewrite one row argos=> UPDATE audit_log SET actor = 'somebody else' WHERE id = 1; ERROR: audit_log is append-only argos=> DELETE FROM audit_log WHERE id = 1; ERROR: audit_log is append-only # the only permitted verbs, verified against the chain argos=> SELECT verify_chain(); verify_chain -------------- intact
A ticket can carry a threat finding, a compliance control and a signed contract — because there is no seam between them to maintain.
That sentence is the whole return on the architecture, and it is worth being concrete about. In a bolted-together stack, each of those three attachments is a separate integration with a separate owner, a separate token, a separate rate limit and a separate day on which it breaks. In Argos they are three references to three nodes on one graph, inside one tenant, recorded on one audit chain. The work of connecting them is not cheaper. It does not exist.
One honest caveat, because this page would be worth less without it: the containment step at the end of that story — the part where a compromised endpoint is cut off the network — is built and dry-run verified, and it is not production-proven•. It also takes two human approvals• before the control plane will sign the command. It stays on the unfinished list until a real endpoint has survived it. The kernel plumbing underneath it is live either way.
The private AI gateway — policy-routed per tenant and per workload.
Every product in this category has bolted AI onto its interface. Almost none of them can tell you, per client, which model saw which data and under whose authority. That is a governance question, not a feature question, so it belongs in the kernel rather than in twenty-seven separate settings pages.
No citizen talks to a model directly. Every AI call routes through one gateway that resolves the tenant, the workload and the governing policy before a single token moves. Your CISO decides which model tier each workload is permitted to use — a ticket summarizer and a security-triage reasoner do not have to be given the same latitude — and that decision is enforced centrally rather than trusted to whoever configured each product.
Prompts are never stored. Only SHA-256 hashes of them are written to the audit spine, which means you can prove afterwards that a given prompt was the one that ran, without the content of that prompt sitting in a log waiting to become somebody’s breach.
You can answer the two questions a regulated client will eventually ask — which AI touched our data, and who authorized it? — with a policy record and an audit entry rather than a shrug and a vendor’s trust page. Tighten a tenant’s policy and it applies everywhere at once, retroactively enforced by the gateway rather than by twenty-seven independent toggles you have to remember to find.
If a client wants AI off entirely for their tenant, that is one policy, in one place, and no citizen can route around it.
We host it. Which means we had to earn the right to.
Argos is hosted by Intelligent Automation. There are two shapes: the standard platform, hosted and fully white-labeled as yours, and Argos Sovereign — a dedicated, isolated instance of the whole operating system, running in our datacenter for one organization and nobody else. Both are ours to operate, which puts the burden of proof on us rather than on your incident-response plan.
So we run our own substrate. We self-host our identity provider, our source control — 84• repositories — our secrets management and our timestamping. Not as a philosophy. Because a company asking you to trust its kernel should not itself be one third-party outage away from losing the ability to ship a fix.
our own substrateAnd the number that governs how you should read every other number on this page: we have zero• Argos OS customers today. Everything described here is running against the MSP we operate ourselves, continuously, since 2013•. That is a real environment with real clients who notice when something breaks — and it is not fleet scale, so we tag every figure with the environment that produced it instead of letting you assume a larger one.
Every number on this page has a scope, a source, and somewhere to verify it.
The claim ledger lists all of them — what we assert, whose environment produced it, and a third-party link wherever a stranger can check it without asking us anything. Read it next to what isn’t finished and you have the entire company on two pages.
Own your stack. Make it talk to itself.