Celebrating the Atsign AI Architect Hackathon Winners

Building secure software fast is a nearly impossible task. In traditional development, security is often treated as an afterthought, and it’s common practice for software to launch with gaps, and for security products to be bolted onto applications with varying degrees of success.

But what happens when developers design their security architecture before writing a single line of code?

That was the challenge at the recent Atsign AI Architect Hackathon. Over a 24-hour build period, developers used Atsign AI Architect to map out complex, decentralized data flows using native agent nodes, custom cryptographic boundaries, and identity-layer controls. Then, they brought those diagrams to life using the Atsign SDK.

The submissions blew us away, proving that peer-to-peer architecture can tackle thorny, real-world vulnerabilities. Here is an in-depth look at the innovative solutions engineered by our top three winning projects.

1st Place: Medshare

• Developed by: Eric Ko
• Source code: GitHub Repository

Decentralized patient data control and automated expiration

Current systems for sharing sensitive medical imaging and patient records are wildly expensive, fragmented, and vulnerable. According to the HIPAA Journal, medical data breaches are on a steep rise due to bad actors intercepting data and holding it for ransom on centralized servers.

Medshare flips the script on healthcare data storage by shifting complete data ownership back to the patient. Utilizing Atsign’s native, platform-provided encryption, the application allows clinics, imaging centers, and specialists to securely route sensitive scans without a centralized backend ever seeing the plaintext data.

The underlying magic of Medshare relies on splitting the application into two completely separate planes:

• The data plane: The locked scan itself. The storage node acts as a secure vault that holds nothing but cyphertext. By design, it remains separate from the content, meaning it cannot see or inspect the files it hosts.
• The control plane: Who may view the data. The patient acts as the sole key holder; a grant is a key given to a specialist, and revocation completely destroys it.

How it works

• The secure hand-off: A clinic takes an imaging scan and sends a copy to the patient’s unique Atsign via a shared atKey (scanref.medshare).
• Patient-driven access: The patient can save the result locally or choose to grant access to a secondary medical specialist. They select a strict expiration window, like one minute, one day, or one week, utilizing Atsign’s native TTL (Time-To-Live) primitive.
• The absolute kill switch: Once the time limit expires, or if the patient decides to manually revoke access early, Medshare fires a cascade-delete (ccd). Unlike legacy platforms that merely block future fetches, cascade-delete reaches out and actively removes the recipient’s cached copy. The specialist app cannot re-fetch the data—it is blocked at the network layer.

By separating the cryptographic grant from the transport policy, Medshare delivers a verifiable prototype showing how true patient data sovereignty can protect healthcare from catastrophic breaches.

Want to see the architecture? Read more about Medshare to explore how Eric Ko used Atsign’s platform-provided encryption to build an un-bypassable patient data control plane. And watch Eric’s video on YouTube.

2nd Place: IoT Lighthouse

• Developed by: Aidan Decker
• Source code: GitHub Repository

Identity-based telemetry protection for telecom networks

Telecommunication signaling environments, such as Diameter nodes and legacy SS7 gateways, form the hidden backbone of global connectivity. Unfortunately, they are plagued by credential theft, weak protocols, and a complete lack of baseline traceability across distributed field hardware.

IoT Lighthouse addresses this enterprise threat by providing identity-based IoT protection, encrypted telemetry, and clear operator isolation workflows without a central application cloud backend.

How it works

IoT Lighthouse isolates all of its operational data inside a dedicated application namespace (iotlighthouse) on the participant’s atServer. Every piece of information is saved as an encrypted key-value record, allowing the Atsign SDK’s native background sync engine to securely pass data between the devices and the operator’s console without any custom backend code.

To prove its end-to-end privacy guarantees, the project features a local MVP encryption proof. When the simulated telecom device transmits data to the Device Protection Service, the application creates a route-specific encrypted telemetry envelope (@device → @service). The management console provides total infrastructure transparency, displaying the plaintext synthetic telemetry, the encrypted payload, the HMAC digest, the decrypted payload, and the live verification status.

If the Threat Monitor identifies a suspected routing tamper or firmware exposure, operators can instantly push a containment command directly to the target node’s Atsign to isolate the threat.

Curious about legacy network security? Read our post on IoT Lighthouse to see how Aidan Decker built identity-based protection for Diameter and SS7 telecom nodes.

3rd Place: Self-Expiring Data Clean Room

• Developed by: Aquib Aquil
• Source code: GitHub Repository

Cryptographically self-destructing cross-company analytics

Cross-company data clean rooms are projected to be an $18 billion market by 2034, but current enterprise solutions suffer from a foundational flaw: they are built as persistent, lingering infrastructure. Setting up a clean room costs companies an average of $879,000, yet most analytical questions, like a partnership audience-overlap study or a due-diligence check, are strictly one-time events. Once a query is complete, the idle infrastructure becomes a standing security liability.

The Self-Expiring Data Clean Room solves this mismatch by engineering a collaborative analysis platform that does not just get decommissioned—it cryptographically stops existing the moment both sides confirm the query is done.

“There is no permission check to bypass, because there is no code that would invoke one.”

How it works

Using Private Set Intersection logic, two separate companies submit salted, hashed identifiers through a strict, write-only data channel. The clean room runs an isolated computation that outputs exactly one thing: a single, shared aggregate overlap count.

Once both company stakeholders verify the result inside the Flutter companion app and click “Confirm Analysis Complete,” a Retirement Policy process is instantly triggered. This event completely deletes the session-scoped cryptographic keys, rendering the underlying data exchanges permanently unrecoverable. The only element that survives the teardown is an immutable receipt documenting what was destroyed and when.

The beauty of the system lies in its verifiable simplicity. The company-side agent is written in just about 110 lines of Dart code. It features zero data-fetching or remote lookup commands, providing a transparent, bulletproof privacy guarantee that can be verified directly from the source code.

Want to audit the code? Read our piece on Self-Expiring Data Clean Rooms to see how Aquib Aquil leveraged 110 lines of simple Dart code to build ephemeral B2B analytics.

Design and code: Sharing the same diagram

The grand takeaway of the Atsign AI Architect Hackathon is how tightly alignment between architectural planning and code execution can become. Across all these winning entries, the asymmetric edges, role boundaries, and policy engines were drawn on the AI Architect canvas first, mapping out identities and data constraints before execution.

Congratulations to our winners and to everyone who spent their 24 hours proving that a more private, decentralized internet is not just an ideal—it is highly buildable.