Raiya takes the toil out of running production.
Raiya investigates incidents, answers questions about your stack, and runs the runbooks you've approved.
faster mean time to resolution
One agent for the whole on-call job.
Root cause and blast radius from logs, traces, and metrics, with the evidence attached.
Ask in plain language, across your telemetry and connected tools.
Executes the remediation steps your team has reviewed, and nothing else.
Periodic investigations and health checks, not only when something pages.
When the cause is in your code, it opens a PR for review. It never merges.
Updates Jira or ServiceNow tickets and posts findings to Slack, through MCP.
Enterprise guardrails, real autonomy.
- Your team decides which tools Raiya can use and broadly how it behaves
- Defined in a Kubernetes custom resource, git backed like the rest of your infrastructure
- Every change to what the agent can reach goes through your normal review before it ships
- Cluster tools, like the Kubernetes or OpenShift MCP, use the RBAC your platform team already manages
- No separate permission system to trust
- Tools outside the cluster, such as Atlassian or ServiceNow, keep their own permission model
- Every run records who triggered it, the steps taken, and the tools called
- The recommendation or action produced is recorded too
- Runbooks carry their own change log: what changed, when, and who approved it
Runbooks: your team's playbook, not the agent's improvisation.
- Reviewed the same way your team reviews production changes
- Raiya can only execute a runbook once it's approved
- A given issue gets the same response, whoever is on call
- Automatically, in response to a detected incident
- On a schedule, as a periodic investigation or health check
- Manually, on demand
- Randoli's own team uses this same workflow on our own infrastructure
- It's how we investigate and respond to our own issues
Full production fidelity. You control where inference happens.
- Runs against your actual logs, traces, and metrics as they're generated
- Not a downstream copy or a sampled subset
- Root cause analysis is only as good as the data behind it
- Reasoning runs against the AWS, Azure, Google, Anthropic, or OpenAI account you already control
- Not a relationship Randoli brokers
- Randoli's own control plane never receives your raw telemetry
- A fully self-hosted model option is on the way
- For teams that want inference to never leave their own environment
Already building your own agents? Plug them in.
Raiya doesn't require you to start over. A custom agent your team has already built can be registered as a tool Raiya calls into, using the agent-as-a-tool pattern. It keeps running your own logic; Raiya's CRD-defined permissions and audit trail still govern when and how it's invoked.
How it works
Raiya watches the same OTel signals your team already collects, no separate instrumentation.
It cross-references logs, traces, and metrics to propose root cause with supporting evidence, not just a guess.
Raiya runs a pre-approved runbook, opens a pull request with a code fix, or hands the on-call engineer a contextual report. Nothing runs that your team hasn't permitted.
Meet Raiya, in under 90 seconds.
A short animated walkthrough of the idea behind Raiya: detect, correlate, and resolve, without waiting on a human to open a second tab.
Transcript
Modern systems don't fail quietly. They generate noise, alerts, logs, metrics, traces. SREs spend hours just figuring out what's actually wrong before they can even think about fixing it. What if your system could investigate itself? Meet the Randoli SRE agent, Raiya. It continuously watches your systems, detecting issues as they emerge from anomalies, signals, or even human input. The moment an issue is detected, the agent begins its investigation. It correlates telemetry across logs, metrics, and traces, identifying impact, dependencies, and likely root causes in seconds, not hours. For known issues, the agent can take action. It executes pre-approved runbooks safely with guardrails, mitigating problems before they escalate. Every action is documented. The agent creates a detailed issue report with context, root cause analysis, and remediation steps. So, SREs don't start from scratch. They start informed. Now, SREs and agents work together. Humans guide strategy. Agents handle speed and scale. The result: production issues resolved up to 40% faster, with less noise and more clarity. Randoli SRE agent. When systems don't just alert, they investigate.