The new version of Subset allows you to connect sharing actions to sharing outcomes.
Say you've saved something to Subset. Now, you can share it to X, maybe adding an excerpt or special note. That share gets recorded and becomes searchable within Subset. Later, you can link the outcome (the X post URL) to the share record. You can get Subset on iOS via TestFlight and try this out now. Or you can see it in action on the Subset landing page.
This isn't an ideal approach, by any means. But right now, it's the best way to match share actions to outcomes. To see why, think about how many ways the average interested person shares things. They post on Farcaster or Bluesky or X. They send messages in work Slacks and community Discord channels. They push links in emails and DMs and group chats. And they often want to reference the things they've posted and sent and pushed. But because this sharing activity traverses public, private and semi-private spheres it remains mostly illegible.
There are four ways to make it legible as a whole, though, to connect share actions (e.g. post this link and a witty comment to X) with their outcomes (e.g. the URL of the X post):
Platform integration
Protocol interop
User labour
Agents
Platform integration means playing nicely with likely-adversarial entities that have a vested interest in maintaining and further enshittifying the web. Even if these entities are neutral or benevolent, it still relies on APIs that are never completely transparent about their inherent capabilities and tradeoffs. Further, even if the entities are neutral/benevolent and they provide rigorous APIs, it creates dependencies on non-1st party resources that have to be continually tracked and maintained and that scale non-linearly as the user base increases.
Protocol interoperation is an alternative. Protocols are designed to promote interoperation and thus represent way less risk than integration with traditional entities and their platforms. And although protocol developments must still be tracked and maintained, this is simpler than platform integration maintenance—interop with every protocol is plausible; integration with every platform is not. Unfortunately, most of the digital realm is still composed of platform fiefdoms, not protocol-ish freedom-loving infrastructure. Protocols as they are only account for a small portion of total sharing activity.
User labour—the thing we've opted for, for now—is next up. Instead of platform integration or protocol interop, the load of mapping can be shifted to a user in the wake of a share. This requires minimal overhead because the user is already auth'd on their device and they're able to navigate enveloping platforms or protocols at will. However, mapping does introduce a severe context switch and flow-break that's unlikely to be sustained in the long-term.
If I'm reading an epic paper in Safari, it's simple enough to punt it to Discord. It's just that getting the link to the outcome from Discord requires me to open the Discord app, nav down to the location of the message, get the URL, and map it to the relevant share record in the Subset extension. The ideal Subset user is a prolific sharer whom, whilst not ecstatic about such a quest, would undertake it in some cases on a consistent basis. But it's still a whole lot of excessive friction.
The final possibility—agents—is where it gets interesting. We don't mean everything agents. We mean Unix-like, Boydian burglar agents that have:
A close alignment to a singular user or entity and their actions
A deliberately constrained set of capabilities and protocol-savviness
A mission-driven approach to objectives
An ability to imaginatively manipulate the space they traverse
To circumvent excessive user labour, an UBB agent could be introduced to perform the same task. The UBB agent doesn't need to touch all the things a user does—it just needs to spin up, receive and execute a mission, then self-destruct. The mission an agent receives in the wake of a sharing action essentially resembles:
Materialise post-sharing action
Receive mission packet with target app/service and contextualising info
Go to target app/service and use contextualising info to locate outcome
Return with and confirm successful mapping
Dematerialise post-mapping
This can occur in the background whilst the user continues in the flow of their original activity and may include arbitrary agent-user touches (e.g. to authenticate or query). Existing precedents for these behaviours exist on more permissive devices and OSs (e.g. mobile agents on Android) as research or academic projects, and they're not present at all on more restricted ones (e.g. iOS). Agentic tech just isn't consumer ready.
Thus, the state of the game: spinning up performant platform integrations for all possible sharing activity isn't viable; there's no set of protocols that adequately covers potential user sharing activity anyway; and agentic tech is neither sophisticated enough nor sufficiently empowered to map on behalf of users in an autonomous manner. So we're left, for now, with user labour. But that's okay—most of the labour is in the mapping.
The sharing? That's real easy.
And with Subset's latest version, it just became searchable.
