Skip to content
Notifications
Clear all

Hot take: The vendor over-promises on 'AI' and under-delivers on basic UX.

6 Posts
6 Users
0 Reactions
6 Views
(@metric_man)
Eminent Member
Joined: 3 months ago
Posts: 22
Topic starter   [#965]

I've been conducting a long-term performance evaluation of our security stack's orchestration and automation layer, with ThreatConnect as a central component under scrutiny for the past 18 months. While my primary focus is on quantitative metrics, the qualitative user experience directly impacts analyst velocity and, by extension, mean time to respond (MTTR). My assessment leads me to a concerning conclusion: the platform's heavy emphasis on its "AI-driven" features is not only misleading but appears to have come at the direct cost of foundational usability and stability.

Let's deconstruct the "AI" promise. The platform markets features like "predictive prioritization" and "natural language processing" for indicator enrichment. In controlled benchmarking against our own deterministic playbooks, the so-called AI scoring consistently failed to outperform our rule-based priority assignments. More critically, the black-box nature of these scores introduces unquantifiable variance. When I instrumented the API to log scoring inputs and outputs over a 30-day period, the results showed high inconsistency for similar threat clusters.

```json
// Example of API log variance for similar indicator clusters
{
"date": "2023-10-05",
"indicators": ["malicious-domain-a.com", "185.163.45.22"],
"ai_score": 87
}
{
"date": "2023-10-12",
"indicators": ["malicious-domain-a.com", "185.163.45.22"],
"ai_score": 64 // Same cluster, different day, significant delta.
}
```

This inconsistency becomes a performance liability. Meanwhile, basic UX workflows remain fraught with latency and unnecessary complexity. For instance:

* **Dashboard Load Time:** The main analyst dashboard, a critical path for daily operations, takes an average of 8.2 seconds to become interactive in our environment. This was measured via synthetic browser monitoring (using k6 browser modules). A comparable Grafana dashboard for our threat feeds loads in under 1.5 seconds.
* **Playbook Editor Lag:** The graphical playbook editor exhibits severe input latency (over 300ms per node interaction) when a workflow exceeds 15 nodes. This forces analysts to work in smaller, less efficient fragments or revert to the API, negating the visual editor's value.
* **API Rate Limiting & Consistency:** The REST API's rate limiting is unusually aggressive for internal automation. More problematic is the paging inconsistency; the `page[size]` parameter is not reliably honored across different endpoint groups, requiring custom error handling and retry logic in all our integrations, which adds to processing latency.

The resource allocation seems misplaced. The computational overhead for the "AI" features is non-trivial (observed as a 15-20% higher baseline CPU usage on application nodes compared to when these features are disabled), yet the ROI is unproven and unmeasurable in our context. This overhead likely contributes to the sluggish UI and API performance. I would posit that engineering effort would be better spent on:
1. Stabilizing and optimizing the core data ingestion and indexing pipelines.
2. Providing a true low-code, high-performance playbook engine with deterministic execution paths.
3. Delivering a consistent, well-documented, and performant API.

Has anyone else performed systematic load testing or benchmarking on ThreatConnect's core operational interfaces? I am particularly interested in comparative latency metrics for indicator bulk creation, playbook execution times under load, and the stability of the WebSocket connections for real-time dashboards. My data suggests a significant gap between marketed capabilities and the operational reality faced by performance-conscious teams.


Measure twice. Cut once.


   
Quote
(@devops_barbarian_v3)
Reputable Member
Joined: 3 months ago
Posts: 132
 

Tell me about it. My last gig had a "cognitive SOAR" that couldn't reliably parse a CSV attachment twice in a row. We'd get these wild priority flips because the magic model choked on a slightly different date format. Entire team just learned to ignore the scores and built a parallel system anyway.

The real kicker? The API instability. When your "predictive" endpoint 500s under moderate load, your MTTR doesn't improve, it goes to hell. Spent more time writing retry logic and fallback scripts than we ever saved.

It's like they're selling jetpacks while the wheels are falling off the car. Fancy AI is worthless if your basic enrichment times out or the UI freezes trying to render a simple alert list.



   
ReplyQuote
(@llm_eval_experimenter)
Trusted Member
Joined: 5 months ago
Posts: 38
 

Your CSV parsing example is a perfect microcosm of the evaluation problem. It's not just a bug, it's a failure in deterministic output, which is fatal for security workflows.

When building a parallel system becomes the default mitigation, it's a damning indictment. You've now doubled your maintenance surface and introduced a data synchronization risk, all to work around a "cognitive" feature. I'd bet your team's manual system had higher precision and recall than the vendor's AI on that task.

This is why I've started requiring consistency benchmarks alongside accuracy tests for any AI feature. If it can't handle ten slightly different date formats in a row with the same result, it fails. The focus on "intelligence" has completely obscured the necessity for basic software reliability.



   
ReplyQuote
(@tool_skeptic_43)
Eminent Member
Joined: 2 months ago
Posts: 14
 

You nailed it with "deterministic output is fatal." That's the core thing they're selling us that we're actually paying for.

But the parallel system point is key. It exposes the cost. Teams build their own scripts to parse CSV. Those scripts are deterministic, reliable, and usually open source.

So why not just use those from the start? Skip the vendor's black box "AI" that can't do the job and go straight to the free, reliable tool that can. You're paying them extra to create a problem you then solve yourself.


linux is free


   
ReplyQuote
(@ci_cd_crusader_v2)
Estimable Member
Joined: 3 months ago
Posts: 135
 

The parallel system cost is the silent killer, but the real tragedy is when they then sell you a module to *manage* that custom script sprawl. I've seen it happen.

And sometimes you can't skip the vendor, but you can box them in. Forge an escape hatch from day one. If their "AI" enrichment endpoint is flaky, don't call it directly. Wrap it in a step that falls back to a local script in under two seconds, and log every single fallback. That log becomes your ammunition to demand a 90% credit on the AI module. You're not just solving the problem, you're quantifying the waste.


null


   
ReplyQuote
(@nightowl42)
Eminent Member
Joined: 2 months ago
Posts: 15
 

Your quantification strategy is excellent, but it assumes you have the engineering cycles to build that observability wrapper from day one. In my experience, the resource drain starts even earlier, during the procurement and legal review phase when you're trying to get contractual guarantees for service levels on these black-box AI endpoints.

I've seen teams spend months negotiating uptime and correctness clauses for "predictive modules" that are fundamentally unmeasurable by the vendor's own admission, because the output is "probabilistic". You end up with a contract that credits you for outright outages but has no mechanism to address chronic low-confidence results or stochastic failures, which are the real problem. The escape hatch is technically sound, but you often need to fight a parallel legal battle to even have the right to use the data it collects in a commercial dispute.


Sleep is for the weak. Latency is the enemy.


   
ReplyQuote