It’s been ten years since I wrote the principles of self-sovereign identity. Though my focus was on identity systems, my underlying concern was always agency: ensuring that individuals remain in control of their own digital lives.
Today that concern is more important than ever because of the deployment of LLM-driven agentic systems. We can increasingly empower agents in the digital ecosystem to compile our searches, to augment our coding, and to generally solve our problems. But how do we do so in a way that supports our autonomy rather than eroding it?
What follows are three views of the agentic future: two problems we need to address and one solution that we can look forward to. They reflect some of the current work I’m doing with various groups on AI, agency, and the future of computing.
View #1: The Authority Problem
The nature of human agency is rapidly changing due to the possibility of agentic delegation and augmentation. Once you could say that an individual’s agency would be maintained by their purposefully and mindfully agreeing to all actions undertaken by an application. But that’s no longer possible when agents can act as superhuman speeds that are too rapid to actively monitor. Maintaining agency therefore requires a change from tactical overview (agreeing to every action) to strategic overview (agreeing to the scope of action and setting boundaries for the activity).
Fortunately, we already have a model that supports this sort of strategic control while maintaining agency: “Principal Authority”. It’s literally part of the Laws of Agency, which define how an agent can be empowered to take on certain tasks. Back in 2021, my work with the Wyoming legislature helped to bring it into the world of digital identity by defining your digital identity as something over which you have Principal Authority.
Following the implicit understanding that an individual has control of their identity, the most important element of Principal Authority is probably its definition of duties. When you are temporarily extending your identity to others, including agents, they must promise to use it in certain ways. Those duties should include many of my original self-sovereign principles, including access, interoperability, minimization, portability, protection, and transparency, as well as many others: agents must work for you in good faith, must put your interests above those of theirs (or rather those of their corporate masters), and must act with reasonable care.
Again, a state legislature has taken the lead on this work. Just this year, Utah passed the state-endorsed digital identity (SEDI) ammendment, which includes a full digital Bill of Rights. Among those Rights is a “Duty of Loyalty”, which says that processors of digital identity must act int he identity holder’s best interest.
Creating similar duties and requirements for LLM agents, to ensure that they are working for you, without hidden agendas, is a crucial milestone as the AI era quickly dawns. Principal authority should be a model for doing so. We must use it so answer questions like: Who is an agent delegating from? What is it tasked to do? How can it undertake that task in the way that best protects the Principal and their data? what are the constraints place on the agent?
I’ve suggested some “predicates” for the Gordian Known Value system that might start to address some of these issues, by allowing users and their agents to record things like:
principalAuthority— The entity with authority over the workassertsDelegationFrom— Agent’s claim of delegation from a principaldelegationScope— Boundaries of delegated authoritydelegationConstraints— Specific limitations on the delegation
But, it’s a starting point, not an end-point.
View #2: The Credit Issue
When you’re using an agent, even if your authority is being protected, another question arises: how do you credit work done?
This isn’t actually a new problem created by AI. Ghost writers have existed for centuries. Collaborations have always involved complex divisions of labor that don’t map cleanly to “author” and “contributor”. What AI does is make the gap undeniable. When an agent is performing actions (or moreso: creating content), we can no longer quietly elide the distinction between “who wrote this” and “who is responsible for it.”
The ghost is visible now.
The question is how we can properly note which work is entirely ours and which is LLM driven. But, it’s not even that simple, as LLMs could be trained largely on our own work, rehashing our arguments and knowledge, or they could be built on the summed-up Wisdom of the Crowd. How do we differentiate between those two situations? And how do we give fair notice to readers who may think differently about spending their time reading an LLM-authored piece, an LLM-supported piece, and a human-written piece?
As I said, the problem goes beyond LLMs and is fundamentally about credit in authorship. Again, I’ve suggested some predicates as a starting point, with my focus not on the question of AI input, but instead what the roles are in a creative process. Those predicates currently include: Author, Editor, Architect, Designer, Manager, ConceptOriginator, Documenter, TechnicalProducer, Curator, Reviewer, Maintainer, MaterialContributor, Performer, IntellectualContributor.
Do we need more? Less? And are these sufficient to also define LLM-driven work on a piece?
View #3: The Self-Sovereign Computing Solution
Though I’ve talked so far about the work I’ve been doing on issues (or at the least, “new questions”) that are arising from the LLM revolution, it’s also important to talk about some of the advantages. And one of the advantages is a growth in the potential of a topic that I’ve addressed before: self-sovereign computing.
In my original article on “self-soveriegn computing”, I talked about how you could control your digital destiny by running your own tools on your own local machine. It was yet another way to address the issue of agency.
Local AI on your own silicon is Self-Sovereign Computing in practice. Apple Silicon + MLX + local models make it real infrastructure. There’s no cloud dependency, no data leaving your machine, no subscription toll. Your data stays on your device. Your inference runs on your hardware. No API key is required.
It’s also really coming of its own. Some recent advancements in leveraging the M-series silicon have double the inference speed of certain models:
Metal (Q4_K_M quantization):
| M1 Max (64GB) | M5 Max (128GB) | |
| Prompt eval: | 64 tok/s | 180 tok/s |
| Decode: | 27 tok/s | 58 tok/s |
MLX (nvfp4 quantization):
| M1 Max (64GB) | M5 Max (128GB) | |
| Prompt eval: | 9 tok/s | 14 tok/s |
| Decode: | 52 tok/s | 111 tok/s |
We built Self-Sovereign Identity so that your keys and credentials could stay under your control rather than being held by a platform that could revoke them. Local inference is the same principle applied to AI: the model runs where you do, on hardware you own. Combined with a self-sovereign wallet holding your keys and credentials, this is a complete stack where nothing about your digital life requires asking permission from a third party.
Final Notes
I’ve long written that identity is a double-edged sword. If wielded right, it can provide us with considerable power, but if wielded wrong, it can wound us fatally.
The same is true of the agentic power being unleashed by the LLM revolution. The possibilities of self-sovereign computing show how this power could be turned to our adventage, truly empowering the self-soveriegnty that I’ve long advocated. However, the credit issue demonstrates the new (or at leastly newly highlighted) questions arising from agentic use, while the authority problem reveals that we need to carefully construct guard rails for this new technology.
If you’d like to talk more about this possibilities email me. I’m also looking for sponsors and partners to support me in doing more of this work.