Refund Ops Automation

The story: 100 Stripe refunds a day

A finance team lead at a growing startup manually processed credit notes and refunds. After an acquisition, her workload shifted toward higher-value work--but the refunds didn't disappear. The result: an hour of repetitive, error-prone work every day.

The prototype was a Claude Skill that uses the out-of-the-box Stripe MCP server. Each morning, she drops in an Excel file in a known format. The agent walks the rows in order, issues refunds against Payment Intents, records successes and failures, and exports a report for quick manual cleanup.

This is not "give a monkey a razor blade." The point is controlled delegation: let the agent do the repetitive steps, and keep a human responsible for the business process.

Then add guardrails (and step back)

To automate a business process responsibly, you progressively move uncertainty out of the agent loop:

This is the core promise of Tactus for business process automation: you can start with natural-language prototyping, then gradually put guardrails around the parts that matter until you can step back safely--without removing humans from accountability.

Hardened procedure (Tactus example)

-- refund_ops.tac (illustrative example)
--
-- Key idea: prototype supervised as a Skill, then harden into a governed procedure:
-- validate inputs, pre-call tools, add human checkpoints, and measure drift.

Stripe = Toolset.mcp {
  server = "stripe",
}

refund_row = Tool.define {
  name = "stripe_refund",
  description = "Create a refund for a payment intent",
  input = {
    payment_intent_id = "string",
    amount_cents = "number",
    reason = "string",
    ticket_id = "string (optional)",
  },
  output = {
    refund_id = "string",
    status = "string",
  },
}

RefundAgent = Agent {
  model = "openai/gpt-4o-mini",
  system_prompt = [[
You are a finance ops assistant.
Follow the procedure and never execute a refund without either:
  (a) passing automated checks, or
  (b) receiving explicit human approval.
Return structured outputs only.
]],
}

Procedure {
  input = {
    rows = field.list{required = true, description = "Validated refund rows"},
  },
  output = {
    results = field.list{required = true},
  },
  function(input)
    local results = {}

    for i, row in ipairs(input.rows) do
      -- 1) Deterministic lookup first (agent can't "forget" to do it)
      local pi = Stripe.payment_intents.retrieve({id = row.payment_intent_id})

      -- 2) Risk check (hard-coded guardrail)
      local high_risk = (row.amount_cents >= 50000) -- example threshold

      if high_risk then
        local approved = Human.approve({
          message = "Approve refund?",
          context = {
            payment_intent_id = row.payment_intent_id,
            amount_cents = row.amount_cents,
            reason = row.reason,
            ticket_id = row.ticket_id,
            stripe_summary = pi,
          },
          timeout = 3600,
          default = false,
        })
        if not approved then
          table.insert(results, {index = i, ok = false, error = "not approved"})
          goto continue
        end
      end

      -- 3) Tool call with structured input
      local r = refund_row(row)
      table.insert(results, {index = i, ok = true, refund_id = r.refund_id})

      ::continue::
    end

    return {results = results}
  end,
}