Bee, an Amazon company, is a personal artificial intelligence (AI) device you wear. It listens to your day, understands what happened, and remembers the commitments and ideas you would otherwise lose. Bee uses that understanding to give you help that’s tailored to your life. With Bee, you can:

  • Get summaries of important conversations and moments.
  • Recall past interactions when you need them.
  • Capture commitments and follow-ups from meetings and client conversations.
  • Spot patterns in your routines and relationships.
  • Gain meaningful insights about your day.

To deliver these experiences, Bee handles conversations about health, finances, and family, some of the most personal parts of users’ lives. Bee securely manages this sensitive data so that it always remains protected. Bee built an architecture with no mechanism for operators (Bee engineers, other Amazon employees, and AWS infrastructure operators) to access customer data. Bee’s own controls cover the first two groups, and protection from AWS infrastructure operators is inherited from the AWS Nitro System. Bee calls this Zero Operator Access (ZOA). In this post, we show how Bee does all of this and share the AWS building blocks used to achieve ZOA.

Solution overview

The AWS shared responsibility model describes security as two domains: security of the cloud, which AWS is responsible for, and security in the cloud, which is the customer’s responsibility. AWS operator access controls are designed so that AWS personnel have no technical pathway to customer data. Bee applies the same principle to its own operators, Bee engineers and other Amazon employees. That means hardening every layer of the stack.

Bee’s core control is EC2 instance attestation: A user’s device releases the keys needed to decrypt their data only to instances running software it has verified. Attestation proves what runs inside an instance, but it can’t measure what surrounds it, such as which networks the instance can reach or who can change account permissions. So, Bee paired attestation-gated key release with network, storage, and organizational controls that close the paths attestation can’t measure. Figure 1 shows how these controls fit together. The sections that follow walk through each one.

Bee’s Zero Operator Access architecture: build-time attestation and transparency steps and runtime key release across AWS services

Figure 1: Bee’s Zero Operator Access architecture on AWS

Build time

  1. A transparency service, run by a separate Amazon team that Bee doesn’t control, keeps a copy of every approved Amazon Machine Image (AMI), container, and model for later audits. It publishes the expected measurements for each approved deployment to Sigstore Rekor, a public transparency log.
  2. The attestable AMI is shared to the Bee account, and the transparency proofs are stored in Amazon Simple Storage Service (Amazon S3).
  3. At boot, each instance records what it’s running in NitroTPM. It then gets a TLS certificate from AWS Private Certificate Authority (AWS Private CA) with its attestation and transparency proofs embedded. The Bee app checks this certificate before it shares any keys. If the software has changed, the app refuses to connect.

Runtime

  1. The Bee mobile app only connects to an attested instance over TLS.
  2. The instance presents its certificate. The app verifies the attestation against the AWS Nitro root and the transparency log.
  3. Only if they match does the app release a short-lived key. The key exists only in memory in the app servers and Redis key stores. Inference servers never receive keys.
  4. Data stored in Amazon Relational Database Service (Amazon RDS), Amazon ElastiCache, and S3 is encrypted before it leaves the boundary. AWS Lambda integrations receive plaintext only with the user’s consent.

Establish a verifiable compute foundation

The first problem Bee had to solve was trust. A user’s device needs to verify that Bee’s servers booted only with the approved software. That verification requires evidence rooted in a trusted mechanism outside the server application itself. Bee uses EC2 instance attestation to provide signed measurements of the instance’s boot software.

Bee builds its base images with an internal, hardened pipeline that produces attestable AMIs for Amazon Elastic Compute Cloud (Amazon EC2). During the build, the pipeline computes reference measurements offline from the Unified Kernel Image (UKI) and the Secure Boot configuration. These are the expected values for platform configuration registers (PCRs), which record cryptographic measurements during boot. Bee uses PCR4, PCR7, and PCR12 as verification targets. Because these values are computed without booting the image, Bee knows the expected measurements before any instance launches.

Following the AWS guidance on isolating data from your own operators, every Bee attestable AMI is built with these properties:

No interactive access. The image includes no SSH, SSM, or shell, so operators have no path into a running instance.

Only trusted software. The image contains only the components the workload needs, and every component is measured.

Read-only file system and ephemeral local storage. The root filesystem is read-only. Local instance storage is encrypted with a key held only in memory, and instances are replaced rather than rebooted, so no data outlives the instance.

At runtime, the bootloader and operating system measure the boot components and extend those measurements into NitroTPM PCRs. NitroTPM provides an attestation document containing the resulting values, signed by the AWS Nitro System through the AWS Nitro Attestation PKI. Any verifier can check these values against the approved reference measurements. With the same measured boot components and configuration, the selected PCR values remain consistent, making them suitable for remote verification.

Extend the chain of trust to your containers and data

A trusted OS is necessary but not sufficient because Bee’s application containers and model weights can change independently of the AMI. If an unauthorized user could swap a container image or a model file without detection, the attestation document would still show clean boot measurements even though the workload had been altered.

Bee solves this with a custom measured boot tool that runs before any application container starts. It resolves each Docker image in the manifest to its immutable Amazon Elastic Container Registry (Amazon ECR) digest. It also retrieves each Amazon Simple Storage Service (Amazon S3) artifact’s SHA-256 checksum. It computes a deterministic hash across the manifest, all container digests, and all artifact checksums, then extends NitroTPM PCR14 with this value. Any change to any container image, model weight, or the manifest itself produces a different PCR14 and a different attestation document.

Critically, PCR14 is extended before the NitroTPM attestation document is obtained. The attestation document that Bee’s application servers present to clients therefore reflects both the OS state (PCR4, PCR7, PCR12) and the workload state (PCR14) as a single signed hardware measurement.

Before deployment, the transparency service runs an independent signing process. It resolves the same ECR digests and S3 checksums, recomputes the expected PCR14, and commits the full PCR map to Sigstore/Rekor, an independent, publicly auditable transparency log. The resulting proof bundle is stored in regionally replicated S3 buckets so that verification at boot time is fully offline, with no runtime dependency on external infrastructure.

Validate attestation at every connection

At boot, the instance first confirms that its own measurements match the approved entry in the transparency log. If they don’t, it stops there. If they match, it requests a TLS certificate from AWS Private CA, with its attestation document and transparency proof embedded in the certificate. The attestation is tied to that certificate’s key, so it can’t be reused by another instance.

The user’s device decides whether to trust the instance. When it connects, it checks the embedded evidence offline against roots built into the app, including the AWS Nitro root. If the measurements don’t match an approved configuration, the client rejects the connection and shares no keys.

The same certificates protect traffic between instances over mutual TLS. Only roles that need to start connections, such as application servers, receive client certificates. Inference instances don’t, so they can’t reach key stores or other services.

Limit what the network can reach

All attested EC2 instances run in isolated subnets of an Amazon Virtual Private Cloud (Amazon VPC) with no internet egress. The only outbound paths are VPC endpoints to Amazon Relational Database Service (Amazon RDS), Amazon ElastiCache, and tightly scoped AWS Lambda functions. These functions handle external integrations such as email or push notifications. Lambda functions receive only data already encrypted with user keys. They never see plaintext.

Keep encryption keys out of persistent storage

Users’ encryption keys originate on their devices. After verifying an instance’s attestation, the device releases a short-lived, scoped key to that instance. The key exists only in memory, in the application instance and in Redis key stores running inside attested instances with persistence disabled. It expires after 7 days without user activity. Because AWS never holds this key, no storage layer, backup, IAM policy, or KMS grant can provide access to it.

Sensitive data is encrypted inside the attested instance before it reaches Amazon RDS, Amazon ElastiCache, or Amazon S3, so those services store only ciphertext. Plaintext stays inside the attested boundary. For the full key hierarchy and data flow, see the Bee Private Compute whitepaper.

Use AWS organizational controls to eliminate unilateral access

Strong technical controls also need strong permission boundaries. If one person could change those controls, they could be bypassed. Bee is designed so that no single team can do this. The Bee team manages the private CA and the deployment pipeline but doesn’t control the transparency service. The transparency team can commit entries to the Sigstore log but has no access to Bee’s AWS accounts. Deploying code that doesn’t appear in the public transparency log would require coordination across independent teams.

AWS Service Control Policies (SCPs) back this separation at the infrastructure level. SCPs apply across all Bee accounts, limit which actions are possible in each account, and need multiple levels of approval to change. This makes the separation of duties enforceable in AWS itself, not only through process. SCPs add defense in depth. The primary safeguard is still attestation: Any change to the software changes its measurements, and the Bee app refuses to connect to software it doesn’t recognize.

Conclusion

In this post, we showed how Bee implemented Zero Operator Access for personal AI on AWS. Users hold their own keys, so they decide who can read their data. Before the Bee app shares a key, it checks that the server is running approved, publicly logged software, and no operator or policy can override that check. Amazon EC2 instance attestation makes that check verifiable. Network isolation, ephemeral storage and organizational controls close the paths attestation can’t measure.

Next, Bee is moving its inference to Amazon Bedrock Mantle, which provides zero operator access as a managed capability. User-held keys and attested application servers will stay part of the Bee architecture, so data stays protected from Bee operators.

You can apply the same pattern to any workload that handles sensitive data. To get started:

If you have a similar use case or want help building it, contact your AWS account team or reach out to AWS.

Further reading

Trail of Bits independently assessed the Bee Private Compute whitepaper, which covers the complete architecture, including client-side cryptography.

If your sensitive workloads run in containers, AWS Nitro Sandboxes give each Amazon EKS pod, Amazon ECS task,
or Amazon EC2 workload its own hardware-isolated VM, with attestation and zero operator access built in.


About the authors

Gopinath Jagadesan

Gopinath Jagadesan

Gopinath is a Senior Solution Architect at AWS, where he works with Amazon to design, build, and deploy well-architected solutions on AWS. He holds a master’s degree in electrical and computer engineering from the University of Illinois at Chicago. Gopinath is passionate about generative AI and its real-world applications, helping customers harness its potential to drive innovation and efficiency. Outside of work, he enjoys playing soccer and spending time with his family and friends.

Steve (Stepan) Korshakov

Steve (Stepan) Korshakov

Steve is a Bay Area engineer who started working on end-to-end encryption after winning Durov’s 2013 Android contest for Telegram. He kept building secure messaging as creator of the open-source Actor platform and co-founder of Openland, a YC-backed messenger for communities. He’s a founding engineer at Bee, the wearable AI company Amazon acquired, where he now leads privacy work.

Ethan Sutin

Ethan Sutin

Ethan is the Head of AI for Bee at Amazon, where he leads the AI powering Bee’s personal AI. Ethan is passionate about the promise of AI living alongside you and constantly thinking how it can make your life better.

Arvind Raghu

Arvind Raghu

Arvind is the Global Head of Confidential Compute at AWS. He works closely with customers to build Confidential compute solutions aimed at protecting sensitive data. He is currently focused on developing capabilities to build solutions for Confidential inferencing and Confidential Agents for multi-agent workflows.