Every feature

What ForgeOps does

ForgeOps connects the signals around a production incident and tells you where to investigate next. Here's the workflow that does it, then everything that feeds it.

Want to see it in action? Explore the live ForgeOps demo →

From an alert to where to look

The job ForgeOps does: catch a production problem, show what changed and who it's hitting, point at where to investigate, and get it to the person who can fix it.

Detect

Find problems before they become bigger incidents.

Automatic grouping

Every exception is fingerprinted from its class, message, and backtrace, so the same bug reported a thousand times shows up as one issue, not a thousand.

Heartbeats

A cron job or recurring task that's supposed to run but silently stopped raises nothing, so nothing would otherwise tell you.

Uptime monitoring

An active check against a real URL, on its own schedule, for the specific case where the app just isn't reachable at all: not something an exception tracker alone can ever see.

Handled exceptions

Code that catches its own error to keep running reports nothing to an exception tracker by default; report it with real context instead, without changing how your code already handles it.

Incident detection

An error-rate spike doesn't just open one more issue; it opens (or updates) one incident, with whatever else changed nearby, a deploy, a slow dependency, a struggling database, already attached to it.

Investigate

See what changed, the likely cause with its evidence, and where to look next.

Session replay

The browser SDK buffers a recording continuously but uploads nothing until an error actually happens; masked by default, played back in a sandboxed frame that can never execute anything it reconstructs.

AI-powered triage

A plain-language summary before anyone opens the backtrace, a search box that understands plain English, and a report that reads itself back to you, every sentence grounded in data the feature was actually given, each running on the operator's own Anthropic key against a real, bounded monthly allowance.

Investigation

An incident's page asks the questions in the order you would: who's affected, what changed, what likely caused it, and which request, query, and dependency to check, ending with a full timeline of what actually happened.

Triage verdict

Every issue and incident opens with one verdict, Needs attention now, Investigate, Monitoring, or Resolved, and the facts behind it, one per line: who it's hurting, how fast it's moving, which endpoint, and what just shipped.

Linked projects

Link the projects that call each other, and an app's error shows the backend error from the very same request, with one trace that runs from the tap to the database.

What changed

A feature flag flipped, a config value edited, a dependency upgraded, a migration run: ForgeOps puts them on one timeline with your deploys, and shows the ones just before an issue started right on the issue.

SQL in a request

An issue opens with the query that took the longest in the request it failed in, how much of the request it cost, and, on PostgreSQL, how the database ran it.

Probable cause

Five named rules, deployment, external dependency, database, database connections, and background job, each scored from real signals already on the incident, and, once GitHub or GitLab is connected, the exact pull request and developer who shipped the change.

Evidence & confidence

A confidence percentage and a bulleted evidence list you can check yourself, on every incident and every generated postmortem, never an unexplained score.

Respond

Get the problem to the person who can fix it.

Alerting

Slack, Microsoft Teams, email, PagerDuty, Opsgenie, or a generic webhook for your own tooling, configured per project, per trigger.

On-call scheduling

A computed rotation, or a fully layered schedule with its own recurrence rules, shown on a calendar you can drag right on the page. One-off overrides for PTO or illness, no rotation to maintain by hand.

Escalation

An escalation policy pages the primary step, then the backup, through whichever channel they've personally set up, until someone actually acknowledges it, not just until an alert was sent.

What feeds the investigation

The data behind an incident's evidence. Each piece makes the likely cause and where to look more specific.

Monitor

The performance, trace, and infrastructure data an incident's likely cause and where to look are built from.

Dashboards

Build dashboards around incidents, errors, performance, and operational trends. Engineers get the detail they work from, and leadership gets to see how production is doing without opening a single incident.

Reports

How many incidents there were, how long they lasted, how many customers they reached, and whether it's getting better: for one application or all of them, on the page or in your inbox on a schedule.

Application health

Controller/action latency and database queries, plus a full nested trace of the one request that was actually slow, correlated the same way an error spike already is.

Custom metrics & infrastructure

Send any named business metric or a reading from your own servers with one call, then chart it on the same dashboards as your errors and latency.

Background jobs

Two distinct signals, how long a job actually took to run and how long it sat waiting in queue before starting, each correlated the same way a request-latency spike already is.

External services

p95 per outbound dependency, trending against its own immediately preceding window, the same comparison an error-rate spike already gets.

For your team and your security review

Access, accounts, and the controls a company needs before it rolls ForgeOps out.

Secure

Give teams access without sacrificing control.

SSO

Every organization brings its own identity provider, but linking an IdP login to an existing account still always has to be proven from the account's own side, never just asserted by the IdP.

Multi-tenant, role-based

organization_id lives on every tenant-owned table directly, and access is always resolved from your own membership: an organization you don't belong to 404s, the same as one that doesn't exist at all.

PII scrubbing

A likely-sensitive value never reaches the job queue in the first place, only the request that reported it: key-name matches and shape-based pattern matching, combined, before anything is persisted.

Agent access

A dedicated write-only triage credential for your own automation, or a real OAuth 2.1 authorization server and MCP endpoint for Claude.ai and any other MCP-speaking client, each one an organization owner has to explicitly approve and can revoke immediately.

Audit logs

Membership changes, project deletions, credential rotations, and more, recorded automatically and filterable in-app on every plan; optionally streamed live to your own security tooling, HMAC-signed so it can prove where it came from.

Want to see it in action?

Explore the live ForgeOps demo, a real production environment with a real incident to follow from detection to resolution.

Explore the Demo