Free tool

What exactly would leave my machine?

A worked example of an Evidence Package, field by field. What crosses the boundary, what never does, and the part most privacy pages leave out — where metadata can still be sensitive.

Sent to 1ADK

Every one of these is present in a real package.

entities[].name

PaymentService

What the thing is called in the code.

entities[].type

SERVICE

One of a fixed set of kinds, so two analyses can be compared.

entities[].description

Creates and changes payment operations.

One sentence, written for somebody who does not read code.

entities[].repository_path

app/Services/PaymentService.php

Relative to the repository root. Never an absolute path.

relations[]

svc.payments WRITES_TO db.main

Which component uses which, and how.

interfaces[].path_or_channel

POST /api/payments

The route, not what travels over it.

evidence[].locator

app/Services/PaymentService.php : 40-88

A path and a line range. Not the lines themselves.

claims[].value

Repeating a request with the same reference returns the first payment.

A readable statement, backed by the evidence above.

unknowns[].question

What happens to a payment the provider never confirms?

A question nobody could answer from the code.

coverage[]

REPOSITORY "." PARTIAL, excluded: vendor, node_modules

What was looked at, and what was not.

source.revision

9f3c1a2

The commit this was read at, so the picture has a point in time.

Not sent to 1ADK

Not optional, not a setting. There is nowhere for these to go.

File contents

Never present in the format

There is no field an agent could put a function body into. A description that reads like source is refused, and the whole package is refused with it.

Configuration values

Never present

Nothing out of .env or any configuration file. Names of settings can appear; their values cannot.

Secrets

Refused on arrival

Tokens, passwords, keys, connection strings and cookies. Free text is scanned for the shapes these take and a package carrying one is rejected whole.

Database contents

Never present

No rows, no dumps, no SQL, no customer records.

Absolute paths

Never present

A home directory contains a person's name. Relative paths only.

Repository access

Never requested

No credential, no deploy key, no OAuth grant. There is no field in the product to put one in.

A connection to you

Never opened

1ADK never initiates a connection towards a customer machine. Every exchange starts on your side.

Where metadata can still be sensitive

This is the part a privacy page usually skips. Metadata is not automatically harmless, and the decision is yours to make with the example in front of you rather than after signing up.

  • app/Services/AcmeBankIntegration.php — a path can name a client you have not announced.
  • LayoffQueue — a component name can describe a plan.
  • POST /api/partners/{'{'}id{'}'}/settlement — a route can describe a commercial arrangement.
  • A description can carry business logic that is itself confidential: how a discount is calculated, what a fraud rule looks for.
  • The map as a whole tells a reader where things are and which parts nobody has checked. In the wrong hands that is a useful document.

Two things follow. Read what your agent produced before it becomes part of anything — it is plain JSON in your repository root on either road, and 1ADK puts what arrived in front of you before you approve it. And if a system is sensitive enough that even its component names must not leave your network, do not run this. That is a legitimate position and 1ADK does not have an answer to it today.

  • invented example
  • no account
  • nothing to install
  • read in 4 minutes

Short answer

What reaches 1ADK is a JSON file describing your system: component names, relative paths, kinds, relationships, one-sentence descriptions, claims with the file and line range behind each, open questions, and a record of what was and was not looked at. What never reaches it is source code, configuration values, secrets, data, absolute paths and access of any kind. Whether a person uploads that file or an agent you connected sends it, nothing in it is written into your project until you have read it and approved it.

#The whole file, as it looks on disk

The two columns above are the argument. This is the object itself — a fragment of an Evidence Package for the invented billing system, exactly as an agent writes it.

1adk-package.json Invented example — not a customer
1adk-package.json
{
  "schema": "1adk.evidence-package/1",
  "protocol_version": "1",
  "scan_job_id": "9d1f…",
  "generated_by": { "agent": "claude-code", "version": "…" },
  "source": { "kind": "AGENT_SCAN", "title": "Static scan", "revision": "9f3c1a2" },

  "coverage": [
    { "kind": "REPOSITORY", "scope_key": ".", "status": "PARTIAL",
      "excluded": ["node_modules", "vendor"],
      "reason": "Dependencies were not read." }
  ],

  "limitations": ["Runtime behaviour was not observed; nothing was executed."],

  "entities": [
    { "key": "svc.payments", "type": "SERVICE", "name": "PaymentService",
      "description": "Creates and changes payment operations.",
      "repository_path": "app/Services/PaymentService.php",
      "confidence": "HIGH" },
    { "key": "db.main", "type": "DATABASE", "name": "Main database",
      "description": "Where orders and payments are kept." }
  ],

  "relations": [
    { "from": "svc.payments", "type": "WRITES_TO", "to": "db.main",
      "description": "Records every payment attempt." }
  ],

  "evidence": [
    { "key": "ev.create", "kind": "CODE_REFERENCE",
      "summary": "Where the payment is created.",
      "locator": { "path": "app/Services/PaymentService.php", "lines": "40-88" },
      "confidence": "HIGH" }
  ],

  "claims": [
    { "about": "op.create", "predicate": "idempotency",
      "value": "Repeating a request with the same reference returns the first payment.",
      "perspective": "OBSERVED", "evidence": ["ev.create"] }
  ],

  "unknowns": [
    { "question": "What happens to a payment the provider never confirms?",
      "why_it_matters": "Money may be taken with nothing recorded against it.",
      "reason_kind": "NOT_ESTABLISHED", "priority": "HIGH", "about": "svc.payments" }
  ]
}

Read it as a whole and the pattern is clear: locators without contents, statements without proof-by-assertion, and questions left open on purpose. There is no field in this format that a function body could go into.

#What happens between your disk and the map

  1. The agent writes the file and stops

    The instruction forbids opening a network connection. The file sits next to your repository and nothing has left the machine.

  2. A person reads it

    This step is deliberately manual. An automatic upload would remove the one moment at which a human can see what is about to leave.

  3. Upload over HTTPS, into quarantine

    The bytes land somewhere that is not a project store. Nothing has been parsed yet.

  4. Validation

    Schema, size, the job it claims to belong to, and a sweep of free text for credential shapes. A package carrying one is refused whole.

  5. Your approval

    A validated package waits. You see what is in it and decide whether it becomes part of the project.

  6. The write

    One writer per project, a verified lock, short transactions. If it fails, the store is untouched.

#The exact claim, and the one nobody else makes

What 1ADK says

1ADK does not require access to your repository and does not require uploading source code to 1ADK.

What 1ADK does not say

That nobody else ever sees your source. That would be false: the coding agent which runs the instruction reads your code, and if it is a cloud agent then that vendor sees it, under their terms — the same terms that already apply to every other task you give that agent on that repository. It is a different claim from ours, and merging the two would be dishonest.

If your code may not be read by a cloud agent, run a local one, or do not run this at all.

#What this page does not prove

What this does not do

  • It is an example, not your file. What your agent produces depends on your system; the shape of the format is the same, the content is not.
  • It does not prove the secret sweep catches everything. Nothing could. It is a second line behind the instruction and the human read, and it is described that way deliberately.
  • It says nothing about the coding agent vendor's handling of your source. That is between you and them.
  • It is not a legal document. The privacy page is the one that states retention, deletion and what personal data is held.

Questions people actually ask

No. It is invented, and it always will be — a customer package would never be published here whatever permission existed. What it shows accurately is the shape of the format and the boundary it enforces.

Yes. The agent writes the JSON file into your repository root on either road, so it is on your own disk to open. By hand it stops there and a person uploads it. If you connected your agent, the same file travels over the connection as soon as it is written — and it is still quarantined, still put in front of you, and still written into your project only when you approve it.

Three things stand in the way and none of them is a guarantee: the instruction forbids values and secrets; a person reads what arrived before it is written into the project; and the server refuses a package whose free text carries credential shapes. The reason the file is readable and the approval deliberate is precisely that the first and third are imperfect.

Sometimes, yes — and this page says so rather than glossing over it. A path can name a client. A component name can describe an unannounced product. That is a judgement for you to make with the example in front of you, which is why the example is here.

See it on your own system.

Create a project, have your agent produce the file — by hand or over a connection you opened — and look at it before you decide whether it becomes part of the project. The first map is free and nothing is charged, ever, without your agreement.

Build your project map — free Read the security page