How Buzz works

1. Architecture

Phone to AWS. Your computer to Bedrock and back, then to the same API.

Swipe the diagram sideways to see all of it. The steps below say the same in words.

1. You wear Bee and talk. The Bee app keeps the recording. BEE_DOCTOR_FULL
2. Your computer reads it through the Bee CLI. The archive and Bee credentials stay there. BEE_DOCTOR_FULL
3. Pollen checks each use of a word. Buzz sends one short speech window to Nova 2 Lite on Bedrock, an AWS service, under your own AWS profile, and gets a structured judgment back. OWN_BEE_RUN
4. Code on your computer decides if the use counts. Then you approve a sync, and hosted Buzz receives bounded result fields: ids, days and reason codes, not transcript text. OWN_BEE_RUNSYNC_PUSH_AND_READBACK
5. API Gateway passes the sync to the Api Lambda, which writes the DynamoDB table and reads it back. OWN_BEE_RUN
6. Your phone loads the web app from CloudFront and S3, signs in with Cognito and reads the same table. OWN_BEE_VISIBLEJUDGE_WALK_B4BA775
7. Honey drafts word cards on Nova 2 Lite when you ask for a pack. LIVE_PACK_DRAFT

Not shown / not run: Forager, a scheduled reader in AWS, is off. The schedule is DISABLED and no Bee session was ever connected to it. FORAGER_ACTIVATION_RECOVERY

2. What a judge taps

Sign in, see a reused word on two days, open the use, read why it counted.

Swipe the diagram sideways to see all of it. The steps below say the same in words.

1. You open the beta on your phone and sign in with Cognito. SIGNIN_VB
2. Home says "You reused a word". JUDGE_WALK_LIVE
3. You tap See both days. The word is delineate: used on 16 Oct and again on 20 Oct, in different conversations. Tap one use. FIRST_REAL_EMBEDJUDGE_WALK_B4BA775
4. What was checked shows Pollen's checks and the server decision: Counted, under the stated rule. OWN_BEE_VISIBLE
5. Words and Practice sit to the side. A practice session on 14 Oct did not count. JUDGE_WALK_B4BA775REHEARSAL_AS_PRACTICE
6. The You tab replays onboarding or the tour of Home. JUDGE_WALK_B4BA775
7. Two pages need no sign-in: the evidence page and the read-only real week. VISITOR_WALK_LIVE

Not shown / not run: The scripted walks ran in a headless browser at 390 and 360 wide. The own-Bee result was read on VB's phone by VB and pasted in. JUDGE_WALK_B4BA775OWN_BEE_VISIBLE

3. Try your own Bee

Nine steps across you, the Bee, your computer, Bedrock and AWS.

Swipe the diagram sideways to see all of it. The steps below say the same in words.

1. You run try:own-bee. It checks your tools and signs in to Bee. OWN_BEE_RUN
2. Bee doctor checks the CLI before anything is read. BEE_DOCTOR_FULL
3. You say which voice is yours. Earlier answers are kept. Buzz sets your start day and time zone once: 16 Oct, Asia/Kolkata. OWN_BEE_RUN
4. Check Bedrock runs the AWS preflight. A judge runs it with their own key: model access passes, and no model call was made with that key. OWN_BEE_RUNJUDGE_KEY_CHECK
5. Buzz imports your recent conversations and checks your speech. It processed 10 and decided 9 Qualified, 12 Rejected, 3 Not assessable. OWN_BEE_RUN
6. The preview lists 16 sources and 24 decisions as ids, days and codes. Nothing is sent to hosted Buzz. You approve by typing your invited email. OWN_BEE_RUN
7. Buzz writes to AWS, reads it back (16 of 16 same revision) and you open the app. OWN_BEE_RUNOWN_BEE_VISIBLE

Not shown / not run: A brand-new conversation. No new Bee conversation existed since 20 Oct, so this run re-checked existing ones. The wrapper's doctor rows show Capture and Write NOT_RUN by design. OWN_BEE_RUNBEE_DOCTOR_FULL

4. Data model

One DynamoDB table: account, ledger, sources, decisions, word targets, packs.

Swipe the diagram sideways to see all of it. The steps below say the same in words.

1. Everything lives in one DynamoDB table. Every key starts with your tenant, read from your sign-in. SIGNIN_VB
2. The account row holds the tenant. The Bee connection row says how your Bee feeds in. A check on 19 Oct found 0 connection rows. FORAGER_ACTIVATION_RECOVERY
3. The ledger is one row per wearer. It carries a revision and a map of sources. After the own-Bee run: revision 30, 16 sources, all current. OWN_BEE_RUN
4. Each source holds its decisions: phrase id, status, reason codes, day, conversation id. OWN_BEE_RUNBETA_READBACK_COUNTED
5. Word targets live in code. The word delineate was used on 16 Oct and 20 Oct, which is the one real recurrence so far. FIRST_REAL_EMBED
6. A pack request holds drafts. An accepted draft becomes a generated pack. One live draft took 9 seconds. LIVE_PACK_DRAFTPACK_READBACK

Not shown / not run: Brain items, daily reading, practice completion, entitlement, audit and idempotency rows exist in the store and are left off to keep this readable.

5. The crew

Pollen, Honey, Nectar and the word brain propose. Code decides.

Swipe the diagram sideways to see all of it. The steps below say the same in words.

1. Pollen reads one use with a short window. The Context Judge and the Skeptic run their checks. OWN_BEE_VISIBLE
2. Code makes the call. The server decision is Counted or not, under a stated rule. OWN_BEE_VISIBLE
3. The wearer reviewed 24 of Buzz's real decisions: 22 agreed, 1 disagreed, 1 unsure. One wearer, n=24, and the wearer built the system. DECISION_REVIEW
4. Honey drafts word cards on Nova 2 Lite. One live draft took 9 seconds and 2 Bedrock calls. You accept or drop each card. LIVE_PACK_DRAFT
5. Nectar runs the Dream graph on Strands: 32 live Nova 2 Lite calls, run locally. DREAM_LIVE
6. The word brain picks your next word from code's shortlist, and any failed check falls back to code's own pick. On 22 Oct it picked a next word live from the builder’s stored data: 3 Nova 2 Lite calls, saved and shown in the app. BRAIN_THINK_REAL_STORE

Recorded scope: The corrected 22 Oct graph run made 35 live Bedrock calls with zero transport failures and stored three legacy coaching cases. Its role outcomes are recorded separately from vocabulary recommendations. AgentCore remains outside this deployment. DREAM_LIVEDREAM_RERUN_1022SAVE_CASE_INVESTIGATIONAWS_PREFLIGHT

6. One sync, step by step

Who talks to whom in one try:own-bee run, and what crosses.

Swipe the diagram sideways to see all of it. The steps below say the same in words.

1. Arrow 1. Buzz asks the Bee CLI for your recent conversations. Text and speaker labels come back to your computer. The run processed 10. OWN_BEE_RUN
2. Arrow 2. You confirm which speaker label is you. Buzz keeps that mapping on your computer. OWN_BEE_RUN
3. Arrow 3. Buzz finds each place a target word appears and cuts a window of 240 characters either side. OWN_BEE_RUN
4. Arrows 4 and 5. The window goes to Bedrock Nova 2 Lite under your own AWS profile. A verdict comes back. This is the one place text leaves your computer. OWN_BEE_RUN
5. Arrow 6. Code decides: Qualified, Rejected or Not assessable, with reason codes. OWN_BEE_RUN
6. Arrows 7 and 8. The preview shows ids, days and codes (16 sources, 24 decisions). You approve. OWN_BEE_RUN
7. Arrows 9 to 12. Buzz posts the sync, AWS writes a ledger revision, Buzz reads it back and counts the matches: 16 of 16. A separate read of the hosted API showed ledger revision 30. OWN_BEE_RUN

Not shown / not run: Cloud-side ingest. The Forager schedule is off, so this desktop push is the only path in. The second run replayed all 10 sources with 0 new model calls. FORAGER_ACTIVATION_RECOVERYOWN_BEE_RUN

7. What stays and what leaves

The archive stays on your computer. Short windows go to Bedrock. Ids, days and codes go to hosted Buzz.

Swipe the diagram sideways to see all of it. The steps below say the same in words.

1. Bee credentials and decrypted conversations sit on your paired computer. A doctor run reports counts only. BEE_DOCTOR_FULL
2. Transcripts and the model cache live under ~/.buzz. The spool is encrypted with a key in your operating system's store.
3. One short speech window per use goes to Bedrock Nova 2 Lite in us-east-2, under your own AWS profile. OWN_BEE_RUN
4. The preview file lists exactly what would be sent, as field names and counts. Nothing is sent to hosted Buzz until you approve; model checking has already sent short speech windows to Bedrock. OWN_BEE_RUN
5. The sync carries ids, days, statuses, reason codes and revisions. The server refuses any field outside that list. SYNC_PUSH_AND_READBACK
6. Buzz writes to Bee only with your approval: one training fact, sent by approved hash and read back. It matched. FACT_CREATE_READBACK

Completed lifecycle: On 22 Oct Buzz updated the same fact to the approved closing text, which ends it, and read it back (FACT_END_READBACK). The paired computer retains encrypted payload files. DynamoDB Local retains results metadata; the moto fallback starts empty after restart. The privacy document preserves its September run and adds the current source explanation. FACT_CREATE_READBACK

8. Release and identity

A deploy carries the label of the commit it came from.

Swipe the diagram sideways to see all of it. The steps below say the same in words.

1. You start from a clean checkout. Tracked files match HEAD. DEPLOY_B4BA775
2. The Lambda bundle and the web app are built from it. Each writes a BUILD_COMMIT stamp equal to HEAD. DEPLOY_B4BA775
3. The guard runs when CDK synthesizes. It stops unless BUZZ_COMMIT equals HEAD and both stamps match. A mislabelled deploy on 14 Oct is why it exists. LABEL_CORRECTION
4. cdk diff shows what changes. For ceafde6: Api and Forager code, the commit setting and the site deploy. No IAM, table or schedule change. DEPLOY_CEAFDE6
5. The owner deploys. VB ran cdk deploy BuzzPilot in his own shell. DEPLOY_CEAFDE6
6. Reads agree on ceafde6: stack output, /BUILD_COMMIT, evidence.json and the evidence page without JavaScript; VB reads the Lambda setting in the console. IDENTITY_CEAFDE6
7. Smoke checks the routes and auth guards. The judge walk then runs through the app. SMOKE_CEAFDE6JUDGE_WALK_CEAFDE6

Recorded release read-back (23 Oct, 05:37 UTC): Read-only checks on 23 Oct recovered the existing a414e63 deployment: stack output, Api Lambda BUZZ_COMMIT, public BUILD_COMMIT, evidence.json and the no-JavaScript evidence page agree. The Api is Active, python3.12, timeout 29 seconds and memory 1024 MB. IDENTITY_CEAFDE6VERIFY_C1ECFD4

The method

Buzz is a vocabulary coach built on Bee. Its BEE Score has three readings: Build (practise it), Express (use it naturally) and Embed (use it again). Unknown is never zero, and practice never counts as use.

When a use counts

1. Bee captures a conversation. Buzz looks only for the exact forms of supported words and phrases.
2. Only the wearer’s own speech is checked, and only once who was speaking is confirmed. Other people are never scored.
3. A judge checks the sense and the setting. A second check looks for reasons it shouldn’t count: a quotation, a rehearsal, the wrong speaker, too little context.
4. The result is Counted, Not counted with its reason, or Checks incomplete. Incomplete never counts and never lowers anything.

Practice, example data and anything written back to Bee never count as use.

Readings, levels and streaks

Build

Optional practice, recorded by the server once recall and application are both done that day.

Express

A supported word used naturally in a checked conversation.

Embed

The same word used again on a later day.

Level

Days with a counted natural use: levels at 1, 3, 7, 14 and 30 days. A missed day takes nothing away.

Practice streak

Consecutive days of completed practice. It is kept apart from the level and never adds to it.

How the next word is chosen

Buzz keeps a small reviewed map of what words are for, such as finding the main point or weighing a decision. Your declared goal and the situations Buzz has evidence for point to a purpose; code picks a word that serves it and that you haven’t marked as known. A Strands agent on Amazon Bedrock can explain the pick, but only from that checked shortlist; on 19 Oct it ran on Bedrock over authored examples with no measured advantage over the code’s pick, and on 22 Oct it picked a next word live from the builder’s stored data on his own computer (3 calls), saved and shown in the app. If the model is slow or wrong, the code’s choice stands.

A suggestion never counts as a use, never changes your kept word unless you accept it, and says why it was made.

Where a reading comes from

• Every number is read from a published snapshot with a revision. A corrected conversation withholds the reading; nothing is republished in place.
• The origin is disclosed on every screen: example data, or your Bee conversations read on your paired machine.
• Activity counts (conversations, minutes, days captured) are counted by code from the captured sources. Where intervals are not verified, minutes are shown as not available.
• Practice, synthetic data and anything written back to Bee never count as evidence.

What leaves your computer: a short window of speech (about 240 characters around each checked word) goes to Amazon Bedrock for the check. The hosted beta receives ids, days, statuses and reason codes. Separately, when you ask the hosted Pack builder for a Pack, your brief and the catalogue forms also go to Bedrock.

The receipts behind each claim are on the Evidence page.