u/Dylan-CS

2026-08-12 - Workflow Wednesday - Taming Noisy Alerts with Deduplication

2026-08-12 - Workflow Wednesday - Taming Noisy Alerts with Deduplication

Welcome back to Workflow Wednesday!

If you’ve ever had a single noisy alert turn into endless workflow executions, email notifications, and duplicate cases, this one’s for you.

The new Deduplicate action gives Fusion workflows a simple way to recognize when they’ve already handled the same activity and decide what should happen next - instead of repeating the same work over and over again.

We're just scratching the surface of what you can do with this. You can throttle noisy detection sources, suppress repeat notifications, avoid rerunning expensive enrichment, prevent duplicate remediation actions, or make sure only one workflow execution performs a shared task while the others reuse its result.

At its core, Deduplicate answers one question: Have I already handled this combination of values within this period?

You define that combination by building a key from one or more fields, choose whether the key is scoped to a single workflow or shared across the CID, and set how long the entry should remain active. From there, Fusion handles the coordination.

The Example

Imagine the same phishing campaign targets 25 users. Each email generates a separate detection, but they all share the same detection name, sender, and subject.

Without deduplication, our workflow could create 25 separate cases for what is really one phishing campaign. With deduplication, we can turn that into: 25 phishing detections → 1 case containing all 25 detections

Here’s how.

Step 1: Define the Trigger

We’ll start by creating a workflow with the following trigger:

Detection → NG-SIEM Third Party Detection

Since we don’t want every third-party detection entering this workflow, we’ll add a condition immediately after the trigger to narrow things down to the phishing detections we care about.

For this example, we’ll use:

  • Vendor includes (exact match): Mimecast
  • Name is equal to: Phishing Detection

https://preview.redd.it/68parrv6e2jh1.png?width=1155&format=png&auto=webp&s=7b0d49e21dfdb91f6182bef909333b763b700a2e

This gives us a clean starting point: only the Mimecast phishing detections we want to correlate will continue through the workflow.

From here, we can start deciding whether each detection represents a new phishing campaign or one we’re already tracking.

Step 2: Create the Deduplication Key

Next, we need to decide what makes two detections part of the same activity.

For this example, we’ll combine three fields: Detection Name + Sender + Subject

One important detail: Deduplicate keys can only contain letters, numbers, underscores, and hyphens. That means we can’t pass values like email addresses or subjects directly into the Key field. Instead, use the cs.hash.sha1 Data Transformation function to hash the fields into a valid deduplication key.

In the Key field, we’ll use:

${cs.hash.sha1(data['GetDetectionDetails.name'] + "|" + data['GetDetectionDetails.raw_response'].header_from + "|" + data['GetDetectionDetails.raw_response'].subject)}

Depending on the fields you want to include, you may need to add a Get detection details action first. That’s what I’m doing here so we can pull the sender and subject into the workflow.

Now, any detection with the same detection name, sender, and subject will generate the same hash and resolve to the same deduplication entry for the period we configure.

Step 3: Configure the Scope and Period

Next, we configure how broadly the deduplication entry should apply.

The Deduplicate action supports two scopes:

  • Workflow: The key is shared only between executions of this workflow.
  • CID: The key can be shared across workflows in the CID.

For this example, we’ll use workflow scope, since we only want executions of this phishing workflow to share the entry.

We also need to specify the period in seconds. We’ll use 86400, which gives us a 24-hour deduplication window.

https://preview.redd.it/khsjen7ni2jh1.png?width=461&format=png&auto=webp&s=f15ab718c1053edf25cbb6b62d334c70143bb1ac

Step 4: Branch on Whether It’s a Duplicate

After Deduplicate runs, it tells us whether the key already exists.

We’ll add a condition: If Duplicate is equal to False

That gives us two paths:

  • TRUE: Fusion has not seen this key during the configured period.
  • ELSE: The key already exists, so this execution is a duplicate.

Only the first matching detection follows the TRUE path and performs the primary work.

https://preview.redd.it/vhhek2mlc2jh1.png?width=1363&format=png&auto=webp&s=bf5d3b1fe1d4f4bf2a18119d1eba3729411af556

Step 5: Create the Case

If Duplicate = False, we know this is the first detection associated with this key. Even if several detections with the same key arrive at the exact same time, only one execution can claim the deduplication entry and follow this path.

On the TRUE path, we’ll:

  1. Create a new phishing case.
  2. Include the original Detection ID in the case.
  3. Store the newly created Case ID using Set Deduplicate Entry Metadata.

For the case name, we can use the sender and subject to make it immediately recognizable:

Phishing Campaign - ${data['GetDetectionDetails.raw_response'].header_from} - ${data['GetDetectionDetails.raw_response'].subject}

https://preview.redd.it/5tngasllc2jh1.png?width=906&format=png&auto=webp&s=745f9eac8ae6ce23d622fe6bc9cc474206c28b4e

https://preview.redd.it/z9a8psllc2jh1.png?width=455&format=png&auto=webp&s=63a058e44abb41128df72cff1334003ac91fbab0

Next, add Set Deduplicate Entry Metadata.

Use the same key we created earlier, then set the Metadata field to the Case ID returned by Create a new Case: ${data['CreateANewCase.id']}

This is the important part: we’re attaching the Case ID to the deduplication entry so every duplicate execution knows which case it belongs to.

https://preview.redd.it/ejodf3zri2jh1.png?width=920&format=png&auto=webp&s=ae4463da07e280400dcf6998556d66b14aa8ab81

Step 6: Handle the Duplicates

Now for the ELSE path.

If an execution lands here, Fusion already has an active deduplication entry for that combination of detection name, sender, and subject.

First, add Wait for Deduplicate Entry Metadata and use the same key again.

Why add the wait action? A duplicate detection could arrive milliseconds after the first one - before the original workflow execution has finished creating the case and storing its case ID.

Wait for Deduplicate Entry Metadata handles that timing problem for us. It waits for the original execution to populate the metadata and returns as soon as that value is available.

Once we have the Case ID, we'll use the Add detections to case action.

Set the Case ID to the metadata returned by the previous action: ${data['WaitForDeduplicateEntryMetadata.metadata']}

Then add the current Detection ID to that case.

Note: For the Case ID field, you’ll need to switch to the Text input option and paste the expression above.

https://preview.redd.it/982aptllc2jh1.png?width=886&format=png&auto=webp&s=ada360edd8b796d7f7832e66d2c7e71027d46943

Let's now test our workflow. Here's the first execution for a given key:

https://preview.redd.it/tv9x1bpqj2jh1.png?width=989&format=png&auto=webp&s=4749f472be480f1f620fe419b86d368683984cae

Subsequent execution(s) using the same key:

https://preview.redd.it/5vc37ydcj2jh1.png?width=1006&format=png&auto=webp&s=170caec169eb5331616f9708d23e07a5f14a4371

Instead of creating a new case every time the same phishing campaign generates another detection, each matching detection now gets added back to the case created by the first execution.

The New Actions

The release includes six new actions:

  1. Deduplicate
  2. Set Deduplicate Entry Metadata
  3. Wait for Deduplicate Entry Metadata
  4. View Deduplicate Entry
  5. Delete Deduplicate Entry
  6. View All Deduplicate Entries

These actions give Fusion workflows a native way to suppress duplicate processing, reduce case sprawl, throttle noisy activity, reuse work across executions, and coordinate workflows around shared state.

And a fun detail before I wrap this up:

After writing this post, I asked Claude Code to build the same workflow using the newly released Fusion Skills. It did pretty well!

https://preview.redd.it/9k4qbg5lf2jh1.png?width=1420&format=png&auto=webp&s=b89cf43fd54701474f207bf75da2e20a982dba8e

That deserves its own post, so we’ll dig into how it works in an upcoming Workflow Wednesday.

That’s it for this week!

reddit.com
u/Dylan-CS — 8 days ago

2026-07-15 - Workflow Wednesday - Building an AI Agent with Charlotte AI AgentWorks

Welcome back to another Workflow Wednesday! I have exciting news to share - AgentWorks is now available to all eligible CrowdStrike customers, which means more teams can start building their own Charlotte AI agents directly inside the Falcon platform.

AgentWorks lets teams build, test, and deploy Charlotte AI agents using plain language, tailored to their own workflows and playbooks. These agents are natively integrated with Falcon platform data and include built-in controls for governance and auditability.

Today, we’ll build an AgentWorks agent that helps SOC analysts unify investigations by searching for related cases and detections, connecting relevant activity, and enriching cases with agent analysis.

Step 1: Opting in for Charlotte AI credits

Eligible CrowdStrike customers can opt in directly from the Falcon console to unlock Charlotte AI capabilities across the platform. This includes 50 free Charlotte AI credits, which renew monthly and can be used across supported Charlotte AI features, including AgentWorks.

To opt in, navigate to:

Menu > Charlotte AI > Charlotte AI credits opt-in

A quick note on eligibility: customers must license one of the qualifying Falcon modules, such as Falcon Insight XDR, Falcon Adversary Intelligence Premium, Falcon Counter Adversary Operations Elite, or paid data ingestion with Falcon Next-Gen SIEM. Only users with the Falcon Administrator role can opt in.

Once that’s complete, you’re ready to start building custom agents with AgentWorks.

Step 2: Building the agent

For this example, we’ll build an agent focused on case triage.

When a detection comes in, the agent reviews the available context, checks for related open cases, and determines whether the activity should be added to an existing investigation or used to create a new case.

Navigate to the AgentWorks homepage: Charlotte AI > AgentWorks > Home

Start by entering a prompt that describes what the agent should do, which tools it should use, and what guardrails it should follow.

https://preview.redd.it/owmwbumzogdh1.png?width=1363&format=png&auto=webp&s=e554472b56c6582f6373d072c883233127430173

Here’s the example prompt:

Create an agent that helps SOC analysts group related detections into cases and manage case updates.
Accept detection IDs, usernames, hostnames, time ranges, case IDs, or natural language queries. Query and verify detection details, then correlate activity using case linkage, shared host/user, time proximity, severity, and related context.
Always check for a relevant open case before creating a new one. Match on host, user, detection ID, and time window. If a match exists, ask for approval, then add detections, update severity if needed, fill in the description if blank, and add a markdown case comment with the full analysis. If no match exists, determine if escalation is justified, then ask for approval before creating a new case with a clear name, description, severity, and markdown analysis comment.
Use available case and detection tools, including querying detections/cases, getting case details, creating cases, adding detections, setting severity, adding comments, and asking for clarification. Use Get Graph Version of a Case when required before adding comments. Do not add case tags.
Return an HTML-compatible markdown report with action summary, case reference, detections processed, correlation criteria, affected assets, MITRE ATT&CK coverage, and next steps.
Prioritize accuracy, avoid case sprawl, and never make case changes without human approval.

Then click Start building.

AgentWorks will begin generating the agent. It’ll identify relevant agents, platform tools, integrations, workflows, and knowledge bases in your environment. You heard that right - agents can invoke other agents (both native and custom).

AgentWorks may ask clarifying questions during the build process. Once created, it’ll include a name, description, instructions, and list of tools. You can refine it manually or continue iterating through the prompt panel on the left side of the screen.

https://preview.redd.it/w7lovcy4pgdh1.png?width=1707&format=png&auto=webp&s=021bae64e980f6aca4198596325a2cf4c157f45b

One important tool you’ll likely see listed is ‘Ask for clarification’.

https://preview.redd.it/p5ygsvmzogdh1.png?width=653&format=png&auto=webp&s=24961c7d627166da2468edd8ba91ad04b60d4c90

This tool is optional, but I like to keep it enabled during testing. It’s often useful to have the agent pause and ask for approval before making any changes, such as adding detections to a case, updating severity, or creating a new case. Once you’re comfortable with the agent’s behavior, you can decide whether to keep that approval step or make the agent fully autonomous.

Before we test this, let’s add one more tool to improve the agent’s decision-making ability.

In the agent builder, click the plus button next to Tools. Search for intel, then select Query Intel Indicators under the Platform Tool section. Click Add tool.

https://preview.redd.it/aex2lomzogdh1.png?width=898&format=png&auto=webp&s=ef4c416ca3db9115ae4e3d425a6624f0d3bd06bb

This gives our agent access to CrowdStrike’s threat intelligence database. That context will help the agent make better decisions when grouping detections, identifying suspicious activity, assessing risk, and deciding whether a new case is warranted.

Now we’re ready to test the agent.

Step 3: Testing the agent

On the right side of the AgentWorks screen, you can prompt the agent. I have a suspicious user I’d like to investigate, so I’ll ask the agent to analyze.

Review recent detections for user jdoe

The agent will begin working through the task. It will query detection details, look for related cases, evaluate correlation criteria, and decide what action to recommend.

https://preview.redd.it/pswe7iydpgdh1.png?width=673&format=png&auto=webp&s=40ed18bb444034d408c4db3077afb86f62ce5fe2

You can click View details to inspect each step of the process, including requests made and data returned.

In my test, the agent found several detections tied to jdoe, checked for related cases, analyzed the broader attack chain, and presented a clear summary before recommending the next step:

I found 16 detections for user jdoe forming a clear multi-stage attack chain (phishing → malware execution → post-exploitation → credential dumping on DC02). No existing open cases match. I propose creating ONE combined new case...

https://preview.redd.it/5tukmomzogdh1.png?width=410&format=png&auto=webp&s=686e42bed4980697b758e581d5348493c2d09deb

I'll select Approve - Create the case as proposed, then click proceed.

The agent continues with its instructions, creating the case, adding the detections, attaching its findings as a case note. When we navigate to the case, we can now see a unified case workbench containing the correlated detections, along with the agent’s note.

https://preview.redd.it/lfrvn2ozogdh1.png?width=1491&format=png&auto=webp&s=9d2cfc0921fe7ae033f61c19e667223ae570de86

Step 4: Publishing and using the agent on demand

Once the agent is working as expected, save it in AgentWorks and click Publish.

At this point, the agent is available for your team to use on demand. To launch it, select the Charlotte AI button at the top of the screen, open the Charlotte AI dropdown, choose AgentWorks, and select your newly created agent. From here, analysts can invoke the agent whenever they need help correlating detections, or investigating a suspicious user or host.

https://preview.redd.it/99pypwmzogdh1.png?width=1019&format=png&auto=webp&s=50e8659fac3479035e143ede11959d51aeda04c9

Step 5: Invoking the agent automatically with Fusion

Next to the Publish button back in AgentWorks, you’ll see an option to generate a workflow using this agent. Select it, then open the workflow in Fusion to review and customize the automation.

https://preview.redd.it/eta0ywmzogdh1.png?width=374&format=png&auto=webp&s=e26e36ac896014fcb24c47b87da490d063a398e8

By default, the workflow will likely use a trigger type of Detection. This captures all detections across the platform, including third-party passthrough detections. 

You’ll want to add some conditions to limit the scope. For the first condition, set Product as the parameter. From there, you can scope the workflow to the detection type you care about, such as EPP Detection, NG-SIEM Detection, etc. Click Next.

You can also narrow the scope further by adding a second condition line. Make sure to use the AND operator, then set the parameter to Severity and, as an example, set the operator to is greater than or equal to and set the value to High.

https://preview.redd.it/futnm4sdrgdh1.png?width=1153&format=png&auto=webp&s=c3a1fe535a6487c00da260127eb529994512c6b3

The last step in building the workflow is defining the agent input. Click the Agent action, then confirm the following Detection ID variable is entered into the input box:

${data['Trigger.Detection.DetectionID']}

https://preview.redd.it/rzgr0ubzrgdh1.png?width=935&format=png&auto=webp&s=1d3f7a74107a3c2fe68cb3ec9c6d6fce89869ff7

You can also enter a limit here for Charlotte AI Credit Consumption. Then, click Next.

At this point, the workflow is ready to be saved, published, and enabled.

Once enabled, the workflow will automatically trigger for detections that match the trigger and condition logic you defined. The agent will receive the detection ID, perform its analysis, check for related cases, and either recommend or take approved action based on its instructions.

Note: If you chose to keep Ask for clarification as an enabled tool, those approval requests will appear under: Charlotte AI > Action requests.

Conclusion

That’s it for today’s Workflow Wednesday!

AgentWorks makes it much easier to move from idea to working agent, and we’re now giving every eligible CrowdStrike customer a practical path to get started.

In future posts, we’ll dive further into AgentWorks, including how to build an orchestrator agent that calls other agents, how to define custom input and output schemas, and how to extend agent capabilities with on-demand workflows to connect to external systems.

Let me know in the comments if you have any questions, and feel free to share what you've built already with AgentWorks!

reddit.com
u/Dylan-CS — 1 month ago

2026-06-26 - Workflow Wednesday - Using Case Templates to Bridge Detection and Response

Welcome back to another Workflow Wednesday Friday!

This week, we’re looking at how Fusion Workflows and Next-Gen SIEM Case templates come together to standardize investigations and automate repeatable actions across the case lifecycle.

For this example, we’ll use a common scenario: suspicious remote monitoring and management activity. Falcon Next-Gen SIEM includes several out-of-the-box rules to detect suspicious RMM tool usage. That makes this a perfect example for case templates. Instead of treating each RMM rule as its own separate workflow problem, we can have those rules create cases using the same Suspicious RMM Activity template.

Now, when one of those rules creates a case, the template can guide the investigation, capture the right details, and make post-incident review easier once the case is closed.

What We’re Building

In this example, a Falcon Next-Gen SIEM rule identifies suspicious RMM activity and creates a case using a Suspicious RMM Activity case template.

That rule could be a custom rule you built from scratch, or one of the many out-of-the-box rule templates available in Falcon Next-Gen SIEM.

From there, the case template defines how the case should be handled and which workflows should run as the case moves from creation to closure.

The flow looks like this:

Rule fires
  → Case is created
  → Case template is applied
  → Fusion workflow runs at case creation
  → Analyst investigates
  → Case is closed
  → Fusion workflow runs at case closure

Along with defining custom fields, SLAs, and notification groups, case templates also act as the operational layer between detection and response.

Instead of building separate workflow mappings for every individual rule, teams can associate similar rules with a case template and attach the right workflows to that template. That provides analysts with a consistent process while keeping automation easier to manage over time.

One quick note before we start: your team may choose different actions depending on your own needs or standard operating procedures. The key here is the template, which defines how this type of case should be handled and lets Fusion automate the repeatable steps around that process.

Step 1: Creating the Case Template

To get started, navigate to Next-Gen SIEM → Case Management → Case Templates

From there, click Add case template, then choose Create new.

Give the template a clear name and description.

For this example:

Name: Suspicious RMM Activity

Description:

Used for cases created from suspicious remote monitoring and management tool activity. This template standardizes the initial triage process, analyst tasks, and closure follow-up for suspicious RMM investigations.

If your team uses access scopes to restrict case visibility to certain individuals, you can configure that here as well.

Once the basic template details are set, the next step is to define the workflows that should run when this template is assigned.

Step 2: Adding an Assignment Workflow

Assignment workflows run when a case template is assigned. Once we attach this template to a rule, the workflow will run automatically whenever that rule triggers and creates a case.

On the assignment workflows page, click Create workflow, then continue.

Falcon opens a draft workflow that is already pre-populated with the right starting point:

Trigger: Case > Case Template Assigned
Condition: Template id equals Suspicious RMM Activity

Click Edit draft in the top-right corner to start adding actions.

For this example, the workflow will do three things:

Case template assigned

  1. Query for related events
  2. Send the results to Charlotte AI for analysis
  3. Add the output to the case description

This gives the analyst a better starting point when they open the case. Instead of starting from a blank slate, the case will include an investigative summary based on the events that caused the rule to trigger.

This is just one example of what you can do with an assignment workflow. The workflow should match your team’s SOP. For some teams, that may mean enriching the case with additional context. For others, it may be as simple as adding a standard case description with the steps an analyst should follow during their investigation.

Step 3: Add a Workflow-Specific Event Query

Now, let’s add an action under the True branch.

Click the plus icon under True, then select the flag icon under Sequential. Select Create event query, then choose Workflow-specific query.

Give the query a name, such as: Get rule match events

Now paste the following into the query box:

definetable(
    query={
        createEvents([""])
        | alert_ids:=?alert_ids
        | splitString(field=alert_ids, by=",", as=alert_ids)
        | split(alert_ids)
    },
    include=alert_ids,
    name=alert_id_list
)
| #repo=xdr_indicatorsrepo | Ngsiem.event.type="ngsiem-rule-match-event" | Ngsiem.event.subtype=result_aggregate_event | alert_ids:=Ngsiem.alert.id
| match(file=alert_id_list, strict=true, field=alert_ids, mode=string)

At a high level, this query builds a small table from the alert IDs in the case, searches for NG-SIEM rule match events, and returns the events where the alert ID matches one of the detections associated with the case. This gives Charlotte the same event context that caused the original detection(s) to fire.

https://preview.redd.it/q0p3xzussn9h1.png?width=1257&format=png&auto=webp&s=35439783c4a2ef14537669741ffbda25389d403b

Click Continue, then click Add to workflow.

You’ll notice there is an Alert ids variable in the left-hand panel with an asterisk in it. Replace that asterisk with the following:

${data['Trigger.Case.Alerts']   .transformList(i, t,     t.ID != null ? string(t.ID) : ""   )   .filter(x, x != "")   .join(",")}

https://preview.redd.it/y31ocrussn9h1.png?width=906&format=png&auto=webp&s=43c63128dbedaa53dbe8c64a5651c1ec70b59d5b

This takes the detection(s) associated with the case, extracts their IDs, removes any blank values, and joins them into a comma-separated list.

Now click Next to save the action.

Step 4: Send the Results to Charlotte AI

Next, add a Charlotte AI - LLM Completion action.

For the prompt, keep the instructions focused. We just want it to summarize the relevant activity and give the analyst a useful starting point.

Example prompt:

You are helping a SOC analyst triage a suspicious RMM activity case.
The events related to this case have been provided below. Generate a concise investigation summary suitable for a case description.
Focus on:
- What activity caused the case to be created
- Any users, hosts, tools, commands, or indicators visible in the events
- Why this activity may need analyst review
- Suggested next steps for the analyst
Keep the summary practical and concise. Use markdown formatting.
Events:
${data['WorkflowSpecificEventQuery.results']}

The result should be something an analyst can review as soon as they open the case.

Step 5: Set the Case Description

Finally, add a Set case description action.

Click the Case ID dropdown and select Case ID.

In the Description field, add the output of the Charlotte AI action. By default, that output is: ${data['CharlotteAILLMCompletion.FaaS.nlpassistantapi.llminvocator_handler.completion']}

https://preview.redd.it/o6ycbrussn9h1.png?width=945&format=png&auto=webp&s=7de3fa61aaa601e50a93fec0aaba3a1508319f52

Now, when the analyst opens the case, they’ll find an investigative summary based on the events that triggered the rule.

Here’s an example of what that output may look like:

https://preview.redd.it/13wr3russn9h1.png?width=988&format=png&auto=webp&s=2f936e232704dc97e3ac7ad94695427eb6e09c34

And here’s the completed workflow:

https://preview.redd.it/tcil0russn9h1.png?width=644&format=png&auto=webp&s=7d70b5d95cd8cbe5c3dcd6186ad8bb39034406cc

Once the workflow is ready, click Publish, toggle the workflow status to On, and then click Publish workflow.

Return to the case template tab and click Refresh. You should see the assignment workflow listed with the actions it will run when the template is assigned.

Click Next.

Step 6: Adding Custom Fields and On-Demand Workflows (Optional)

The next page gives you options to add custom fields and on-demand workflows to the case. Custom fields are useful when you want analysts to capture structured information as part of the investigation. On-demand workflows are workflows that analysts can manually execute from within the case.

For this walkthrough, we’ll add a custom field to capture whether the detection needs tuning.

Click the dropdown for Add custom field or workflow, then select Custom field.

Give the field a name, such as: Tuning required?

Next, select the field type. For this example, we’ll use a Dropdown. Add two options: Yes / No

Then, check the box to require this field before the case can be closed. This ensures that the analyst documents whether the detection needs tuning as part of the closeout process.

https://preview.redd.it/g7mjerussn9h1.png?width=883&format=png&auto=webp&s=454c4c75dea5a0535bb0905962e3728b86571fbb

Now click Next.

Step 7: Adding an SLA (Optional)

The next section lets you select an SLA if you have one configured.

You can apply the same SLA to all cases that use this template, or you can set different SLAs by severity.

For example:

  • Critical: 30 minutes
  • High: 2 hours
  • Medium: 8 hours
  • Low: 24 hours

This is useful if your team wants cases to follow a defined response timeline.

Feel free to define an SLA, then click Next.

Step 8: Adding a Closure Workflow (Optional)

Now we can add a workflow that runs when the case is closed.

This is where the case outcome can drive the next action or support post-incident review. For the sake of time, we’re going to skip building the closure workflow in this walkthrough, but the process is the same as the assignment workflow.

Click Save to finalize the template.

Step 9: Assigning the Template to Rules

Now we need to assign the case template to the detection rules.

Navigate to: Next-Gen SIEM → Monitor and Investigate → Rules

Select the rule you want to update. This could be a custom rule or one of the out-of-the-box RMM rule templates that you’ve deployed.

From the Actions dropdown, select Edit.

Click Next to move to the second page of the rule configuration.

Make sure Create case containing detection is selected.

Then use the Case template dropdown to select the new Suspicious RMM Activity template.

Save the rule.

You can repeat this same process for any other RMM rules that should follow the same investigation process.

Now, when any of those rules fire and create a case, the case will use the Suspicious RMM Activity template. The assignment workflow will run when the template is applied, and any closure workflows associated with the template will run when the case is closed.

Reviewing the Final Case

Once the rule fires, open the case that was created.

You should now see the Suspicious RMM Activity template applied to the case. The case description includes the investigation summary generated by Charlotte from the related rule match events.

This gives the analyst immediate context without having to manually reconstruct the event details before starting triage.

You’ll also see the custom field we added earlier, Tuning required?, available in the case details. Since we marked it as required before closure, the analyst will need to select Yes or No before closing the case.

https://preview.redd.it/kupx1svssn9h1.png?width=1605&format=png&auto=webp&s=20601c938437f8baac9bc20ac4a1b4920af990d4

Conclusion

That’s the entire process for creating and assigning a case template. The important thing to remember is that many rules can share the same case template.

For our example, the detection creates the case, the template defines how the case should be handled, and Fusion automates the steps that should happen when the case is created and when it closes. This keeps the investigation process consistent without forcing you to define every rule within a workflow.

The result is a cleaner operating model that scales across case types. Whether you’re focused on RMM activity, suspicious logins, malware detections, credential abuse, cloud misconfigurations, or anything else, case templates give you a consistent way to connect detection, investigation, and automation.

Feel free to let me know what you’d like to see next!

reddit.com
u/Dylan-CS — 2 months ago

Workflow Wednesday: Building Dynamic Lookup Files with Falcon Fusion

Welcome back to another Workflow Wednesday!

This week’s workflow will be focused on using Falcon Fusion to keep lookup files updated automatically, so they can be used for threat hunting and custom correlation rules in Next-Gen SIEM.

Lookup files are useful when tracking things like known bad IPs, critical assets, high-risk users, partner VPN ranges, temporary watchlists, approved admin accounts, or business-specific allowlists and blocklists. The issue is maintenance. If the file is uploaded once and forgotten, the detection logic depending on it starts to age immediately.

Fusion gives us a clean way to handle that. Instead of manually updating a CSV, we can schedule a workflow to pull the latest data, format it, and either create or overwrite the lookup file automatically.

For this example, we’ll be creating a list of known public Tor relay nodes and hunting for traffic to those IP addresses.

What We’re Building

The workflow will pull the latest public Tor relay node addresses from Onionoo, convert the results into a clean IPv4 lookup file, and keep that file updated on a schedule.

Then we’ll reference that lookup file from a custom correlation rule in Falcon Next-Gen SIEM.

The flow is pretty straightforward:

Scheduled Fusion workflow
  → Cloud HTTP request to Onionoo
  → Parse relay addresses
  → Check if the lookup file exists
    → Create it if it does not exist
    → Overwrite it if it does exist
  → Reference the lookup file in a correlation rule

Build the Fusion Workflow

Create a new workflow in Fusion SOAR and choose Create from scratch.

For the trigger, select Scheduled workflow. Set the interval and choose the start time you want. Daily is a good starting point here. If you’re working with faster-moving indicators, you can shorten the interval.

Next, add an action and select Create HTTP Request. Choose Create cloud HTTP Request and click Next.

For authentication, select None

For the endpoint URL, use https://onionoo.torproject.org/details

In the query section, add:

type = relay
fields = or_addresses
running = true

https://preview.redd.it/z8c4npsdbh6h1.png?width=1031&format=png&auto=webp&s=54dd7d9888292cf765b3f081b3382cc84dba86ae

This keeps the API response focused on currently running public Tor relays and only returns the relay address field we need. 

Click Test to validate the request, then click Generate Schema.

https://preview.redd.it/tc35wbudbh6h1.png?width=467&format=png&auto=webp&s=c64cf1460e11070a13fa4f3e8e0c0018c15143cd

Once the schema is generated, click Next.

Create or Overwrite the Lookup File

Fusion has a few actions for managing lookup files, including create, overwrite, and append.

For this workflow, I want the logic to include:

If TORrelays.csv does not exist, create it.
If TORrelays.csv already exists, overwrite it.

Let’s first add an action to Get lookup file metadata.

For the view, select ALL

For the file name, use TORrelays.csv

https://preview.redd.it/gkqptpsdbh6h1.png?width=937&format=png&auto=webp&s=184864837d44d91c8377da60b3a92380f55916a6

Click Next.

Now add a condition under this action. Set the condition to Lookup file exists is equal to False

Click Next twice.

Under the True branch, add an action to Create lookup file. Use the same view and file name:

View: ALL
File name: TORrelays.csv
Content type: plain text

For the lookup file content, use the following expression:

${"ip\n" + data['CloudHTTPRequest.relays']
  .map(relay, relay.or_addresses)
  .flatten()
  .filter(address, !address.startsWith("["))
  .map(address, address.split(":")[0])
  .distinct()
  .join("\n")}

This does a few things at once. It adds the ip header, loops through the relay addresses, drops IPv6 entries, removes the port from the IPv4 addresses, deduplicates the list, and writes one IP per line.

The final output should look like this:

ip
152.53.144.50
188.195.48.170
191.115.245.228
204.137.14.106

https://preview.redd.it/j9y79xsdbh6h1.png?width=1164&format=png&auto=webp&s=26a16666cccdcc0e939148c4c7813e7e43e9ade0

Next, go back to the condition diamond, select the plus icon, and choose the Else branch.

Under Else, add an Overwrite lookup file action. Use the same settings as the create action, including the same file name, content type, and expression.

https://preview.redd.it/fq46vwsdbh6h1.png?width=1511&format=png&auto=webp&s=2ae45c207e96d93be406c792bdc4304061a2c02f

Once that’s done, publish and enable the workflow.

After publishing, use the kebab menu on the right-hand side and select Execute workflow. On the first run, the workflow should take the create branch because the file does not exist yet. On later runs, it should take the overwrite branch and refresh the existing file.

After the run completes, review the lookup file (Next-Gen SIEM -> Log management -> Lookup files). You should see a single column called ip, with each row containing an IPv4 address for a Tor relay node.

https://preview.redd.it/oi5heqydbh6h1.png?width=643&format=png&auto=webp&s=83810df56458600c93061b96f1bc2eaad66cf3e1

Reference the Lookup File in Next-Gen SIEM

Now that Fusion is maintaining the file, we can use it in a query or correlation rule.

Go to Next-Gen SIEM → Advanced Event Search and run:

#event_simpleName=NetworkConnectIP4
| RemoteAddressIP4=*
| match("TORrelays.csv", column="ip", field="RemoteAddressIP4")

// Normalize fields for readability
| TorRelayIP := RemoteAddressIP4
| RemoteEndpoint := format("%s:%s", field=[RemoteAddressIP4, RemotePort])
| LocalEndpoint := format("%s:%s", field=[LocalAddressIP4, LocalPort])
| ProcessName := ContextBaseFileName

// Tor Metrics Relay Search
| format("[Link](https://metrics.torproject.org/rs.html#aggregate/all/%s)", field=["TorRelayIP"], as="Tor Relay Search")

// Group results for triage and tuning
| groupBy(
    [ComputerName, aid, TorRelayIP, RemotePort, ProcessName, "Tor Relay Search"],
    function=[
      count(as=ConnectionCount),
      collect([LocalEndpoint, RemoteEndpoint, Tactic, Technique, TechniqueId, event_simpleName, aip], limit=20)
    ],
    limit=max
  )

This checks for any RemoteAddressIP4 that matches an IP in TORrelays.csv. Feel free to expand the search to include other data sources, such as ones that use destination.ip.

I’d expand the time window while testing. That gives you a better sense of whether you have matches in the environment and whether you need to do any tuning before converting it into a rule.

https://preview.redd.it/1xb7967dgh6h1.png?width=3344&format=png&auto=webp&s=3884c6ccb8e52d4c4b9ae1183c2d89a41ccaa8fe

Once the query looks right, click the Create rule dropdown and select New rule.

Fill out the rule details based on how you want the detection to behave. A reasonable name would be: Network Connection to Known Tor Relay

I’d start with Medium severity. Tor traffic is not automatically malicious, but unexpected traffic to Tor relay infrastructure is worth reviewing in most enterprise environments.

For the rule type, use the option that matches how you want detections created:

Verbose: creates a detection for each result in the query
Summary: combines the results into a single detection

If you want a detection per matching result, use verbose. If you want a single rollup detection, use summary.

A Quick Note on Coverage

This workflow uses public Tor relay data and builds an IPv4-only lookup file. It’s not perfect coverage for every possible Tor scenario. Bridges are handled differently than public relays, and this workflow doesn’t include IPv6. Both could be added later if needed.

The main point is the pattern: Fusion keeps the lookup file current, and Next-Gen SIEM uses that file in a correlation rule. This gives you a repeatable way to bring fresh internal or external data into your detections without turning lookup-file maintenance into another manual task.

Conclusion

In this example, Fusion runs on a schedule, pulls the latest relay data, turns it into a clean lookup file, and keeps that file updated over time. Next-Gen SIEM can then reference the same file in a query or correlation rule.

The same approach would work for threat intel, asset lists, watchlists, allowlists, partner IP ranges, or any other data source that needs to stay fresh.

Feel free to let me know in the comments what you’d like to see next!

reddit.com
u/Dylan-CS — 2 months ago

2026-05-27 - Workflow Wednesday - Human in the Loop Automation

Welcome back to Workflow Wednesday!

Today, we’ll be taking a look at a really important response pattern: human in the loop automation.

We’ll create a Fusion SOAR workflow that triggers on a detection, uses Charlotte AI to triage and summarize that detection, sends the context to a Slack channel, then waits for an analyst to approve or decline containment.

For teams that aren’t ready to jump into the deep end of the Agentic SOC, this gives them a nice middle ground: automated enrichment and orchestration up front, with human judgment before the response action.

What We’re Building

Today’s workflow will:

  • Trigger on a high/critical EPP detection
  • Use Charlotte AI to analyze and summarize the detection
  • Send the detection context and Charlotte verdict to Slack
  • Include a direct link back to the detection in Falcon
  • Wait for a human response
  • Contain the device if the request is approved
  • Record the response if the request is declined

We’re using an EPP detection for this example, but the same pattern can apply across other detection sources too, including Next-Gen SIEM, Identity, SaaS, Cloud, and more.

Step 0: Configure the Slack Action

Before we start building, make sure your Slack SOAR Actions app is configured. The setup steps are documented here: https://docs.crowdstrike.com/r/en-US/wlmfpr5u/bd97f40e/dfe838e5/pf575999/n94f6582

Note: If your team prefers to use email, Fusion SOAR also includes an equivalent action called Request human input - Send email

Step 1: Create a New Workflow

Navigate to Fusion SOAR → Workflows.

Click Create workflow, then select Create workflow from scratch.

For the trigger, search for and select EPP Detection.

Step 2: Add a Severity Condition

Under the trigger, add a Condition block.

Set the condition to Severity is greater than or equal to High

Then click Next twice.

Step 3: Triage the Detection with Charlotte AI

Next, we’ll use Charlotte AI to analyze the detection before asking a human to make a decision.

One quick note: This is an optional step that requires a Charlotte AI subscription. Reach out to your account team to learn more. If you don’t have access to Charlotte AI, feel free to skip this step and continue building the approval workflow without the triage action.

Add a new action under the true branch of the severity condition.

Search for Triage Detection with Charlotte AI and select it.

This uses the Charlotte Detection Triage Agent, which is purpose-built to analyze Falcon detections and provide a verdict with supporting reasoning.

For Detection ID, click the dropdown and select Detection ID.

Click Next.

At this point, Charlotte will analyze the detection and generate a triage result that we can pass into our Slack approval message.

Step 4: Send a Slack Message for Human Input

Now we’ll ask the team to review the detection and decide what should happen next.

Under the Charlotte triage action, add a new action. Search for Request human input - Send Slack message and select it.

First, choose the Slack channel where the message should be sent. This can be a public or private channel within your Slack workspace.

Next, define the message that analysts will see in Slack. 

For this example, we’ll use the following message. If you skipped the Charlotte AI step, remove the Charlotte verdict, confidence, recommendation, and summary fields from the message before continuing.

Containment review needed for ${data['Trigger.Detection.SeverityDisplayName']} severity EPP detection on ${data['Trigger.Detection.EPP.Sensor.Hostname']}

Charlotte AI completed triage and provided context to support your containment decision.

Verdict: ${data['TriageDetectionWithCharlotteAI.FaaS.charlotte_ai.triage_alert.verdict']}
Confidence: ${data['TriageDetectionWithCharlotteAI.FaaS.charlotte_ai.triage_alert.verdict_confidence']}
Recommendation: ${data['TriageDetectionWithCharlotteAI.FaaS.charlotte_ai.triage_alert.recommendation']}

Summary:
${data['TriageDetectionWithCharlotteAI.FaaS.charlotte_ai.triage_alert.agentic_response_summary']}

Detection:
Name: ${data['Trigger.Detection.Name']}
Host: ${data['Trigger.Detection.EPP.Sensor.Hostname']}
User SID: ${data['Trigger.Detection.EPP.Behavior.UserSID']}
Time: ${data['Trigger.Detection.EPP.Behavior.Timestamp']}

Process:
Image: ${data['Trigger.Detection.EPP.Process.ImageFileName']}
Parent: ${data['Trigger.Detection.EPP.ParentProcess.ImageFileName']}
Grandparent: ${data['Trigger.Detection.EPP.GrandParentProcess.ImageFileName']}
Cmd: ${data['Trigger.Detection.EPP.Process.CommandLine']}

This uses workflow variables to make the message dynamic.

Instead of sending a generic “please review this detection” message, Fusion includes the severity, affected host, Charlotte verdict, recommendation, detection details, and process context directly in Slack.

That helps to give the reviewer the context they need to make a containment decision quickly.

Step 5: Include the Detection URL

Next, choose the data you want to include alongside the Slack message.

In the Data to include section, click the dropdown and type url, then select Detection → EPP Detection URL

This adds a direct link back to the detection in Falcon, so the reviewer can quickly pivot from the Slack approval request into the full detection details if they need more context.

https://preview.redd.it/crokbwn6ep3h1.png?width=922&format=png&auto=webp&s=a323e3828b102f4e6c96cf44bbb0349b2a3fdb4e

Step 6: Add Response Options

Now define the available response options.

For this workflow, we’ll select Approve & Decline.

Approve means the workflow should move forward with containment.

Decline means the workflow should not contain the host, but we still want to record the decision for audit and future reference.

After adding the response options, click Next.

Now we need to decide what happens after that response comes back.

https://preview.redd.it/a9oxcvn6ep3h1.png?width=888&format=png&auto=webp&s=f3aadf454000286aacba565880e2c5379e3e5467

Step 7: Add a Condition for Approval

Under the Slack human input action, click the plus button and add a Condition.

Set the condition to Human response is equal to Approve

Click Next twice.

This gives us a true branch where we can place the containment action.

The workflow now says: if an analyst approves the request in Slack, continue to containment.

https://preview.redd.it/hjw29zn6ep3h1.png?width=2048&format=png&auto=webp&s=f7ff126828a1492ae1ff7546e75c7bc4a514c09c

Step 8: Contain the Device

Under the true branch of the approval condition, add a new action.

Search for Contain device and select it.

For Device ID, click the dropdown and select Sensor host ID.

In the Notes field, add any details you want captured as part of the containment action.

A useful option is to include the full Slack response object: ${data['RequestHumanInputSendSlackMessage.result']}

This lets you capture who responded, which option they selected, and any notes they may have included.

Click Next.

Now the approval path is complete.

https://preview.redd.it/bscdd2o6ep3h1.png?width=1942&format=png&auto=webp&s=7bd9fde0577ae1ffc35acac43d8a48ed3839b45a

Step 9: Add a Condition for Decline

Next, go back to the Slack human input action.

Click the plus button again, then select the parallel condition option on the right.

This time, set the condition to Human response is equal to Decline

https://preview.redd.it/5zt9ern6ep3h1.png?width=1458&format=png&auto=webp&s=0744e0c5488685f883bf8d6b932fcd9ecb23d348

Click Next twice.

Under this true branch, add an action to Print data.

For the data, include the Slack response result again: ${data['RequestHumanInputSendSlackMessage.result']}

This gives you a record of the declined response without taking containment action.

https://preview.redd.it/igy31yn6ep3h1.png?width=944&format=png&auto=webp&s=c684ec213f141ba3f407882a6c5da056f66feb87

Step 10: Save, Publish, and Enable

Once the workflow is complete, click Save Draft.

Give it a name, for example Human Approval for High/Critical EPP Containment

Then publish and enable the workflow.

At this point, the workflow is live and ready to run when a matching detection fires.

https://preview.redd.it/xnsgd2o6ep3h1.png?width=952&format=png&auto=webp&s=573e197a025d0ac7c1661315a41558109266005e

Let’s See What Happens

When an EPP detection triggers, Fusion evaluates the workflow. If the severity condition matches, Charlotte AI triages the detection. Fusion then sends a Slack message to the configured channel with the detection context, Charlotte verdict, detection URL, and a link to respond in Falcon.

An analyst reviews the message, then clicks the link to either Approve or Decline within Falcon. If they approve, the host is contained. If they decline, the response is recorded and the workflow stops.

https://preview.redd.it/ugc3k3o6ep3h1.png?width=1230&format=png&auto=webp&s=6552ae092fb48238d684ce6c4a1987db5f5008a2

https://preview.redd.it/3wpeufboep3h1.png?width=1191&format=png&auto=webp&s=456640daec177e4a91d32d396fb02496edb5c79b

Hot off the press: Web Forms for Non-Falcon Users

We just released a new capability that extends this idea even further.

Instead of requiring users to authenticate into Falcon before responding, we can now generate a web form to collect input from either Falcon or non-Falcon users. That could be useful for people-manager approvals, business owner validation, application owner input, or incident-specific data collection.

We’ll save this for a future Workflow Wednesday post.

Conclusion

That’s it for this week!

We’ve walked through how to build a human in the loop response process using Fusion SOAR, Charlotte AI, and Slack. With this workflow, you can now give analysts better context, faster routing, and a simple approval step before action gets taken. By doing so, you're able to accelerate response times without having to give up control.

Drop any questions below, or let us know what workflow you want to see next.

reddit.com
u/Dylan-CS — 3 months ago

2026-05-13 - Workflow Wednesday - Building a One-Click Containment Workflow

Welcome to our first Workflow Wednesday!

We’re starting with a simple but useful pattern: building an on-demand Fusion SOAR workflow that lets an analyst contain a host directly from the case workbench.

The idea is straightforward. If a host is already sitting in a case, the analyst shouldn’t have to bounce between consoles, hunt for the right device ID, or remember which tool owns which action. Containment should be right there.

What We’re Building

Today we’re building an on-demand Fusion SOAR workflow that appears inside the case workbench when a host entity is present.

When the analyst runs it, the host’s Agent ID, or AID in CrowdStrike lingo, gets pulled in automatically. The analyst adds a note, clicks execute, and Falcon contains the device.

Before building from scratch, it’s worth checking the content library. Fusion already ships with 120+ OOTB playbooks that use the On demand trigger. They’re useful for ideas, patterns, and seeing how others have wired these together.

You can find them here - US1, US2, EU1, GOV

One more note before we build: some containment actions are already available directly in the case workbench, but we’re not using those today.

Why? First, they can’t be customized. In this example, we want the analyst to add a note before containment, which the built-in action doesn’t support. Second, they can’t easily be extended across other tools, which matters now that Next-Gen SIEM supports Microsoft Defender and other connected response actions.

For this post, we’re starting with a blank canvas so you can see how the pieces fit together.

Step 1: Create a New Workflow

Navigate to Fusion SOARWorkflows.

Click Create workflow, then select Create workflow from scratch.

The first thing you’ll configure is the trigger. Select On demand.

On-demand triggers are exactly what they sound like: an analyst runs them manually when they need to take action. We’ll get into other trigger types another time. For now, we’ll stick with on-demand.

Step 2: Define the Input Schema

The input schema defines what data gets passed into the workflow at execution time.

That data can come from the analyst manually, automatically from the case entity, or both.

Under root, click the plus button to add a new field.

Since we’re building host containment, the field we need is the machine identifier. In CrowdStrike terms, that’s the Agent ID, or AID.

Set the property name to aid

Click Apply, then select this new field.

Here’s the part that actually matters: the Format should have automatically been set to Sensor ID.

https://preview.redd.it/6v933d1tcx0h1.png?width=1624&format=png&auto=webp&s=14e1be4c75d8d0e7548ab51c5b723c59919cbb75

That format is what tells Falcon how to map this workflow to entities in the case workbench. Because aid is formatted as a Sensor ID, Falcon knows this workflow is relevant to host entities. That’s how it surfaces in the right place when an analyst is looking at a host inside a case.

Click Apply, then Next.

Step 3: Add the Containment Action

Click the green flag under the trigger for Actions.

Search for Contain device and select it.

You’ll see two inputs:

  1. Device ID - required
  2. Note - optional

For Device ID, click the dropdown and select Aid

Fusion should surface the relevant workflow fields automatically.

Leave Note alone for now. We’ll wire that up in the next step.

https://preview.redd.it/1mq9ff1tcx0h1.png?width=904&format=png&auto=webp&s=af633004e0e5b7f00b4d27f0572e2ad618be2f53

Click Next.

Step 4: Add an Analyst Note Field

Go back into the On demand trigger and add a second field under the input schema.

Name it Notes, click Apply, then select it.

If you want analysts to be required to fill this in before executing the workflow, check Required and click Apply.

That makes sense if your process requires business justification for response actions. It’s also useful for future-you, who may be wondering why a host was isolated at 2 AM.

Click Next.

Step 5: Map the Note Into the Action

Go back to the Contain device action.

From the workflow data pane on the right, click on the Notes field and paste it into the Note input.

https://preview.redd.it/tvw4oh1tcx0h1.png?width=1633&format=png&auto=webp&s=eb385e6bb7cf814207d88b4af7c167bc75c0cedb

Now, whatever the analyst types gets passed into the containment action as part of the execution. This note can be found within the workflow execution logs, as well as the fusion audit trail.

Click Next.

That’s the whole workflow.

Step 6: Save, Publish, and Enable

In the top-right corner, click Save Draft.

You’ll need to give it a name. This name shows up in the case workbench, so make it clear and action-oriented.

Something like ‘Isolate Host with Falcon Sensor’.

Then publish and enable the workflow.

Step 7: Let’s See it in Action

Open a case that has a host entity, go to the workbench and click on the host.

On the right side, look for Fusion SOAR workflows.

Your new workflow should be listed there.

https://preview.redd.it/hotauk1tcx0h1.png?width=1400&format=png&auto=webp&s=50b586aa0129325bbfa8598737bd866158b35749

Click the eye icon to view the workflow, or click the lightning bolt to open the execution pane.

Because aid was formatted as Sensor ID, the AID populates automatically from the host entity. The analyst reviews the pre-populated inputs, adds any required notes, and clicks Execute now to run the workflow.

https://preview.redd.it/11tk6c1tcx0h1.png?width=842&format=png&auto=webp&s=a8b2098f72a045025f9a8e75752204e0c52f0a54

Once executed, Falcon contains the host.

Why the Format Field Matters

The key concept tying all of this together is the Format field in the input schema.

The format of the input field determines where the workflow appears in the case workbench and what data gets passed into the workflow automatically.

For this workflow, aid mapped to Sensor ID, which made the workflow available on host entities.

That same idea applies to other entity types too.

Here’s the cheat sheet I’d keep nearby when building these:

Case workbench entity Common input formats you can use
Host / hostname aid, hostname, ipv4, ipv6, cloudInstanceID
IP address ipv4, ipv6, aid, hostname, cloudInstanceID
Domain / DNS request domain, url
User userID, userSID, email, responseUserID
Process aid, commandLine, localFilePath, userSID, sha256, investigatableID
File sha256, md5, localFilePath
Hash sha256, md5

Application in the Wild

Host containment is the obvious starting point, but the same pattern works across a ton of response scenarios.

For hosts, you could build workflows to:

  • Run RTR actions
  • Kill suspicious processes
  • Capture memory dump
  • Collect host details
  • Isolate device via third-party EDR

For users, you could build workflows to:

  • Reset MFA
  • Disable an account
  • Revoke sessions
  • Force password reset
  • Add to a watchlist

For indicators and network entities, you could build workflows to:

  • Block an IP
  • Submit a domain for enrichment
  • Add an IOC
  • Trigger a firewall or proxy action via third-party tooling

The same model applies beyond first-party CrowdStrike actions. If the tool is connected to Fusion and has actions available, you can start chaining together response steps across Falcon and third-party tools from the same case workflow.

Conclusion

That's it for our first Workflow Wednesday! The goal wasn’t to build the most advanced workflow possible. It was to show the basic pattern:

On-demand trigger → input schema → field format → action → Case Workbench

Once that pattern makes sense, the rest is just deciding what should be one click away for your analysts.

Drop any questions, or let us know what workflows you want to see covered next.

reddit.com
u/Dylan-CS — 3 months ago