AI Engineer World's Fair 2026
Privacy-Preserving Intelligence — Steve Korshakov, Bee (acq. Amazon)
Loading slides…
Read the talk
Privacy-Preserving Intelligence
Bee’s architecture pairs a persistent personal agent with device-held keys, attested workloads, controlled deployments, and sandboxes that limit what autonomous software can affect.
From a talk by Steve Korshakov
Before you start: Basic familiarity with encryption keys, cloud services, and TLS certificates will help with the architecture.
A wearable that hears your private life
A microphone worn on your wrist can capture conversations with friends and family, then turn that context into a personal agent. Bee also lets users extract the resulting data for their own systems and agents. Continuous capture creates a privacy problem even without permanent storage of the original audio: the derived personal context is itself sensitive.
Steve Korshakov estimates that a single Bee wearer captures roughly ten million tokens per year. He says highly sensitive disclosures commonly appear within the first week—enough, in his assessment, to learn an extraordinary amount about someone. The problem is not merely protecting a collection of individual recordings; it is protecting the accumulated picture of a person’s life.
That sensitivity sets the architectural goal: encrypt the data and prevent operator access, including access by Amazon employees. Korshakov describes this as the mission of Bee’s system after its acquisition. Being inside the company that supplies the infrastructure makes the problem harder: protections offered to an external customer do not, by themselves, settle the question of access from within the organization.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
From requests to continuous work
A personal agent should work continuously on the user’s behalf without consuming the user’s battery to do that work. This requirement pushes beyond the familiar phone-to-LLM interaction: the phone sends a request, a backend computes a response, and the interaction ends. Work that lasts for days needs a runtime whose lifetime is independent of that exchange.
Korshakov uses Claude Code as an analogy for the transition. What began as a sequence of small change requests can now involve hours of work, and he expects personal agents to follow the same trajectory. Bee therefore built a stateful runtime with persistent memory, designed to keep that memory inaccessible to the operator. The runtime can connect to tools and to third-party services when programmed to do so. It does not require the phone to remain online: autonomy from device connectivity is meant to coexist with user control.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Four constraints on the encryption design
The runtime has to satisfy four constraints:
- Device-managed keys. The customer’s iPhone or Android phone manages and persistently stores the key. Backend use, described next, is temporary rather than another persistent copy.
- Mandatory encryption. There is no opt-out, disable switch, or bypass.
- Transparent, audited workloads. The system must make the software handling private data inspectable to address internal threats.
- A smaller trust base. Minimize the components and dependencies whose behavior must be trusted.
These principles make key management the central engineering problem: how can a cloud agent keep working while the phone remains the only persistent key holder?
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Attest first, then share the key temporarily
The key begins on the phone. Before releasing it, the phone connects to the backend and runs an attestation pipeline that checks workload integrity and verifies that the specific workload appears in a public transparency log. Bee uses Sigstore for that log. The distinction matters: establishing which workload is running and whether it was recorded does not establish that its code is bug-free. Korshakov leaves the detailed attestation protocol outside the talk, with publication planned for later.
Once attestation succeeds, the client shares its key with the main frontend/backend service. That service replicates it to selected peer nodes inside the confidential-compute environment. Because plaintext must remain inside this perimeter, Bee also runs its own inference, accommodating multiple models and inference implementations rather than forwarding private inputs to an external inference service. This is Korshakov’s account of the runtime’s boundary.
Key replication is narrower than the inference perimeter: inference nodes do not receive replicated keys. They still perform inference; keeping a decryption key off a node is a different restriction from withholding every input it processes. Wherever backend keys do reside in memory, Bee enforces a seven-day expiration. Korshakov describes seven days as a useful autonomy horizon: a 24-hour limit could interrupt work simply because the user did not open their phone that day.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
From measured images to attested certificates
The deployment process separates the foundation of a node from the particular workload it will run:
- Prepare the base image. Include the tools needed to measure the build, manifest, workloads, and data loaded onto the node.
- Publish the deployment manifest. Use the base image together with a specific manifest recorded in the transparency log.
This separation lets the system establish a measured foundation while recording the details of individual deployments.
Historical artifacts make the record useful for investigation. Korshakov says Bee can provide images and data from past deployments so auditors can trace weaknesses if something was deployed incorrectly. Public verification of the transparency log does not mean all those audit materials are public: the team works with internal and external security auditors, but does not publicly release the full audit material.
After a VM verifies itself, the system issues a certificate containing the transparency proofs and attestation documents. Bee uses a private certificate authority for this flow. Korshakov’s stated reason is to avoid populating public certificate-transparency logs with these certificates; this is the rationale for Bee’s deployment, rather than a universal restriction on what public certificates can contain. He also describes a possible proxy offering ordinary TLS with a lighter attestation mode, but it was not implemented at the time of the talk.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
The acquisition changes the trust boundary
The first audience question asks what changed when Bee moved from an independent startup into Amazon: did established security processes force a different approach? Korshakov’s answer returns to the distinction between being an AWS customer and being part of Amazon. In his framing, customer guarantees no longer suffice to address the internal threat model; additional protections are needed against access from within the organization. Configuration had previously been simpler, though he limits how much more he can disclose about the changes.
A follow-up asks whether the stack had to be reprovisioned. Korshakov identifies ordinary EC2 instances as the infrastructure, then distinguishes the custom security machinery from the established software around it. Korshakov reports approximately 20,000 lines of custom code in a memory-safe language, based on a count he made before the talk. He does not name the language. Most of that code verifies attestation, keeping the custom scope small enough to audit while reusing common software for other functionality.
That restraint is deliberate. Korshakov recalls building custom cryptography while at Telegram and calls that a questionable approach. For Bee, the preference is to avoid repeating that reinvention: concentrate custom work on the verification boundary and reuse established components where possible.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Keep capable agents inside a bounded environment
The final question shifts from protecting information to protecting the systems an agent can change. What prevents an agent from corrupting a database, issuing destructive filesystem commands, or participating in ransomware? The audience raises these as possible failures, not reported incidents. Encryption alone does not answer the question: an agent can misuse access it legitimately possesses.
Korshakov prefers not to give agents direct access to personal computers. After experiments with attempts to restrain their behavior, he favors sandboxing and withholding harmful capabilities. His analogy is the brain’s inability to stop the heart at will: some controls should simply be unavailable to the decision-making system. When an agent needs to change something outside its boundary, an intermediary should stand between its request and the change. He does not specify an approval protocol; the key requirement is structural separation from the resource it could damage.
The audience then points to OpenClaw as an example of agents already taking actions. Korshakov says that, in his own use, tightening its restrictions made it less useful. That is a personal observation about the version he tried, not a measured comparison of sandbox implementations.
His goal remains a highly capable autonomous agent. The preferred direction is to deploy a sandbox for the specific agent, limiting the resources and actions it can reach while allowing it to work freely inside that boundary. His closing conviction that other approaches fail is grounded in his own experience: preserve the agent’s ability to act, but put the limit on what its actions can affect.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
From the talk
Bee's wearable overview, recording controls, audio-handling explanation, and privacy FAQ.
An introduction to software signing, identity verification, and public transparency through Rekor.
Further reading
- Bee Privacy NoticeDocumentation
Bee's notice covering personal information, service providers, retention, and user rights, last updated September 2, 2025.
Updates since the talk
Current instructions for exporting Bee conversations, facts, and todos and connecting personal context to agents.
Current controls for isolating agent tools, restricting workspace access, and managing host mounts.
Full transcript
Loading transcript…