Polylane

The cloud graph

Nobody remembers how production is actually wired. Your code and cloud in one live, greppable graph, with a wiki that rewrites itself as the system drifts.

Anomalies

No thresholds to tune. An agent reads the actual series and decides, the way you would at 3am.

Change intelligence

Most incidents start with a change. Every sync records exactly what changed, and agents check that first.

Threads and incidents

Every run is a transcript you can watch, interrupt, and share, with every number cited back to its source.

Automations

Describe the job in plain English. Polylane builds the trigger, the instructions, and the allowed actions.

Skills

Typing the same investigation prompt a third time? Make it a skill. Fix it once, every caller inherits the fix.

Autofix

Investigations that end at a line of code end as a pull request. Your review and CI still gate the merge.

Every surface

Console, CLI, API: one platform. The CLI is built for coding agents, and Cmd+. puts the agent on any browser tab.

The cloud graph

• [done] One graph, every cloud: Connect AWS, Cloudflare, Vercel, Fly, and Render, and every resource you run lands in a single living graph with its edges, config, and history.
• [done] Kubernetes: Clusters, workloads, and their churn alongside everything else. Hand us a kubeconfig and EKS wires itself up.
• [done] Wikis that write themselves: Every cloud resource gets living documentation that rewrites itself as your system drifts, and your repositories are indexed for agents to grep.
• [done] Change intelligence: Every sync writes down exactly what appeared, changed, or disappeared. When production breaks, the culprit is usually in here.
• [done] Blast radius: Every anomaly maps the slice of the graph it touches, and the investigation starts from that map: agents walk the affected edges to the offending resource instead of guessing.
• [done] Resource tiers: An agent ranks every resource by how load-bearing it is. Tier one gets watched closest and investigated first, and you can overrule the ranking anytime.
• [planned] Applications: Resources grouped into the applications they serve, so agents know what's load-bearing before they touch anything.
• [planned] More clouds: GCP, Azure, Supabase, Railway, and DigitalOcean. Same graph, same treatment.

Detection without thresholds

• [done] Proactive observability: Agents comb your metrics, logs, traces, and access logs on a cadence and flag what's actually wrong, before your customers do. No thresholds to tune, no alert rules to babysit.
• [done] Observability providers as sources: Datadog, Sentry, Honeycomb, and Axiom join the graph as first-class citizens, and an agent triages every alert they fire the moment it lands.
• [done] Your charts become checks: That dashboard your team curated? Every query and chart saved in a provider gets picked up on the next sync and watched from then on.
• [done] Déjà vu detection: Repeat detections fold into one anomaly instead of re-paging you. An 18x P99 regression is one anomaly, not forty pages.
• [done] Scan reports: Ask for a sweep of a whole account and an agent walks the graph, queries the telemetry, and hands you a written report of what it found.
• [in progress] Telemetry attribution: Logs, metrics, and datasets from your observability providers matched to the exact resources that emit them. No tagging homework, an agent works out the mapping.
• [in progress] Vercel runtime telemetry: Function logs and runtime metrics from Vercel joining the graph, next to the deployments and domains we already sync.
• [planned] Cloud doctor: Like react-doctor, for your cloud. One command grades the whole account: misconfigurations, missing observability, security posture, and the five things to fix first.
• [planned] Cost intelligence: Billing joined to the graph, and agents that point at exactly which resources are burning money for nothing.
• [planned] More providers: Grafana, Splunk, Better Stack, SigNoz, and Logfire, with the same first-class treatment.
• [planned] Closing the loop with product: PostHog, Mixpanel, and Amplitude in the graph, so an incident's blast radius includes what your users actually felt.

From signal to reviewed fix

• [done] Incident threads: Every investigation is a transcript with cited tool calls. Watch it think, interrupt it, hand it to a teammate, or make it public.
• [in progress] Marathon investigations: The agent loop is moving onto durable workflows: investigations that grind for hours, survive restarts, and pick up exactly where they left off.
• [done] Autofix: Investigations that end at a line of code end as a pull request, with a regression test and the evidence trail. You review, you merge.
• [done] Bring your own executor: Route autofix through Cursor or Devin with your own key, or let the built-in agent open the PR.
• [in progress] The next autofix engine: The built-in executor is moving to the open-source pi coding agent, running in the same sandbox with the same review gates.
• [planned] More executors: Claude Code, Codex, and Factory: delegate the fix to whichever agent your team already trusts.
• [done] Memory: Agents remember what they confirm; so can you. Each day the workspace also writes its own notes from your threads, durable facts plus a daily log, so every investigation starts already knowing your system.
• [done] Skills: The way your team debugs, packaged into procedures agents reach for on the next incident. Write them once, benefit every time.
• [planned] Dynamic skills: Agents notice what keeps working and write their own skills, sharpening them with every incident.
• [done] Automations: Cron, webhooks, GitHub events, and alerts trigger agent runs; results land in email, Slack, or your webhook.
• [done] Advisories: Every resource carries its misconfigurations and risks, each one marked fixable in place or with guidance.
• [planned] Agents on your pull requests: A comment when a change looks like tomorrow's incident, an answer when you ask whether it'll break production.
• [planned] Change intelligence for pull requests: Every PR annotated with what it will actually change in your cloud, before you merge instead of after the deploy.
• [planned] Issue trackers: Findings filed as issues in Linear or Jira, where your team already plans work.

Every surface

• [done] A CLI built for coding agents: Structured output, non-interactive flags everywhere, and a skill that teaches Claude Code or Cursor when to reach for it.
• [done] MCP server: The whole platform as tools for any agent that speaks MCP.
• [done] Bring your own MCP: Connect your own MCP servers and their tools show up in the agent's hands mid-investigation.
• [done] Public API: Everything the console does, scriptable.
• [done] Slack: Notifications where your team lives, and investigations you can spin off from any message.
• [in progress] Browser extension: Cmd+. puts the agent on whatever tab you're reading; the page becomes the thread's context.
• [planned] Your incident platforms: An incident fires in PagerDuty or incident.io and an agent is already investigating before anyone picks up the page. Resolved with evidence, not just acknowledged.

I'm Betting My Company on Proactive Agents

Agents can do almost anything you ask. That's the problem, you still have to ask. The next evolution is agents that figure out the job to be done. I started with operations, because nobody should be on-call in 2026.

Jul 5, 2026 · Boris Tane · markdown

Founding Growth

San Francisco, CA · Full-time, in-person · $200k to $400k + meaningful equity · markdown

Founding Engineer

San Francisco, CA · Full-time, in-person · $200k to $400k + meaningful equity · markdown

Founding Researcher

San Francisco, CA · Full-time, in-person · $200k to $400k + meaningful equity · markdown