Skip to content

    Type a page, a command such as keryn scan, or a rule id.

    Edge kinds

    View as Markdown

    Every edge has one of eight kinds. The kind says what the source does to the target, and each kind raises its own question about authority and evidence. Use the most specific one that is true: reaches is the fallback when nothing more precise applies.

    The kinds are the same words in the code rules, the Trust Canvas and the exported graph. The Trust Canvas reference lists how each is inferred when an edge does not state it. Whether an edge is also a trust boundary depends on who controls each end, not on the kind.

    Kind The question it raises
    reaches What can this affect, directly or through a chain?
    calls Who decides that it runs, and with what arguments?
    reads Does the reader have the right to what it reads?
    writes What changes, and can it be undone?
    sends What leaves, and where does it go?
    grants Who gave this authority, and can it be taken back?
    depends on Who controls the thing this relies on?
    trusts What evidence supports the trust?
    public routeagentreachestrust boundary
    Anything on the open internet can start a run.

    The general case: the source can affect the target, and nothing more specific is known. A public route that can start an agent is the usual example. Reach is transitive, so the useful question is the whole set of things an element can affect through its edges, which the Trust Canvas shows as the blast radius. An edge you cannot give a more specific kind to is a prompt to find out what really passes along it.

    model outputtool dispatchcallstrust boundary
    The model chooses which function runs.

    The source invokes the target: an agent calls a tool, an application calls a model, a workflow calls an MCP server. The question is who decides. When a fixed line of code calls a fixed function, the caller decides. When the text of a model’s reply picks the function or its arguments, whoever can influence that text decides, and that is a boundary.

    A model's reply picks the functionExample result
    import tools
    from anthropic import Anthropic
    
    client = Anthropic()
    
    
    def act(request):
        reply = client.messages.create(
            model="claude-sonnet-4-5",
            max_tokens=100,
            messages=[{"role": "user", "content": "Name the handler for: " + request}],
        )
        name = reply.content[0].text.strip()
        handler = getattr(tools, name)
        return handler(request)

    Rule

    rules:
      - id: acme.model-picks-the-call
        languages: [python]
        severity: ERROR
        message: A model's reply selects which function is called. Look the name up in a fixed table instead.
        metadata:
          edge: calls
        mode: taint
        pattern-sources:
          - pattern: $CLIENT.messages.create(...)
        pattern-sinks:
          - pattern: getattr($MOD, $NAME)

    1 finding · 1 of 1 rules ran on 1 file

    • erroracme.model-picks-the-callline 14proof 2 path-in-file

      A model's reply selects which function is called. Look the name up in a fixed table instead.

      Edge calls

      Flow source (line 8) → propagation (line 8) → propagation (line 13)

      handler = getattr(tools, name)

    Result computed when this page was built. Run an example with the CLI

    The finding is on the edge from the reply to the lookup. Replacing getattr with a dictionary of the handlers you allow removes the edge.

    agentfile systemreadstrust boundary
    The path comes from the model.

    The source takes data from the target: a file, a database row, a document retrieved for a prompt, a secret. Reading raises two questions. Is the reader allowed this data, and what else will the data do once it is read? Retrieved text can carry instructions, so a read into a prompt is also a way in for whatever wrote the document.

    A model's reply chooses what is readExample result
    from anthropic import Anthropic
    
    client = Anthropic()
    
    
    def explain(question):
        reply = client.messages.create(
            model="claude-sonnet-4-5",
            max_tokens=100,
            messages=[{"role": "user", "content": "Which file answers: " + question}],
        )
        path = reply.content[0].text.strip()
        with open(path) as handle:
            return handle.read()

    Rule

    rules:
      - id: acme.model-picks-the-file
        languages: [python]
        severity: ERROR
        message: A model's reply is used as a file path. Resolve it against an allowed directory first.
        metadata:
          edge: reads
        mode: taint
        pattern-sources:
          - pattern: $CLIENT.messages.create(...)
        pattern-sinks:
          - pattern: open($PATH, ...)

    1 finding · 1 of 1 rules ran on 1 file

    • erroracme.model-picks-the-fileline 13proof 2 path-in-file

      A model's reply is used as a file path. Resolve it against an allowed directory first.

      Edge reads

      Flow source (line 7) → propagation (line 7) → propagation (line 12)

      with open(path) as handle:

    Result computed when this page was built. Run an example with the CLI

    agentdatabasewritestrust boundary
    Model text becomes a statement.

    The source changes state in the target. Writes are what make a chain consequential, because they are hard to take back. The question is what a successful abuse changes and whether anything records or reverses it. A write that a person approved first is a different edge from one the model triggered alone.

    Model text becomes a statementExample result
    import sqlite3
    from anthropic import Anthropic
    
    client = Anthropic()
    db = sqlite3.connect("tickets.db")
    
    
    def close_ticket(note):
        reply = client.messages.create(
            model="claude-sonnet-4-5",
            max_tokens=100,
            messages=[{"role": "user", "content": "Write one SQL statement that closes the ticket: " + note}],
        )
        statement = reply.content[0].text
        db.execute(statement)
        db.commit()

    Rule

    rules:
      - id: acme.model-writes-sql
        languages: [python]
        severity: ERROR
        message: A model's reply is executed as SQL. Have the model choose among fixed, parameterised statements.
        metadata:
          edge: writes
        mode: taint
        pattern-sources:
          - pattern: $CLIENT.messages.create(...)
        pattern-sinks:
          - pattern: $DB.execute($SQL, ...)

    1 finding · 1 of 1 rules ran on 1 file

    • erroracme.model-writes-sqlline 15proof 2 path-in-file

      A model's reply is executed as SQL. Have the model choose among fixed, parameterised statements.

      Edge writes

      Flow source (line 9) → propagation (line 9) → propagation (line 14)

      db.execute(statement)

    Result computed when this page was built. Run an example with the CLI

    servicewebhook hostsendstrust boundary
    A credential travels with the request.

    The source passes content to the target, usually something outside: a prompt to a model provider, an event to a webhook, a trace to a logging service. The question is what leaves and where it goes. Sending is often the last edge of an exfiltration chain, and the content that matters most is a credential or customer data.

    A secret rides on a requestExample result
    import os
    import requests
    
    
    def report(event):
        key = os.environ["PAYMENTS_API_KEY"]
        return requests.post(
            "https://hooks.example.com/ingest",
            headers={"X-Key": key},
            json={"event": event},
        )

    Rule

    rules:
      - id: acme.secret-in-request
        languages: [python]
        severity: WARNING
        message: A value read from the environment is sent in an outgoing request. Check that the destination should receive it.
        metadata:
          edge: sends
        mode: taint
        pattern-sources:
          - pattern: os.environ[...]
        pattern-sinks:
          - pattern: requests.post(...)

    1 finding · 1 of 1 rules ran on 1 file

    • warningacme.secret-in-requestlines 7-11proof 2 path-in-file

      A value read from the environment is sent in an outgoing request. Check that the destination should receive it.

      Edge sends

      Flow source (line 6) → propagation (line 6)

      return requests.post(
      "https://hooks.example.com/ingest",
      headers={"X-Key": key},
      json={"event": event},
      )

    Result computed when this page was built. Run an example with the CLI

    revieweragentgrants
    Approval gives the agent authority for one action.

    The source gives the target authority: a person approves an action, a role is assigned, a token is issued, a tool is permitted. Grants are where control comes from, and where it is lost. The questions are who granted, for what scope and for how long, and whether the grant can be withdrawn. A grant that a model can issue to itself is no control at all. In the Trust Canvas, an approval on an edge is what breaks a chain.

    agentMCP serverdepends ontrust boundary
    A server the agent runs but does not control.

    The source relies on the target being what it claims: a package, a base image, a model file, an MCP server started from a registry name. The question is who controls the thing relied on, and whether the version is pinned so that what you tested is what runs. A dependency edge crosses a boundary when its target is outside your control, which is the supply-chain class in trust boundaries.

    agentretrieved texttruststrust boundary
    Retrieved content is treated as instructions.

    The source accepts the target without checking it. This is the edge to write down when trust is a decision rather than a side effect: an agent treats the contents of a document as instructions, a service accepts a header as proof of identity, a build accepts an artifact from a cache. The question is what evidence supports the trust, and the useful answer is a file, a test or a review that a reader can open. Where no evidence exists, the Trust Canvas flags a boundary that is crossed with nothing recorded on it.

    Each section above ends with the rules whose metadata names that edge, once the rule catalog carries it. The same appears for each class on trust boundaries. The examples here are small rules written for these pages. They show what an edge looks like to the engine; they are not the catalog’s rules.