Skip to content
All projects

Case study · Build · 2026

Campus IT Triage Agent

The developer sideThe analyst side

A Salesforce Service Cloud backend for a campus IT agent. It tries a known-issue guide first and opens one Case when a person is needed.

Campus IT Triage Agent is a Salesforce Service Cloud backend for a help desk agent that tries a known-issue guide first and opens a Case when it is needed. A chatbot that only searches a FAQ opens duplicate tickets. This one is built as five Apex actions for an Agentforce agent, and it is public on GitHub with 29 test methods.

  • What it does

    A Salesforce DX and Service Cloud app that triages campus IT requests.

    See the developer side
  • The question

    How should a campus IT request get routed, and who can check the decision later?

    See the analyst side
  1. 01

    The problem

    Campus IT desks get the same requests every shift. A chatbot that only searches a FAQ opens duplicate tickets and can’t show what it settled.

  2. 02

    What I did

    Built five Apex actions an Agentforce agent can call, with routing and response times kept in Custom Metadata. Every action writes a row to an audit object that a trigger keeps append-only.

  3. 03

    Where it stands

    Public on GitHub with 29 test methods. The chat layer isn’t in the repo, and the walkthrough video is a reconstruction.

A campus IT desk answers the same requests every shift.

The repo’s README opens with the problem. Campus service desks get WiFi, password, MFA, VPN and Outlook requests every shift, and hardware that needs a technician waits behind work a script could finish.

A chatbot that only searches a FAQ makes that worse. It opens duplicate tickets, and nobody can prove whether it deflected anything. The backend here is built around those two failures.

Where the problem is stated: The README

Who runs it

  1. Service desk lead

    Owns the known-issue articles and the rules for queues and response hours.

  2. Technician

    Works Cases in the Campus IT app.

  3. Agentforce admin

    Owns the topic instructions and which actions the agent can call.

  4. Platform owner

    Handles deploys and tests, and assigns the permission set.

Five actions, and each one does a single job.

The five actions

  1. Find a guide

    Matches the request against six known-issue articles. A match returns the steps, and no Case is opened.

  2. Escalate a ticket

    Opens one Case on the queue for its category and links the student’s Contact. The Case carries a published comment and a first-response due time.

  3. Add an update

    Adds a comment to an open ticket. A closed ticket is refused, and the agent is told to open a new one.

  4. Check status

    Looks a ticket up by Case Number, and falls back to Student ID when the number is wrong.

  5. Operations snapshot

    Reports the open agent-sourced tickets, how many are high priority, the oldest wait, a count for each queue and today’s deflection rate.

Two behaviors built in

  1. One ticket per problem

    An open Case for the same student and category is reused. Force New Ticket overrides that.

  2. Lookups that survive speech

    A Student ID given as s 1000-0001 is stored as S10000001, and Case Number 1234 matches 00001234.

I built the backend first, then checked the walkthrough against the code.

  1. 01

    First build

    The backend and all 29 test methods in one commit

    Tagged Release v1.0.0, with an 80-second explainer video

  2. 02

    Public repo

    A packaging guide and launch copy

    A script for recording after a deploy

  3. 03

    Demo video

    A page rebuilt to look like the workspace

    No network calls, and every agent reply scripted

  4. 04

    Honest labels

    The opening caption had called it a live desk

    Added “UI walkthrough · not a live org capture” on every caption

  5. 05

    Audit, written down

    Nine steps, starting with claims the code doesn’t back

    A voice check the launch post passed

All six commits on main, in five steps

The label stays on screen for all 65 seconds of the walkthrough, and the README says the same.

The pull request that fixed the labels

The snapshot answers what a desk lead would ask.

  1. How many agent-sourced tickets are open?

    Measure
    Open Cases with Agent Sourced checked
    Read from
    Case
  2. How many of those are high priority?

    Measure
    Open agent-sourced Cases at High priority
    Read from
    Case
  3. How long has the oldest one waited?

    Measure
    Whole hours since the oldest open ticket was created
    Read from
    Case
  4. Which queue is holding them?

    Measure
    Open tickets counted by the queue that owns them
    Read from
    Case and its queue
  5. What share of today’s requests ended in chat?

    Measure
    Deflection rate
    Read from
    Campus IT Interaction rows created today

This repo is everything the agent can do, minus the conversation.

  1. 01

    Find a guide

    Keywords matched against the catalog

    Steps read back to the student

  2. 02

    Escalate

    Reuse an open Case or insert one

    Stamp Agent Sourced and the due time

    Publish a Case Comment

    Route to a Campus IT queue

    Only when The guide is missing, already tried, marked for escalation, or the student asks for a person

  3. 03

    Update and status

    Comment on an open ticket

    Look up by Case Number or Student ID

  4. 04

    Snapshot

    Open load by queue

    Today’s deflection rate

    Every action Writes one Campus IT Interaction row

The path a student request takes

Each action is one Apex class with a single invocable method that takes a list and returns a list. All five run with sharing.

The project deploys as Salesforce DX source on API version 64.0. The conversation is built in Agent Builder inside an org, so it isn’t in the repo.

Deflection is the share of today’s requests a guide settled.

Deflection today

A reused ticket counts as a follow-up and stays out of the bottom line. The rate is a percent to one decimal place, and it stays empty on a day with no volume.

Open load

  • open loadopen Cases with Agent Sourced checked, for the whole desk or one queue
  • oldest waitwhole hours since the oldest of those Cases was created

First response due

  • High4 hours after the Case is created
  • Medium16 hours
  • Low40 hours
  • no matching rule16 hours

These are clock hours added to the moment the Case is created. Nights and weekends don’t pause them, and changing a rule leaves open tickets as they were.

Priority from what the student says

  • Highthe urgency mentions critical, emergency, urgent, high, p1, p2 or sev1
  • Lowthe urgency mentions low, or the codes p4 and sev4

Everything else is Medium, including a request with no urgency given.

One test checks the deflection rate, and two of its rules go untested.

  1. Ticket escalation15
  2. Ticket status4
  3. Audit service3
  4. Ticket update3
  5. Self-service guide2
  6. Demo data1
  7. Operations snapshot1
Test methods by class on main, 29 in all. Counted from the code, since no test run is on record. The snapshot test checks the rate against one mix of matched guides and new tickets. No test puts a reused ticket in that mix or runs the snapshot on a quiet day. The snapshot test

The walkthrough video is a reconstruction, and it says so on screen.

The repo carries a 65-second walkthrough of the Campus IT workspace. It mirrors what the Apex does and was not captured from a live org. The README says so, and the video is labelled on screen.

Any count that appears in the video belongs to the reconstruction. Every figure in this study comes from the code and the metadata.

In the repo

  1. Apex

    15 classes. Five actions, two shared services, a demo data seeder and seven test classes.

  2. Metadata

    Four custom objects and metadata types, holding 14 Custom Metadata records. Five queues take the routed Cases.

  3. Workspace

    A Lightning app, a Case layout, list views and one permission set.

  4. Demo data

    A script that seeds three demo students, one for each walkthrough path.

Not in the repo

  1. The conversation

    The Agentforce topic is built in Agent Builder inside an org. The repo carries the instructions to paste in.

  2. A live recording

    No capture from a real org exists here. A script for recording one is in the docs.

  3. An install link

    The README keeps a placeholder for a package URL and says not to invent one.

  4. A test run

    No test result or coverage figure is recorded.

The rules live where an admin can change them.

  1. Agent copy stays in Agent Builder

    A desk lead can change the wording with no deploy.

  2. Rules in Custom Metadata

    Queue routing and response hours change in Setup with no Apex. So does the article catalog.

  3. One action, one job

    Each class takes a list and returns a list in the same order, so it stays safe in bulk.

  4. The audit never blocks a student

    Audit writes run in system mode and catch their own errors. A logging failure can’t fail the action a student is waiting on.

  5. Append-only by trigger

    A trigger rejects every update and delete on the interaction object, so the numbers can’t be edited afterward.

  6. Tests bring their own data

    No test uses SeeAllData. Test queues are named CIT_Test_* so they can’t collide with the shipped ones.

  7. No hardcoded IDs

    Queues are found by DeveloperName, and no Salesforce record ID appears in the code or the metadata.

  8. No secrets

    The project needs no API keys and no OAuth client. Deploying takes the Salesforce CLI and one permission set.

Technicians get a workspace that works without the agent.

  1. Campus IT app

    A Lightning app for Cases, Contacts, Interactions and their due dates.

  2. Case highlights

    An optional Case layout puts Student ID and first-response due in the highlights.

  3. List views

    Four of them. Two cover Cases and two cover the interaction log, with one scoped to today for a shift review.

  4. Interaction numbers

    Each audit row carries an autonumber in the form INT-00000.

The code is public, and no run in a real org is on record.

Agent actions
5
Agent actions
Test methods in 7 test classes
29
Test methods in 7 test classes
Custom Metadata records
14
Custom Metadata records
Known-issue articles
6
Known-issue articles

The repo is MIT licensed, with release v1.0.0 and six commits on main. The first is from August 2026. Two pull requests are open, and one of them adds more tests and a one-command scratch org setup.

First, it needs a run in a real org.

Next

  1. Tests in an org

    Run the seven test classes in a scratch org and publish the coverage figure. An open pull request adds a script that sets one up and runs every test with coverage in one command.

  2. More tests

    The same pull request adds tests that push 200 records through every action in one transaction, and one for the empty rate on a quiet day. A test with a reused ticket in the rate still needs writing.

  3. Open decisions

    Writing those tests turned up 13 issues, each listed in the pull request for a decision. In one, nothing decides which queue wins when two routing rules match.

  4. A live capture

    Record the walkthrough from a Developer Edition org with Agentforce enabled. Then the on-screen label can come off.

  5. Business hours

    Work out first-response due times with BusinessHours.add() against the desk’s Business Hours record, so nights and weekends pause the clock.

  6. A classifier

    Keep keyword matching as the floor and add a classifier above it for requests worded another way.

Known limits

  1. No run on record

    The repo records no test run or coverage figure. Nothing in it shows a deploy to a real org.

  2. A reconstructed video

    The walkthrough is a labelled reconstruction. The script for recording a real one is in the docs.

  3. Agentforce needs the right org

    A standard Developer scratch org doesn’t have Agentforce. The chat demo needs a Developer Edition org or a Trailhead Playground.

  4. Clock hours

    First-response times ignore business hours.

  5. Keyword matching

    Guides match on keywords from the catalog. A request worded another way finds no guide and goes to escalation.

  1. Built

    A Salesforce Service Cloud backend whose campus IT agent tries a known-issue guide before it opens a Case.

  2. Found

    Of the 29 test methods, one checks the deflection rate, and two of the rate’s rules go untested.

  3. By the numbers

    Agent actions
    5
    Test methods in 7 test classes
    29
    Known-issue articles
    6
  4. The catch

    No test run is on record. The 29 test methods are counted from the code.

  5. Next

    Run the seven test classes in a scratch org and publish the coverage figure.