> For the complete documentation index, see [llms.txt](https://docs.pharos.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.pharos.ai/platform-overview/why-pharos.md).

# Why Pharos

Why Pharos — a rich, extensible observability platform built natively for Salesforce, from unified logs and issues to AI analysis and open telemetry export.

Pharos is the observability platform built natively for Salesforce—but it is far more than error tracking. It unifies logs, issues, alerting, ticketing, tracing, monitoring, change tracking, and org insights into one native system; layers **AI** on top to explain and help resolve problems; and stays **open**, so you can stream Salesforce telemetry to the observability tools your teams already run. The result turns reactive troubleshooting into proactive, intelligent system stewardship.

## The Salesforce Observability Gap

Salesforce has historically lagged in developer tooling for comprehensive logging and monitoring. Error reporting is disjointed, ephemeral, and scattered across exception emails, platform events, bulk API queues, and the developer console. This creates a "black box" where engineering teams work reactively, spending days reproducing issues reported by frustrated users.

**Common pain points:**

* Exception emails flood inboxes and get deleted without review
* Bulk API failures stay hidden in job queues no one monitors
* Flow errors arrive as cryptic text without visual context
* Debug logs require manual setup and expire after hours
* No way to tell whether the same error is hitting one user or a thousand

{% hint style="danger" %}
**Real-world impact:** One company discovered their invoice automation had been broken for two weeks—emails silently stopped going out, and nobody noticed until customers did. That gap directly hit revenue. Observability is the difference between finding out in minutes and finding out from an angry customer.
{% endhint %}

## More Than Error Tracking — a Platform

Illuminating the black box is where Pharos starts, not where it stops. Pharos spans the full observability lifecycle and stays extensible at every layer:

| Pillar                   | What it gives you                                                                                                |
| ------------------------ | ---------------------------------------------------------------------------------------------------------------- |
| **Logs & Issues**        | Enriched, persistent logs automatically grouped into de-duplicated Issues with impact statistics                 |
| **Alerting & Ticketing** | Context-rich notifications (Slack, Teams, PagerDuty, Email, Webhooks) and two-way ticketing (Jira, Azure DevOps) |
| **Tracing**              | Automated Salesforce debug-log capture and cross-technology transaction tracing—no manual trace flags            |
| **Monitoring**           | Governor-limit and Event Monitoring so you catch pressure *before* it becomes failure                            |
| **Change Tracking**      | Version-controlled metadata history to correlate new errors with the change that caused them                     |
| **Org Insights**         | Org-level views of complexity, automation, and security posture                                                  |
| **AI (Org Genie)**       | AI-assisted root-cause analysis and remediation, at the issue and org level                                      |
| **Open Telemetry**       | Export Salesforce telemetry to any OpenTelemetry backend—Salesforce joins your enterprise stack                  |
| **Extensibility**        | A rules engine, native APIs, platform events, webhooks, AI-agent operability, and custom instrumentation         |

## Familiar Power, Salesforce-Native

Teams who use Datadog, New Relic, or Splunk know the value of centralized logging, error aggregation, tracing, and intelligent alerting. Pharos brings those same capabilities to Salesforce—with Salesforce-specific intelligence built in, and without exporting your data to get them.

| Capability              | Off-Platform Tools             | Pharos for Salesforce                                                               |
| ----------------------- | ------------------------------ | ----------------------------------------------------------------------------------- |
| **Centralized logging** | Application logs in one place  | Every Salesforce error unified in one native log lake                               |
| **Error aggregation**   | Group similar exceptions       | Fingerprinting tuned per technology (Apex, Flow, Integration, LWC, Bulk API)        |
| **Impact analysis**     | User sessions affected         | Salesforce users *and* records impacted, with occurrence trends                     |
| **Distributed tracing** | Traces across services         | Cross-technology transaction traces (LWC → Apex → Flow) plus auto debug-log capture |
| **AI analysis**         | Anomaly detection / assistants | Org Genie root-cause + remediation, and plain-language investigation via AI agents  |
| **Alert management**    | Rule-based notifications       | Salesforce-aware rules across Slack, Teams, PagerDuty, Email, and Webhooks          |
| **Open standards**      | Native OTLP                    | Export Salesforce signals to any OpenTelemetry backend—no lock-in                   |

## Intelligence: AI That Explains—and Investigates in Plain Language

Pharos doesn't just collect data; it helps you understand it.

**Org Genie** brings AI analysis to the platform. At the **issue level**, it reads the error, its context, and correlated data to propose a likely root cause and remediation. At the **org level**, it surfaces patterns and health signals across the whole environment—turning a wall of logs into a shortlist of what actually needs attention.

**Troubleshoot by asking.** Connect any MCP-capable AI agent to Pharos (via the `@pharosai/mcp` server) and investigate in natural language—no filters, SOQL, or knowledge of Pharos internals required. Ask *"why is checkout failing?"* or *"why did Issue #1234 start, and is anything else broken?"* and the agent scopes the query from your symptom, correlates logs and recent changes, runs AI root-cause analysis, and answers in plain language. It works the full loop—investigate, trace, triage, even open a ticket—**but every change is proposed for your confirmation first.** Root-cause analysis without predefined criteria: you describe the symptom, the agent does the digging.

## Open and Extensible

Native doesn't mean closed. Pharos is built to fit into the ecosystem you already run:

* **OpenTelemetry export (Hermes).** Stream Salesforce telemetry—Triton application logs *and* Salesforce Event Monitoring—as standard OpenTelemetry spans, metrics, and logs to Honeycomb, Splunk, Datadog, Grafana, and other OTLP backends. Salesforce stops being the one tier-one system your SREs can't see, without you giving up your existing tools. *(Early-access capability.)*
* **Triton instrumentation.** An open-source logging framework for Apex, LWC, and Flow that propagates one transaction identity across runtimes—so you get correlated, cross-technology traces from your own code.
* **Automation & APIs.** A flexible rules engine drives alerting, ticketing, monitoring, retention, and masking; and because everything is native, standard Salesforce APIs, platform events, and webhooks are all first-class extension points.

## Native Architecture Advantages

Unlike external monitoring that requires exporting your data, Pharos stores all observability data as native Salesforce objects:

✅ **Security:** Inherits all Salesforce security (profiles, permission sets, sharing)\
✅ **Compliance:** Data never leaves your org unless you choose to export it (HIPAA, GDPR, SOC 2)\
✅ **Integration:** Standard Salesforce APIs for reporting, extension, and data export\
✅ **Performance:** Real-time visibility without export delays\
✅ **Reporting:** Build dashboards with the Salesforce tools you already know

## Pharos in Action

The platform shows its range across very different jobs-to-be-done:

**From alert to fix in minutes.** An Apex exception spikes after a Friday release. Pharos groups every occurrence into one Issue, fires a Slack alert with impact stats, and Org Genie proposes the root cause and a fix. A Jira ticket opens automatically, and resolution is tracked back in Pharos—no one spends the weekend hunting logs.

**Ask, don't filter.** A developer tells their AI agent, *"something's wrong with case routing—dig in."* Through the Pharos MCP server, the agent investigates without any predefined criteria: it scopes the query from the symptom, correlates recent logs and metadata changes, runs AI root-cause analysis, and reports in plain language—then offers to open a ticket, pending confirmation.

**Catch it before it breaks.** Governor-limit and Event Monitoring flag a nightly batch creeping toward its SOQL ceiling *before* it starts failing in production—so the team tunes it on their schedule, not during an incident.

**Blame the right deploy.** A new cluster of errors appears Monday morning. Change Tracking correlates it with a metadata change from the last deployment, pinpointing the culprit instead of guessing.

**Salesforce in your enterprise stack.** Via OpenTelemetry export, Salesforce traces and metrics land in Datadog and Splunk alongside the rest of the company's services—giving SRE teams one correlated view across the whole system, with no vendor lock-in.

**Security and audit as observability.** Salesforce Event Monitoring signals—anomalous logins, API spikes, threat-detection events—surface as first-class telemetry, so security and reliability share the same lens.

## The Pharos Solution

At its core, Pharos resolves three fundamental problems in Salesforce environments—then builds a platform on top of the solution:

| Challenge         | Impact                               | Pharos Solution                                                             |
| ----------------- | ------------------------------------ | --------------------------------------------------------------------------- |
| **Fragmentation** | Errors scattered across many systems | A unified, native log lake as the single source of truth                    |
| **Opacity**       | Vague errors without context         | Enriched logs and traces with full execution state—and AI to interpret them |
| **Noise**         | Alert fatigue from duplicates        | Intelligent fingerprinting, grouping, and impact-ranked alerting            |

{% hint style="success" %}
**Ready to learn more?**

Continue to [How Pharos Does It](https://docs.pharos.ai/platform-overview/how-pharos-does-it.md) for the methodology, or jump to [Pharos Platform Architecture](https://docs.pharos.ai/platform-overview/pharos-platform-architecture.md) to see every component.
{% endhint %}
