← Case studiesUST / RFP TRIAGE AGENT
UST / PUBLIC SECTORWORKING PILOT · TESTING & TUNING

The first pass.
The final call.

01 / AUTOMATION

Handle
the volume.

Ingestion. Retrieval. Rubric. Scoring. Digest.

02 / PEOPLE

Hold
the judgment.

The rules. The edge cases. The pursuit decision.

UST RFP Triage Agent

Built end to end / 2024
ILLUSTRATIVE WORKFLOW / BASED ON THE PILOT

Follow a request.
See the handoffs.

An explanation of the system’s paths, using generic scenarios.

The full request is available. The system applies the team’s current rubric and prepares an auditable first pass.

  1. 01

    Request arrives

    Power Automate turns the email into a text file.

  2. 02

    Team-owned rubric

    The agent applies the current rules table.

  3. 03

    Score + store

    A spreadsheet records the rule results; a summary carries the score and flags.

  4. 04

    Teams digest

    The team receives a morning synopsis and recommendation.

  5. 05

    People decide

    Worthwhile requests receive a human review before pursuit.

A human path in. A human decision out.

The brief

The public sector team at UST had a volume problem. Every morning, requests for proposals and quotes landed in the inbox from request systems, from scraping, sometimes direct. Roughly twenty a day. Some were potentially worth half a million dollars or more. And each one needed a decision. Is this worth pursuing, or not?

That decision wasn't simple. It depended on what the team does and doesn't do, the type of project, which level of government it came from, conflicts of interest, whether UST actually had the skills the work required. A real rubric lived in the team's heads and in a checklist. Applying it to twenty requests a day, fast enough to matter, was more than anyone could keep up with.

The question I asked before building anything. Which parts of this decision repeat the same way every time, and which need a person? The rubric repeated. The final call didn't. That split became the architecture.

I built a working pilot to handle the first pass.

How it works

The team's decision criteria became a rules table. A structured, editable rubric the team owns. They add to it, trim it, and the agent always scores against the current version. The judgment stays theirs. The system just applies it at volume.

Each morning's requests flow through Power Automate, which simplifies every email into a text file and hands it to a CoPilot agent. When an email doesn't contain the full RFP, which happens often, Power Automate scrapes the rest.

Sometimes scraping hits a wall. A request gated behind a login, a system that blocks automated access. The system doesn't pretend that case away. It hands it to a person, who logs in, copies or downloads the full RFP, and pushes it back into the flow. A designed fallback, not a failure.

The agent checks each request against the team's rules. A couple are hard stops. If one applies, the request is marked no-go and recorded with the rejection reason. For the other requests, the agent creates a spreadsheet with the rule scores and a summary with a synopsis, final score, flags, and a go, maybe, or no-go recommendation.

Every request is stored, including hard-stop rejections, so the team can review what was turned away and why.

The summaries are posted to a Teams channel each morning. The team can review them whenever they choose and decide which requests to pursue.

The hard part

The hard part wasn't the plumbing. It was trust.

These were recommendations about six-figure opportunities. When I left UST, the system was a working pilot, still in testing and being tuned.

The other thing I took away was about the tools themselves. Working in Power Automate, the logic was sound but the experience of assembling it fought me the whole way. The machine sits at the center of these builders, not the person, which makes the build far more complicated than it needs to be.

What I built

I built the automation and the CoPilot agent end to end. The ingestion flow, the scraping and human-fetch fallback, the scoring logic, the spreadsheet and summary generation, the Teams delivery. The rules, the spreadsheets, and the final decisions stayed with the public sector team, where they belong. The system applies the team's judgment. It doesn't replace it.

That split is the point. Automation handles the volume and the messy inputs. People handle the judgment and the edge cases. A human path in when ingestion hits a wall, a human decision out when the digest lands. The agent triages so the team can decide. That's the only responsible way to put AI near a decision this expensive.