Clearpath

From offer accepted to Day-1 ready - fully automated.

Comment

Inspiration

Every company hires people. And almost every company makes their first week a disaster. I was thinking about how much invisible coordination happens every time someone new joins a team where HR sends forms, IT opens tickets, the manager books meetings, someone remembers to add them to Slack. Each of these is a simple task. But together, spread across multiple people and systems, they consistently take days to complete. New hires sit idle. First impressions suffer. Productivity is delayed for weeks. The frustrating part is that none of this coordination requires human judgement, it just requires human time. And that felt like exactly the problem AI agents were built to solve. That insight inspired ClearPath: what if the entire onboarding pipeline could run itself, the moment an offer was accepted, with humans only stepping in where their judgement actually matters?

What it does

ClearPath is an autonomous multi-agent AI system that orchestrates employee onboarding from offer acceptance to Day-1 ready automatically. When a new hire's details are submitted, a single trigger kicks off a coordinated pipeline: An Orchestrator agent plans the workflow and delegates to four specialised sub-agents. The IT Provisioner provisions all required systems such as Google Workspace, Slack, GitHub, Notion, Figma, and VPN. The HR Documents agent generates a fully personalised welcome pack tailored to the hire's role, department, and manager. The pipeline pauses at a human-in-the-loop checkpoint, where the hiring manager reviews and approves system access. On approval, the Calendar agent automatically books intro calls, team standups, and buddy sessions. The Comms agent sends personalised welcome messages to Slack and email.

A real-time dashboard shows every agent's status as the pipeline runs, and an admin view lets HR teams track all active onboardings simultaneously.

How we built it

ClearPath is built on three layers: Backend - A Python FastAPI server with a webhook endpoint that acts as the onboarding trigger. Each agent is a standalone Python class with an async run() method. The Orchestrator uses asyncio.gather() to run independent agents in parallel, cutting total execution time significantly compared to sequential processing. An in-memory state store tracks each onboarding's progress in real time.

Agent layer - Five agents handle distinct responsibilities. The IT Provisioner simulates multi-system provisioning with realistic async delays. The HR Documents agent generates personalised content dynamically using each hire's specific attributes. The Calendar agent constructs a realistic first-week schedule. The Comms agent crafts tailored Slack announcements and welcome emails. The Orchestrator coordinates everything, including managing the human approval gate.

Frontend - A React dashboard polls the backend every two seconds to display live agent status. The human-in-the-loop approval card surfaces exactly what access is being requested before the manager approves. An admin view shows all active onboardings with live progress bars.

The architecture deliberately separates concerns, each agent is independently testable, replaceable, and extendable, making it straightforward to swap mock integrations for real ones in production.

Challenges we ran into

Designing the human-in-the-loop checkpoint correctly was harder than expected. The pipeline needed to genuinely pause mid-execution and wait for an external signal, not just check a flag at the start. Implementing this as an async polling loop inside the Orchestrator, with a proper timeout and both approve/reject paths, required careful thought about state management and race conditions.

Parallel execution with shared state introduced subtle bugs early on. When multiple agents write to the same state object simultaneously, the order of updates matters. We had to design the state store carefully to ensure agent updates were atomic and the frontend always received a consistent snapshot. Node.js and React tooling compatibility caused friction during setup where react-scripts had conflicts with newer Node versions. We resolved this by building a zero-dependency single-file HTML frontend as an alternative, which actually made the project more accessible and easier to demo.

Making the demo feel real without live enterprise credentials required building convincing mock integrations. Each mock needed realistic timing, structured response data, and incremental state updates, so the dashboard looked genuinely dynamic rather than just flipping from pending to complete instantly.

Accomplishments that we're proud of

A genuinely working multi-agent pipeline that runs end-to-end, not just a prototype or mockup. True parallel agent execution using async Python - IT provisioning and HR document generation run simultaneously, as do calendar scheduling and comms. A human-in-the-loop checkpoint that actually pauses the pipeline and waits, not a checkbox that gets ticked automatically. A real-time dashboard that updates live as each agent completes its work, making the orchestration visible and understandable to non-technical users. An architecture clean enough that swapping any mock integration for a real one requires changing only a single file.

What we learned

Multi-agent orchestration is an architecture problem as much as an AI problem. The hardest decisions weren't about what the agents should do, they were about how agents communicate, how state is shared, how failures are handled, and where humans fit in the loop.

Human-in-the-loop is a feature, not a limitation. Early in the design process it was tempting to make everything fully autonomous. But the approval checkpoint turned out to be one of the most compelling parts of the demo, it shows judges and enterprise users that the system is trustworthy, not just fast. Enterprises won't adopt AI agents that remove humans entirely from sensitive decisions.

Parallel execution compounds value quickly. Running two agents simultaneously doesn't just save time, it changes the user's mental model of what's happening. Watching two things complete at once makes the system feel genuinely intelligent rather than just automated.

Good demos are designed, not discovered. The four-minute demo we built tells a specific story with a deliberate dramatic arc like setup, execution, pause, approval, completion. That structure made the technology much more compelling than a raw feature walkthrough would have been.

What's next for Clearpath

Real integrations - Replace mock clients with live API calls to Google Workspace, Slack, GitHub, and calendar platforms. The architecture is already designed for this, each integration is isolated in its own module.

Expanded HITL controls - Allow managers to modify access levels, add or remove systems, and leave comments before approving, not just a binary approve/reject.

Offboarding pipeline - The same multi-agent architecture applies perfectly to employee offboarding: revoking access, archiving files, scheduling exit interviews, and notifying teams.

Beyond onboarding - The Orchestrator pattern is domain-agnostic. The next natural applications are client onboarding, contract approval workflows, and compliance monitoring, any enterprise process that requires coordinating multiple systems with human oversight at key decision points.

Analytics layer - Track time-to-ready across hires, identify bottlenecks in the pipeline, and surface insights to HR leadership about where the most time is being saved.

ClearPath started as a solution to a specific problem. The architecture it's built on is a foundation for the autonomous enterprise workforce of tomorrow.

Built With

Share this project:

Updates

Submission history