How to Generate an AI-Written Weekly Support Trends Report from Front

Build a Spojit workflow that runs every Monday morning, pulls the past week's Front conversations and tags, has Miraxa distill the top themes, sentiment and volume trends into structured JSON, and posts a readable summary to your Slack support channel.

What This Integration Does

Support teams generate a lot of signal that nobody has time to read. This workflow turns a week of Front conversations into a short, scannable digest: the busiest themes, where sentiment is sliding, which tags are spiking, and how total volume compares to a normal week. Instead of someone scrolling through hundreds of threads on a Monday, the report lands in Slack automatically, ready for a standup. Because the AI step is forced to return a fixed JSON shape with a Response Schema, you get the same fields every week and can format them consistently, rather than a free-form paragraph that drifts each run.

The workflow is driven by a Schedule trigger on a weekly cron. On each run it lists the past week's conversations from Front, pulls the tag catalog, and hands that material to a Connector node in Agent mode whose Response Schema guarantees structured output. A Connector node on Slack in Direct mode then posts the formatted summary. The workflow holds no state between runs: each execution reports only on the window it queried, so re-running it (or running it manually to test) simply re-summarizes the same week and posts again. There is no database to maintain and nothing to clean up.

Prerequisites

  • A Front connection (API token) added under Connections, with access to the inboxes you want reported on.
  • A Slack connection added under Connections, with permission to post to your target support channel.
  • The Slack channel ID of the channel you want the report posted to (for example C0123456789), not the channel name.
  • An agreed timezone for the schedule (for example Australia/Sydney) so the weekly window lines up with your business week.
  • Enough AI credits for one agent run per week. The agent summarization step costs credits; the Front and Slack calls do not.

Step 1: Add a Schedule trigger for Monday mornings

Create a new workflow in the Workflow Designer and set the Trigger node to type Schedule. Schedules use a 5-field Unix cron plus an IANA timezone. To run at 8am every Monday, use:

Cron:     0 8 * * 1
Timezone: Australia/Sydney

The trigger output is { scheduledAt }, an ISO timestamp of the fire time, available downstream as {{ scheduledAt }}. A single trigger can hold multiple schedules if you later want the same report on more than one day.

Step 2: Compute the start of the past week

Add a Connector node on the date connector in Direct mode and pick the subtract tool to roll back seven days from the run time. Pass {{ scheduledAt }} as the base date and subtract 7 days. Capture the result in an output variable such as weekStart.

You will use this value to bound the Front search. Front's search query accepts an after: filter expressed as a Unix timestamp, so add a second date Direct node with the unix tool to convert {{ weekStart }} into seconds, captured as {{ weekStartUnix }}. Keeping these as separate, deterministic steps means the AI never has to do date math.

Step 3: List the past week's Front conversations

Add a Connector node on the front connector in Direct mode and select the list-conversations tool. Set the search query field q to scope it to the last seven days using Front's search syntax:

after:{{ weekStartUnix }}

The tool returns a list of conversation objects (the _results array inside the Front envelope), each with fields such as id, subject, status, tags, created_at, and last_message. Capture the output in a variable like conversations.

Front paginates results. list-conversations exposes a page_token input and returns a pagination cursor for the next page. For a high-volume week, wrap this step in a Loop node (While) that re-calls list-conversations with the page_token from the previous page until no further cursor is returned, accumulating conversations as you go. If your weekly volume is modest, a single call is usually enough.

Step 4: Pull the tag catalog

Add another Connector node on the front connector in Direct mode and select the list-tags tool. It takes no inputs and returns every tag in the account, each with id, name, and description. Capture this as tags.

Conversations reference tags, so giving the AI the tag catalog lets it report by human-readable tag name ("Billing", "Bug", "Refund request") and surface which tags are spiking, rather than echoing raw identifiers it cannot interpret.

Step 5: Summarize trends with an Agent and a Response Schema

Add a Connector node and switch it to Agent mode. Agent mode lets Miraxa, the intelligent layer across your automation, reason over the conversation and tag data and decide how to characterize the week. Crucially, turn on the Response Schema so the output is forced into reliable, structured JSON instead of prose. Write a prompt that references your upstream variables:

You are analyzing one week of customer support conversations from Front.

Conversations (subject, status, tags, created_at, last_message):
{{ conversations }}

Tag catalog (id, name, description):
{{ tags }}

Identify the top recurring themes, overall sentiment, notable sentiment
shifts, the tags that appear most often, and the total conversation
volume for the week. Be concise and factual. Do not invent numbers you
cannot derive from the data.

Define the Response Schema so every run yields the same fields. For example:

{
  "type": "object",
  "properties": {
    "totalConversations": { "type": "integer" },
    "overallSentiment": {
      "type": "string",
      "enum": ["positive", "neutral", "negative", "mixed"]
    },
    "topThemes": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "theme": { "type": "string" },
          "count": { "type": "integer" },
          "sentiment": { "type": "string" }
        },
        "required": ["theme", "count", "sentiment"]
      }
    },
    "topTags": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "tag": { "type": "string" },
          "count": { "type": "integer" }
        },
        "required": ["tag", "count"]
      }
    },
    "notableShifts": { "type": "array", "items": { "type": "string" } },
    "headline": { "type": "string" }
  },
  "required": ["totalConversations", "overallSentiment", "topThemes", "topTags", "headline"]
}

Capture the structured result in an output variable such as report. Downstream you can reference fields directly, for example {{ report.headline }}, {{ report.totalConversations }}, and {{ report.overallSentiment }}.

Step 6: Format the digest text

Add a Transform node to assemble a Slack-ready message from the structured fields. Because the schema guarantees the shape of {{ report }}, you can lay out a clean, repeatable digest. For example, build a string like:

:bar_chart: *Weekly Support Trends*  ({{ weekStart }} to {{ scheduledAt }})

{{ report.headline }}

*Volume:* {{ report.totalConversations }} conversations
*Sentiment:* {{ report.overallSentiment }}

*Top themes:*
- (one line per item in report.topThemes: theme, count, sentiment)

*Top tags:*
- (one line per item in report.topTags: tag, count)

*Notable shifts:*
- (one line per item in report.notableShifts)

If you prefer, you can iterate the arrays with a Loop node and a text connector (join) to expand topThemes and topTags into bullet lines, then concatenate the sections. Capture the final text as {{ summaryText }}.

Step 7: Post the summary to Slack

Add a final Connector node on the slack connector in Direct mode and select the send-message tool. Set the channel field to your support channel ID (for example C0123456789) and the text field to {{ summaryText }}:

channel: C0123456789
text:    {{ summaryText }}

If you want richer layout, send-message also accepts an optional blocks field for Block Kit formatting; the plain text still serves as the notification fallback. Save the workflow and enable it. From now on the report posts itself every Monday morning.

Tips

  • Keep the date math and Front/Slack calls in Direct mode and reserve Agent mode for the single summarization step. This keeps the workflow deterministic and cheap, with AI credits spent only where judgment is needed.
  • Trim what you feed the agent. If you only need subject, tags, status, and last_message, use a json pick step on each conversation first. Fewer tokens means lower cost and a sharper summary.
  • Add a small instruction in the prompt to skip conversations with status of spam or deleted so noise does not inflate the volume count.
  • Want the same digest in email too? Add a Send Email node after the Transform step using the same {{ summaryText }}, or branch with a Parallel node to do both at once.

Common Pitfalls

  • Channel name instead of ID. Slack send-message expects a channel ID like C0123456789, not #support. If posting fails, confirm you used the ID.
  • Timezone drift. The schedule timezone determines when "Monday 8am" actually fires. Set an explicit IANA zone rather than relying on a default, or your weekly window can land a day off.
  • Forgetting pagination. A single list-conversations call returns one page. On busy weeks, loop on the page_token cursor or your volume count and themes will only reflect a fraction of the week.
  • Skipping the Response Schema. Without it, the agent may return prose that varies run to run and breaks your Transform formatting. The schema is what makes the digest stable and the fields safe to reference as {{ report.field }}.

Testing

Before enabling the schedule, test on a small scope. Temporarily narrow the Front search query q to a short window (for example yesterday) so the agent has only a handful of conversations to summarize, and point the Slack send-message node at a private test channel rather than your real support channel. Use the Run button to execute the workflow manually, then open the execution log to confirm each step: that list-conversations returned results, that {{ report }} matches your Response Schema exactly, and that the Slack post reads cleanly. Once the digest looks right, widen q back to the full seven-day window, repoint the Slack channel to your support channel, and enable the workflow.

Learn More

Did this answer your question? Thanks for the feedback There was a problem submitting your feedback. Please try again later.