Skip to content

The cross-harness, self-improving memory layer for AI agents. Join our community: https://discord.com/invite/zdNChS2fBu

docs: add Devin Cloud Agents page + v0.0.67 changelog

shukieshahdfaadbaf5872
diff --git a/docs/changelog/cli.mdx b/docs/changelog/cli.mdx
index e289984e..42020990 100644
--- a/docs/changelog/cli.mdx
+++ b/docs/changelog/cli.mdx
@@ -11,6 +11,12 @@ Stay up to date with the latest changes to the Agent Beacon CLI.
## June 2026
+### v0.0.67 · June 15, 2026
+
+- **Devin Cloud agent telemetry** · Added `beacon cloud devin pull` to capture autonomous [Devin Cloud agent](/runtimes/devin-cloud-agents) telemetry org-wide. Using a Devin organization service key, one central run pulls every user's cloud sessions from the Devin API, normalizes them into Beacon endpoint events (`provider=devin_cloud`), writes the runtime JSONL, and optionally uploads a per-session snapshot to a customer-managed GCS bucket. No per-user or per-sandbox setup is required.
+- **Live and scheduled capture** · `--watch` polls continuously for near-real-time capture; a single sweep (the default) suits cron and CI runners. Re-runs are idempotent — events are deduplicated by Devin event id and unchanged sessions are skipped — and `--full-resync` re-fetches and re-uploads every session for backfills.
+- **Per-user attribution** · Devin Cloud events carry the Devin session id as `run_id` and the Devin user id as `run.actor`, so org-wide telemetry stays attributable per end-user and forwards to any existing SIEM destination over the normalized runtime log. Telemetry is message-level (session lifecycle, prompts, agent messages, status, pull requests, and ACU usage); the Devin API does not expose per-tool or per-command events for autonomous sessions.
+
### v0.0.66 · June 13, 2026
- **Dashboard routing fixes** · Fixed local dashboard route handling so Log Search, Security Overview, Detections, Findings, and inventory views resolve reliably from the loopback dashboard.
diff --git a/docs/docs.json b/docs/docs.json
index 415ffd1b..7bcca76a 100644
--- a/docs/docs.json
+++ b/docs/docs.json
@@ -152,6 +152,7 @@
"sdk/integrations-claude-agent-sdk",
"runtimes/claude-code-cloud-agents",
"runtimes/cursor-cloud-agents",
+ "runtimes/devin-cloud-agents",
"sdk/integrations-openai",
"sdk/integrations-vercel-ai-sdk"
]
@@ -949,6 +950,10 @@
"source": "/cursor-cloud-agents",
"destination": "/runtimes/cursor-cloud-agents"
},
+ {
+ "source": "/devin-cloud-agents",
+ "destination": "/runtimes/devin-cloud-agents"
+ },
{
"source": "/detections",
"destination": "/detections"
diff --git a/docs/runtimes/devin-cloud-agents.mdx b/docs/runtimes/devin-cloud-agents.mdx
new file mode 100644
index 00000000..717b920e
--- /dev/null
+++ b/docs/runtimes/devin-cloud-agents.mdx
@@ -0,0 +1,241 @@
+---
+title: "Devin Cloud Agents"
+description: "Capture autonomous Devin Cloud agent telemetry org-wide with the Beacon CLI and forward it to customer-managed storage or a SIEM"
+---
+
+## Integration Overview
+
+Use this integration to capture telemetry from **autonomous Devin Cloud agents**
+(sessions at [app.devin.ai](https://app.devin.ai)) for every user in your
+organization, using the Beacon CLI. Unlike the [Devin CLI](/runtimes/devin) and
+[Devin Desktop](/runtimes/devin-desktop) integrations — which capture telemetry
+through local hooks — the autonomous Devin Cloud agent does not run the Devin
+hook engine. Beacon instead pulls session activity from the Devin
+**organization API** with a single command you run centrally.
+
+<Info>
+ If you're interested in leveraging this telemetry ingest across your
+ enterprise, [Asymptote Managed](/asymptote-managed) is designed for
+ production cloud-agent telemetry ingest at scale.
+</Info>
+
+## Overview
+
+`beacon cloud devin pull` authenticates to the Devin v3 organization API with an
+organization **service key** and enumerates every user's cloud sessions. It maps
+each session and its messages into Beacon endpoint events, writes them to the
+local runtime JSONL, and — when GCS is configured — uploads a per-session
+snapshot to your bucket. Because the service key is organization-scoped, one
+central runner captures all of your users' Devin Cloud sessions; there is
+nothing to install per user, per repository, or per session.
+
+```mermaid
+flowchart LR
+ DevinCloud["Devin Cloud sessions (all users)"] --> API["Devin v3 org API"]
+ API --> Pull["beacon cloud devin pull (central runner)"]
+ Pull --> RuntimeLog["runtime.jsonl (normalized Beacon events)"]
+ RuntimeLog --> GCS["Customer-managed GCS bucket"]
+ RuntimeLog --> SIEM["SIEM / log forwarders"]
+```
+
+Each session writes one readable JSONL object:
+
+```text
+gs://<bucket>/<prefix>/provider=devin_cloud/user_id=<devin_user_id>/run_id=<devin_session_id>/runtime.jsonl
+```
+
+Beacon uses the Devin session id as the `run_id` and the Devin user id as
+`run.actor`, so cloud sessions are attributable per end-user.
+
+<Note>
+ Telemetry from the autonomous Devin Cloud agent is **message-level**: session
+ lifecycle, submitted prompts, Devin's responses, status, pull requests, and
+ ACU usage. The Devin API does not expose structured per-tool, per-command, or
+ per-file events for autonomous sessions, so command- and file-level detail is
+ not available through this path. For command and file telemetry, use the
+ [Devin CLI](/runtimes/devin) or [Devin Desktop](/runtimes/devin-desktop) hook
+ integrations.
+</Note>
+
+## Prerequisites
+
+- Beacon CLI `v0.0.67` or later.
+- A Devin **organization service key** (`cog_` prefix) and your **organization
+ id** (`org-...`). Create a service user with session-read access under Devin
+ **Settings → Service Users**. A Teams-tier plan is sufficient — an Enterprise
+ plan is not required.
+- A host (workstation, VM, or CI runner) to run the connector centrally, on a
+ schedule or continuously.
+- For GCS upload: `gcloud` installed and authenticated, and a Google Cloud
+ project where you can create a bucket, service account, and IAM bindings. The
+ runner must reach `oauth2.googleapis.com` and `storage.googleapis.com`.
+
+Install or upgrade Beacon:
+
+```bash
+brew tap asymptote-labs/tap
+brew install beacon
+brew upgrade beacon
+beacon version
+```
+
+## 1. Create the GCS Upload Path
+
+Skip this step if you only want events in the local runtime log (for example to
+forward to a SIEM from the runner). To archive per-session snapshots to your own
+bucket, create the upload path with Beacon:
+
+```bash
+export GCP_PROJECT="your-gcp-project"
+export BEACON_TEST_BUCKET="your-beacon-cloud-agent-traces"
+export BEACON_CLOUD_GCS_PREFIX="agent-traces/customer=my-team"
+
+beacon cloud gcs setup \
+ --project "$GCP_PROJECT" \
+ --bucket "$BEACON_TEST_BUCKET" \
+ --location us-central1 \
+ --prefix "$BEACON_CLOUD_GCS_PREFIX" \
+ --service-account beacon-cloud-trace-uploader \
+ --apply \
+ --print-env
+```
+
+Copy the printed `BEACON_CLOUD_GCS_*` values. Treat
+`BEACON_CLOUD_GCS_CREDENTIALS_B64` as a sensitive credential.
+
+## 2. Provide Devin Credentials
+
+On the central runner, export the organization service key and id:
+
+```bash
+export DEVIN_API_KEY="cog_…your_service_key…"
+export DEVIN_ORG_ID="org-…your_organization…"
+```
+
+<Warning>
+ The organization service key can read sessions across your whole org. Keep it
+ on one controlled runner — never distribute it to individual user machines or
+ agent sandboxes.
+</Warning>
+
+## 3. Pull Devin Cloud Telemetry
+
+Preview the mapped events without writing or uploading anything:
+
+```bash
+beacon cloud devin pull --print | jq -c '{action: .event.action, run_id: .run.run_id, actor: .run.actor}'
+```
+
+Run a single sweep (writes the local runtime JSONL):
+
+```bash
+beacon cloud devin pull
+```
+
+Run continuously to capture sessions as users work:
+
+```bash
+beacon cloud devin pull --watch --interval 30s
+```
+
+When the `BEACON_CLOUD_GCS_*` variables from step 1 are exported, each changed
+session's snapshot is also uploaded to your bucket. Re-runs are idempotent —
+events are deduplicated by their Devin event id, and unchanged sessions are
+skipped. Use `--full-resync` to re-fetch and re-upload every session (for a
+backfill, or after enabling GCS on an existing runner).
+
+<Tip>
+ For unattended capture, run the `--watch` command under a process supervisor
+ (systemd, launchd, or a container) or invoke `beacon cloud devin pull` from a
+ cron job / scheduled CI workflow on the central runner.
+</Tip>
+
+## 4. Verify the Upload
+
+```bash
+gcloud storage ls --recursive "gs://${BEACON_TEST_BUCKET}/${BEACON_CLOUD_GCS_PREFIX}/provider=devin_cloud/"
+```
+
+You should see one object per session:
+
+```text
+provider=devin_cloud/user_id=<user_id>/run_id=<session_id>/runtime.jsonl
+```
+
+Inspect a session log:
+
+```bash
+gcloud storage cat "gs://${BEACON_TEST_BUCKET}/${BEACON_CLOUD_GCS_PREFIX}/provider=devin_cloud/user_id=<user_id>/run_id=<session_id>/runtime.jsonl" | jq -c '.event.action'
+```
+
+Expected fields include:
+
+```text
+vendor=beacon
+product=endpoint-agent
+schema_version=1.0
+origin=cloud
+harness.name=devin
+run.provider=devin_cloud
+```
+
+## Forward to a SIEM
+
+The connector writes Devin Cloud events into the same normalized runtime JSONL
+as every other Beacon source, so existing forwarders work unchanged: install a
+destination content pack on the runner and point it at the connector's runtime
+log. Events carry `run.actor=<user_id>` for per-user attribution. See
+[Google Cloud Storage forwarding](/siem-forwarding-gcs) and the other SIEM
+forwarding guides for the available destinations.
+
+## Security Note
+
+This flow keeps your Devin organization service key and (optionally) a
+GCS uploader credential on a single controlled runner. Beacon's use of the Devin
+API is read-only. Retained prompt and message text is routed through Beacon's
+redaction, truncation, and size controls before it is written or uploaded.
+Review access before using this flow with sensitive telemetry.
+
+## Troubleshooting
+
+### No sessions or events
+
+Confirm the service key and org id are correct and reach the API:
+
+```bash
+beacon cloud devin pull --print
+```
+
+A `403` indicates the key is not valid for `DEVIN_ORG_ID`; a `404` usually means
+the organization id is wrong.
+
+### Local events exist but the bucket is empty
+
+Confirm the `BEACON_CLOUD_GCS_*` variables are exported on the runner and that
+the host can reach `oauth2.googleapis.com` and `storage.googleapis.com`. If you
+enabled GCS after an earlier local-only run, use `--full-resync` once to upload
+the already-synced sessions.
+
+### A session shows no `session.ended`
+
+Devin suspends sessions on inactivity. `session.ended` is emitted once a session
+reaches a terminal status (`suspended`, `finished`, or `expired`); an
+in-progress session shows `session.started`, `prompt.submitted`, and
+`agent.message` events until it suspends.
+
+## Related
+
+<Columns cols={2}>
+ <Card title="Devin CLI runtime" icon="terminal" href="/runtimes/devin">
+ Capture command- and file-level Devin telemetry through local CLI hooks.
+ </Card>
+ <Card title="Devin Desktop runtime" icon="display" href="/runtimes/devin-desktop">
+ Capture Devin Desktop (Cascade) telemetry through local hooks.
+ </Card>
+ <Card title="Google Cloud Storage forwarding" icon="database" href="/siem-forwarding-gcs">
+ Review local endpoint GCS forwarding for persistent deployments.
+ </Card>
+ <Card title="Asymptote Managed" icon="cloud" href="/asymptote-managed">
+ Use managed secure ingest for production enterprise cloud-agent telemetry.
+ </Card>
+</Columns>