What a small computation does is not downstream of a large agent that runs it and gives it authority to do things.
Like, the question is, how do you figure that this giant messy agent will actually follow that contract? Instead of laughing at you when you waste resources on following that contract? The point is, which actions it will perform.
In iterative causal interactions you can use them as choke points, you check what kind of contract I proposed, what kind of delegate bot I sent to you, but when you deal with acausal case, the whole situation chains without choke points.
I have like literally no idea how the notion of contracts helps here.
how do you figure that this giant messy agent will actually follow that contract?
First of all, it’s only useful to figure out to the extent the contract itself can figure it out, otherwise it won’t be able to use that knowledge to coordinate (act depending on how the points of instantiation relate to each other). So your part is just following the contract, not figuring out whether others do. When you are figuring out who is following the contract (if even you are following the contract) on behalf of the contract, as part of considering its instantiation, you need to do so updatelessly, without taking into account the facts of your own situation or knowledge. This corresponds to the various veil of ignorance setups, it’s just updateless reasoning (crucially, contract’s own values don’t need to be the same as your values or anyone else’s values).
There isn’t a specific giant messy agent counterparty that you need to understand (or that the contract needs to understand), it instead needs to understand the whole class of such agents, presented in a way relevant to the contract. For example, it could matter if there are a lot of such agents (something an assurance contract would care about, including an acausal assurance contract), without it being relevant who they are in detail, or whether a specific agent is one of them.
For acausal coordination, it’s probably not useful to consider a specific contract, just like an LLM isn’t about a specific circuit. Instead, you consider (and give influence to) many useful contracts at once, like an LLM considers many circuits at once (and gives them influence over the logits of the output tokens).
Okay. A bit too abstract for me. I’d think the general form should be generalization on top of particular cases where the general form seems to succinctly resolve them. Your way of thinking is kind of unmoored from particulars.
Like, the question is, how do you figure that this giant messy agent will actually follow that contract? Instead of laughing at you when you waste resources on following that contract? The point is, which actions it will perform.
In iterative causal interactions you can use them as choke points, you check what kind of contract I proposed, what kind of delegate bot I sent to you, but when you deal with acausal case, the whole situation chains without choke points.
I have like literally no idea how the notion of contracts helps here.
First of all, it’s only useful to figure out to the extent the contract itself can figure it out, otherwise it won’t be able to use that knowledge to coordinate (act depending on how the points of instantiation relate to each other). So your part is just following the contract, not figuring out whether others do. When you are figuring out who is following the contract (if even you are following the contract) on behalf of the contract, as part of considering its instantiation, you need to do so updatelessly, without taking into account the facts of your own situation or knowledge. This corresponds to the various veil of ignorance setups, it’s just updateless reasoning (crucially, contract’s own values don’t need to be the same as your values or anyone else’s values).
There isn’t a specific giant messy agent counterparty that you need to understand (or that the contract needs to understand), it instead needs to understand the whole class of such agents, presented in a way relevant to the contract. For example, it could matter if there are a lot of such agents (something an assurance contract would care about, including an acausal assurance contract), without it being relevant who they are in detail, or whether a specific agent is one of them.
For acausal coordination, it’s probably not useful to consider a specific contract, just like an LLM isn’t about a specific circuit. Instead, you consider (and give influence to) many useful contracts at once, like an LLM considers many circuits at once (and gives them influence over the logits of the output tokens).
Okay. A bit too abstract for me. I’d think the general form should be generalization on top of particular cases where the general form seems to succinctly resolve them. Your way of thinking is kind of unmoored from particulars.