Skan AI Raises $63M: Why Watching How Employees Work Is the Missing Layer of Enterprise AI

The observation-first thesis

Skan AI raised $63M in Series C funding, co-led by Cathay Innovation and Dell Technologies Capital. Total war chest: roughly $120M. The company does one thing with precision: it watches how actual employees work, then models and automates the friction out.

According to VentureBeat, Skan AI raised $63 million in Series C funding to build what it calls a "context graph of work."

One bank deployed Skan. The bank observed 11.2 million context switches across 1,500 finance professionals. That single observation layer exposed $37 million in annual friction. The bank cut costs 32 percent and lifted throughput 41 percent.

Not projections. Observed reality.

Enterprise AI has spent four years optimizing hallucinations and fine-tuning inference. Meanwhile, the real constraint sits in plain sight: nobody knows what their employees actually do. You cannot automate what you have not measured. You cannot optimize what you have not watched. Process beats ego.

The missing layer

Enterprise AI deployment feels stuck. Companies buy agents, LLM platforms, and reasoning engines. Then they deploy them into workflows nobody has actually mapped. The agent moves fast. The process it's supposed to optimize? Unknown.

It's like launching a submarine without casualty drills. You have capable machinery. You have no idea how your crew will move through compartments under load.

Celonis released a case study with AWS. The problem was automotive manufacturing: order-to-delivery coordination across fragmented systems. Hundreds of manual touch points. No single source of truth for process steps. Celonis and AWS grounded the agent in observed process data. AgentCore provided observability—every tool call logged, every decision traceable. Then the agent had context.

Microsoft's Process Mining connector integrates with Copilot Studio agents. The architecture is explicit: you ingest actual process data via MCP (Model Context Protocol). Then your agent operates inside a mapped, observable workflow. Not a guess. A blueprint built from receipts.

Skan's three-product stack mirrors this:

• Skan AI Intelligence discovers what employees actually do.
• Blueprint models the process from that data.
• AI Agents execute optimization inside the mapped process.

No intelligence without observation. No modeling without intelligence. No execution without a model.

What this means for $1M–$5M businesses

Owner-operators get this instinctively. You run your own business. You know bottlenecks because you live inside them. You work through the cash crunch, the customer handoff, the back-office chaos.

But as you scale, observation breaks down. You hire a layer of operations. They manage processes you no longer touch. What they actually do drifts away from your documented procedures. Friction accumulates in shadows.

The 90-Day Bottleneck Audit exists for this reason. You block a weekend. You watch one critical process—order intake, delivery logistics, customer onboarding:from end to end. No assumption. Pure observation. You interview three people doing the work. You time each step. You document delays, workarounds, context switches.

Then you model it. Then you fix it.

Small-business automation fails because it skips the observation step. A founder buys Zapier, wires up a workflow from documentation, and wonders why the agent kills edge cases.

Why? Because the documentation lied. The real workflow is what happened yesterday, not what the employee handbook promised.

Skan's insight scales down perfectly. Watch your fulfillment team for three days. Map every step. Count handoffs. Find the moments a human picks up a task because automation failed silently. That's your friction. That's your starting point.

Navy watchstanding and the log book

I stood watch on a ballistic missile submarine for years. USS Jefferson City, reactor compartment. We logged every parameter before we touched anything. Core exit temperature. Flux. Coolant flow. Pressure trends. Then and only then did you intervene.

If something went sideways, the log book told the story. We did not guess. We had receipts.

Enterprise automation still guesses. Deployment teams assume the process. They optimize for the happy path. Then they get shocked when users route around the agent because the agent does not handle the real world.

You log before you intervene. That is the doctrine.

Skan forces the discipline. You cannot hand an agent a workflow you have not observed. The agent will fail. Your users will notice. Your investment tanks. Better to spend two weeks observing, modeling, and grounding the agent in reality.

Cost? Four percent of the project timeline. Return? Forty-one percent throughput lift in the live example. Do the math.

The observability loop

Once your agent runs inside a mapped process, observability becomes a asset.

AgentCore logs every tool call, every decision, every output. That log feeds back into Celonis. Teams see what the agent did, how it changed outcomes, where it failed. That loop closes the gap between intention and reality.

Small example: your fulfillment agent reroutes fifteen percent of orders to manual review. You notice. You ask why. The agent's logging shows a pattern: overseas customers with complex shipping rules. The agent is conservative:it throttles and escalates. You retrain on that cohort. Next month, escalation drops to eight percent.

Without observability, you never see the pattern. The agent just feels slow.

With observability, you get a continuous-improvement engine.

The honest caveat

Skan's $63M raise is real. The bank's results are real. The insight about observation-first is not new:Lean manufacturing knew this in the 1950s. What is new is the machine-learning stack that turns observation into automation at scale.

But observation requires time, discipline, and honesty. You have to watch people do sloppy, human, messy work. You cannot observe what you do not want to see:broken processes, wasted hours, people grinding through workarounds because your system is poorly designed.

Many companies will skip the watching step. They will buy Skan, point it at a process, expect magic. They will not get magic. They will get what they paid for.

You get what you observe, not what you hope.

The actionable next step

Block your team for three days. Pick one process. Watch it happen, end-to-end. Do not interrupt. Do not fix anything. Just log.

Then ask yourself: where does a human drop what they are doing to pick up a task because the system failed? Where does someone context-switch because information is not available? Where does a step take ten minutes that should take two?

That is your friction. That is where your ROI lives.

You do not need Skan to start. You need discipline. You need the Navy watchstanding mindset: log before you intervene. Observe before you automate.

Process beats ego. Always.

Sources

• VentureBeat
• Celonis Process Mining
• Gartner Process Mining Report

FAQ

Q: Can we skip the observation step and just tell our AI agent the process?

No. The documented process and the actual process live in different universes. Your employee handbook describes happy-path workflows. Your employees work through around broken systems, missing data, and handoff delays that nobody documented. An agent trained on documented process crashes on actual reality. Observation is not optional:it is the foundation.

Q: How much does observing a process cost?

Time and attention. Set aside forty hours for a critical workflow. Have three people watch, interview, log. That costs about two percent of a typical automation project. The payoff is that your agent lands in reality, not fantasy. Most teams skip this step. Most agent deployments then disappoint them.

Q: Does this only work for back-office processes?

No. Skan's bank deployed on finance professionals:cognitive, judgment-driven work. The context switches, handoff delays, and information gaps show up everywhere. Customer service, sales handoff, supplier coordination, hiring workflows. If humans do it, there is friction to observe and model.

Q: What happens if we observe the process but get the model wrong?

Then you have observability logs to show you where the agent failed. You refine the model. You do not have to guess why the agent crashed:you watch the decision tree in the log. That continuous loop between observation, modeling, and execution is where AI agents finally become reliable.

Q: If we observe, model, and deploy, how do we know the agent is actually working?

Observability. Every Skan deployment runs on Nvidia AI Enterprise, which provides full tracing. You log before you intervene. Then you measure the outcome. If context switches dropped from 8.2 per day per person to 5.1, your agent is working. If they stayed flat, your model missed something. Go back, observe, adjust.