Core concepts

Polylane runs a four-step loop:

• Context: connect your stack and the platform builds a live context graph of it.
• Detection: the platform watches that graph and raises issues.
• Investigation: agents answer questions in threads and work confirmed issues in investigations.
• Remediation: autofixes, automations, and skills close the loop.

Every primitive belongs to one of these steps.

Context

The context graph

The context graph is the live model of your stack. Clouds, repositories, integrations, and memories all feed it, and every agent reads from it.

Clouds

Connect a cloud provider and Polylane syncs every resource into the graph, assigns resource tiers, and records every change. See Clouds.

Topology

Topology is the graph view of your infrastructure: resources as nodes, relationships as edges. Each node carries its properties, its wiki, and its change history. The galaxy view renders the same graph spatially. See Topology.

Repositories

Connect a code host and Polylane indexes your code so agents can search and read files. Repositories link to the cloud resources they deploy to. See Repositories.

Integrations

Integrations connect observability providers, chat, code hosts, and coding agents. Each one contributes tools agents can call and events automations can listen to. See Integrations.

Memories

Memories are confirmed findings agents and people record for the next investigation. Relevant memories surface in future threads so agents do not rediscover the same facts. See Memories.

Detection

Issues

An issue is the single detection record: something may be wrong with a resource. Polylane's own checks raise issues, and when a provider alert fires from a connected tool such as Datadog, Sentry, or Honeycomb, it becomes an issue on the same surface. Triage gives every issue a verdict, Incident or No incident, and confirmed issues get an investigation. See Issues.

Change intelligence

Every cloud sync produces change records describing what was added, modified, or removed. Change intelligence summarises them and correlates them with issues. See Change intelligence.

Advisories

Advisories are configuration and reliability recommendations computed against your resources. They point at specific nodes and describe what to change. See Advisories.

Scans

A scan is a full review of a connected account that produces a shareable report. Run one after connecting to get a baseline. See Scans.

Investigation

Threads

A thread is a conversation with an agent that has your full context graph. Threads carry a type: chat when you start one by hand, automation when an automation run opens one, investigation when an agent works a confirmed issue, and hypothesis when a sub-agent tests one hypothesis inside an investigation. See Threads.

Investigations

An investigation is the coordinating agent engagement on one confirmed issue, embedded in the issue itself. It spawns hypothesis sub-agents that test possible causes in parallel and writes everything to the issue timeline. Investigations start from triage, an automation, a chat handoff, or by hand. See Investigations.

Remediation

Automations

An automation is the unattended path: a trigger such as polylane.change_record.created, instructions for the agent, the actions it may take, and destinations such as email, Slack, or a webhook where results land. Every run is a thread. See Automations.

Autofixes

When an agent has a reviewable code fix, it opens a pull request instead of just commenting. An autofix runs on an executor: Polylane's native coding agent, or a connected agent such as Devin, Cursor, or Factory. See Autofix.

Skills

Skills are reusable, named agent workflows. Package an investigation you keep repeating, then threads and automations invoke it consistently. See Skills.

The autonomy model

Agents read by default. Cloud accounts connect read-only, and write calls against them are refused until a workspace admin turns read-only off. Where writes are allowed, every mutating call passes a safety review, and in chat threads it also waits for your explicit confirmation. Code changes always land as pull requests behind your review: an autofix pushes a branch, opens the pull request, and the merge stays with you.