The 2026 context: Agentforce Nonprofit, frozen NPSP, and where a layer fits
If you run Salesforce at a nonprofit in 2026, you are on one of two generations of the product, and the difference matters more than it ever has.
Agentforce Nonprofit is the current generation. Salesforce announced the rename from Nonprofit Cloud on December 2, 2025, attaching prebuilt AI agents for prospect research, participant management, volunteer coverage, and donor support. The Power of Us program changed at the same time: since December 2025, new applicants receive 10 free Agentforce Nonprofit CRM licenses instead of the 10 free NPSP licenses the sector relied on for over a decade.
NPSP is the previous generation, and it is frozen. Salesforce announced the end of innovation for NPSP in 2024. It remains supported, with no announced end-of-life date, but it has not received a new feature in roughly three years, and none of the new AI agents run on it. Moving off it is not an upgrade: Salesforce implementation partners describe the NPSP to Agentforce Nonprofit transition as a full re-implementation with a different data model, typically taking months.
That leaves thousands of nonprofits in the same spot: a stable, paid-for NPSP org that works, a migration project nobody has budgeted, and AI capabilities gated behind the platform they have not moved to.
This is exactly the gap an integration layer fills. Gratefully connects to both generations, NPSP included, through the same standard Salesforce APIs. You do not need to migrate, buy Data Cloud, or license agents to get cited, plain-English answers from the donor data you already have. Weighing the layer against Salesforce's own AI? That comparison lives on its own page: Gratefully vs Salesforce Nonprofit.
"The NPSP orgs I talk to are not unhappy with Salesforce as a system of record. It holds the gifts, the households, the campaign history, and it holds them well. What they cannot do is get intelligence back out of it. The answer to a simple question like 'who is slipping away and why' is technically in there, but it takes a report request, an admin, and a week. That gap is what we built the layer for."
A layer on top of Salesforce, not a replacement
Gratefully connects to Salesforce Nonprofit Cloud (NPC), Agentforce Nonprofit, and the Nonprofit Success Pack (NPSP) via standard REST and Bulk APIs. Salesforce remains your system of record for constituents, gifts, recurring schedules, pledges, soft credits, and campaign hierarchies. Nothing about your org changes: no schema changes, no custom objects, no managed package.
What Gratefully adds is a knowledge graph that combines your structured Salesforce records with the unstructured material Salesforce reporting cannot see: gift officer notes, email threads, meeting recaps, board memos, and attached documents. That combined graph is what lets your team ask questions in plain English and get answers cited back to the specific record, note, or email they came from. More on how the graph works: nonprofit knowledge graphs.
What is a Salesforce intelligence layer?
An intelligence layer is software that connects to Salesforce through its APIs, reads your existing records without modifying them, and adds capabilities on top: natural-language querying, entity resolution across structured and unstructured sources, and cited answers. Salesforce stays the system of record; the layer is where the questions get answered.
Standard, Nonprofit Cloud, and NPSP objects we read
Gratefully consumes both the NPSP and the Nonprofit Cloud object models. No custom fields are required, but custom fields on the objects below are automatically picked up.
| Object | What it gives the knowledge graph | Access |
|---|---|---|
Account (Household / Organization) Pulled with RecordType, Household Naming, and primary contact relationships preserved. | Donor entity, household roll-up, organization profile | Read |
Contact Email, mailing address, do-not-contact flags, salutation rules, and affiliation links. | Individual donor, board member, volunteer, prospect | Read |
Opportunity (Gift / Pledge / Recurring Donation) Includes Stage, CloseDate, Amount, Campaign, and NPSP roll-up fields (npo02__). | Single gifts, soft credits, pledges, recurring schedules | Read |
Campaign + CampaignMember Used for RFM cohorting and natural-language queries like 'donors who gave to the gala but not the annual fund'. | Appeal performance, donor cohorts, segmentation | Read |
Task / Event / ContentNote The unstructured layer most CRMs treat as second-class, and the primary source of institutional memory. | Logged calls, meetings, and free-text notes | Read |
EmailMessage / Activity Body, ToAddress, FromAddress, and ThreadIdentifier indexed for retrieval and entity resolution. | Inbound and outbound donor correspondence | Read |
ContentDocument / Attachment Streamed through the parsing layer; PII detected at write time before being chunked into the knowledge graph. | PDFs, proposals, gift agreements, prospect briefs | Read |
User Enables 'what was David working on?' continuity queries after a staff transition. | Map staff to interaction history for handoff continuity | Read |
Sync architecture: bulk backfill, then change data capture
The first sync is a bulk backfill through Salesforce Bulk API 2.0. For a typical mid-sized nonprofit, 50,000 to 500,000 constituents and one to five million activity records, the backfill completes in under an hour, with adaptive throttling so it does not crowd out your org's own API limits.
From there, the connector subscribes to Change Data Capture on the eight primary objects, so edits, new gifts, and new activities reach the knowledge graph in near real time. If CDC is not enabled in your org, the connector falls back to incremental polling on SystemModstamp, every five minutes by default. Both paths are idempotent and resumable: an interrupted sync picks up where it left off instead of starting over.
Before anything enters the searchable graph, records pass through PII detection, the same redaction pipeline described in our donor data redaction guide.
Authentication and OAuth scopes
Gratefully connects through the standard OAuth 2.0 web server flow against a dedicated Gratefully connected app. Your Salesforce admin installs the connected app, approves the requested scopes, and assigns a least-privilege integration user. The core scopes:
| Scope | Why |
|---|---|
| api | Read access to standard, Nonprofit Cloud, and NPSP objects through the REST and Bulk APIs. This scope also covers reading ContentDocument bodies. |
| refresh_token, offline_access | Lets background sync continue without re-prompting a user. |
That is the full list. No write scopes, no Analytics scopes, and no hybrid-app session scopes are requested.
Refresh tokens are stored encrypted at rest. Your admin can revoke them at any time from Salesforce Setup, and ingestion halts within one polling cycle.
Entity resolution across Salesforce and unstructured sources
The same donor shows up as a Salesforce Contact, a separate Account, a spouse on an Affiliation, an email signature, and a name in a meeting note. Gratefully's resolver ties those mentions together using deterministic keys first (Salesforce IDs, email, household roll-up) and probabilistic matching second (name normalization, address fuzzy matching, affiliation graph traversal). Every resolved mention carries a confidence score and a pointer back to the originating Salesforce record, so an answer can always show its work.
Security boundaries your IT team will want to verify
Read-only by default
The default connected app requests no write scopes. Gratefully cannot create, edit, or delete Salesforce records unless your admin explicitly grants write scope later.
Isolated per-org tenancy
Each nonprofit's data lands in a dedicated encrypted tenant. It never trains shared or third-party models, and that is enforced architecturally, not by policy.
Field-level filtering
Sensitive fields (SSN, payment tokens, protected custom fields) can be excluded at the connector level so they never leave Salesforce.
Full audit trail
Every retrieval, prompt, and generated answer is logged with the originating SObject IDs, exportable for board oversight or incident review.
For the full security model, see Nonprofit AI data security and the Safe AI Policy Pack.
What plain-English queries look like against your Salesforce data
"Which Major Gift Opportunities in Cultivation stage have not had a logged Task in 60 days?"
Resolves: Opportunity.StageName + Task.ActivityDate + OwnerId, answered with citations to each record.
"Summarize everything we know about the Harrison household before tomorrow's meeting."
Resolves: Account household roll-up + Contacts + Opportunities + ContentNotes + EmailMessage threads, synthesized with source links.
"What was David working on across all his Opportunities and Tasks before he left?"
Resolves: User to OwnerId across objects, plus 90 days of unstructured notes.
"Donors who gave to the 2024 Gala Campaign but not the 2025 Annual Fund, sorted by total giving."
Resolves: CampaignMember + Opportunity roll-ups + NPSP household totals.
Do you need Data Cloud or Agentforce to do this?
No. This is the question the 2026 rename created, so it deserves a direct answer.
Salesforce's path to AI on nonprofit data runs through its own stack: Agentforce Nonprofit as the platform, Einstein and agent licensing on top, and Data Cloud where unification across sources is needed. That stack is real, and if you are already migrating to Agentforce Nonprofit, the built-in agents are worth evaluating; the side-by-side comparison covers capabilities and cost honestly, and our longer write-up on why Nonprofit Cloud still needs an intelligence layer explains where the two categories diverge.
But none of it is a prerequisite for an intelligence layer. Gratefully needs three things: API access via the connected app, a least-privilege integration user, and read scope on the objects you approve. Those exist on every Salesforce nonprofit org, including NPSP orgs that will never see an Agentforce agent. The knowledge graph, PII redaction, entity resolution, and cited answers all run on Gratefully's side of the API boundary.
The practical implication: an NPSP org can add modern donor AI this quarter without touching its migration timeline, and an org mid-migration can keep its intelligence layer constant while the CRM underneath it changes. The integration is the same either way.
Setup: under 60 minutes, no managed package
- Authorize. Your Salesforce admin authorizes the Gratefully connected app (read-only scopes) and assigns the integration user profile.
- Scope. Select in-scope objects and custom fields; exclude sensitive fields at the connector level.
- Backfill. The Bulk API 2.0 backfill runs in the background; you can start querying as the first batches land.
- Stay current. Change Data Capture (or fallback polling) keeps the graph current; audit logs and citations are available from the first answer.
Ready to connect Salesforce?
Add an intelligence layer to the Salesforce you already run, NPSP or Nonprofit Cloud, in an afternoon
Salesforce remains the system of record. Gratefully adds the cited, plain-English donor intelligence layer that surfaces everything your team knows, including the parts that never fit in a Salesforce field.
Related reading: Nonprofit Knowledge Graphs whitepaper · AI Data Security guide · Institutional memory loss
Frequently asked questions
Does Gratefully work with NPSP or only the new Nonprofit Cloud?
Both. Gratefully connects to NPSP, Nonprofit Cloud, and Agentforce Nonprofit through the same standard REST and Bulk APIs. NPSP orgs get the full intelligence layer even though Salesforce's own new AI agents do not run on NPSP.
Is Agentforce Nonprofit the same thing as Nonprofit Cloud?
Yes. Salesforce renamed Nonprofit Cloud to Agentforce Nonprofit on December 2, 2025 and added prebuilt AI agents. Both names still appear on Salesforce's own pages, but it is the same underlying platform.
Do I need Salesforce Data Cloud for Gratefully to work?
No. Gratefully builds its knowledge graph on its own infrastructure from data read through the standard APIs. No Data Cloud, Einstein, or agent licensing is required.
Does the integration require a managed package or schema changes?
No. Gratefully uses a connected app with OAuth 2.0 and reads through the REST and Bulk APIs. Nothing is installed in your org and no objects or fields are added.
Can Gratefully write to or change our Salesforce records?
Not by default. The connected app requests read-only scopes. Write access exists only if your admin explicitly grants write scope later.
How long does the initial sync take?
For a typical mid-sized nonprofit (50,000 to 500,000 constituents), the Bulk API 2.0 backfill completes in under an hour, and querying can begin as the first batches land.
What happens if we revoke access?
Your Salesforce admin can revoke the refresh token from Salesforce Setup at any time. Ingestion halts within one polling cycle.
Should we migrate from NPSP before adding an intelligence layer?
The two decisions are independent. The layer connects to both generations, so you can add it now and migrate on your own timeline, or keep it constant through a migration. NPSP remains supported with no announced end-of-life date, though it stopped receiving new features.
About the author
Muddsar Jamil is the founder of Gratefully, the AI workspace built for nonprofit fundraising. He spent 20 years as a software engineer in Silicon Valley at Adobe, Workday, and SugarCRM, and nearly as long volunteering and working with nonprofits across the San Francisco Bay Area. Gratefully is where his two passions meet: technology that helps nonprofits raise more and build deeper donor relationships.