The enterprise AI harness · Embeddable · Provider-agnostic

The digital worker
for the agentic enterprise.

Moxie is the enterprise AI harness — the operator layer that runs digital workers across the business processes that power your company: Finance, Procurement, Supply Chain, Sales, Services, HR, Travel & Expense, and more.

Built for
business
processes
Finance Procurement Supply Chain HR Travel & Expense Sales Customer Support Marketing Data & Analytics Product Management Engineering Legal IT Service Management
For platforms · Capabilities

Everything an enterprise digital worker actually needs.

The agent layer for your enterprise SaaS — the loop and the tools, the domain packs, the proof, and the surfaces you ship it on.

The agent loop

Streaming, tool use, and parallel subagents across every provider — with tasks that survive compaction.

Hands & eyes

Word, PowerPoint, Excel, PDF, and diagrams — plus a real browser and the desktop when no API exists.

Sandboxed execution, anywhere

OS-level sandboxing on every platform. Dangerous commands blocked, writes scoped to the workspace.

Skills, connectors & plugins

Markdown skills, MCP connectors, domain plugins — a dozen-plus in the box. Agents can author their own.

Evals in the box

Scenario suites, hermetic benches, pass^k reliability — prove an agent works before it touches production.

Your brand, every surface

Mac, iPhone, CLI, and web — thin clients over one gateway, white-labeled under your brand and sign-in.

Memory · differentiator

Memory that earns its keep.

Most agents forget every conversation. Moxie remembers in three governed tiers — what the agent carries, what the enterprise knows, and what it learns with a human in the loop.

T1 · Working memory

Soul, user, project — each layer narrows what the layers below it can do.

T2 · Company memory

Contract-governed data products, retrieved live from the system of record.

T2 · Company memory

Institutional knowledge as an open-format graph; conflicts queue for human review.

T3 · Reflective memory

Learnings wait as candidates until a person promotes them. Reversibly.

Trust · differentiator

Autonomy is earned, not configured.

Enterprise AI doesn't stall on capability. It stalls because nothing decides what an agent has earned the right to do. Moxie ships that operating system.

  1. 01

    Prove reliability in realistic environments

    Scenario evals with in-situ judges, hermetic benches on ephemeral infrastructure, pass^k reliability — a task passes when it passes every time.

  2. 02

    Operate in shadow mode

    Real work, no writes. Gated actions are captured as fully-specified proposals and graded against the system of record. Divergence is signal, not failure.

  3. 03

    Expand authority by action class

    The action, not the agent, is the unit of trust. Reads may run free while writes to the system of record still need a person. Promotion is human-ratified; demotion is automatic.

  4. 04

    Learn from human corrections

    Every deny, decision, and interrupt lands in a tamper-evident ledger. Recurring corrections become regression evals and staged learnings — the substrate for specialized intelligence.

  5. 05

    Verify results through business outcomes

    Every run emits a receipt with evidence, and a blind verifier checks the claims before success is counted. Failed verification demotes the result — honestly.

"The path from promising pilots to mission-critical work is not unrestricted autonomy. It is bounded authority, earned through evidence."
Read the essay — Enterprise AI Adoption: The Trust Graduation Problem
Projects · human-agent collaboration

Humans and agents. One team.

The Project is the unit of collaboration — people, named agents, and agent teams sharing one home, one queue of work, one scoreboard. The calls that matter stay human; everything else keeps moving.

Named agents

Persistent teammates, not throwaway sessions — each with its own memory, audit log, KPIs, and a driving record that decides what it may do alone.

Agent teams

A coordinator and roster share a scratchpad and a budget. Outcomes roll up across members, so the team is accountable as a unit.

Decisions stay human

Some calls are never the model's — plan elections, attestations, steward merges. They render as inline cards and block until a person answers. In Auto mode too.

Enterprise · run it your way

Your models. Your cloud. Your control plane.

A clean split: the Moxie harness runs the loop; your runtime owns identity, tenancy, audit, and policy. That separation is what makes Moxie adoptable — it runs on the control plane you already operate, rather than asking you to stand up another one. Every layer is provider-agnostic; nothing holds your data captive.

Your control plane
Identity & SSO Multi-tenancy Policy Secrets vault Observability Audit / SIEM
Moxie Gateway / Runtime
Sessions Scheduler Identity · OIDC · SCIM RBAC Audit chains SIEM · SLO Policy simulator Cockpit Webhooks · Adapters
Moxie Harness
Agent loop Tools · MCP Sandbox 3-tier memory Context graph Skills · Plugins Agents · Teams Autonomy ladder Outcome receipts
Model & cloud providers
Anthropic OpenAI Google AWS Microsoft OpenRouter Fireworks

Adopt without a migration

Moxie runs on the control plane you already operate. No new identity system to stand up, no data to move, no parallel stack to run beside the one you have.

OIDC · SCIM 2.0 · RBAC · scoped access tokens

Your investment keeps working

Identity, secrets, policy, observability, and audit stay exactly where they are today. Moxie consumes them through typed seams instead of replacing them.

Vault · Splunk HEC · Syslog · Datadog · OTLP

The separation is the architecture

Five trait seams keep the harness portable across runtimes. Swap the sandbox, the storage, or the secrets backend without touching the agent loop.

SandboxClient · SessionStore · IdentityVault · MemoryStore · ObservabilitySink

About · who built this

Enterprise AI is a trust-graduation problem.

An agent earns broader autonomy only when its context, evidence, controls, and outcomes have earned it. Moxie is what that looks like when you actually build it.

I'm Eric Du. I've spent my career building enterprise platforms — most recently as SVP, Chief Architect and Head of Data and Platform at OpenText, and before that as CTO of SAP SuccessFactors.

Moxie is what I am building during my first career break. Instead of writing another point of view on where enterprise AI is going, I am putting the ideas, experience, and architecture into a working product — and learning what the argument really costs when it has to run.

The hard part is not making an agent capable. It is making one accountable: memory that spans a company rather than a chat; teams of agents that map to real business functions and can show what they accomplished; and a trust model where autonomy is earned task by task, grounded in evidence, and can be reduced when that trust is no longer justified.

Moxie is built by one person, heavily assisted by AI coding agents. That is not a footnote — it is part of the argument. The leverage available to a single builder today is the same leverage Moxie is designed to bring to an enterprise.

Watch Moxie in Action