Coming soon
It sees the problem first
pks-agent-ops
A diagnostic OPS agent in one small binary: point your OpenTelemetry exporters at it, and it investigates failures across traces, metrics, and logs the instant they happen.
Observability tells you something broke. It never does anything about it.
We built telemetry stacks that capture everything — then assigned a human to stare at dashboards and wait. By the time the alert fires, the context is already gone: the hot window has rolled on, and the expensive part is reconstructing what actually happened. Dashboards don't react. Tickets don't react. Humans react slowly. pks-agent-ops inverts it: telemetry lands straight into an agent that investigates on the spot.
Dashboards wait for a human to look. The problem doesn't wait for you to have time.
By the time a ticket lands, the hot window has rolled on — the context has evaporated.
Telemetry without action is just expensive log files waiting for an autopsy.
Three steps. Then it investigates on its own.
Drop the binary next to the system.
One static Go binary — no sidecar zoo, no agent fleet, no runtime to install. Run `pks-agent-ops serve`.
Point your OTLP exporters at it.
The embedded receiver listens on gRPC and HTTP and takes your traces, metrics, and logs exactly as they are. No new SDK, nothing to rewrite.
Let it watch.
It keeps a hot window ready for instant queries, and an autonomous loop steps in the second a pattern breaks — you do nothing.
Ask it directly whenever you want.
Connect Claude Code or Desktop over MCP and ask the same agent questions in plain language: "what went wrong at 2pm?"
Embedded OTLP receiver
gRPC and HTTP in one binary take traces, metrics, and logs directly — no separate collector to operate.
Schema fingerprinting
Every payload gets a structural hash of its shape, not its values — so the agent recognizes patterns without leaking data.
Hot window for instant answers
A sliding DuckDB window keeps the last minutes ready, so investigations are answered immediately.
Autonomous investigation loop
An Anthropic tool-use loop fired by triggers investigates the problem itself — without waiting for a human.
Interactive MCP server
The same tool surface as the autonomous agent, exposed to Claude Code and Desktop, so you can ask directly.
Immutable cold archive
Every hour it writes an LLM-summarized package to a time-indexed, immutable archive — your history never disappears.
Built from the foundation up, not assembled from parts. One static Go binary — the receiver, hot window, memory, archive, and agent loop are ours, not a mesh of third-party services we don't own.
Runs everywhere. Statically linked with no runtime dependencies, it sits beside any system — from your laptop to an isolated production node — without dragging an entire platform tree along.
Owns its own state. DuckDB for the hot window, SQLite for agent memory, and a filesystem archive you control. No external database to trust, no control plane outside your reach.
Layer on layer in the suite. It's the runtime layer beneath your agents: it keeps them healthy while the other layers feed them and ship their work onward.
Composes with
Monitoring waits for an alert. Your agent doesn't.
pks-agent-ops is a single static Go binary you drop next to any system. It receives your OpenTelemetry signals, keeps a hot window ready for instant queries, and runs an autonomous investigation loop that acts the moment a problem appears — long before anyone notices.