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.

Slide titled “A Year of Human Signals” with four columns illustrated by a microphone, envelope, locked head, and globe.Open full source frame
A year of human signals: abundant personal data, high sensitivity, and incomplete digital coverage.

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.

0:160:35
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

0:16 · section reference included

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.

Two-column slide contrasts a user-to-LLM request–response diagram with a stateful Bee AI hub connected to mail, files, APIs, apps, external agents, and third-party services.Open full source frame
Request–response inference compared with Bee’s stateful personal AI runtime.
1:592:12
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

1:59 · section reference included

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?

3:534:08
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

3:53 · section reference included

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.

5:025:14
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

5:02 · section reference included

Make software changes visible

Encryption leaves another route to private data: someone could change the software that receives the keys. Bee’s deployment goal is therefore to prevent anyone inside Amazon from shipping a change unnoticed. That is a visibility and authorization requirement, not a claim that deployed software cannot contain bugs.

A separate Amazon team—or teams—manages the privacy controls and transparency log. Bee’s shipping team cannot control that authority, and its signing keys are embedded in the client applications and backends. Changes require approval from high-level employees. Korshakov regards this organizational separation as a substantial obstacle to unilateral changes, but the approval process is slow enough that deployment has to be split into two parts.

7:077:19
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

7:07 · section reference included

From measured images to attested certificates

The deployment process separates the foundation of a node from the particular workload it will run:

  1. Prepare the base image. Include the tools needed to measure the build, manifest, workloads, and data loaded onto the node.
  2. 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.

Two-panel pipeline shows base image preparation on the left and manifest publication, boot verification, and certificate issuance on the right, with Sigstore and S3 connections.Open full source frame
The image build and transparency pipeline separates base image preparation from runtime bootstrapping.
8:218:34
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

8:34 · section reference included

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.

10:2710:45
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

10:27 · section reference included

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.

13:1813:33
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

13:18 · section reference included

Resources

From the talk

  • Bee Privacy NoticeDocumentation

    Bee's notice covering personal information, service providers, retention, and user rights, last updated September 2, 2025.

Updates since the talk

Transcript download
Full transcript

Loading transcript…