AICASSINDRA · LEARN BY EXPERIMENTING
Streaming systems labs
Explore the interactive side of AICassindra. Read a topic, test an idea, and follow the results.
Choose a topic, explore the model, and compare what changes. Each experiment explains its assumptions and limitations.
Browse the collection below.
Cassandra token ring
Inspect exact text-key tokens, stable virtual-node ranges and the keys affected by a node join.
Interactive lab Apache CassandraCompaction strategies
Inspect which SSTables are read, which record versions survive, and how output ranges change.
Interactive lab Apache CassandraHinted handoff: a queue is not a guarantee
Watch missed writes queue, expire and replay only when the replica can receive them.
Interactive lab Apache CassandraTombstones: repair, grace and resurrection
Follow one deleted value across three replicas and inspect exactly when its marker disappears.
Interactive lab Artificial intelligenceA2A artifact assembly: append, replace and finish
Follow exact content through assembly, a conditional write and a scoped version read.
Interactive lab Artificial intelligenceA2A push configuration: validate, deliver and inspect
Watch individual webhook attempts. Change authentication, timeouts and retry policy; inspect exactly what the receiver applied.
Interactive lab Artificial intelligenceA2A push delivery: retries do not prove exactly-once effects
Watch individual webhook attempts. Change authentication, timeouts and retry policy; inspect exactly what the receiver applied.
Interactive lab Artificial intelligenceAgent Card discovery: access and validation
Follow the request, inspect the card, and see exactly why discovery succeeds or stops.
Interactive lab Artificial intelligenceAgent Card discovery: capability compatibility
Follow the request, inspect the card, and see exactly why discovery succeeds or stops.
Interactive lab Artificial intelligenceAgent tracing: connect parent and child spans
Inspect actual span IDs, parent relationships, sampling decisions and a deterministic execution schedule.
Interactive lab Artificial intelligenceAI availability monitor
Derive a routing decision from timestamped check results. These are fictional routes, not live provider status.
Interactive lab Artificial intelligenceArtifact handoff: bind a reader to a generation
Follow exact content through assembly, a conditional write and a scoped version read.
Interactive lab Artificial intelligenceArtifact parts: text, structured data and inline files
Follow exact content through assembly, a conditional write and a scoped version read.
Interactive lab Artificial intelligenceBuffered response versus incremental event consumption
Fragment real encoded bytes, inspect the parser buffer and follow complete events into an ordered text consumer.
Interactive lab Artificial intelligenceBuild a message and inspect every part
Edit a real request document. Follow validation, decoded payloads, a local handler and response-id matching.
Interactive lab Artificial intelligenceCapability intersection: unsupported requirements stay explicit
Inspect seven synthetic registry entries. Apply hard eligibility gates before ranking and proposing a compatible local contract.
Interactive lab Artificial intelligenceCapability negotiation: agree on a usable contract
Inspect seven synthetic registry entries. Apply hard eligibility gates before ranking and proposing a compatible local contract.
Interactive lab Artificial intelligenceCircuit breaker: outage and recovery
Break a dependency, watch the gate protect it, and decide when traffic can safely return.
Interactive lab Artificial intelligenceConversation identity: inspect routed histories
Edit message envelopes and see exactly which conversation stores each message.
Interactive lab Artificial intelligenceCurated registry: inspect candidates before selection
Inspect seven synthetic registry entries. Apply hard eligibility gates before ranking and proposing a compatible local contract.
Interactive lab Artificial intelligenceDead-letter intent: reconcile an uncertain outcome
Follow one logical operation across repeated attempts, late responses, deduplication and committed server effects.
Interactive lab Artificial intelligenceDecision Boundary Visualizer
Compare a nearest-centroid boundary with five-neighbor voting on the same labeled points.
Interactive lab Artificial intelligenceEmbedding Similarity (2D)
Place words in 2D embedding space; compute cosine similarity.
Interactive lab Artificial intelligenceError handling: classify before retrying
Follow one logical operation across repeated attempts, late responses, deduplication and committed server effects.
Interactive lab Artificial intelligenceError recovery: know what the client cannot know
Follow one logical operation across repeated attempts, late responses, deduplication and committed server effects.
Interactive lab Artificial intelligenceFailure isolation: contain a stalled dependency
Follow each request from arrival to completion, rejection or timeout.
Interactive lab Artificial intelligenceFile parts: bytes versus URI references
Edit a real request document. Follow validation, decoded payloads, a local handler and response-id matching.
Interactive lab Artificial intelligenceGradient Descent
Tune learning rate; watch convergence (or divergence).
Interactive lab Artificial intelligenceIdempotency: one intent, repeated attempts
Follow one logical operation across repeated attempts, late responses, deduplication and committed server effects.
Interactive lab Artificial intelligenceIn-Browser LLM Playground
Load a small language model and run inference with WebGPU in this tab. Model assets download from third parties; do not enter secrets or personal data.
Interactive lab Artificial intelligenceJSON-RPC: correlate a request with its response
Edit a real request document. Follow validation, decoded payloads, a local handler and response-id matching.
Interactive lab Artificial intelligencek-NN Classifier
Place training points; classify queries by k nearest neighbors.
Interactive lab Artificial intelligenceLoad shedding: reject before the queue fills
Fill the waiting room, watch workers process real model requests, and inspect every admission decision.
Interactive lab Artificial intelligenceMessage envelope: validate identifiers and structure
Edit a real request document. Follow validation, decoded payloads, a local handler and response-id matching.
Interactive lab Artificial intelligenceMessage examples: pass and fail a concrete fixture
Edit a real request document. Follow validation, decoded payloads, a local handler and response-id matching.
Interactive lab Artificial intelligenceMessage parts: text, data and file payloads
Edit a real request document. Follow validation, decoded payloads, a local handler and response-id matching.
Interactive lab Artificial intelligenceMessage type failures: inspect the schema boundary
Edit a real request document. Follow validation, decoded payloads, a local handler and response-id matching.
Interactive lab Artificial intelligenceMulti-tenancy: who gets the next worker?
Follow each request from arrival to completion, rejection or timeout.
Interactive lab Artificial intelligenceNegotiation failure: do not invent a compatible format
Inspect seven synthetic registry entries. Apply hard eligibility gates before ranking and proposing a compatible local contract.
Interactive lab Artificial intelligenceObserve a message transaction end to end
Edit a real request document. Follow validation, decoded payloads, a local handler and response-id matching.
Interactive lab Artificial intelligenceOrchestration: parallel branches and a guarded join
Run six local transformations. Watch dependency gates, worker assignments, retries and the exact artifacts produced.
Interactive lab Artificial intelligenceProtocol errors: classify the failing layer
Edit a real request document. Follow validation, decoded payloads, a local handler and response-id matching.
Interactive lab Artificial intelligenceProtocol orientation: inspect a complete exchange
Edit a real request document. Follow validation, decoded payloads, a local handler and response-id matching.
Interactive lab Artificial intelligenceProtocol workbench: from wire text to local receipt
Edit a real request document. Follow validation, decoded payloads, a local handler and response-id matching.
Interactive lab Artificial intelligenceRAG retrieval workbench
Change the query and inspect computed document scores, context decisions and cited evidence.
Interactive lab Artificial intelligenceRate limiting: burst budget versus sustained rate
Fill the waiting room, watch workers process real model requests, and inspect every admission decision.
Interactive lab Artificial intelligenceRate limiting: inspect the 429 response
Fill the waiting room, watch workers process real model requests, and inspect every admission decision.
Interactive lab Artificial intelligenceReputation evidence: account for sample size
Inspect seven synthetic registry entries. Apply hard eligibility gates before ranking and proposing a compatible local contract.
Interactive lab Artificial intelligenceRetry identity: stable intent versus new keys
Follow one logical operation across repeated attempts, late responses, deduplication and committed server effects.
Interactive lab Artificial intelligenceRouting preferences: cost versus latency
Inspect seven synthetic registry entries. Apply hard eligibility gates before ranking and proposing a compatible local contract.
Interactive lab Artificial intelligenceSkill matching: filter first, rank second
Inspect seven synthetic registry entries. Apply hard eligibility gates before ranking and proposing a compatible local contract.
Interactive lab Artificial intelligenceTask delegation: retain dependency and artifact ownership
Run six local transformations. Watch dependency gates, worker assignments, retries and the exact artifacts produced.
Interactive lab Artificial intelligenceTask lifecycle: cancellation and partial work
Interrupt a task, supply what it needs, and follow the actual state and artifact changes.
Interactive lab Artificial intelligenceTask lifecycle: clarification before execution continues
Interrupt a task, supply what it needs, and follow the actual state and artifact changes.
Interactive lab Artificial intelligenceTask lifecycle: identity and terminal immutability
Interrupt a task, supply what it needs, and follow the actual state and artifact changes.
Interactive lab Artificial intelligenceTask lifecycle: inspect every state
Interrupt a task, supply what it needs, and follow the actual state and artifact changes.
Interactive lab Artificial intelligenceTask lifecycle: rejection versus execution failure
Interrupt a task, supply what it needs, and follow the actual state and artifact changes.
Interactive lab Artificial intelligenceTask lifecycle: resume interrupted work
Interrupt a task, supply what it needs, and follow the actual state and artifact changes.
Interactive lab Artificial intelligenceTask-history pagination: a changing collection
Inspect every returned ID as the collection changes between pages.
Interactive lab Artificial intelligenceTimeouts: waiting ends, server work may continue
Follow one logical operation across repeated attempts, late responses, deduplication and committed server effects.
Interactive lab Artificial intelligenceTrust policy: approval is not a ranking weight
Inspect seven synthetic registry entries. Apply hard eligibility gates before ranking and proposing a compatible local contract.
Interactive lab Artificial intelligenceVersion negotiation: inspect payload compatibility
Negotiate a fictional revision, adapt a real JSON payload, and verify that the client can decode the response.
Interactive lab Audio engineeringAcoustic Echo Cancellation
Adaptive filter learns the echo path and subtracts it.
Interactive lab Audio engineeringAudio Jitter Buffer
Network jitter → buffer absorbs it. Tune buffer size and watch underruns.
Interactive lab Audio engineeringSample Rate Conversion
Visualize upsampling and downsampling with anti-aliasing.
Interactive lab Audio engineeringVoice Activity Detection (VAD)
Energy threshold VAD: detect speech vs silence in synthetic audio.
Interactive lab Audio engineeringVoice agent: reject a false turn from background noise
Compare speech-and-turn gating with triggering on every sound.
Interactive lab Bidirectional streamingHead-of-Line Blocking — TCP vs QUIC
Drop one packet; see how HTTP/2 stalls while HTTP/3 doesn't.
Interactive lab Bidirectional streamingHTTP/2 Stream Multiplexing
Multiple streams interleave over one connection.
Interactive lab Bidirectional streamingReconnect with Exponential Backoff
When the connection drops, retry with increasing delays + jitter.
Interactive lab Bidirectional streamingServer-Sent Events (SSE)
Server-push one-way stream over HTTP.
Interactive lab Bidirectional streamingWebSocket Frame Flow
Animate frames flowing between client and server.
Interactive lab Concurrency & threadingLock Contention
N threads compete for one mutex; see throughput collapse with contention.
Interactive lab Concurrency & threadingProducer-Consumer with Bounded Queue
Tune producer/consumer rates; watch the queue fill and drain.
Interactive lab Concurrency & threadingRace Condition — Counter Increment
N threads doing counter++ without synchronization. Watch the lost updates.
Interactive lab Concurrency & threadingVirtual Threads vs OS Threads
Memory cost of spawning N threads under each model.
Interactive lab Concurrency & threadingWork-Stealing Scheduler
Worker queues fill at different rates; idle workers steal from busy ones.
Interactive lab DatabasesB-tree Index Visualizer
Insert values; see B-tree splits and growth.
Interactive lab DatabasesConnection pools: occupancy, queues and timeouts
Follow each request from arrival to completion, rejection or timeout.
Interactive lab DatabasesDatabase tool: typed keys and bounded values
Edit real JSON arguments, inspect policy gates and watch an approved local function change a synthetic ledger.
Interactive lab DatabasesMVCC: a snapshot remembers active writers
Compare two SELECT statements against the same committed and uncommitted row versions.
Interactive lab Databasespgvector ANN Search
2D vector search with adjustable recall threshold.
Interactive lab DatabasesPostgres Streaming Replication Lag
Adjust write rate vs replica apply rate; see lag accumulate.
Interactive lab DatabasesSession storage: inspect what survives a crash
Follow concurrent drafts into committed revisions, inspect the checkpoint and reconstruct state after a simulated crash.
Interactive lab Distributed systemsAgent consensus: quorum versus unanimity in a three-voter fixture
Inspect twelve proposals while one voter becomes unavailable.
Interactive lab Distributed systemsBackpressure: distinguish held demand from failures
Fill the waiting room, watch workers process real model requests, and inspect every admission decision.
Interactive lab Distributed systemsBackpressure: tune the waiting room
Fill the waiting room, watch workers process real model requests, and inspect every admission decision.
Interactive lab Distributed systemsBackpressure: watch pause and resume signals
Fill the waiting room, watch workers process real model requests, and inspect every admission decision.
Interactive lab Distributed systemsDistributed tracing: preserve context across agents
Inspect actual span IDs, parent relationships, sampling decisions and a deterministic execution schedule.
Interactive lab Distributed systemsGossip Protocol Spread
Watch a rumor spread through a 50-node cluster via gossip.
Interactive lab Distributed systemsPartition Tolerance — CAP in Action
Cause a network partition; see how AP and CP systems behave.
Interactive lab Distributed systemsQuorum Reads and Writes
N=5 replicas. Tune R and W; see when R+W > N gives strong consistency.
Interactive lab Distributed systemsRaft Leader Election
5-node cluster: kill the leader and watch a new election.
Interactive lab Distributed systemsVector Clocks
Three processes exchanging messages — see vector clock updates and concurrency detection.
Interactive lab Large language modelsA/B capacity: sample size changes operational exposure
Compare control and candidate traffic volume alongside accepted outcomes.
Interactive lab Large language modelsA2A architecture: isolate one child-agent failure
Run two child tasks and decide whether one error destroys healthy work.
Interactive lab Large language modelsA2A interop: select a compatible protocol version
Compare a negotiated version with an assumed fixed one.
Interactive lab Large language modelsA2A load balancing: keep a local task on its owning server
Route the second request with or without session affinity.
Interactive lab Large language modelsADK application overview: check authority at the tool boundary
Compare a permitted read with an out-of-scope write.
Interactive lab Large language modelsADK code executor: reject a forbidden import
Compare a small arithmetic script with a fictional filesystem read.
Interactive lab Large language modelsADK Java and A2A: validate a discovered peer before handoff
Inspect a trusted Agent Card and one whose endpoint origin differs.
Interactive lab Large language modelsADK Java core: keep session state tenant-scoped
Resume a stored preference as its owner or as a different tenant.
Interactive lab Large language modelsAfter-tool callback: redact returned content
Edit real JSON arguments, inspect policy gates and watch an approved local function change a synthetic ledger.
Interactive lab Large language modelsAgent A/B assignment: expose the candidate deliberately
Route a fixed request cohort into control and candidate agents, then inspect the observed answers.
Interactive lab Large language modelsAgent accessibility: preserve keyboard focus through an error dialog
Inspect labeled controls, status announcements, and focus restoration.
Interactive lab Large language modelsAgent alerting: open an incident only after enough failures
Watch an error threshold become an alert on a numbered request stream.
Interactive lab Large language modelsAgent architecture: propagate trace context through a failing tool
See whether a child error remains connected to the user request.
Interactive lab Large language modelsAgent as tool: cap a delegated child’s permissions
Watch a child agent attempt a read or out-of-scope write.
Interactive lab Large language modelsAgent batching: throughput grouping versus request wait
Group twelve request arrivals into batches of two or four.
Interactive lab Large language modelsAgent billing: one invoice from validated usage
Follow individual meter records into invoice lines, one credit application and a separate collection/refund ledger.
Interactive lab Large language modelsAgent cancellation and resumption: restore from a checkpoint
Interrupt an eight-step task and inspect exactly which work replays.
Interactive lab Large language modelsAgent Card discovery: cache and capacity
Follow the request, inspect the card, and see exactly why discovery succeeds or stops.
Interactive lab Large language modelsAgent Card discovery: follow the request
Follow the request, inspect the card, and see exactly why discovery succeeds or stops.
Interactive lab Large language modelsAgent Card discovery: invalid and unavailable cards
Follow the request, inspect the card, and see exactly why discovery succeeds or stops.
Interactive lab Large language modelsAgent Card discovery: trace changes over time
Follow the request, inspect the card, and see exactly why discovery succeeds or stops.
Interactive lab Large language modelsAgent chaos gate: survive a regional outage
Inject a primary-region failure and inspect whether a secondary route serves.
Interactive lab Large language modelsAgent CI/CD: four evidence gates before promotion
See which build, contract, evaluation, or canary defect escapes a shallow pipeline.
Interactive lab Large language modelsAgent CI/CD: keep a failing integration test from release
Follow a candidate through build, test gate and fictional promotion.
Interactive lab Large language modelsAgent code execution: terminate a runaway script
Compare finite work and a nonterminating loop under an execution deadline.
Interactive lab Large language modelsAgent context failure: answer unknown when an early fact is evicted
Compare a short conversation and a long one under two window budgets.
Interactive lab Large language modelsAgent cost control: reject an over-budget call
Compare a six-unit request with a fourteen-unit burst under a ten-unit cap.
Interactive lab Large language modelsAgent dashboards: separate error rate from tail latency
Inspect twelve requests through two different dashboard lenses.
Interactive lab Large language modelsAgent debate: let a counterexample change the decision
Inspect proponent, opponent, rebuttal, and release gate stages.
Interactive lab Large language modelsAgent debugging: trace the wrong tool output
See whether a structured trace identifies an intermediate error.
Interactive lab Large language modelsAgent deployment: route only after readiness
Follow worker lifecycles and the invocations they own. Test readiness, shutdown deadlines and the point at which results commit.
Interactive lab Large language modelsAgent evaluation: inspect every decision
Inspect each recorded score, compare its decision with the reference label and watch the confusion matrix fill.
Interactive lab Large language modelsAgent event release gate: protect a required consumer field
Remove taskId and see whether a contract test blocks the producer.
Interactive lab Large language modelsAgent events: deduplicate a redelivered effect
Trace one event ID through one or two deliveries.
Interactive lab Large language modelsAgent feedback UI: collect an actionable signal
Trace a rating from learner input through validation and reviewer triage.
Interactive lab Large language modelsAgent filesystem: read versus write authority
Edit real JSON arguments, inspect policy gates and watch an approved local function change a synthetic ledger.
Interactive lab Large language modelsAgent framework landscape: choose by constraints, not popularity
Compare a public prototype with a restricted-data workload.
Interactive lab Large language modelsAgent hierarchy: inspect a broken delegation chain
Follow root, lead, and specialist routes through failure and backup choices.
Interactive lab Large language modelsAgent history: inspect committed state changes
Follow concurrent drafts into committed revisions, inspect the checkpoint and reconstruct state after a simulated crash.
Interactive lab Large language modelsAgent host lifecycle: initialize resources and drain work
Follow worker lifecycles and the invocations they own. Test readiness, shutdown deadlines and the point at which results commit.
Interactive lab Large language modelsAgent hotfix: verify the fix without skipping regression evidence
Replay an incident fixture, patch assertion, adjacent contracts, and a canary rollback check.
Interactive lab Large language modelsAgent identity: trust and audience boundaries
Inspect credential claims, policy gates and the resource decision. Change a condition and follow the exact denial reason.
Interactive lab Large language modelsAgent inspection API: enforce a tenant boundary before returning a trace
Compare an authorized trace read with a cross-tenant lookup.
Interactive lab Large language modelsAgent integration testing: follow a request across boundaries
Trace authentication, tool response, persistence, and callback replay with injected defects.
Interactive lab Large language modelsAgent invocation lifecycle: admit, execute, commit
Follow worker lifecycles and the invocations they own. Test readiness, shutdown deadlines and the point at which results commit.
Interactive lab Large language modelsAgent logs: redact sensitive fields before emission
Compare safe masking with a deliberately unsafe fictional raw-field path.
Interactive lab Large language modelsAgent map tool: route policy versus traffic ETA
Compare a faster toll road with a slower toll-free route under a jam.
Interactive lab Large language modelsAgent market: assign work under skill and budget constraints
Inspect eligible bids, award costs, and tasks left unassigned by a tight cap.
Interactive lab Large language modelsAgent marketplace: compare eligible offers transparently
Inspect seven synthetic registry entries. Apply hard eligibility gates before ranking and proposing a compatible local contract.
Interactive lab Large language modelsAgent memory compression: preserve the user’s report preference
Inspect whether a concise-bullets preference survives a long incident conversation.
Interactive lab Large language modelsAgent memory hierarchy: keep a preference across sessions only when approved
Compare ephemeral session state with a scoped durable preference.
Interactive lab Large language modelsAgent pipeline: ordered transformations and failure propagation
Run six local transformations. Watch dependency gates, worker assignments, retries and the exact artifacts produced.
Interactive lab Large language modelsAgent progress UI: make a stalled tool visible
Compare milestone updates with a silent final-only spinner.
Interactive lab Large language modelsAgent red-team test: expose instruction injection in a document
Compare a benign document with a malicious instruction under two release gates.
Interactive lab Large language modelsAgent release train: hold promotion after canary errors
Inspect build, canary, and promotion stages for a candidate agent.
Interactive lab Large language modelsAgent release: blue/green and rollback
Route individual requests, observe both versions and stop candidate traffic when the measured release gate fails.
Interactive lab Large language modelsAgent runtime capacity: every invocation needs an owner
Follow worker lifecycles and the invocations they own. Test readiness, shutdown deadlines and the point at which results commit.
Interactive lab Large language modelsAgent sandboxing: deny outbound network from untrusted code
See a local calculation and a fictional exfiltration attempt under two policies.
Interactive lab Large language modelsAgent scoring: threshold and error cost
Inspect each recorded score, compare its decision with the reference label and watch the confusion matrix fill.
Interactive lab Large language modelsAgent serving scale: compare fixed and elastic capacity
Put six or twelve fictional concurrent requests against two or four replicas.
Interactive lab Large language modelsAgent shell execution: restrict commands before they run
Compare a status read with a destructive fictional command.
Interactive lab Large language modelsAgent simulator: replay the same case before comparing versions
Compare a baseline and candidate with a fixed or changing scenario seed.
Interactive lab Large language modelsAgent skills: load only trusted instructions for the task
Compare an approved skill with an untrusted extra skill that requests a secret.
Interactive lab Large language modelsAgent smoke testing: find a broken startup before release
Run four concrete probes and see when a shallow green check lets a broken agent escape.
Interactive lab Large language modelsAgent soak test: expose a slow memory leak
Compare a five-minute check with an hour of repeated fictional traffic.
Interactive lab Large language modelsAgent swarm: elect one owner for a duplicated task
Give one task to one or two workers and count effects.
Interactive lab Large language modelsAgent team: independent specialists and a final check
Run six local transformations. Watch dependency gates, worker assignments, retries and the exact artifacts produced.
Interactive lab Large language modelsAgent telemetry events: validate correlation fields
Quarantine events whose trace or tenant context is missing.
Interactive lab Large language modelsAgent types: choose sequential or parallel work by dependency
See a dependent synthesis task fail when launched too early.
Interactive lab Large language modelsAgent unit testing: exercise boundaries and repeated effects
Compare a happy-path unit check with schema, limit, and idempotency fixtures.
Interactive lab Large language modelsAgent user analytics: respect opt-out before collecting events
Inspect consent, field minimization, collection, and reporting stages.
Interactive lab Large language modelsAgent UX: clarify an ambiguous account request
Prevent a report lookup from using an invented default tenant.
Interactive lab Large language modelsAgent voting: majority decision with a recorded dissent
Compare a two-of-three rule with unanimity before promotion.
Interactive lab Large language modelsAgent web browsing: keep page text out of the instruction channel
See a fictional prompt injection blocked or executed at the page boundary.
Interactive lab Large language modelsAgno-style remote agent: bound the Java adapter wait
Compare a fast response with a stalled remote worker under a deadline.
Interactive lab Large language modelsAnalogical prompting: test whether a pattern transfers
Compare a close router analogy with a distant batch-import analogy.
Interactive lab Large language modelsApplication result caching: reuse without changing the answer
Watch concrete requests fill a bounded cache. Inspect stored vectors, expiry, eviction and incorrect reuse.
Interactive lab Large language modelsApproval workflow: bind review to operation intent
Edit real JSON arguments, inspect policy gates and watch an approved local function change a synthetic ledger.
Interactive lab Large language modelsArtifact capacity: count stored content bytes
Follow exact content through assembly, a conditional write and a scoped version read.
Interactive lab Large language modelsArtifact service contract: assemble, commit and read
Follow exact content through assembly, a conditional write and a scoped version read.
Interactive lab Large language modelsAsync state: prevent a lost update
Follow concurrent drafts into committed revisions, inspect the checkpoint and reconstruct state after a simulated crash.
Interactive lab Large language modelsAsynchronous work: worker capacity versus dependencies
Run six local transformations. Watch dependency gates, worker assignments, retries and the exact artifacts produced.
Interactive lab Large language modelsAttention Mask Visualizer
See causal, bidirectional, and prefix-LM attention masks side by side.
Interactive lab Large language modelsAudit trail: reconcile actions with record effects
Follow actual fictional records through primary storage, a backup, an export and a restore.
Interactive lab Large language modelsAutoGen-style team: stop a conversation that never terminates
Count team turns with or without a termination cap.
Interactive lab Large language modelsBaseLlm interface: normalize a provider response shape
See a renamed provider field either mapped or leaked to callers.
Interactive lab Large language modelsBeeAI-to-Java bridge: preserve a renamed response field
Normalize a response envelope or lose its answer at the boundary.
Interactive lab Large language modelsBenchmark audit: inspect reference labels and scores
Inspect each recorded score, compare its decision with the reference label and watch the confusion matrix fill.
Interactive lab Large language modelsBenchmark design: show denominators and failures
Inspect each recorded score, compare its decision with the reference label and watch the confusion matrix fill.
Interactive lab Large language modelsBidirectional agent: prevent a burst from overrunning the receiver
Send a short stream or a burst through a four-message processing window.
Interactive lab Large language modelsBigQuery-style query budget: filter before scanning
Estimate bytes scanned under a partition filter and a hard cap.
Interactive lab Large language modelsBlue/green observability: measure both versions
Route individual requests, observe both versions and stop candidate traffic when the measured release gate fails.
Interactive lab Large language modelsBlue/green release: inspect the cutover
Route individual requests, observe both versions and stop candidate traffic when the measured release gate fails.
Interactive lab Large language modelsBulkheads: reserved capacity versus borrowing
Follow each request from arrival to completion, rejection or timeout.
Interactive lab Large language modelsCalendar boundaries: adjacent is not overlapping
Edit real JSON arguments, inspect policy gates and watch an approved local function change a synthetic ledger.
Interactive lab Large language modelsCalendar tool: detect overlapping intervals
Edit real JSON arguments, inspect policy gates and watch an approved local function change a synthetic ledger.
Interactive lab Large language modelsCanary exposure: speed versus blast radius
Route individual requests, observe both versions and stop candidate traffic when the measured release gate fails.
Interactive lab Large language modelsCanary failure: stop a bad candidate
Route individual requests, observe both versions and stop candidate traffic when the measured release gate fails.
Interactive lab Large language modelsCanary release: compare observed cohorts
Route individual requests, observe both versions and stop candidate traffic when the measured release gate fails.
Interactive lab Large language modelsCapacity planning: find the saturation point
Fill the waiting room, watch workers process real model requests, and inspect every admission decision.
Interactive lab Large language modelsChain of verification: catch an unsupported delivery claim
Compare an independent evidence question with merely restating a draft.
Interactive lab Large language modelsCheckpointing: recover the gap after a snapshot
Follow concurrent drafts into committed revisions, inspect the checkpoint and reconstruct state after a simulated crash.
Interactive lab Large language modelsCI evaluation gate: accept or reject a fixture run
Inspect each recorded score, compare its decision with the reference label and watch the confusion matrix fill.
Interactive lab Large language modelsCircuit breaker: in-flight capacity
Break a dependency, watch the gate protect it, and decide when traffic can safely return.
Interactive lab Large language modelsCircuit breaker: protected vs bypassed
Break a dependency, watch the gate protect it, and decide when traffic can safely return.
Interactive lab Large language modelsCircuit breaker: recovery tuning
Break a dependency, watch the gate protect it, and decide when traffic can safely return.
Interactive lab Large language modelsCircuit breaker: recovery verification
Break a dependency, watch the gate protect it, and decide when traffic can safely return.
Interactive lab Large language modelsCitation check: does the cited source support the claim?
Inspect a reference identifier, source existence, numerical claim, and source version.
Interactive lab Large language modelsCloud tools: keep the agent service role least-privileged
Inspect a read request and a destructive fictional operation under two roles.
Interactive lab Large language modelsCode agent: gate a patch on regression evidence
See a boundary-condition change caught or released by a test gate.
Interactive lab Large language modelsCollaborative tasks: worker limits and shared results
Run six local transformations. Watch dependency gates, worker assignments, retries and the exact artifacts produced.
Interactive lab Large language modelsConcurrent tools: isolate failures before joining results
Run six local transformations. Watch dependency gates, worker assignments, retries and the exact artifacts produced.
Interactive lab Large language modelsConditional object writes: protect the live generation
Follow exact content through assembly, a conditional write and a scoped version read.
Interactive lab Large language modelsConfiguration and secrets: bind before activation
Edit real JSON layers. Trace each winning value and compare the candidate with the configuration that is actually active.
Interactive lab Large language modelsConfiguration precedence: trace the winning value
Edit real JSON layers. Trace each winning value and compare the candidate with the configuration that is actually active.
Interactive lab Large language modelsContainer packaging: pin the tested image
Watch a mutable registry tag drift away from the image that passed tests.
Interactive lab Large language modelsContainer termination drill: observe an ignored signal
Follow worker lifecycles and the invocations they own. Test readiness, shutdown deadlines and the point at which results commit.
Interactive lab Large language modelsContent filter threshold: a quoted phrase versus a harmful request
See why an aggressive block rule can reject allowed content while a loose one misses harm.
Interactive lab Large language modelsContent moderation pipeline: find the missed boundary
Inspect request, tool, candidate, and private-data checks before release.
Interactive lab Large language modelsContext compaction: retain the retry policy or lose the answer
Watch eight turns enter a bounded window and inspect the exact retained messages.
Interactive lab Large language modelsContext compression: compare space saved with evidence retained
Replay a deployment conversation and test whether a region fact survives.
Interactive lab Large language modelsContinuous evaluation: compare frozen fixtures
Inspect each recorded score, compare its decision with the reference label and watch the confusion matrix fill.
Interactive lab Large language modelsCooperative tasks: inspect scheduling and cancellation
Run six local transformations. Watch dependency gates, worker assignments, retries and the exact artifacts produced.
Interactive lab Large language modelsCost attribution: trace a tenant invoice to meter events
Follow individual meter records into invoice lines, one credit application and a separate collection/refund ledger.
Interactive lab Large language modelsCrew-style task assignment: name one owner before work starts
Send one task to one or two agents and count side effects.
Interactive lab Large language modelsCross-session memory: scope before similarity
Follow real ranking calculations from stored memory cards through scope filters into a bounded context tray.
Interactive lab Large language modelsCustomer credits: offset once and carry the remainder
Follow individual meter records into invoice lines, one credit application and a separate collection/refund ledger.
Interactive lab Large language modelsData agent: expose a malformed row before aggregation
Compare strict integer validation with unsafe numeric-prefix coercion.
Interactive lab Large language modelsData map: trace primary, backup and export copies
Follow actual fictional records through primary storage, a backup, an export and a restore.
Interactive lab Large language modelsData policy: separate use, export and deletion
Follow actual fictional records through primary storage, a backup, an export and a restore.
Interactive lab Large language modelsData-asset dependencies: execute and inspect a finite DAG
Run six local transformations. Watch dependency gates, worker assignments, retries and the exact artifacts produced.
Interactive lab Large language modelsData-flow review: map copies before assessing risk
Follow actual fictional records through primary storage, a backup, an export and a restore.
Interactive lab Large language modelsDataset-driven evaluation: choose the test slice
Inspect each recorded score, compare its decision with the reference label and watch the confusion matrix fill.
Interactive lab Large language modelsDead-letter review: preserve the operation identity
Follow one logical operation across repeated attempts, late responses, deduplication and committed server effects.
Interactive lab Large language modelsDebugging hallucinations: compare a claim with its source
Catch a generated claim that contradicts the supplied document.
Interactive lab Large language modelsDebugging latency: inspect work and waiting
Inspect actual span IDs, parent relationships, sampling decisions and a deterministic execution schedule.
Interactive lab Large language modelsDelegated result gate: verify before accepting a report
Run six local transformations. Watch dependency gates, worker assignments, retries and the exact artifacts produced.
Interactive lab Large language modelsDelegation contract: join only successful artifacts
Run six local transformations. Watch dependency gates, worker assignments, retries and the exact artifacts produced.
Interactive lab Large language modelsDeletion: primary storage is only one copy
Follow actual fictional records through primary storage, a backup, an export and a restore.
Interactive lab Large language modelsDeployment fixture gate: account for every invocation
Follow worker lifecycles and the invocations they own. Test readiness, shutdown deadlines and the point at which results commit.
Interactive lab Large language modelsDeployment gate: evidence before promotion
Route individual requests, observe both versions and stop candidate traffic when the measured release gate fails.
Interactive lab Large language modelsDevOps agent: gate an unsafe release
Compare a tested release with a direct promotion of a failing artifact.
Interactive lab Large language modelsDisaster recovery: test that a backup can restore
Compare a restore drill with mere backup existence when corruption is injected.
Interactive lab Large language modelsDocumentation agent: answer only with a supporting passage
Return a cited retry rule or an explicit unknown when retrieval misses.
Interactive lab Large language modelsDSPy-style optimization: do not select on training examples
Compare training and held-out evidence for one fictional prompt candidate.
Interactive lab Large language modelsDunning: retry collection without rebilling
Follow individual meter records into invoice lines, one credit application and a separate collection/refund ledger.
Interactive lab Large language modelsDynamic reload: keep the complete last-good revision
Edit real JSON layers. Trace each winning value and compare the candidate with the configuration that is actually active.
Interactive lab Large language modelsEdge deployment: fit the model inside the worker budget
Test a small or large fictional artifact against edge and central memory limits.
Interactive lab Large language modelsEmail observability: receipt versus repeated delivery
Edit real JSON arguments, inspect policy gates and watch an approved local function change a synthetic ledger.
Interactive lab Large language modelsEmail review: invalidate approval after edits
Edit real JSON arguments, inspect policy gates and watch an approved local function change a synthetic ledger.
Interactive lab Large language modelsEmail tool: review intent before an effect
Edit real JSON arguments, inspect policy gates and watch an approved local function change a synthetic ledger.
Interactive lab Large language modelsEmbedding cache failure: the transform version belongs in the key
Watch concrete requests fill a bounded cache. Inspect stored vectors, expiry, eviction and incorrect reuse.
Interactive lab Large language modelsEnvironment configuration: convert strings explicitly
Edit real JSON layers. Trace each winning value and compare the candidate with the configuration that is actually active.
Interactive lab Large language modelsEpisodic memory: retrieve a past incident
Follow real ranking calculations from stored memory cards through scope filters into a bounded context tray.
Interactive lab Large language modelsEvaluation datasets: expose coverage gaps
Inspect each recorded score, compare its decision with the reference label and watch the confusion matrix fill.
Interactive lab Large language modelsEvaluation framework: inspect metric trade-offs
Inspect each recorded score, compare its decision with the reference label and watch the confusion matrix fill.
Interactive lab Large language modelsEvaluation harness: repeat a deterministic run
Inspect each recorded score, compare its decision with the reference label and watch the confusion matrix fill.
Interactive lab Large language modelsEvaluation integration: scores into decisions
Inspect each recorded score, compare its decision with the reference label and watch the confusion matrix fill.
Interactive lab Large language modelsEvaluation observability: errors behind the score
Inspect each recorded score, compare its decision with the reference label and watch the confusion matrix fill.
Interactive lab Large language modelsExecution plan: dependencies, deadlines and acceptance
Run six local transformations. Watch dependency gates, worker assignments, retries and the exact artifacts produced.
Interactive lab Large language modelsFailure propagation: client state versus server state
Follow one logical operation across repeated attempts, late responses, deduplication and committed server effects.
Interactive lab Large language modelsFault injection: lose an acknowledgement after a side effect
Count whether retry makes one fictional operation or two.
Interactive lab Large language modelsFew-shot library: select examples that cover the query
See how irrelevant demonstrations and ambiguous inputs affect a label gate.
Interactive lab Large language modelsFile tools: bound the virtual workspace
Edit real JSON arguments, inspect policy gates and watch an approved local function change a synthetic ledger.
Interactive lab Large language modelsFinal summary: reconcile the inputs behind the result
Run six local transformations. Watch dependency gates, worker assignments, retries and the exact artifacts produced.
Interactive lab Large language modelsFirestore-style document access: compare path owner to caller
Block a cross-tenant document read before returning data.
Interactive lab Large language modelsFlat agent team: direct handoff or broadcast
Route four fixed tasks across peers and inspect the cost of broad coordination.
Interactive lab Large language modelsFlowise-style Agentflow: validate a disconnected tool node
Run a three-node graph with a present or missing tool edge.
Interactive lab Large language modelsFree tier: apply allowances to the correct meter
Follow individual meter records into invoice lines, one credit application and a separate collection/refund ledger.
Interactive lab Large language modelsFunction calling: structured arguments into a local function
Edit real JSON arguments, inspect policy gates and watch an approved local function change a synthetic ledger.
Interactive lab Large language modelsFunction dispatch: inspect a validated file operation
Edit real JSON arguments, inspect policy gates and watch an approved local function change a synthetic ledger.
Interactive lab Large language modelsFunction tools: validate before dispatch
Edit real JSON arguments, inspect policy gates and watch an approved local function change a synthetic ledger.
Interactive lab Large language modelsFunction-call inspection: validate a state mutation
Edit real JSON arguments, inspect policy gates and watch an approved local function change a synthetic ledger.
Interactive lab Large language modelsGAIA-style benchmark: keep evaluation answers out of tuning
Inspect how answer leakage can make a score untrustworthy.
Interactive lab Large language modelsGemini 2.5 thinking budget: inspect a bounded reasoning trade-off
Compare a short and long fictional task under two teaching budgets.
Interactive lab Large language modelsGemini integration: catch missing credentials before request
Compare configuration preflight with an avoidable failed call.
Interactive lab Large language modelsGemini LLM tool call: validate typed arguments before dispatch
Send a count tool an integer or an invalid string.
Interactive lab Large language modelsGemini multimodal input: send pixels when the question needs them
Compare an attached image with a filename-only reference.
Interactive lab Large language modelsGemini variant comparison: quality versus latency
Run the same twelve prompts against two fictional variants and inspect the paired observations.
Interactive lab Large language modelsGemini-style safety thresholds: inspect category decisions
Compare synthetic category scores under stricter and looser blocking presets.
Interactive lab Large language modelsGeneralist agent: route a specialized question to a qualified path
See a required policy check disappear when all tasks use one generalist.
Interactive lab Large language modelsGitOps rollout: validate a desired manifest
Inspect whether an invalid resource limit reaches a fictional sync.
Interactive lab Large language modelsGovernance gates: holds and retention exceptions
Follow actual fictional records through primary storage, a backup, an export and a restore.
Interactive lab Large language modelsGraceful shutdown: stop admitting, then drain
Follow worker lifecycles and the invocations they own. Test readiness, shutdown deadlines and the point at which results commit.
Interactive lab Large language modelsGraph of thoughts: keep independent evidence branches
Prune or merge two reasoning paths and inspect the final evidence gate.
Interactive lab Large language modelsGriptape-style workflow: honor a parent-output dependency
Compare a workflow edge with launching child work prematurely.
Interactive lab Large language modelsGround truth: make the rubric explicit
Inspect each recorded score, compare its decision with the reference label and watch the confusion matrix fill.
Interactive lab Large language modelsHuman evaluation: resolve grading disagreement
Inspect each recorded score, compare its decision with the reference label and watch the confusion matrix fill.
Interactive lab Large language modelsIncident recall: relevance versus recency
Follow real ranking calculations from stored memory cards through scope filters into a bounded context tray.
Interactive lab Large language modelsIntegrating guardrails at agent and tool boundaries
See why a prompt check cannot replace tool, returned-data, and response checks.
Interactive lab Large language modelsInterrupted agent effect: reuse a receipt after a lost ACK
Count whether a retry creates one fictional invoice or two.
Interactive lab Large language modelsJudge evaluation: audit recorded quality scores
Inspect each recorded score, compare its decision with the reference label and watch the confusion matrix fill.
Interactive lab Large language modelsKV cache memory: storage versus recomputation
Compare retained K/V with the work of recomputing the context.
Interactive lab Large language modelsLayered guardrails: compare one check with four boundaries
Test whether a request-only policy misses later action, data, or response defects.
Interactive lab Large language modelsLlmAgent release gate: approve a high-impact tool action
Compare read-only work with an effectful write under approval policy.
Interactive lab Large language modelsLoad testing: throughput and admission outcomes
Fill the waiting room, watch workers process real model requests, and inspect every admission decision.
Interactive lab Large language modelsLong-running task: inspect progress without premature success
Run six local transformations. Watch dependency gates, worker assignments, retries and the exact artifacts produced.
Interactive lab Large language modelsLong-term memory: retain previous sessions
Follow real ranking calculations from stored memory cards through scope filters into a bounded context tray.
Interactive lab Large language modelsMatrix agent organization: resolve dual ownership
Compare two-owner approval with a shortcut that can leave contested work.
Interactive lab Large language modelsMemory bank: pack a bounded context
Follow real ranking calculations from stored memory cards through scope filters into a bounded context tray.
Interactive lab Large language modelsMemory forgetting: age and superseded facts
Follow real ranking calculations from stored memory cards through scope filters into a bounded context tray.
Interactive lab Large language modelsMemory recall: inspect the retrieval score
Follow real ranking calculations from stored memory cards through scope filters into a bounded context tray.
Interactive lab Large language modelsMemory retrieval: inspect missing evidence
Follow real ranking calculations from stored memory cards through scope filters into a bounded context tray.
Interactive lab Large language modelsMiddleware ordering: inspect the stopping gate
Edit real JSON arguments, inspect policy gates and watch an approved local function change a synthetic ledger.
Interactive lab Large language modelsModel fallback: distinguish primary failure from slow response
Trigger a secondary route only for an explicit primary incident.
Interactive lab Large language modelsModel settings: validate a candidate before activation
Edit real JSON layers. Trace each winning value and compare the candidate with the configuration that is actually active.
Interactive lab Large language modelsModeration release gate: block on the wrong error type
Use four labeled cases to inspect whether a candidate policy is fit to ship.
Interactive lab Large language modelsMulti-agent workflow: explicit handoffs and verified output
Run six local transformations. Watch dependency gates, worker assignments, retries and the exact artifacts produced.
Interactive lab Large language modelsMulti-region A2A: resume a task after home-region failure
Compare replicated task state with a region-local process memory.
Interactive lab Large language modelsMultimodal agent: align frames before describing an event
Receive three frames in order or out of order and reconstruct the timeline.
Interactive lab Large language modelsObservability CI: detect a missing tool span
Compare a release gate with a blind promotion when instrumentation is incomplete.
Interactive lab Large language modelsObserve the complete record lifecycle
Follow actual fictional records through primary storage, a backup, an export and a restore.
Interactive lab Large language modelsOutput grounding check: inspect every factual sentence
Expose missing evidence, unrelated sources, and dropped conditions in a candidate answer.
Interactive lab Large language modelsPayment operation: inspect attempts, receipts and refunds
Follow individual meter records into invoice lines, one credit application and a separate collection/refund ledger.
Interactive lab Large language modelsPrivacy engineering failure: deleted data returns
Follow actual fictional records through primary storage, a backup, an export and a restore.
Interactive lab Large language modelsProcedural memory: retrieve an action sequence
Follow real ranking calculations from stored memory cards through scope filters into a bounded context tray.
Interactive lab Large language modelsProcessing inventory: identify purpose and copies
Follow actual fictional records through primary storage, a backup, an export and a restore.
Interactive lab Large language modelsProgressive rollout: expand candidate exposure
Route individual requests, observe both versions and stop candidate traffic when the measured release gate fails.
Interactive lab Large language modelsRAG grounding: test retrieval, freshness, support, and injection
Follow a fixed policy question from retrieval to a grounded answer decision.
Interactive lab Large language modelsRefunds: never return more cash than was collected
Follow individual meter records into invoice lines, one credit application and a separate collection/refund ledger.
Interactive lab Large language modelsRegistry design: budget and freshness are separate gates
Inspect seven synthetic registry entries. Apply hard eligibility gates before ranking and proposing a compatible local contract.
Interactive lab Large language modelsRegression testing: inspect changed predictions
Inspect each recorded score, compare its decision with the reference label and watch the confusion matrix fill.
Interactive lab Large language modelsRelease flag: route a controlled traffic slice
Route individual requests, observe both versions and stop candidate traffic when the measured release gate fails.
Interactive lab Large language modelsRequest hedging: race a backup against a slow primary
Start a speculative second execution after a deadline and see whether it wins.
Interactive lab Large language modelsRetention: expire records at the policy boundary
Follow actual fictional records through primary storage, a backup, an export and a restore.
Interactive lab Large language modelsRetry safety: backoff and side effects
Follow one logical operation across repeated attempts, late responses, deduplication and committed server effects.
Interactive lab Large language modelsRole-based agent team: permission at the action boundary
Watch authorized tasks, revoked roles, and cross-role actions under two policies.
Interactive lab Large language modelsRollback: preserve evidence and stop exposure
Route individual requests, observe both versions and stop candidate traffic when the measured release gate fails.
Interactive lab Large language modelsSafety evaluation: inspect false positives and false negatives
Run four labeled examples against a threshold and compare the exact error cells.
Interactive lab Large language modelsSearch tool: validate a bounded local query
Edit real JSON arguments, inspect policy gates and watch an approved local function change a synthetic ledger.
Interactive lab Large language modelsSearch-tool integration: prefer current evidence over a stale top hit
Inspect ranking, freshness, citation, and the chosen document.
Interactive lab Large language modelsSeat billing: quantity and effective date
Follow individual meter records into invoice lines, one credit application and a separate collection/refund ledger.
Interactive lab Large language modelsSeat proration: charge the remaining period
Follow individual meter records into invoice lines, one credit application and a separate collection/refund ledger.
Interactive lab Large language modelsSecret references: pinned versions and tenant boundaries
Edit real JSON layers. Trace each winning value and compare the candidate with the configuration that is actually active.
Interactive lab Large language modelsSemantic memory: retrieve stored facts
Follow real ranking calculations from stored memory cards through scope filters into a bounded context tray.
Interactive lab Large language modelsServer-side agent: authorize before reading a tenant record
Compare an owner request with a cross-tenant request.
Interactive lab Large language modelsSession recovery: replay recorded transitions
Follow concurrent drafts into committed revisions, inspect the checkpoint and reconstruct state after a simulated crash.
Interactive lab Large language modelsSession resumption: recover a consistent revision
Follow concurrent drafts into committed revisions, inspect the checkpoint and reconstruct state after a simulated crash.
Interactive lab Large language modelsSession state: separate a snapshot from history
Follow concurrent drafts into committed revisions, inspect the checkpoint and reconstruct state after a simulated crash.
Interactive lab Large language modelsShadow deployment: compare without serving v2
Route individual requests, observe both versions and stop candidate traffic when the measured release gate fails.
Interactive lab Large language modelsShadow testing: observe isolated candidate failures
Route individual requests, observe both versions and stop candidate traffic when the measured release gate fails.
Interactive lab Large language modelsSharing an artifact: read permission is not write permission
Follow exact content through assembly, a conditional write and a scoped version read.
Interactive lab Large language modelsShort-term context: current session only
Follow real ranking calculations from stored memory cards through scope filters into a bounded context tray.
Interactive lab Large language modelsSpeculative Decoding
Draft model proposes K tokens; main model verifies in parallel.
Interactive lab Large language modelsStartup validation: fail closed on invalid settings
Edit real JSON layers. Trace each winning value and compare the candidate with the configuration that is actually active.
Interactive lab Large language modelsState diff: compare drafts, revisions and commits
Follow concurrent drafts into committed revisions, inspect the checkpoint and reconstruct state after a simulated crash.
Interactive lab Large language modelsState export: preserve a reproducible replay
Follow concurrent drafts into committed revisions, inspect the checkpoint and reconstruct state after a simulated crash.
Interactive lab Large language modelsState management: concurrent intent and revisions
Follow concurrent drafts into committed revisions, inspect the checkpoint and reconstruct state after a simulated crash.
Interactive lab Large language modelsState replay: inspect deterministic reconstruction
Follow concurrent drafts into committed revisions, inspect the checkpoint and reconstruct state after a simulated crash.
Interactive lab Large language modelsSubject export: verify identity and scope
Follow actual fictional records through primary storage, a backup, an export and a restore.
Interactive lab Large language modelsSubject requests: preserve the identity boundary
Follow actual fictional records through primary storage, a backup, an export and a restore.
Interactive lab Large language modelsSubscription changes: inspect a prorated downgrade
Follow individual meter records into invoice lines, one credit application and a separate collection/refund ledger.
Interactive lab Large language modelsSynthetic monitoring: one-region alert versus quorum
Probe three fictional regions and compare alert policies.
Interactive lab Large language modelsTask-DAG scheduling: measure the parallel critical branch
Run six local transformations. Watch dependency gates, worker assignments, retries and the exact artifacts produced.
Interactive lab Large language modelsTemperature sampling: reshape and inspect probabilities
Compute stable softmax and see how temperature changes probability concentration.
Interactive lab Large language modelsTenant billing: isolate usage and event identity
Follow individual meter records into invoice lines, one credit application and a separate collection/refund ledger.
Interactive lab Large language modelsTenant capacity: scale the constrained partition
Follow each request from arrival to completion, rejection or timeout.
Interactive lab Large language modelsTenant configuration: scoped overrides and source tracking
Edit real JSON layers. Trace each winning value and compare the candidate with the configuration that is actually active.
Interactive lab Large language modelsTenant data: principal versus resource ownership
Inspect credential claims, policy gates and the resource decision. Change a condition and follow the exact denial reason.
Interactive lab Large language modelsTenant isolation: prevent cross-tenant access
Inspect credential claims, policy gates and the resource decision. Change a condition and follow the exact denial reason.
Interactive lab Large language modelsTenant migration: compare before cutover
Move one fictional tenant and inspect the cost of two missing rows.
Interactive lab Large language modelsTenant offboarding: stop late writes
Follow actual fictional records through primary storage, a backup, an export and a restore.
Interactive lab Large language modelsTenant onboarding: validate before provisioning
See a missing storage binding stopped or allowed to create a broken tenant.
Interactive lab Large language modelsTenant registry: do not route across scope
Inspect seven synthetic registry entries. Apply hard eligibility gates before ranking and proposing a compatible local contract.
Interactive lab Large language modelsTenant service targets: count every offered request
Follow each request from arrival to completion, rejection or timeout.
Interactive lab Large language modelsTenant usage analysis: compare isolated meter totals
Follow individual meter records into invoice lines, one credit application and a separate collection/refund ledger.
Interactive lab Large language modelsToken-cost ledger: inspect input and output charges
Follow individual meter records into invoice lines, one credit application and a separate collection/refund ledger.
Interactive lab Large language modelsTool callbacks: block before execution
Edit real JSON arguments, inspect policy gates and watch an approved local function change a synthetic ledger.
Interactive lab Large language modelsTool design: separate schema, authority and effect
Edit real JSON arguments, inspect policy gates and watch an approved local function change a synthetic ledger.
Interactive lab Large language modelsTool plugin policy: transform or reject a call
Edit real JSON arguments, inspect policy gates and watch an approved local function change a synthetic ledger.
Interactive lab Large language modelsTop-k and nucleus sampling: inspect retained candidates
Remove candidates, renormalize their probabilities and inspect the actual draw.
Interactive lab Large language modelsTrace integration: follow an outgoing traceparent
Inspect actual span IDs, parent relationships, sampling decisions and a deterministic execution schedule.
Interactive lab Large language modelsTraffic shifting: follow each routed request
Route individual requests, observe both versions and stop candidate traffic when the measured release gate fails.
Interactive lab Large language modelsUndo state: append a compensating transition
Follow concurrent drafts into committed revisions, inspect the checkpoint and reconstruct state after a simulated crash.
Interactive lab Large language modelsUsage cost tracking: quantities before totals
Follow individual meter records into invoice lines, one credit application and a separate collection/refund ledger.
Interactive lab Large language modelsUsage metering: detect duplicates and invalid records
Follow individual meter records into invoice lines, one credit application and a separate collection/refund ledger.
Interactive lab Large language modelsUsage reports: reconcile finalized and deferred records
Follow individual meter records into invoice lines, one credit application and a separate collection/refund ledger.
Interactive lab Large language modelsWorkflow inspection: states, workers and intermediate data
Run six local transformations. Watch dependency gates, worker assignments, retries and the exact artifacts produced.
Interactive lab Large language modelsWorkflow runtime: inspect ready, running and blocked states
Run six local transformations. Watch dependency gates, worker assignments, retries and the exact artifacts produced.
Interactive lab Large language modelsWorking memory: assemble the active context
Follow real ranking calculations from stored memory cards through scope filters into a bounded context tray.
Interactive lab Model Context ProtocolA2A and MCP interop: scope a delegated tool grant
Translate an agent task to a read or out-of-scope write.
Interactive lab Model Context ProtocolMCP + OAuth 2.1
Remote MCP server with OAuth scoped authorization.
Interactive lab Model Context ProtocolMCP Capability Negotiation
Client and server agree on supported features at handshake.
Interactive lab Model Context ProtocolMCP Message Flow
Walk through initialize → list_tools → call_tool → response.
Interactive lab Model Context ProtocolMCP Server Lifecycle
Spawn → initialize → serve → shutdown.
Interactive lab Model Context ProtocolMCP Tool Registry
Inspect tool schemas; see how the LLM picks a tool.
Interactive lab NetworkingAnycast Routing — Same IP, Many Places
Click a user location; see which anycast PoP receives the traffic.
Interactive lab NetworkingBBR vs CUBIC Congestion Control
Compare throughput and cwnd dynamics under simulated packet loss.
Interactive lab NetworkingDNS Resolution with Caching
Recursive DNS resolution from stub to root to authoritative, with TTL cache.
Interactive lab NetworkinggRPC-style framing: length, payload and parser boundaries
Fragment real encoded bytes, inspect the parser buffer and follow complete events into an ordered text consumer.
Interactive lab NetworkingHTTP response body: separate reads from decoded events
Fragment real encoded bytes, inspect the parser buffer and follow complete events into an ordered text consumer.
Interactive lab NetworkingStreaming RPC body: queue pressure and message framing
Fragment real encoded bytes, inspect the parser buffer and follow complete events into an ordered text consumer.
Interactive lab NetworkingTCP 3-Way Handshake
Animated SYN / SYN-ACK / ACK between client and server, with sequence numbers.
Interactive lab NetworkingTLS 1.3 Handshake
1-RTT TLS 1.3 handshake with key share and encrypted application data.
Interactive lab ObservabilityAgent metrics: counter versus latency distribution
Aggregate the same requests into error counts and an observed p95.
Interactive lab ObservabilityAgent observability: trace a failed dependency
Inspect actual span IDs, parent relationships, sampling decisions and a deterministic execution schedule.
Interactive lab ObservabilityAgent SLI and SLO: measure success against a target
Track a running success ratio and see when an objective is missed.
Interactive lab ObservabilityAlert fatigue
Explore the controls, compare outcomes and record your observations.
Interactive lab ObservabilityDeep trace inspection: critical path versus span totals
Inspect actual span IDs, parent relationships, sampling decisions and a deterministic execution schedule.
Interactive lab ObservabilityGolden Signals Dashboard
Live RED metrics: rate, errors, duration.
Interactive lab ObservabilityPrompt records: retention and backup recovery
Follow actual fictional records through primary storage, a backup, an export and a restore.
Interactive lab ObservabilitySLO Burn Rate Alerting
Watch error budget burn at different rates; multi-window alerts fire.
Interactive lab ObservabilityTrace observability: distinguish execution from export
Inspect actual span IDs, parent relationships, sampling decisions and a deterministic execution schedule.
Interactive lab ObservabilityTrace Sampling Strategies
Head-based vs tail-based; see which interesting traces are kept.
Interactive lab ObservabilityTrace visualization: inspect the waterfall
Inspect actual span IDs, parent relationships, sampling decisions and a deterministic execution schedule.
Interactive lab ObservabilityTraceparent: validate and propagate version-00 context
Inspect actual span IDs, parent relationships, sampling decisions and a deterministic execution schedule.
Interactive lab ObservabilityWhy Percentiles Matter
Compare average, p50, p99 across different latency distributions.
Interactive lab QuantizationFP16 vs INT8 vs INT4
Same weight tensor; see precision/range for each format.
Interactive lab QuantizationGGUF File Format
Inspect a GGUF model file structure.
Interactive lab QuantizationPerplexity vs Quantization Level
Curve of model quality (perplexity) as bit width drops.
Interactive lab QuantizationQuantization Calibration
See how calibration data choice affects quantized weight ranges.
Interactive lab QuantizationSmoothQuant — Migrating Outliers
See how SmoothQuant moves difficulty from activations to weights.
Interactive lab SecurityAccess control: identity before permission
Inspect credential claims, policy gates and the resource decision. Change a condition and follow the exact denial reason.
Interactive lab SecurityAgent boundary: enforce action permissions
Inspect credential claims, policy gates and the resource decision. Change a condition and follow the exact denial reason.
Interactive lab SecurityAuthentication: inspect a rejected credential
Inspect credential claims, policy gates and the resource decision. Change a condition and follow the exact denial reason.
Interactive lab SecurityBearer access: audience, expiry and scope
Inspect credential claims, policy gates and the resource decision. Change a condition and follow the exact denial reason.
Interactive lab SecurityDependency injection: avoid a mutable cross-tenant singleton
Interleave two tenants and inspect which client returns a result.
Interactive lab SecuritymTLS Handshake
Both client and server present certificates; mutual identity verification.
Interactive lab SecurityOAuth 2.1 Authorization Code + PKCE
Step through the modern OAuth flow for public clients.
Interactive lab SecurityPrivacy controls: scope, minimization and recovery
Follow actual fictional records through primary storage, a backup, an export and a restore.
Interactive lab SecurityPurpose notice versus enforced behavior
Follow actual fictional records through primary storage, a backup, an export and a restore.
Interactive lab SecuritySecurity tracing: locate the denying gate
Inspect credential claims, policy gates and the resource decision. Change a condition and follow the exact denial reason.
Interactive lab SecuritySQL Injection — Vulnerable vs Parameterized
Type input; see how concatenated SQL fails and parameterized SQL stays safe.
Interactive lab SecurityTool authorization: scope and role must agree
Inspect credential claims, policy gates and the resource decision. Change a condition and follow the exact denial reason.
Interactive lab Standalone toolsAgent Harness Builder
Turn a model call into a system: select the tools it can use, define where a human must approve, set a budget, and add the checks that make a run auditable.
Tool Standalone toolsChat Template Renderer
Explore the controls, compare outcomes and record your observations.
Tool Standalone toolsCloud GPU Pricing Comparison
Explore the controls, compare outcomes and record your observations.
Tool Standalone toolsCloud Service Matcher
Explore the controls, compare outcomes and record your observations.
Tool Standalone toolsGGUF Quantization Chooser
Explore the controls, compare outcomes and record your observations.
Tool Standalone toolsJSONL Training Data Validator
Explore the controls, compare outcomes and record your observations.
Tool Standalone toolsLoRA + QLoRA Memory Calculator
Explore the controls, compare outcomes and record your observations.
Tool Standalone toolsPrompt Injection Scanner
Explore the controls, compare outcomes and record your observations.
Tool Standalone toolsRAG Chunker Visualizer
Explore the controls, compare outcomes and record your observations.
Tool Standalone toolsSLM Selector
Explore the controls, compare outcomes and record your observations.
Tool Streaming systemsBackpressure Demo
Producer rate exceeds consumer → bounded buffer → producer slows.
Interactive lab Streaming systemsKafka Consumer Lag
Producer pushes; consumer reads. Watch lag accumulate or drain.
Interactive lab Streaming systemsKafka Partition Routing
Watch how messages with different keys map to partitions.
Interactive lab Streaming systemsStream-Table Duality
Watch a stream of updates fold into a table view.
Interactive lab System designCache patterns: separate expiration from eviction
Watch concrete requests fill a bounded cache. Inspect stored vectors, expiry, eviction and incorrect reuse.
Interactive lab System designCircuit Breaker Pattern
Three states: closed, open, half-open. Watch transitions.
Interactive lab System designLoad Balancer Algorithms
Round-robin, least-connections, random, weighted compared.
Interactive lab System designSharding Strategies
Range, hash, geo — visualize key distribution.
Interactive lab Transformer math & SLMsAutoregressive generation: one decision at a time
Predict → select → append → repeat. Inspect how each output becomes the next input.
Interactive lab Transformer math & SLMsBackprop Chain Rule
Watch gradients flow backwards through a 3-layer net.
Interactive lab Transformer math & SLMsBeam Search Tree
K parallel hypotheses expand and get pruned.
Interactive lab Transformer math & SLMsBlocked multiplication: inspect the traversal order
Keep the arithmetic fixed and change the order in which matrix tiles are visited.
Interactive lab Transformer math & SLMsCache Hits and Misses
L1/L2/L3 latency stacked up.
Interactive lab Transformer math & SLMsCompare greedy, top-k and top-p decoding
Hold the fixture fixed while changing candidate selection and sampling policy.
Interactive lab Transformer math & SLMsComplete Transformer Block
Animate data flowing through pre-norm + attention + residual + pre-norm + FFN + residual.
Interactive lab Transformer math & SLMsCPU Inference Latency Breakdown
Per-token time = bandwidth-bound weight reads + compute.
Interactive lab Transformer math & SLMsCPU Training Memory Calculator
Adjust model size; see RAM needed.
Interactive lab Transformer math & SLMsCross-Entropy Loss Surface
See how loss changes as the model's predicted probability shifts.
Interactive lab Transformer math & SLMsDataLoader Pipeline
Workers prefetching batches into a queue.
Interactive lab Transformer math & SLMsDot Product Geometry (2D)
Drag vectors; see dot product, magnitude, angle.
Interactive lab Transformer math & SLMsDPO Preference Loss
Direct preference optimization vs reward + PPO.
Interactive lab Transformer math & SLMsEmbedding lookup: track IDs to stored rows
Trace each coordinate copied from a six-token embedding table.
Interactive lab Transformer math & SLMsEnd-to-End CPU SLM Recipe
Train → quantize → serve, all on CPU.
Interactive lab Transformer math & SLMsFFN Expansion + Activation
d → d_ff → d. Two matmuls with an activation in between.
Interactive lab Transformer math & SLMsFlashAttention Tiling
Tile attention block-by-block; keep working set in SRAM.
Interactive lab Transformer math & SLMsForward vs Backward FLOPs
Backward is ~2× forward. Total training ~3× forward.
Interactive lab Transformer math & SLMsFP32, BF16 and FP16: inspect range and rounding
Enter an actual value. Inspect its sign, exponent and fraction bits, then pause at the boundaries where a format rounds, underflows or overflows.
Interactive lab Transformer math & SLMsFrom logits to a selected token
Inspect every arithmetic stage between an unnormalized score and a token.
Interactive lab Transformer math & SLMsFull CPU SLM Stack — Top to Bottom
Application → engine → kernels → CPU instructions.
Interactive lab Transformer math & SLMsGradient Accumulation
K micro-batches build up to an effective large batch.
Interactive lab Transformer math & SLMsGradient Clipping in Action
See spikes get truncated to max_norm.
Interactive lab Transformer math & SLMsKV cache growth: count every stored position
Follow context growth and reconcile cache bytes with model dimensions.
Interactive lab Transformer math & SLMsLayerNorm and RMSNorm: inspect row statistics
Compare mean-centering with root-mean-square scaling using the same input.
Interactive lab Transformer math & SLMsLayerNorm Statistics
Watch mean, variance, and normalized output for a tensor.
Interactive lab Transformer math & SLMsLoss Curves Diagnosis
Healthy, spiky, divergent — what each looks like.
Interactive lab Transformer math & SLMsLow-rank adapters: compute the base and the update
Inspect XW and (alpha/r)(XA)B separately, then add their actual outputs.
Interactive lab Transformer math & SLMsLR Schedule — Warmup + Cosine
Visualize the canonical LLM training learning rate.
Interactive lab Transformer math & SLMsMatrix multiplication: follow every accumulator
Choose a row and column. Watch their products build one output entry.
Interactive lab Transformer math & SLMsMoE Top-K Routing
Tokens route to top-K experts; load balance matters.
Interactive lab Transformer math & SLMsMulti-Head Split + Concat
One big projection reshapes into h heads then back.
Interactive lab Transformer math & SLMsMulti-Token Prediction Heads
N heads predicting tokens at +1, +2, +3, +4.
Interactive lab Transformer math & SLMsPerplexity Calculator
Perplexity from loss; what numbers mean.
Interactive lab Transformer math & SLMsPositional Encoding Curves
Sinusoidal at different dimensions = different frequencies.
Interactive lab Transformer math & SLMsQ4_K Block Layout
Block of 256 weights = sub-groups × 4-bit values + scales.
Interactive lab Transformer math & SLMsRepetition penalty: inspect signed-logit changes
Apply a sign-aware penalty only to tokens already present in the context.
Interactive lab Transformer math & SLMsResidual Gradient Flow
With and without residuals: how gradient survives depth.
Interactive lab Transformer math & SLMsRoPE Extension Strategies
Linear, NTK-aware, YaRN compared.
Interactive lab Transformer math & SLMsSGD vs Adam — Step Trajectories
Two optimizers descending the same loss surface.
Interactive lab Transformer math & SLMsSIMD Register — AVX-512 + AMX
See how one instruction operates on multiple values.
Interactive lab Transformer math & SLMsSLM Architecture Comparison
Phi-3, Qwen 2.5, Gemma 2 — hyperparams side by side.
Interactive lab Transformer math & SLMsSLM Parameter Breakdown
Where the parameters live: embedding, attention, FFN.
Interactive lab Transformer math & SLMsSpeculative Decoding Acceptance
Watch draft tokens get accepted or rejected.
Interactive lab Transformer math & SLMsStable softmax and temperature
Inspect exponentiation and normalization without overflow-prone direct exponentials.
Interactive lab Transformer math & SLMsTied embeddings: reuse the output weights
Follow lookup, transpose sharing and vocabulary-logit calculation.
Interactive lab Transformer math & SLMsTokenizer Compression Comparison
Same text, different tokenizers.
Interactive lab Transformer math & SLMsWeight Initialization Distributions
Xavier, Kaiming, normal — visualized.
Interactive lab Transformer math & SLMsWeight Layout on Disk (GGUF / SafeTensors)
See how tensors are arranged in a binary model file.
Interactive lab TransformersFeed-Forward Layer (MLP)
Hidden dimension expansion + activation + projection back.
Interactive lab TransformersMixture of Experts Routing
Router picks K experts per token. See activation patterns.
Interactive lab TransformersMulti-Head Attention
See how heads specialize on different patterns.
Interactive lab TransformersPositional Encoding — Sinusoidal vs RoPE
Two ways to inject position information.
Interactive lab Video streamingABR Rendition Selection
Throughput vs buffer-based ABR pick renditions differently as bandwidth changes.
Interactive lab Video streamingCodec Comparison — H.264 vs H.265 vs AV1
Quality (VMAF) at different bitrates for three codecs.
Interactive lab Video streamingEvent streaming: byte chunks are not message boundaries
Fragment real encoded bytes, inspect the parser buffer and follow complete events into an ordered text consumer.
Interactive lab Video streamingGenerated-text streaming: preserve bytes and event identity
Fragment real encoded bytes, inspect the parser buffer and follow complete events into an ordered text consumer.
Interactive lab Video streamingHLS Segment Timeline
See how HLS playlist segments are generated and consumed.
Interactive lab Video streamingLength-prefixed streaming: reconstruct complete messages
Fragment real encoded bytes, inspect the parser buffer and follow complete events into an ordered text consumer.
Interactive lab Video streamingSSE client framing: decode before appending
Fragment real encoded bytes, inspect the parser buffer and follow complete events into an ordered text consumer.
Interactive lab Video streamingStream failure: distinguish partial output from completion
Fragment real encoded bytes, inspect the parser buffer and follow complete events into an ordered text consumer.
Interactive lab Video streamingStreaming UX: time to first useful output
Fragment real encoded bytes, inspect the parser buffer and follow complete events into an ordered text consumer.
Interactive lab Video streamingSynthetic bitrate ladder: choose feasible renditions
Change complexity, desired quality and bitrate budget. See which resolution can meet each target—and why others cannot.
Interactive lab Video streamingWebRTC Pipeline
End-to-end video flow through encode, transport, decode.
Interactive labNo matching labs. Try another term or clear the filters.