Inspiration

Every company wants to become AI-native, but most are stuck at the starting line. Building agents means rebuilding each workflow from scratch, so teams end up automating nothing.

Yet the best candidates for automation are already written down. Every operations team keeps a binder of standard operating procedures (SOPs): step-by-step guides for onboarding a vendor, approving a purchase, closing out a month, analyzing a stock, etc. These workflows are repetitive, well defined and already reviewed and signed off. People follow them line by line every week.

We realized the SOP already describes the agent. If we could read it properly, any company could turn the procedures it already has into agents, without redesigning a single process. SOPilot makes that the first step toward AI-native operations: start with the work you've already defined, and automate it.

What it does

SOPilot reads your SOP as written and turns it into an AI agent that follows it.

  • Reads the document. Every line becomes a step: something the agent does, something it checks, or something a person has to sign off on.
  • Tells you what it can't do. Steps that still need a human are flagged with the reason, so you know how much is automated before anything runs.
  • Follows the rules. Approval rules like "purchases over $500 need Compliance sign-off" are enforced by fixed logic, not left to the AI's judgment. If something looks off, the agent stops and asks a person.
  • Shows its work. Every action is logged and linked to the line of the SOP that called for it.
  • Keeps up with changes. When the SOP is updated, SOPilot shows what the agent will now do differently.
  • Exports a portable agent. Every compiled agent can be exported as standard files: a SKILL.md with the agent's instructions, MCP bindings for the tools it uses, and a policy.yaml with its approval rules. Companies can run their agents on their own infrastructure or in other agent platforms without rebuilding them.

How we built it

  • Google Gemini reads each SOP and compiles it into a step-by-step plan. During a run, it also picks which tool to use at each step.
  • simpleeval evaluates approval rules, so a fixed rule, not the AI, decides when a person has to sign off.
  • SerpApi lets the agent search the web for product quotes, business listings and vendor news.
  • Capital One Nessie provides a banking sandbox the agent uses to make purchases.
  • SEC EDGAR lets the agent look up company filings.
  • Tiger Data stores SOPs and their versions, along with a full trace of every run.
  • FastAPI powers the backend that connects the AI, the tools and the database.
  • Next.js, Tailwind and shadcn/ui power the dashboard, which draws each run as a live flowchart.
  • Docker and Vultr host it all online.

Challenges we ran into

  • Consistency. Gemini phrased and analyzed steps slightly differently every time it read the same SOP. Instead of comparing wording, we compare what the agent actually does.
  • AI Hallucinations The compiler and a tool sometimes used different names for the same field, so the AI filled in the missing value itself, which meant the agent could have sent a payment for an amount nobody approved. Bugs like this don't crash anything, so they are easy to miss and dangerous where money is involved. Now every parameter is validated against each tool's expected schema before a run starts, and any mismatch stops the run instead of letting the AI guess.
  • Speed A fresh compile is one long Gemini call, because the model has to see the whole SOP to resolve thresholds from appendices. Batch compile runs SOPs in parallel, and specs are cached by content, so the 5 demo SOPs load quickly.

Accomplishments that we're proud of

  • An agent in minutes Upload an SOP and SOPilot compiles it into a working agent. Tool connections, model configuration, policy checks and monitoring are already handled, so there is nothing to set up per agent.
  • One platform, many uses. Vendor onboarding, purchasing, due diligence, month-end close: any procedure a team has written down can become an agent.
  • Built from what teams already have. Users don't write prompts or draw workflows. The SOP is the agent's instructions, and editing the SOP updates the agent.
  • Ready for business use today. SOPilot fits into how companies already operate instead of asking them to change. The approval chains, spending limits and sign-offs in the SOP carry straight into the agent, so the same people still approve the same decisions. Teams can deploy now and automate more over time.
  • End to end in 24 hours. Two of us built a platform that turns written procedures into working agents end to end. Any team with documented processes can now automate repetitive work without engineers, prompt writing or workflow builders, which puts agents within reach of every department rather than only the few with technical resources.

What we learned

  • LLMs are good readers but bad decision makers. Gemini is great at turning messy prose into structured steps, but we didn't trust it to decide whether $480 is under a $500 limit. Splitting the work so the AI interprets and fixed code enforces made the system easier to trust and easier to debug.
  • Contracts matter most. Most of our hardest bugs came from the handoff between the SOP compiler and the runtime. A shared, typed spec format that both sides validated against caught problems that code review missed.
  • Saying "I can't do this" is a feature. People trust an agent more when it flags the steps it can't automate than when it guesses.
  • Fixtures keep you moving. Recording real API responses and replaying them let us iterate quickly without burning API calls, and kept the demo working even when an external service was slow.
  • Async teamwork needs a proper management We split the project into a compile side and a run side and handed work off through shared plan files instead of messages. That let us build in parallel without stepping on each other.

What's next for SOPilot

  • Agents that keep up with the SOP. Connect to wherever SOPs live (Google Docs, Notion, Confluence, SharePoint) and recompile the agent automatically when someone edits the document.
  • Scheduled and triggered runs. Run recurring procedures like month-end close or quarterly vendor reviews on a schedule, or start a run from an event such as a new purchase request, an incoming invoice email or a form submission.
  • More integrations. Add connectors for the tools companies already use: Slack, Gmail, Jira, Salesforce, QuickBooks, NetSuite and internal APIs. Teams could also register their own tools so the compiler can map SOP steps to them.
  • A richer approvals flow. Let approvers leave notes, request changes or delegate to someone else, with deadlines, reminders and automatic escalation when no one responds. Approvals should also work directly from Slack or email, so nobody has to open another dashboard.
  • Learning from the humans in the loop. Track which flagged steps people handle the same way every time and suggest updates to the SOP or new rules, so the share of automated work grows over time.
  • Compliance-ready audit trails. Export a run's full trace, with each action, approval and the SOP line behind it, as a report for auditors. Add retention controls and role-based access.
  • Team and enterprise features. Shared workspaces, SSO, role-based permissions for who can edit SOPs, approve runs or change policies, and per-team dashboards that show how much of each process is automated.
  • Agents that go anywhere. Expand export so compiled agents run in other agent frameworks and platforms, keeping SOPilot's policy checks and tracing intact.

Built With

  • caddy
  • capital-one-nessie
  • docker
  • fastapi
  • google-finance
  • google-gemini
  • google-oauth
  • lucide
  • next.js
  • postgresql
  • pytest
  • python
  • react
  • sec-edgar
  • serp-api
  • simpleeval
  • tailwind-css
  • tiger-data
  • timescaledb
  • typescript
  • uvicorn
  • vultr
Share this project:

Updates

Submission history