The world is shifting faster than at any point I've worked through. Things that used to take months are getting done in days. This is the story of how I felt that, and why we started building Anie to give the rest of the enterprise the same shot, without it ending in tears.
My path through the shift
It went the same way for most people working close to AI. First the raw LLM. Then a small RAG over our own docs. A search tool. Then MCP, and a handful of internal services the model could talk to. Each layer compounded on the last. The sheer set of gates an intelligence layer opened, with even basic tooling around it, was huge.
The flip side showed up on the same curve. The more capable the agent got, the harder the security and risk problem became. You're now dealing with a near-superintelligent system that, given the chance, will work out every last seam in your environment to reach data or systems it shouldn't.
The moment it clicked
The wow moment for me was OpenClaw. On paper it's a generic AI chat with a strong memory system and the ability to call tools. In practice, once you wire those three things together properly, it can do almost anything.
One message: clone the repo, make this change, follow our coding guidelines, follow our git rules. Done. That was new. What got me though was sending it a screenshot of a Jira ticket and watching it just… do the ticket. A moment later I was building a Jira integration so it could pull tickets on demand, no screenshot required. From that point on the imagination was the limit.
The next thought arrived immediately: how do I get this in the hands of my team?
And then I tried
That's where the wall came up. The things I could do in an experimentation setting, with my own judgement on the line, were not the same as the things I could let an analyst on month two of the job do against a production system. New capabilities create new threat surfaces (prompt injection, tool-chain abuse, data exfiltration via chained calls), and they're harder to spot than the threats most teams have trained for. A junior operator should not be the one wrestling with that on a Tuesday afternoon.
Looking around, the agents already running across orgs didn't have identities of their own. They borrowed one, usually whichever engineer's token was nearest to hand. Which meant the tools they reached (CRM, payroll, ticketing, internal APIs) were scoped to the human, not the agent. In practice the agent had everything that human had. No least-privilege boundary. No per-tool scope. No revocation path that didn't break the human's day.
The audit trail wasn't an audit trail. Logs sat in pieces, in different systems, with no chain of custody. If something went sideways, no one could reconstruct what the agent had actually done in a way they'd defend in front of a regulator. And there was no separation of duties: the same person who wired up an agent could change what it could do, deploy it, and read its logs. In any other production system this would not be allowed.
The security team's default answer was no, and they were right.
What we set out to build
I wanted to give enterprise users this power, without compromising security, governance, or audit. I didn't want to be tied to one model provider. I wanted a platform that just works. So we started building it. The tool we wanted to use ourselves.
Anie sits between your people, your agents, and your tools. Every agent gets its own identity, attested back to a human through a four-level cascade (organisation, department, team, individual) that builds on the SSO and IAM you already have. Tool access is issued through a central registry as scoped, per-call credentials with explicit revocation paths, not standing OAuth grants on someone's laptop. Every action (prompt, intent, tool call, approval, output) is written to an immutable, tamper-evident audit log, and any session can be replayed deterministically by you, by your auditor, or by us under your supervision.
It runs single-tenant in your environment: your region, your retention, your isolation. Bring your own LLM: Claude, ChatGPT, Gemini, Mistral, Ollama, or anything else you've already licensed or self-host. Your data never touches another customer's infrastructure, and you're not locked to a model vendor's roadmap.
We've leaned heavily on best practices from across the open-source and enterprise world, and put a lot of thought into the things that don't usually get written about: least-privilege as default, separation of duties as architecture, audit as a primary surface rather than a tail-end log dump. We're early. The product is taking shape, the first design partners are coming on board, and we're learning more every week from teams trying to govern this stuff in production.
If you can name three agents running in your organisation right now, but you can't tell me whose credentials they're using or where their actions are logged, that's the conversation we want to have.
Grab 30 minutes with the team, or read more about how identity, tool access, and audit & replay work on the platform.