Edge kinds
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? |
reaches
Section titled “reaches”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.
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.
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
- error
acme.model-picks-the-callline 14proof 2 path-in-fileA 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.
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.
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
- error
acme.model-picks-the-fileline 13proof 2 path-in-fileA 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
writes
Section titled “writes”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.
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
- error
acme.model-writes-sqlline 15proof 2 path-in-fileA 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
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.
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
- warning
acme.secret-in-requestlines 7-11proof 2 path-in-fileA 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
grants
Section titled “grants”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.
depends on
Section titled “depends on”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.
trusts
Section titled “trusts”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.
The rules for an edge
Section titled “The rules for an edge”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.