Today, C1 is announcing the C1 Autonomous Worker (C1AW).
Most companies reaching for AI to handle enterprise work landed on chatbots: ask a question, get an answer, go do the work yourself. Transactional inference, text prediction.
We built the future state. For the first time, the system that governs your enterprise can also run it. C1AWs are agents that run work loops, carry state, execute code, and act on your behalf across C1's full API surface.
Three building blocks power the agent harness:
A local file system. State storage for a long-running job. C1AW can start an analysis, write intermediate results, pull from those results in a subsequent step, and deliver a finished artifact at the end. This is what gives a harness a long working horizon: the ability to do sophisticated, multi-step work without losing context.
Code mode. When C1AW needs to do something, it writes code and executes it. Not inference over data. Actual computation on actual data. This is how it handles analysis across thousands of entitlements without losing accuracy. Inference is prediction. Code is deterministic.
Delegated API access. C1AW runs with the exact access of the person who operates it. Every call is checked against that person's real permissions, so the agent can never reach anything its operator couldn't. And every action it takes is attributed to that user's agent identity in the audit trail, reviewable like any other access event.
A chatbot hands you a to-do list. C1AW clears it.
What it does today#
Hand C1AW a job in plain language. It carries the whole thing out.
"Revoke every admin grant in Snowflake nobody has touched in 90 days."
"Build a quarterly access review for Engineering and route it to managers."
"Put together the audit evidence for who could reach production last quarter."
"Find out how many leads we have in Salesforce this month."
"Find every deactivated user who is still listed as an entitlement owner."
Each of those is multiple steps across a dozen views. C1AW does all of them: reasoning over data, writing code to analyze it, taking action through the same policy engine that governs every other access change in C1, and delivering the artifact, the real CSV, PDF, or JSON, right where you're working.
It approves, denies, reassigns, and escalates requests. It manages entitlements, stands up review campaigns, creates automations, and monitors for conflicts. How much it does on its own is configurable. Sensitive changes route to a human approver before they run.
The UX problem this solves#
In a large SaaS product, any given task requires navigating a tree of pages, often multiple times. You open a tab, find the object, click through to the relevant setting, make the change, go back, find the next object. Governance work is particularly brutal.
When you're talking to C1AW, the tree disappears. It has full access to all of C1's APIs. It can do everything the console can do, and things the console does not yet support.
Take entitlement descriptions. Ask C1AW to crawl your entitlement tree, research each entitlement's actual purpose, draft descriptions using inference, and post the updates back to the platform. That is work that would require months of UI engineering to surface through a product interface. C1AW does it today.
Where this goes#
The enterprise is turning into a place where most of the work gets done by agents, not people clicking through dashboards. That shift is already starting, and it changes the one question every company has to answer. When any worker — human or machine — can reach almost anything, what keeps you safe is knowing who is allowed to do and know what.
As the work moves to agents, C1 becomes the layer it all runs through: the place the work gets done, and the place it gets governed. The work that always got pushed is about to get done. Here's what that looks like as we build toward it.
Workers that run on their own. Today you hand C1AW a job. Next, you give it a schedule and let it go. A security worker wakes up every Monday, checks your environment for deactivated users still active in apps, policy gaps, entitlement owners who left the company — and files the findings. Nobody has to remember to run it. Every person in the company can have a worker of their own, scoped to their access and tuned to their job: an AE's worker reviews yesterday's calls and leaves coaching notes before the first meeting; an admin's worker watches for drift and surfaces it before it becomes an incident. The work that always got pushed — the weekly sweep, the access review nobody had time to do properly — gets done. Not because you hired more people, but because workers are running on your behalf, governed by the same controls you trust for humans.
One control plane for every agent. No company is going to run all its work on a single model or a single vendor. You'll have Salesforce agents, ServiceNow agents, Bedrock workloads, coding agents, agents people spin up themselves. Every one of them needs governed access to do anything useful, and someone has to decide what each is allowed to touch. C1 governs all of it: workload identity to prove what an agent is, access control over what it can reach, policy enforced at runtime — whether C1 built the agent or someone else did.
Govern context and execution. The harder question isn't just what an agent can see — it's what context it receives, what it's allowed to act on, and how far its execution can reach. When a marketing worker pulls from engineering's knowledge base, it should get the context it needs, not operational details it has no business seeing. C1 already maps who has access to what across your company. That same graph controls what an agent is fed, what it can execute, and where its reach stops.
The next hire at your company might not have a name. It will have an identity, a set of skills, an access scope, and a schedule. C1 is how that hire gets provisioned, governed, and put to work.
Available now#
C1AW is live for every C1 customer today — and it lives where your team already works. Install the C1 app in Slack, link your Slack identity to your C1 account, and start handing off work in the thread.
The access that used to take hours of clicking now takes one request. The reports that required manual exports get built and delivered in the thread. The secure path is now the fastest path.
Want to see it in action? Book a demo.
