The intelligence layer beneath enterprise platforms
Know what breaks
before you change it
Deterministic, source-traceable blast-radius analysis for Salesforce. The graph determines correctness; LLMs narrate.
112 ANTLR Parsers
Broad Salesforce metadata coverage — Apex, LWC, Flow, validation rules, fields, permission sets, CPQ, Data Cloud, Einstein settings, Prompt Builder — parsed into typed ASTs.
Execution Graph
Neo4j-backed dependency graph built from real code paths. 150K+ nodes per enterprise org. Not metadata XML — actual execution flow.
Blast Radius
Deterministic impact analysis grounded in source code. Understand downstream impact with graph and source evidence — auditable results, not probabilistic estimates.
How it works
Three steps. No black boxes.
From raw Salesforce metadata to a deterministic blast-radius answer in three deterministic stages. Every result traces back to a line of code.
-
01 — PARSE
Pull metadata, parse the code
OAuth-authenticated sync via the Salesforce CLI pulls broad metadata coverage — about 200 distinct metadata types including CPQ, Data Cloud, Einstein settings, and Prompt Builder. 112 ANTLR parsers turn Apex, LWC, Flow XML, validation rules, formulas, and permission sets into typed ASTs.
Output: typed ASTs, confidence = 1.0 -
02 — GRAPH
Build the execution graph
Walk the ASTs to extract real dependencies — not metadata XML, actual code-level edges. The result is a Neo4j-backed directed graph with up to 150K nodes per enterprise org.
Output: Neo4j graph, every edge traceable -
03 — QUERY
Answer "what breaks if…"
23 pre-built query patterns answer blast-radius, dependency, cross-org, and rename-impact questions in milliseconds. Deterministic by design — same input yields the same answer.
Output: auditable result with source lines
Products
Three products. One graph underneath.
Plexur isn't just a graph — three products sit on top, each unlocking a different way to work with your Salesforce intelligence. They share the same execution graph, so they share the same ground truth.
Axon
Ask your org. Get cited answers.
- Impact, data-quality, debug, permission, process, and semantic-aware questions
- Code-derived claims cite source evidence; metadata-derived claims cite graph metadata
- Multi-tool chaining, up to 50 reasoning hops
Forge
From intent to deployment artifact.
- Four modes: REFACTOR · GENERATE · FIX · MIGRATE
- Full lifecycle: Plan → Sign-off → Build → Deploy → Test → Prod package
- Integrates with your CI/CD — produces the artifact, doesn't replace it
Clarity
Living docs + change co-design.
- Three tiers: org overview · process chains · technical reference
- Auto-regenerated on every validated sync
- Co-design changes by annotating any node in a process chain
One graph. Three products. Every answer, every refactor, every doc traces back to actual code.
Semantic Layer
Your vocabulary, applied to your org
Salesforce field names mean nothing to your business. Plexur's Organizational Truth Registry maps technical metadata to your real terms — so Axon, Forge, and Clarity all speak your language, not Salesforce's.
Organizational Truth Registry
Per-tenant term mapping that translates between Salesforce API names and your business vocabulary. Define it once; every product uses it.
One truth across every org
Same business term applies across Dev, Partial, Full sandboxes, and Prod. When a sandbox calls it StageName and Prod renamed it to Pipeline, the Semantic Layer reconciles both as "Pipeline Stage".
Drives every product
Axon: ask "show me customer deals" — translates correctly. Forge: "rename our pipeline field" resolves to the right technical name. Clarity: docs read in your company's voice, not Salesforce defaults.
Why Plexur
Deterministic-first. LLM-optional.
LLM-only approaches can be probabilistic when not grounded in source evidence. Plexur parses the source code first; LLMs are reserved for narration. Here's the practical difference.
Probabilistic without grounding
- Same question can produce different answers across runs
- Can surface references without verifiable source evidence
- Coverage depends on training data, not what's in your org
- Harder to show the path that justifies an answer
- Harder to evidence for audit or compliance review
- Pay per token — $0.50–$2 per complex query, scales with usage
- Agents pay tokens to reason about your Salesforce structure on each run
Deterministic, source-traceable
- Deterministic — same input produces the same output
- Every code-derived claim cites source evidence; metadata-derived claims cite graph/source metadata
- Broad metadata coverage across supported Salesforce types (incl. CPQ, Data Cloud, Einstein settings, Prompt Builder)
- Designed for audit review, with graph paths and source evidence on each result
- Blast-radius results are deterministic; LLM-generated narratives are evidence-grounded
- Substantially lower per-query cost than LLM-only reasoning
- Agents query Plexur over MCP for deterministic, traceable answers
Plexur is deterministic-first by design. The execution graph determines correctness; LLMs are reserved for narration, summarization, and natural-language UX — never in the blast-radius path. Plexur complements your DevOps and documentation stack: it adds source-traceable change intelligence before the deployment path begins, and produces artifacts that feed Gearset, Copado, Salesforce DevOps Center, and your existing CI/CD — not a replacement.
One way to summarize the wedge: other tools describe the gap between how Salesforce systems are designed and how they behave using AI. Plexur solves it by reading the actual code.
Platform thesis
A graph-native enterprise reasoning layer
Blast radius is the first useful thing the graph does. It isn't the last. Plexur is being built as a foundational reasoning layer for enterprise platforms — Salesforce first, with the same architecture extending to other SaaS and iPaaS systems over time.
Source-traceable, not probabilistic
Every result has a provenance — a graph path back to source code. LLMs narrate; the graph determines correctness. The same property scales from impact analysis to documentation, to refactoring, to agent grounding.
One architecture, many platforms
Parse → graph → query is platform-agnostic. Salesforce is the first and most complex implementation. The same pattern is designed to extend to other SaaS / iPaaS platforms — and our patent claims cover that generalization.
Semantic + structural together
The execution graph carries technical structure; the Semantic Layer maps it to your business vocabulary; downstream tools (Axon, Forge, Clarity) reason over both. Every claim, refactor, and doc trace back to something concrete.
Use cases
What teams use Plexur for
Concrete problems Plexur is designed to prevent.
Stop shipping breakage to prod
Before your release moves from sandbox to production, Plexur shows every downstream component the change touches. QA stops being a guessing game. The "we didn't know that flow read this field" post-mortem stops happening.
Refactor across 18 sandboxes safely
Renaming a field used across dev, partial, and full sandboxes? Plexur traces references across the orgs you've connected and shows what's likely affected where — including paths a human review can miss.
Answer "who can see this field?" in seconds
Auditor asks who has access to a sensitive field. Plexur traces the permission-set graph (sharing rules, OWDs, FLS) and produces an exportable report. No more all-hands archaeology in Setup.
Cheaper, grounded AI agents
Your Claude, GPT, or Cursor agents query Plexur over MCP — deterministic Salesforce answers at substantially lower per-query cost than LLM-only reasoning about your org. Teams running heavy AI workflows see meaningful LLM-bill reductions and fewer hallucination-driven false leads in downstream reasoning.
ROI
From cost center to operating leverage
Plexur replaces several recurring costs across your Salesforce operation. Some show up on a CFO's P&L; others show up as engineering velocity.
Lower-cost AI on Salesforce
Route Salesforce questions through Plexur's MCP server instead of token-intensive LLM-only reasoning about your org structure. Per-query cost is substantially lower because answers come from a graph traversal, not an LLM completion.
Stop the "we didn't know X depended on Y" P1
Deterministic blast radius catches the dependencies humans miss in QA. Fewer prod incidents means less paging, less on-call, less escalation, and fewer post-mortems.
Living docs, not stale wikis
Clarity auto-regenerates docs on every validated sync. Tier 1/2/3 documents stay current without a tech writer touching them. No more "the wiki is 18 months old" archaeology.
Answer in seconds, not days
Auditor asks "who can read this field?" or "what writes to this object?" — Plexur traces the permission and dependency graphs and produces an exportable report. No more all-hands Setup archaeology before every SOX cycle.
Channels
Where Plexur shows up
Three delivery channels for the three products. Pick the one that fits the task.
Web Portal browser · primary UI
The full UI — browse the execution graph, run blast-radius queries, chat with Axon, drive Forge from a form, read Clarity docs, manage tenants, review change-aware diffs across orgs. Built for admins, architects, release managers.
Chrome Extension browser · in-context
Right-click any field, object, or flow on a Salesforce page. Get instant blast radius, dependency list, or Axon-style answer without leaving the org. Zero-friction way to put Plexur in front of admins and devs.
Synapse MCP Server protocol · for AI agents
Plexur exposed via the Model Context Protocol. Claude Desktop, Cursor, Continue, or any MCP-compatible agent can call Plexur as a tool — getting deterministic Salesforce answers at substantially lower per-query cost than LLM-only reasoning. 23 query patterns covering blast radius, dependencies, cross-org, permission analysis, and more.
Security & trust
Designed for enterprise from day one
We shipped privacy and observability infrastructure before we shipped pricing. SOC2 Type 1 audit and external penetration testing planned ahead of GA.
GDPR, CCPA, SOC2-aligned controls
DSAR export tooling with HMAC-signed manifests. Erasure sagas across the platform's backing services. Per-user consent ledger. SOC2-aligned evidence package available under NDA; SOC2 Type 1 audit planned ahead of GA, Type 2 thereafter. Read the Privacy Notice →
Encryption everywhere
AES-256 PBKDF2 (100,000 iterations) for OAuth tokens and PII-classed fields at rest. TLS 1.2+ in transit. Field-level @PiiEncrypted annotation enforced at the JPA layer.
Audit trail on every request
Seven-year audit-log retention. Every authenticated request logs actor, target, action, and outcome. Cross-tenant access returns 404 (not 403) to avoid existence disclosure.
Live system status
Real-time status of seven customer-facing capabilities. 30-day uptime history visible to everyone. We don't hide incidents. status.plexur.ai →
Founder
Built by someone who lived the problem
Nagaraju Padidam
Fifteen years as VP of Enterprise Applications across three M&A-heavy companies — Kony, Temenos, and DTN. Built the IT organization at Kony from zero. Consolidated 167 legacy systems to 73 at DTN, arresting $3M/year in billing leaks. Led the post-$559M-acquisition CRM consolidation at Temenos — three platforms merged, 297 systems rationalized to 157. Two provisional patents on the underlying methodology.
Plexur came out of the M&A pattern that repeated at every company: inherit a Salesforce org from an acquired entity, find that the architects who built it are long gone, and reverse-engineer the dependencies by hand. The map existed — it was in the code. Nobody was reading it. Plexur is the system I wish I'd had every time I had to walk a CFO through why billing was broken.
FAQ
Frequently asked questions
Does Plexur work with Salesforce sandboxes?
How does the initial sync work?
Does Plexur support platforms other than Salesforce?
How is my data secured?
When do pilots start?
How is Plexur different from Gearset, Copado, or Salesforce DevOps Center?
How is Plexur different from Sweep.io?
Sweep is an LLM-reasoning layer over Salesforce metadata XML — impact analysis and documentation are AI-inferred. Plexur is a deterministic ANTLR-AST parser feeding a Neo4j execution graph — 112 parsers covering Apex, LWC, Flow, validation rules, permission sets, plus CPQ, Data Cloud, Einstein settings, and Prompt Builder. Every result derives from actual code paths, with graph and source evidence cited. The graph determines correctness; LLMs narrate.
Practical implications:
• Reproducibility — Plexur's answer is the same on Day 1 and Day 30; LLM-inferred results can vary across runs.
• Code-level depth — Plexur reads inside the trigger to know what fires when; metadata-level analysis stops at the declaration.
• Cross-org reasoning — Plexur traces references across multiple sandboxes with source citations; metadata-only tools have multi-org but at shallower depth.
• Forge vs. Build Mode — Plexur's Forge generates code that feeds Gearset / Copado / DevOps Center pipelines; Sweep's Build Mode is a visual no-code editor — different deployment models.
• Synapse MCP — Plexur leads with MCP as a first-class product for grounding external AI agents in deterministic Salesforce knowledge.
• Semantic Layer (OTR) — Plexur maps business vocabulary to Salesforce API names consistently across sandboxes; no equivalent in Sweep.
Simplest evaluation test: ask both products the same impact question on Day 1 and again on Day 30. Plexur's answer is reproducible by architecture.
Can AI agents query Plexur directly?
How much can Plexur save on my AI bill?
What's the difference between Axon, Forge, and Clarity?
Pilots begin August 2026 · GA 1.0 October 2026
Built for enterprise. Ready for agents.
2 provisional patents · 71 claims · Covers any SaaS/iPaaS platform
nagaraju@plexur.ai