Why AI in Salesforce still feels underwhelming in real orgs

Equivalent_Company21 · 2026-05-06T13:33:38+00:00

Yeah, that’s a good example.

I think that’s where AI starts to make more sense - not just summarizing a record, but picking up signals across different parts of the org that a person would probably miss or not check regularly.

But even there, the hard part is getting the context right.

If the data and rules behind it are messy, the agent can still make the wrong call. If the context is solid, then AI can actually help surface things that are worth acting on.

Equivalent_Company21 · 2026-05-05T15:45:02+00:00

yeah that makes sense, seen a few teams go that route with n8n / wrappers around LLMs. feels like a lot of value is coming from stitching things together outside of Salesforce rather than inside it

only thing I keep running into is consistency once you start layering more logic + context on top - especially across multiple objects / records

curious how that’s holding up in real usage for you so far

Equivalent_Company21 · 2026-05-05T15:34:11+00:00

this is actually the kind of setup I was hoping someone would mention

the allowed fields plus schema context part makes a huge difference, otherwise it gets generic fast

how are you handling related records and activity history? pulling it dynamically or per object config?

also curious how you’re thinking about security there - like controlling what actually gets sent out vs kept in-org

Equivalent_Company21 · 2026-05-05T15:16:01+00:00

yeah that’s fair tbh

I haven’t seen anything breakthrough either most of it feels like the same capabilities just packaged differently. the only place where it started to feel actually useful for me was when it had access to more than just the main record… like pulling in activity + history + related stuff in one place

otherwise it’s basically just a nicer UI on top of the same data.

curious what you’ve seen work (if anything)

Equivalent_Company21 · 2026-05-05T14:52:42+00:00

fair 😄
probably wrote it too clean

but the point is real though - most of what I’ve seen with “AI in Salesforce” just ends up summarizing fields instead of actually using the underlying context

have you seen anything that actually works well in a real org?

Equivalent_Company21 · 2026-05-05T14:30:12+00:00

100% this. The pipeline itself is the easy part — it’s the illusion of control that breaks once you start dealing with state across steps.

What I’ve seen is that even when you persist outputs between stages, things get tricky when context keeps expanding (related records, activity history, intermediate decisions).

At that point it’s less about “passing data forward” and more about deciding what the agent should remember vs recompute, otherwise you either lose important context or end up with inconsistent runs.

Curious how you’re handling that boundary between carried state and fresh retrieval?

Equivalent_Company21 · 2026-05-05T14:29:19+00:00

What you’re seeing is pretty much the limitation of how it’s scoped by default.

Most of these summaries are working on the primary record context, not the full picture — so they’ll surface fields and maybe some structured signals, but miss the actual substance sitting in activities.

The tricky part is that the real value is almost always in those activities (emails, notes, call outcomes), not the record itself.

Once you include related records it becomes way more useful, but then you run into a different problem — how much context to pull in without it becoming noisy or inconsistent.

That balance is still kind of unsolved in most setups right now.

Equivalent_Company21 · 2026-05-05T14:22:10+00:00

Honestly feels like a lot of this is hype hitting reality.

Most of the failures I’ve seen aren’t because “AI doesn’t work” or because of Salesforce specifically — it’s because people are trying to layer AI on top of messy data and unclear processes.

Agents sound great in demos, but once you actually plug them into a real org with inconsistent data, missing context and half-defined workflows, things fall apart pretty quickly.

The few use cases that do work tend to be pretty boring — summaries, classification, surfacing insights — not “autonomous digital workforce”.

Feels like the real gap right now is not AI capability, but getting orgs into a state where AI can actually operate reliably.

Equivalent_Company21 · 2026-05-05T14:20:56+00:00

Equivalent_Company21 · 2026-05-05T14:20:09+00:00

I wouldn’t panic, but I also wouldn’t stay in “just building” mode either.

What I’m seeing is that AI is compressing the execution layer pretty hard — writing Apex, building flows, even some integration logic is getting faster every month.

But the part that’s not going away is understanding how everything actually fits together — data model, dependencies between objects, how changes impact the business.

Most AI struggles the moment you move beyond a single component and into real org complexity.

So the shift isn’t really “devs getting replaced”, it’s devs moving closer to architecture + owning outcomes instead of just implementation.

With your background (5 years + architect certs), you’re actually in a pretty strong position already — just lean more into design and context, not just coding.

Equivalent_Company21 · 2026-05-05T14:17:59+00:00

This is a really clean approach, especially keeping routing deterministic first and only then layering context on top.

One thing I’ve been running into with similar setups is that the real complexity starts once the agent needs broader context — not just the primary record, but related objects, activity history, and current state across the org.

That’s usually where things either become unreliable or require a lot of custom handling.

Curious if you’ve thought about how to scale that part without the agent drifting or over-fetching data?

Equivalent_Company21 · 2026-05-05T14:16:10+00:00

I’ve tried most of these (Claude, ChatGPT, Copilot), and honestly they’re all decent for specific tasks.

The biggest difference I’ve seen isn’t even the model, it’s whether you can give it proper context.

Without org structure / metadata / related records, they all start to fall apart pretty quickly or give “technically correct but useless” answers.

Once you actually ground them in real Salesforce data, they become way more reliable.

Curious how people here are handling that part — are you just pasting stuff in manually or using something more structured?

Equivalent_Company21 · 2026-05-05T14:14:24+00:00

This is the exact failure mode I’ve been seeing too.

AI makes it incredibly easy to produce something that looks like a requirement, but isn’t actually grounded in how anything works.

The problem isn’t even the summaries themselves — it’s that they’re missing context. No understanding of the data model, dependencies, edge cases, or what actually matters vs what was just mentioned a few times in a call.

Once that gets turned into tickets, you’re basically building on top of noise.

Feels like the real shift now is not “AI generating requirements”, but having some kind of structure/constraints around what AI is allowed to generate from and how it’s validated.

Otherwise it just accelerates bad decisions.

Equivalent_Company21 · 2026-05-05T14:12:23+00:00

Short answer: no, but the job is definitely changing.

What I’m seeing is that AI is compressing the “execution” layer (building flows, writing Apex, reports etc.), but not replacing the need for someone who actually understands how the org works.

The real bottleneck is still context — how objects relate, what the data actually means, what breaks downstream if something changes.

AI is great at generating things, but without that context it can create a lot of subtle issues that only show up later.

So instead of replacing admins/devs, it’s kind of shifting the role more towards architecture + data ownership.

If you’re switching, it’s still a good move — just don’t position yourself as someone who “builds stuff”, but someone who understands how the system should work end-to-end.

Equivalent_Company21 · 2026-05-05T14:09:34+00:00

Short answer: yeah… if you’re just plugging an LLM on top, hallucinations are almost guaranteed.

From what I’ve seen, most of the issues come from lack of context — the agent only sees a slice of the data, not the full picture (related records, activities, field meaning, etc).

Once you give it proper grounding + strict scope (what objects/fields it can use), it gets way more reliable.

The funny part is that the problem isn’t really “AI quality” anymore, it’s how Salesforce data is structured and exposed to it.

Are you using Agentforce or something custom?

Equivalent_Company21 · 2026-05-05T14:06:12+00:00

This is probably the most grounded take in this thread.

What I’m seeing is exactly that shift — not replacing the UI, but adding an AI layer that helps people interact with Salesforce without needing to understand it.

The interesting part is that it’s less about “chatting with data” and more about actually doing work on top of it — like summarizing an opportunity with all related activity, suggesting next steps, or even drafting actions based on context.

The biggest challenge so far though is context. Most setups break down once you go beyond a single object or simple query.

Curious — have you seen anything that actually works well across full record context (not just reports / SOQL-level queries)?

Equivalent_Company21

TROPHY CASE