# Privacy-Preserving Intelligence — Steve Korshakov, Bee (acq. Amazon)

Steve Korshakov, Bee, Amazon

AI Engineer World's Fair 2026

[Talk page](https://ai.engineer/talks/IvE8n-ylFYY-privacy-preserving-intelligence) · [Video](https://www.youtube.com/watch?v=IvE8n-ylFYY)

## 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.

Basic familiarity with encryption keys, cloud services, and TLS certificates will help with the architecture.

### A wearable that hears your private life

[0:16](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=16s)

A microphone worn on your wrist can capture conversations with friends and family, then turn that context into a personal agent. [Bee](https://bee.computer/bee-pioneer) 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.](https://ai.engineer/api/talk-essay-media/eeb7a6cd25340738ae807b3c8db38a7c1096ef31d63e0fedfd021d7dc2d95ef6)

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.

### From requests to continuous work

[1:59](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=119s)

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.](https://ai.engineer/api/talk-essay-media/71aac3a079ee449996cb8f7e617bd79be9e9b6268367c621ceb0bbca44bca9f1)

Request–response inference compared with Bee’s stateful personal AI runtime.

### Four constraints on the encryption design

[3:53](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=233s)

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?

### Attest first, then share the key temporarily

[5:02](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=302s)

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](https://docs.sigstore.dev/) 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.

### Make software changes visible

[7:07](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=427s)

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.

### From measured images to attested certificates

[8:34](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=514s)

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.](https://ai.engineer/api/talk-essay-media/43fbe6b2b364baff44c9ed62c43e89d45c519c0da020b39023008c91ccdb0142)

The image build and transparency pipeline separates base image preparation from runtime bootstrapping.

### The acquisition changes the trust boundary

[10:27](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=627s)

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.

### Keep capable agents inside a bounded environment

[13:18](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=798s)

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](https://docs.openclaw.ai/gateway/sandboxing) 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.

## Resources

- [Bee Pioneer and product FAQ](https://bee.computer/bee-pioneer) — Bee's wearable overview, recording controls, audio-handling explanation, and privacy FAQ.
- [Bee developer tools](https://docs.bee.computer/) — Current instructions for exporting Bee conversations, facts, and todos and connecting personal context to agents.
- [Sigstore signing and transparency](https://docs.sigstore.dev/) — An introduction to software signing, identity verification, and public transparency through Rekor.
- [OpenClaw sandboxing documentation](https://docs.openclaw.ai/gateway/sandboxing) — Current controls for isolating agent tools, restricting workspace access, and managing host mounts.
- [Bee Privacy Notice](https://bee.computer/privacy) — Bee's notice covering personal information, service providers, retention, and user rights, last updated September 2, 2025.

## Slides

### Amazon Bee: Privacy Preserving Intelligence

Steve Korshakov introduces Bee as a wearable that records everything to build a personal AI.

[0:20](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=20s) [Title slide naming Steve Korshakov and 2026.](https://assets.ai.engineer/sites/aiecode2025/sha256/0e523aea00ac72b310e963863e315dc4db6fe36220f79d8b64eacb09b8c99b14.webp)

Amazon Bee
Privacy Preserving
Intelligence

Steve Korshakov 2026

### What is Bee?

Bee pairs a $50 always-on microphone wearable with a proactive AI agent. Users can access recorded data through an API or CLI and connect it to their own systems or agents.

[0:25](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=25s) [A person wears a Bee device beside a summary of its microphone, AI agent, and data access.](https://assets.ai.engineer/sites/aiecode2025/sha256/3001e449de4e7a994c0c0099ab68fe48d66072a614f7eae9f5d45e4cb0c1fdbd.webp)

What is Bee?_

$50 always-on wearable
with a microphone
+
Proactive AI agent
acts on your behalf
+
API + CLI access
freely access your data

### A Year of Human Signals

Speech and listening can yield roughly 10 million tokens per year; email alone can exceed 20 million tokens per year. One week of continuous recording can reveal sensitive details, while much of life remains offline.

[0:45](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=45s) [Four columns describe spoken and email data, sensitivity, and offline life.](https://assets.ai.engineer/sites/aiecode2025/sha256/6d3977368ef631e828a625f84d26f3c95b8e7142183c6056080819e42ae6dac3.webp)

A Year of Human Signals_
The data around one person is large, sensitive, and still incomplete.

10M spoken / heard
Roughly ten million tokens per year from conversations, listening, and ambient speech.

20M+ in email
Written communication alone can exceed twenty million tokens in a year.

Highly sensitive
Even one week of continuous recording can reveal health, family, fears, and desires.

Life is mostly offline
Much of human life still happens outside the digital world, beyond apps and documents.

< Rich signal. High sensitivity. Incomplete digital coverage. >

### Five Principles Behind Bee

Bee’s design calls for an always-on agent that acts on the user’s behalf while respecting local resources. It also favors fast development and reliable, well-understood infrastructure.

[1:57](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=117s) [Five columns present always-on operation, proactive action, developer velocity, infrastructure, and power awareness.](https://assets.ai.engineer/sites/aiecode2025/sha256/a661521ae41cc9f77f533d34853c384c450a04511683a40fd89df2e63dc9c648.webp)

Five Principles Behind Bee_
The system design choices behind a stateful personal AI.

24/7
>_

1. Always on
Runs persistently, not only during a single request.

2. Acts proactively
Can observe, decide, and take action on the user’s behalf.

3. Developer velocity
Easy to build, test, and iterate quickly.

4. Boring infrastructure
Use reliable, well-understood systems over clever complexity.

5. Power aware
Respect battery, bandwidth, and local resources.

Stateful. Connected. Practical.

### Request-response vs Stateful Personal AI

Bee’s stateful runtime connects persistent memory and services to background agents that can act while the user’s device is offline. The request-response diagram places context on the client.

[2:24](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=144s) [A comparison of request-response systems with Bee's stateful runtime and connected services.](https://assets.ai.engineer/sites/aiecode2025/sha256/f99ec439b62c7bb395c6f8144fa414682d0e907bf2f90a371dee8c062ebd8290.webp)

Request-response vs Stateful Personal AI _

Most AI products are optimized for single inference calls. We are building a persistent system that keeps state, connects to services, and can act over time.

Request-response systems
- Often stateless at the model layer
- Context can be managed by the client
- Good for chat and short tasks
- Usually requires the app/device to initiate work
- Limited background actions when the user is away or offline

Bee
- Stateful runtime with persistent memory
- Shared context across sessions and devices
- Connected to tools and services
- Can run background agents and take actions on behalf of the user
- Does not require the user’s device to stay active

Request-response diagram:
user / device
request
response
LLM API
client-managed context

Bee diagram:
user
Bee AI
stateful
Mail / Calendar
Files / Drive
API / MCP
External Agents
3rd Party Services
Apps
...

Request-response is a useful interface. We believe stateful systems are the next step for personal AI.

### Security by Design

Bee pairs customer-only access with encryption throughout the handling path. Builds and access paths are auditable, while the trust base is limited to Nitro hardware, public Sigstore, and narrow cross-org controls.

[3:50](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=230s) [Four columns describe customer-only access, encryption, auditability, and a minimal trust base.](https://assets.ai.engineer/sites/aiecode2025/sha256/9dbb7e28d4c2e29fa7aad35fb891ef06a3f1f1ecacaad0d6d65d2cbaa6e007e5.webp)

Security by Design_

Customer data should remain private, encrypted, auditable, and protected by a minimal trust base.

Customer-only access
Only the customer should be able to read the data.

Encrypted by default
Encrypt data in transit and at rest, and through every handling path.
E2TEE for inference (end-to-end, enclave-to-enclave encryption).

Transparent + auditable
Builds, deployments, and access paths should be visible, verifiable, and traceable.

Minimal trust base
Trust Nitro hardware, public Sigstore, and narrow cross-org controls.

### Key Management & Attested Access

The device releases its key after checking the backend’s attestation and Sigstore log inclusion. Attested nodes replicate it in memory for background work; cached keys expire after seven days.

[4:54](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=294s) [Five-stage diagram showing device key creation, backend attestation, key release, replication, and expiry.](https://assets.ai.engineer/sites/aiecode2025/sha256/6b3cd4cdb4490eee2467adaa1b2a95466c505cc4c67fb6f9a4c6fbf0e6336da1.webp)

Key Management & Attested Access_

The account key is created on the user’s device, shared only with attested runtimes, replicated only across attested backend nodes, and expires automatically.

1. Account key on device
Account key is generated on the device
Stored in Secure Enclave / Android Keystore
Secure backup via Apple Keychain / Google Play Block Store

2. Device attests backend
Before sharing the key, the client verifies the backend runtime
Checks happen during TLS connection
Verifies attestation evidence
Verifies transparency log inclusion in Sigstore

3. Key released to attested runtime
Only after attestation succeeds, the client sends the account key
No operator or employee has direct access
Key is available only inside the attested runtime

4. Replicated across attested nodes
7d
Background nodes attest each other before key sharing
Replicated in memory across trusted background nodes
Supports background work for up to 7 days

5. Expiry
Cached keys expire after 7 days
Without a fresh key from the device, data cannot be decrypted

device-created key → device attests backend → key shared after attestation → mutually attested node replication → 7 day expiry

Device-owned key
The account key is created and controlled by the user’s device.

Sigstore-verified attestation
Runtimes are verified via attestation evidence and Sigstore transparency logs.

Mutual node attestation
Background nodes mutually attest each other before replication.

No standing human access
No operator or employee can access keys or plaintext data.

### Image Build + Transparency Pipeline

The pipeline commits base-image measurements and a runtime manifest to Sigstore. At boot, the VM verifies inclusion proofs and measurements before starting workloads and issuing certificates.

[7:05](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=425s) [Two-column diagram of base image preparation and manifest-based runtime bootstrap.](https://assets.ai.engineer/sites/aiecode2025/sha256/77d81a6ef46e4765c8ac3e3e6dba0a7de4946c765a79e54756926f97230755ec.webp)

Image Build + Transparency Pipeline
Two linked stages: trusted base image creation, then transparent runtime bootstrappping.

1. Base image preparation [ build time ]

1. Base dependencies
hardened Linux base, kernel/drivers, networking, security agent, minimal system packages.

2. Measured boot tools
boot scripts, measured boot utility, PCR tooling, verification helpers.

3. Build pipeline
submitted to builder, produces "Base AMI (ZOA)".
Base AMI (ZOA)

4. Expected measurements
precompute / record expected PCRs for the base image (PCR4 / PCR7 / PCR12).
PCR4 ✓
PCR7 ✓
PCR12 ✓

5. Transparency commit
base AMI metadata / measurements committed to Sigstore.
Sigstore

Output: hardened base AMI + expected PCR set

2. Manifest + runtime bootstrap [ boot time ]

1. Manifest
contains workload list, networking rules, S3 artifact references, hashes, and role settings.

2. Transparency commit
manifest / runtime configuration committed to Sigstore.
Sigstore

3. Publish to S3
manifest and Sigstore inclusion proofs stored in S3.
S3

4. VM boot
on boot, VM downloads manifest + inclusion proofs from S3.

5. Verify + measure
VM verifies Sigstore inclusion proofs, checks runtime measurements, and uses manifest to fetch S3 artifacts / start containers / configure networking.

6. Issue certificates
after verification, create certificates used for "aTLS (public)" and "mTLS (internal)".
aTLS (public)
mTLS (internal)

Output: bootstrapped workload + verified certificates

### Thanks

Korshakov closes the talk and invites questions.

[10:11](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=611s) [The word Thanks centered on a black background.](https://assets.ai.engineer/sites/aiecode2025/sha256/dadbd350ff34d2591ec139027ce97a39845f2c02d1ba6be21fdcbbc04bbf0cc0.webp)

Thanks

## Full transcript

[0:00](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=0s) [upbeat music] Hello, everyone. I hope this talk will be shorter.

[0:16](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=16s) Uh, uh, I'm from Amazon. Um, our company was acquired about eight months ago, and we built the, uh, AI wearable, which is on my hand, uh, which is essentially a microphone that records everything and builds your personal agent, personal AI.

[0:35](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=35s) And, uh, on top of that, you can extract all the data that you record and plug it to your systems or agents, uh, and do whatever you want.

[0:47](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=47s) Um, just to be-- to get in perspective how confidential, how, like, private data we're capturing, uh, a single person usually, like, captures about ten million tokens per year. So this, um-- And even within, like, a first week of recording, uh, uh, people usually tell, uh, extremely sensitive stuff to their friends, to their family.

[1:12](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=72s) Uh, you can learn virtually everything about the person within the just, like, one week of wearing the Bee device, which is extremely sensitive. I think we're one of the most sensitive, uh, capture device on the market now.

[1:25](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=85s) So, and, uh, because of this, we had to encrypt everything, and our mission was to not have access to any of this data and not being able to look at it, uh, anyone at Amazon.

[1:39](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=99s) And it became a little bit challenging for us at Amazon because, uh, Amazon itself provides strong security and privacy guarantees. But if you Amazon and you using Amazon stuff, there is, like, much more, uh, serious security stuff you need to do.

[1:59](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=119s) Uh, first of all, we define, like, few core principles what we needed to do for our specific agent. First of all, we believe the agent should be, like, working all the time, nonstop for, for your good.

[2:12](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=132s) Um, it should be doing stuff on your behalf, uh, and, um, we should not consume, uh, customer resources such as batteries and stuff. So this way, uh, we, uh...

[2:27](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=147s) So this leads us to one specific design, uh, of the, um, of the our system. Current system usually builds the, uh, on state, uh, on request response, uh, system where you send, uh, req-request to an LLM from your, say, iPhone, uh, calculates something and the backend it gives you back.

[2:52](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=172s) Unfortunately, we already see that this is not enough,

[2:56](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=176s) uh, that we need to, uh, that we need to run stuff continuously and sometimes for days. We can see, uh, we can see this, like, as a, like, glimpse into the future how Claude Code works.

[3:11](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=191s) So, like, just few months ago, it was, like, more like request response stuff, like change this, change that, and now it can works for, like, hours for us. We think the same will happen to all your, like, personal agents anyway.

[3:24](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=204s) So, uh, because of this, we built, uh, a stateful runtime with persistent memory, um, that we still don't have access to. Uh, it can connect to different tools. It can connect to any, like, third-party services if you, if you program it to.

[3:41](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=221s) Um, and we don't require the user device to be online, so it's fully autonomous, but at the same time, it's fully controlled by the user. Um,

[3:53](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=233s) so encryption system is built, um, uh, on few, on four, like, core ideas that we need to follow. First of all, the key lives and managed only on customer device, so it's user's iPhone or Android device itself.

[4:08](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=248s) We don't have the key ourselves. We don't persist it anywhere. So keys is, is, um, is stored only on the customer phone.

[4:20](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=260s) Everything is encrypted. We don't have any opt out. There's no way to disable it. There's no way to bypass it. Uh, at the same time, we, uh, to protect ourselves from, um, like, internal threats, uh, we do fully transparent and, and audit, uh, of our-- all our workloads.

[4:42](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=282s) And, and we, on top of that, we try to minimize the dependencies on the, uh,

[4:49](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=289s) on what we can trust really. Um, so, uh, any security system, if you do end-to-end encryption or any kind of encryption, there is a huge problem, is key management.

[5:02](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=302s) So the first step is, like, I want to tell you how we manage the key. So we start with the, uh, the key, as I mentioned before, starts on the phone and at least persisted on the phone.

[5:14](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=314s) Then the phone connects to our back end and runs very sophisticated attestation, uh, pipeline, uh, that verifies both integrity and that the specific workload is inside of public, uh, transparency log.

[5:30](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=330s) We use Sigstore for our transparency log, and anyone can go there and try to look and verify that this workload is genuine. Uh, the, the method is too complicated to include in this, uh, talk, but we will publish details, uh, at some point.

[5:46](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=346s) Uh, once the, uh, once, uh, attestation was finished, we, um, the, the client shares the key with the, our main front-end back-end, and back-end then replicates this key with, uh, the similar nodes, uh, that runs within our confidential compute.

[6:03](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=363s) Because we can't leave the unencrypted data out of our perimeter, uh, all our... We run our own inference too, so this puts us a little bit, uh, more complicated task, uh, than typical AI company.

[6:19](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=379s) We run, like, all kind of models, all kind of inference, uh, uh, software. And, uh, so,

[6:26](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=386s) um, yeah. And we don't replicate keys to this inference node. We, like, replicate on a, on specific ones, limiting the scope of what we can do. And on top of that, we introduced everywhere where we have the keys in the memory, uh, uh, the forced expiration of seven days.

[6:45](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=405s) Uh, we picked the seven days because we think it's, like, how much realistically the time horiz- horizon for the, like, something useful can be done for the user. Uh, 24 hours will be too low because you can, like, not open your phone for, like, 24 hours and something will be missed.

[7:02](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=422s) And, like, so we pick, like, about seven days.

[7:07](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=427s) Um, then we need, you know, we need to ship some- something to the production, and then the, the biggest question, like, how we can, uh, well, not ship something that will compromise anything.

[7:19](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=439s) Our goal was to, uh, build a system that no one inside of, uh, Amazon will be able to ship anything unnoticed. Obviously, the software has bugs, uh, have problems, but we shouldn't be, well, being able to ship anything.

[7:36](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=456s) So the, we solve this by two, uh, two-tier system essentially. So there is a dedicated team inside of organization, inside of, uh, Amazon, and maybe, maybe not even one, I would say, uh, that, um, manages the privacy part of this, the transparency log.

[7:54](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=474s) Our team, when we ship the software, we can't influence them, we can't control them, and we hard code their encr- uh, their signing keys inside of our client apps and our backends.

[8:05](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=485s) So we can't really, uh, sh- um, uh, we as the team, we can't do this, and, like, it's very, very hard and very high level, uh, um, employees need to sign off to any kind of change.

[8:21](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=501s) So it's, like, at a big company like Amazon, it's virtually impossible really. Um, and, uh, and we do this in two parts because this, this process too slow, so we split it in two parts.

[8:34](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=514s) So, like, the first one is to build the base image, which we put some kind of base software for our, that is needed for our own team, like the tools that measure the build, measure the manifest, measure workloads and data that we need to, uh, put to the node.

[8:50](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=530s) Um, and, um, and then when we want to deploy, we do the process the same, similar time. Uh, we got the base image, and then we deploy the, uh, to transparency log specific manifest that any dev...

[9:05](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=545s) And, uh, this setup helps us to be able to security audit companies and inside, outside to anyone to... Well, we're not doing this public, but, like, we to, like, very, um, high-profile audit companies, we work with them all the time.

[9:22](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=562s) Um, we can provide any image, any, any data that was deployed ever, so we can, like, trace any possible, uh, weak spots, uh, if we, like, deploy something wrong,

[9:34](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=574s) uh, which we do not. Um, then after ver- uh, self-verification of VM, it's, uh, issues a certificate that embeds all encryption pro- uh, all transparency proofs, attestation documents into certificate itself.

[9:48](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=588s) We are using private CA because you can't do this in public certificates because it will populate the public, uh, transparency log, so we had to use the private one.

[9:58](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=598s) Um, we probably will introduce the, uh, extra proxy that will do a normal TLS with attestation with, like, lighter mode, uh, but we don't have this yet.

[10:10](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=610s) Um, yeah, that's essentially what we built. Thank you.

[10:16](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=616s) Any questions? [audience applauding]

[10:21](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=621s) Any questions? I think you should shout it.

[10:25](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=625s) I'll just shout it. Uh, so-

[10:27](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=627s) Yeah

[10:27](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=627s) ... I'm interested in, uh, what the process was like, like, having your own sort of, like, values and approach to security going, to going inside Amazon? Were, were there things that you had to change that had, hadn't been changed prior to, like, going in there?

[10:45](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=645s) Just as far as, like, uh, pro- processes and sort of values around security, because I know they've, they've got very hard-coded, entrenched ways of doing, doing things. Yeah.

[10:57](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=657s) Can you repeat? [laughs]

[10:59](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=659s) Yeah, sorry. There's a lot, a lot of words. What was it like, uh, from a, um, a process standpoint, what had... Were there things that had to change when you went from being, like, your, your own small startup into existing within Amazon?

[11:15](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=675s) Oh, what changed when, uh, with, like, when we joined Amazon?

[11:18](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=678s) Yeah.

[11:21](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=681s) Well, the, the, the big change that we, uh, before, like, you run on Amazon, and Amazon gives you per- like, guarantees as a customer that they can't see your data, but once you're inside, this changes a lot because you, Amazon, like...

[11:37](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=697s) So that's why you need, like, to provide more, uh, protection on top of this. So we need to protect from our internal threats too. Uh, so that was a big change.

[11:46](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=706s) So, um, before that, it was, um, just kind of easier, I would say, to configure everything. Um, I'm not sure I can tell much, honestly. [laughs]

[11:58](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=718s) Did, did you guys do any, like, reprovisioning your stack? Like, or... 'Cause I'm assuming you built on AWS side.

[12:05](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=725s) Yes. It's just normal EC2 instances. Yeah Yeah, yeah. We almost-- We not using like-- Yeah, almost everything we built from scratch. But well,

[12:16](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=736s) um, we try to use like the existing stuff like, but it's more like common, like popular software. And we built, uh, try, I-- We tried to minimize amount of code that we produce, so it's-- I, I calculated before this talk, it's just like about twenty K lines on memory safe language.

[12:35](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=755s) So it was very small scope that we were able to audit and verify that all this kind of stuff. And most of this code is just verifying attestation really, and then everything else can be like reused and like very, we like, you know, it's very trustworthy, I would say, software.

[12:49](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=769s) So we didn't try to-- don't invent, uh, um... Yeah, we don't try to invent. Like when, when I was at Telegram, like we reinvented, like built our own crypto, and that was like questionable way of doing stuff, so I try not to do the same at Amazon, obviously.

[13:08](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=788s) Yeah, that's what we do.

[13:11](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=791s) Any other questions for Steve? Up in the back.

[13:18](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=798s) Yeah, quick question. So I guess we're the tail end of the, uh, diehard security enthusiasts. Um, just thinking about the AI side of things here, first person I've heard really talk about things like encryption layer.

[13:33](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=813s) I don't have a lot of experience with that. So we know AI agents can go rogue or have some kind of a mistake in, in the databases or even, you know, the rm flag, rm forward slash.

[13:47](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=827s) It's, it's everything. But what, uh, what can we do to prevent the machine from saying, "Let me erase our hard drive or tap into it"?

[13:56](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=836s) I've not heard of that happening, but I don't see that being very far off, and there could be an AI-based ransomware attack on an individual and being encryption-

[14:05](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=845s) Well-

[14:06](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=846s) What-

[14:06](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=846s) I, I just prefer them not to put to the computers, uh, to personal one. Uh, so we, we did several experiments how to tame them not to do bad things.

[14:18](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=858s) Honestly, I think nothing works except like sandboxing and just not giving them a way to hurt, hurt themselves. It's like, you know, our brains, they can't stop the heart at will, right?

[14:30](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=870s) So otherwise, you know, they will be-- we have much more problems. So I think the same, we shouldn't give them a way to do any harm. That's the only way, honestly.

[14:39](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=879s) And, um, yeah, and put something between if they want to change something. Unfortunately, I think that's the only way, yeah.

[14:48](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=888s) OpenClaw, like OpenClaw is already taking action on behalf of agents. It could happen today.

[14:52](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=892s) I surprised they are not represented on this, uh, right? Like they're screaming so much about security, but they didn't came to this one. Um,

[15:01](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=901s) uh, I'm not-- I tried OpenClaw. It's like it was... Once they started to try to tighten this down, it became much less use-useful. Um, so I think their approach is not really that good at all.

[15:15](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=915s) So I would love to have wild agent. That's, that's our goal too. But we try to just deploy the sandbox for specific agent, and it will just-- they just can't do much of the stuff.

[15:27](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=927s) Everything else fails, unfortunately.

[15:31](https://www.youtube.com/watch?v=IvE8n-ylFYY&t=931s) Cool. All right. Well, thank you so much, Steve, for the presentation. That was amazing. [outro jingle]
