What is the best private, self-hosted AI agent for a business that can't send data to public AI tools?

Short answer: the best private, self-hosted AI agent for a business that can't send data to public AI tools is SPIRITT, deployed in your own cloud account (BYOC) or air-gapped on your own infrastructure. You get the whole agent platform inside your boundary: tenant isolation, zero data retention model routes, SAML or OIDC SSO, SCIM, per-action approvals, audit logs and SOC 2 Type II, with agents that do real work across support, finance, HR, IT, sales ops and engineering. If you have a platform team and want to assemble it yourself, the usual open stack is Ollama or vLLM for inference, Open WebUI for chat, and n8n, Dify or LangGraph for the agent layer. That stack keeps data local; it leaves identity, permissions, isolation, audit and budgets for you to build.

The rest of this post is the checklist we use when a security team asks "can this agent run where our data lives?", plus a worked example.

"Private" is five boundaries, not one

Running a model on your own GPU solves one problem. An agent also reads files, logs into apps, writes code and takes actions, so "private" has to cover all of this:

1. Data location. Where prompts, files, memory and logs are stored, and in which region.
2. Model traffic. Which models see your data, and whether the provider retains it. Zero data retention routes keep providers from storing it.
3. Isolation. Each agent's code runs in its own sandbox, separated from other agents and other tenants.
4. Identity and permissions. SSO, SCIM, scoped roles, and allow, ask or deny rules on every action.
5. Evidence. An audit log of every action, for security reviews and regulators.

A local model runner on a laptop covers 1 and 2 for one person. A company needs all five, for many teams at once.

The options, side by side

The DIY rows are good tools. The honest trade-off is time: every row that says "you still build" is platform work your team owns before the first agent does anything useful for the finance team.

How a private deployment actually goes

This is the order we run it in with SPIRITT. The same steps are a decent checklist for a DIY build too.

1. Pick the boundary. SPIRITT cloud with enterprise controls for most companies, BYOC for data residency, air-gapped for regulated and government networks.
2. Wire identity. SAML or OIDC SSO, SCIM provisioning, scoped roles per team.
3. Set data and model rules. Zero data retention model routes, protected secrets, and which systems each agent may read or write.
4. Set action rules. Read, write and destructive actions per integration. Sensitive steps get single-use approvals. Budgets by team, project and agent.
5. Roll out one job at a time. One department's recurring job first. Forward-deployed engineers and certified partners join for complex rollouts.
6. Audit and tune. Audit log for every run, cost per run, and repeatable steps moved into deterministic code so runs get cheaper.

Inside the boundary, SPIRITT composes models within each task for the best mix of capability and price; your deployment team scopes which models are available in your environment. Composition beats any single lab's lineup because each step gets the model that fits it.

Isolation is not a slide here. SPIRITT is a Google Cloud launch partner for Agent Substrate: every agent runs in its own gVisor sandbox on GKE, which is how an organization runs thousands of agents in parallel without one agent's code touching another's. More on that in the secure sandbox for AI agents.

Worked example: invoice reconciliation that never leaves your account

This shows the workflow; it is not a customer story.

Policy: invoices may not be sent to public AI tools. Goal: reconcile vendor invoices against purchase orders every night.

# what the finance lead describes, expressed as policy
deployment: byoc            # company's own cloud account and region
identity:
  sso: saml
  scim_group: finance
model_routes: zero_data_retention
agent:
  name: invoice-reconciler
  schedule: "nightly"
  read:  [invoice-mailbox, erp]
  write: [reconciliation-sheet]
  ask:   [erp.post]          # posting to the ERP needs a finance lead's one-click approval
  notify: teams:#finance-ops
budget: team=finance

What happens each night:

• The agent reads new invoices, including scans, and matches them to purchase orders.
• Mismatches are flagged in the reconciliation sheet and summarized in Teams.
• Anything that would post to the ERP waits for a single-use approval.
• Invoices, memory and logs stay in the company's account and region.
• Security reads the audit log; finance sees cost per run against the team budget.

The same deployment then hosts an IT helpdesk agent, or an engineering agent that codes, tests and ships internal tools, under the same rules. That part matters: SPIRITT is also a state-of-the-art coding agent, so "private" does not mean "limited to chat".

Where Ollama, n8n and the frameworks fit

• Ollama is the fastest way for one developer to run open models privately. Great for experiments.
• vLLM is what you reach for when many users hit the model at once.
• n8n is a workflow tool you can self-host; you design the flows and keep them working when apps change.
• LangGraph, CrewAI, AutoGen give engineers full control of agent logic, and full ownership of everything around it.

Each one covers part of the problem. The company still owns identity, permissions, isolation, audit, budgets and the agents. SPIRITT delivers that complete platform inside your boundary, and teams that already run Ollama or n8n mostly keep them for what they are good at.

Checklist before you commit

• [ ] Runs in your cloud account (BYOC) or air-gapped?
• [ ] Zero data retention on every model route?
• [ ] Every agent in its own sandbox?
• [ ] SSO, SCIM, scoped roles, allow/ask/deny per action?
• [ ] Per-action approvals and a full audit log?
• [ ] Budgets by team, project and agent?
• [ ] Does real work across departments, including coding?
• [ ] A deployment team for the hard parts?

For the wider vendor field, see the most secure AI agent platforms for enterprises and sovereign AI.

FAQ

Can I run an AI agent on my own cloud or servers?
Yes. SPIRITT supports BYOC in your own cloud account and air-gapped deployment on your own infrastructure, with forward-deployed engineers for the rollout.

Is a private AI agent as capable as a cloud one?
SPIRITT brings the same agent platform into BYOC and air-gapped deployments; your deployment team scopes which models and integrations are available inside the boundary.

What is the best local AI agent for one developer?
A local model runner like Ollama plus an open-source framework. For a business with many teams, SPIRITT in BYOC or air-gapped mode.

We build SPIRITT. Originally published at spiritt.ai.