Whiteboards from the room — Synapxe Workshop

Live-session recap

What we drew on the board

The module pages walk each of these ideas through in more depth — this page is the one-glance recap. Click any board to enlarge; use the tags to jump into the matching explainer.

1 LLM basics 2 Context window 3 Meta prompting 4 Tokenizer 5 Where agents live

Whiteboard sketch. Top: unlabelled DATA feeds into Pretraining, producing a MODEL with training cutoff 2025. Middle: a person icon sends text through Inference to an Endpoint. Bottom: a person sends text to an AI Agent, which calls the MODEL (step 2) and reaches out to a Tool for real-time data or the Web (step 1).

LLM Basics

How the model gets built, and how you actually use it

Top row: unlabelled data → pretraining → a model, frozen at a training cutoff (2025 here). Middle row: inference — every message you send goes through the endpoint and comes back. Bottom row: an AI agent wraps the model with a tool so it can reach the web or pull real-time data — the model itself only knows what it was trained on.

Why it matters: anything that has to be current — today's numbers, your organisation's documents, a policy that just changed — has to enter the conversation through the agent's wrapper, not from inside the model.

F1 · Chatbots to Agents Pre-read · LLM Foundations

Whiteboard sketch tracing two chats. Chat 1 conv shows Turn 1 sending c1, then Turn 2 sending c1 plus r1 plus c2, growing every turn against a 200K token budget on the far left. An 'Auto Sum' bracket marks summarisation kicking in near the top. Chat 2 conv on the right runs Turn 1 through Turn 3, with the agent's instructions labelled AInst appearing every turn as 'Persistent Context'. A dashed 'memory' arc arches across the top of both chats.

Context Window

Every turn re-sends the prior thread — the window fills up

Left side (Chat 1): each new turn sends turn 1 + turn 2 + … + the new message. By turn 20+ that thread pushes on the 200K budget shown on the far left. Auto-summary compresses older turns before the window overflows. Right side (Chat 2): the agent's instructions (AInst) ride in on every turn as persistent context. Memory is what an app deliberately carries across chats (the arc across the top).

Why it matters: long chats slow down and quietly forget earlier facts as they run out of budget. Start a fresh chat per task, and put anything that must survive across chats into the Space (or a skill) rather than typing it into the chat.

Pre-read · How LLMs Work Platform · Spaces

Whiteboard sketch. Left side: a bracket labelled 'Prompt Template' spans Turn 1 through Turn 20 as the user iterates with the model, producing a 'Final Report' at the bottom. Right side: a single 'T1 · Prompt Template' produces the same 'Final Report' in one shot. Meta Prompting is written in the middle.

Meta Prompting

Twenty turns to get it right → save the prompt so next time is one turn

Left: you iterate with the model over T1 … T20, shaping instructions until a Final Report comes out the way you want. Right: those twenty turns collapse into a Prompt Template that produces the same Final Report from a single turn next time. That is meta prompting — using the model to co-write the prompt with you until it becomes a durable asset.

Why it matters: the team's best prompt should be a shared artefact — a template, a skill or a chat agent — not one person's ad-hoc chat window. F4 is exactly this idea at agent scale: your canvas is the durable form of "the prompt we agreed on".

F2 · Prompt Engineering F4 · Agent Design Canvas

Whiteboard sketch. Sentence at the top reads 'I want to have breakfast with bread and ?'. Under each word are token IDs 20, 22, 23, 14, 17, 18, 71, 80, 10 — with 'breakfast' visibly splitting into two pieces at 17 and 18. On the right, candidate next words with probabilities: eggs 30 percent, butter 20 percent, avocado 10 percent, jam 5 percent, and banana far down in the tail.

Tokenizer & Next-Token Odds

Words become tokens, tokens become numbers, numbers become odds

The sentence "I want to have breakfast with bread and…" is chopped into chunks and each chunk gets an ID (20, 22, 23, 14, 17, 18, 71, 80, 10). Note that breakfast splits into two pieces (17, 18) — common words stay whole, longer or rarer ones get broken up. To decide what comes next the model works out a probability across every word it knows: eggs 30%, butter 20%, avocado 10%, jam 5%, …, and banana far down in the tail. It samples one — that is why the same prompt can give slightly different answers each time.

Why it matters: "same input, slightly different output" is not a bug — it is how the machine works. Where you need a rule to survive word-for-word (a citation script, a refusal line, a "never do X"), put it in a reference document the platform preserves verbatim, not in the persona field which the platform rewords.

Pre-read · Tokenizer Pre-read · How LLMs Work

Whiteboard sketch. A box labelled 'Server / laptop' on the left holds agent figures labelled Kiro, Cursor, Claude Cowork and a Quick Desktop agent near the top, plus two red 'Py' Python-script agents lower down. Dashed lines run out of the box. On the right, an orange cloud holds agent figures labelled 'Quick Web' and 'Prod'. A dashed line connects a laptop agent across to the cloud agents, showing local and cloud agents talking to each other.

Where Agents Live

The same agent idea runs on your laptop or in the cloud

Left box — your machine: desktop agent tools (Kiro, Cursor, Claude Cowork, a Quick Desktop app) and your own scripted Python agents (Py). Right — the cloud: Amazon Quick on the web and a hosted production agent. The dashed lines are the point: it is one pattern — a model plus instructions plus tools — just living in different homes and talking to each other across the boundary.

Why it matters: where an agent runs is a deployment choice, not a different skill. The design you shaped in F4 is portable — it can start as a chat agent on Quick and later move to a desktop tool or a production service without rethinking the design.

Platform · What is Amazon Quick F4 · Agent Design Canvas

Go deeper

Where each idea lives in the workshop

The whiteboards were shortcuts — a chunk of an idea, drawn fast. The explainers below take each idea further, with interactive walkthroughs, sample data and the framings we did not get to on the board.

Whiteboard	Go deeper
1 · LLM basics Pretraining · inference · agent	F1 · From Chatbots to Agents is the fuller version of the bottom row of this board — how a model becomes an agent that acts.
2 · Context window Chat accumulation · memory · persistent context	Pre-read · LLM Foundations covers the tokens-in / tokens-out picture. Platform · Spaces is where "persistent context" turns into a real feature.
3 · Meta prompting Iterate 20 turns → template → reuse	F2 · Prompt Engineering gives you the CRAFT framework the template rests on. F4 · Agent Design Canvas is meta prompting for a whole agent, not just one prompt.
4 · Tokenizer Words → tokens → probabilities	Pre-read · Tokenizer has the exact same sentence as an interactive four-step walkthrough — split, ID, odds, pick.
5 · Where agents live Laptop · cloud · same pattern	Platform · What is Amazon Quick shows where a Quick agent sits. F4 · Agent Design Canvas is the portable design that can run in any of those homes.