AICASSINDRA · LEARN BY EXPERIMENTING
Audio engineering 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.
A2A tasks under failure: reattach, retry, reconcile
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionAgent memory: write less, reconcile more, forget on time
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionApproval gates: stop harmful tool calls without drowning reviewers
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionAutoscaling LLM replicas: pick the signal that sees the work
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionBudget the thinking: buy accuracy without paying for overthinking
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionCalibration lab: make 90% confident mean 90% right
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionCascades and routers: send each query to the cheapest model that gets it right
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionChunked prefill: slice the prompt, keep every stream moving
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionChunking showdown: keep answers whole without flooding the context
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionContext compaction: keep the facts, drop the bulk
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionContiguous vs paged KV: stop reserving memory you never write
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionDPO vs GRPO: train a toy policy without hacking the reward
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionExpert traffic control: route tokens without drops or stragglers
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionFilter by ACL without starving users or leaking revoked documents
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionGoodput: count only the requests that met their SLO
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionGrounded citations: catch every claim its source does not support
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionHNSW tuning: build a graph and race the beam search
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionIdempotency keys: retry the tool call, not the refund
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionINT4 under pressure: groups, outliers and AWQ-style scaling
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionKeep the index fresh: batches, deletes, tombstones and compaction
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionKV capacity planner: from gigabytes to concurrent users
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionKV heads on a budget: fit more users per GPU with GQA
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionKV pressure: preempt, swap or recompute without stalling
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionLoRA tuning bench: rank, alpha and where to put them
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionLost in the middle: pack and order chunks so the answer gets read
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionMask the logits: JSON schema mode without invented values
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionMCP fleet: sessions, silent streams and rolling deploys
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionMulti-hop retrieval: chain the hops without blowing the latency budget
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionOne agent, a supervisor or a swarm: pick the cheapest that works
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionpass@k vs pass^k: grade agents the way users experience them
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionPrefix caching: keep the KV you already paid for
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionRAG latency budget: find the milliseconds before the first token
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionRank fusion lab: let BM25 rescue what embeddings miss
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionRerank depth: find the knee before the GPU queue finds you
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionRewrite the question: condense, multi-query and HyDE under pressure
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionSampling settings: break loops and cut junk without killing variety
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionSemantic cache: tune the threshold before it answers the wrong question
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionSpend the budget: size a model with IsoFLOP curves
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionSplit the fleet: prefill pool, decode pool, and the link between
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionSqueeze the vectors: int8, int4 and binary without losing the top 10
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionStatic vs continuous batching: fill the GPU without stalls
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionStep budgets and loop detectors: stop the runaway agent
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionStretch the context: RoPE scaling without breaking retrieval
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionTensor vs pipeline parallelism: split a model without wasting GPUs
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionToken audience: stop one leaked token opening every server
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionToken buckets and priority lanes: keep one tenant from starving the rest
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionTokenizer economics: train BPE merges and watch the bill change
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionTool poisoning: scan, pin and taint before it bites
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionTool routing at scale: find the right tool among hundreds
Explore the controls, compare outcomes and record your observations.
Interactive lab ai_productionTriage the funnel: find which RAG stage loses the answer
Explore the controls, compare outcomes and record your observations.
Interactive lab Apache CassandraCassandra 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 AgentExecutor events: final states, late artifacts and cancellation
Explore the controls, compare outcomes and record your observations.
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 intelligenceA2UI return form: catalogs, data binding and unknown components
Explore the controls, compare outcomes and record your observations.
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 intelligenceAP2 cart re-confirmation: when the total moves after signing
Explore the controls, compare outcomes and record your observations.
Interactive lab Artificial intelligenceAP2 over A2A: extension activation, data keys and roles
Explore the controls, compare outcomes and record your observations.
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 intelligenceOnline agent evaluation: traffic mix shift versus quality drop
Explore the controls, compare outcomes and record your observations.
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 intelligencePer-feature degradation ladders through a scripted provider outage
Explore the controls, compare outcomes and record your observations.
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 intelligenceReliability math for multi-step agents: retries, detectors and checkpoints
Explore the controls, compare outcomes and record your observations.
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 intelligenceRetry, replan or give up: error policies for a refund agent
Explore the controls, compare outcomes and record your observations.
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 intelligenceStreaming LLM timeouts: one total timeout, a read timeout or three budgets
Explore the controls, compare outcomes and record your observations.
Interactive lab Artificial intelligenceStuck agent loops: step budgets versus call and progress detectors
Explore the controls, compare outcomes and record your observations.
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 Artificial intelligencex402 payment flow: quotes, verify, settle and replays
Explore the controls, compare outcomes and record your observations.
Interactive lab Attention Is All You Need (paper series)The Transformer from the paper, running live
Figure 1 of Attention Is All You Need, with every block moving and every value real: a Transformer built line by line from the 2017 paper and trained on a laptop CPU, normalising a Belgavi's Book Store order date.
Interactive lab Audio engineeringAcoustic echo cancellation: learn the delayed path
Watch an adaptive filter learn real coefficients, then challenge it with a changed path or near-end speech.
Interactive lab Audio engineeringJitter buffer: arrivals versus playout deadlines
Trace fixed-rate packets through variable network delays and see exactly which ones miss their playout slots.
Interactive lab Audio engineeringSample-rate conversion: expose aliasing and filtering
Compare linear interpolation with a finite anti-alias filter, and inspect the exact output samples.
Interactive lab Audio engineeringVoice activity detection: measure energy, inspect mistakes
Compute RMS from actual synthetic samples and compare detector decisions with the known speech intervals.
Interactive lab Audio engineeringVoice turns: measure activity, wait for an endpoint
Turn measured audio frames into accepted or rejected candidates and explore the trade-off between false triggers and endpoint delay.
Interactive lab Bidirectional streamingHead-of-line blocking: follow the missing data
Compare TCP and QUIC delivery from the same packet arrivals, including recovery and packets carrying multiple streams.
Interactive lab Bidirectional streamingHTTP/2 multiplexing: one connection, two credit limits
Schedule actual DATA byte counts while tracking each stream’s credit and the shared connection window.
Interactive lab Bidirectional streamingReconnect backoff: compare synchronized and jittered retries
Inspect reproducible retry timestamps, delay caps and connection recovery across a group of synthetic clients.
Interactive lab Bidirectional streamingServer-sent events: bytes, fields and dispatch
Edit an event stream and inspect how UTF-8 chunks, blank lines and event IDs change what the client receives.
Interactive lab Bidirectional streamingWebSocket frames: inspect masking and message assembly
Encode text into WebSocket frames, split the wire bytes and inspect fragmentation, masking, ping and rejection behavior.
Interactive lab Concurrency & threadingLock contention: ownership, queues and barging
Follow each lock acquisition and release, compare queue fairness and measure completion using modeled time.
Interactive lab Concurrency & threadingProducer and consumer: blocking is not dropping
Inspect bounded FIFO item identities and compare a producer that holds its item with one that drops full-queue offers.
Interactive lab Concurrency & threadingRace condition: follow every read, add and write
Step through actual shared-counter interleavings and compare them with indivisible atomic increments.
Interactive lab Concurrency & threadingVirtual threads: release a carrier while waiting
Compare retained platform workers with unmounted virtual tasks using the same CPU and I/O workload.
Interactive lab Concurrency & threadingWork stealing: move tasks, preserve their actual work
Follow task identities and durations as idle workers steal queued work and compare the same workload without stealing.
Interactive lab DatabasesB-tree: insert, split and search
Build a balanced tree from your own keys and inspect every comparison, promotion and lookup.
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 DatabasesDDL lock queue timeline: blocked readers and lock_timeout retries
Issue a synthetic ALTER TABLE while a long transaction holds the table and watch readers queue behind it, the pool drain, and lock_timeout retries fix it.
Interactive lab DatabasesMVCC: a snapshot remembers active writers
Compare two SELECT statements against the same committed and uncommitted row versions.
Interactive lab DatabasesReplication lag: WAL positions and delayed feedback
Trace individual records and separate byte backlog, unapplied-record age and delayed feedback.
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 DatabasesVector ANN: inspect candidates and exact recall
Search actual index lists and compare returned neighbors with a full-scan baseline.
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 systemsConditional-write ledger: publishers racing for two slots
Explore the controls, compare outcomes and record your observations.
Interactive lab Distributed systemsCPU limits and CFS throttling: quota, periods and bursts
Explore the controls, compare outcomes and record your observations.
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 propagation
Inspect the real message paths behind epidemic dissemination.
Interactive lab Distributed systemsHealth checks and fail-open: a shared outage across a fleet
Explore the controls, compare outcomes and record your observations.
Interactive lab Distributed systemsMetastable overload: a short slowdown, retries and a backlog
Explore the controls, compare outcomes and record your observations.
Interactive lab Distributed systemsNode memory pressure: kubelet eviction versus kernel OOM
Explore the controls, compare outcomes and record your observations.
Interactive lab Distributed systemsOne chosen value: competing proposers
Inspect actual protocol state and majority certificates in single-decision Paxos.
Interactive lab Distributed systemsPartition tolerance
Keep local state honest when two sites cannot communicate.
Interactive lab Distributed systemsPod termination timeline: preStop, SIGTERM and dropped requests
Delete a synthetic Pod and watch proxies, the preStop hook, SIGTERM handling and the grace period decide which requests fail.
Interactive lab Distributed systemsPodDisruptionBudget drain: eviction budget, 429s and stuck drains
Explore the controls, compare outcomes and record your observations.
Interactive lab Distributed systemsQuorum reads and writes
Inspect the replica sets and partial effects behind each operation.
Interactive lab Distributed systemsRaft leader election
Follow local terms and real vote certificates through failures and recovery.
Interactive lab Distributed systemsVector clocks: build causal histories
Control every event and see exactly how knowledge moves between processes.
Interactive lab java_harnessCheckpoint aliases: watch a published snapshot change
Explore the controls, compare outcomes and record your observations.
Interactive lab java_harnessExecutor overload: inspect queue growth and rejection
Explore the controls, compare outcomes and record your observations.
Interactive lab java_harnessG1 evidence triage: classify a synthetic pause fixture
Explore the controls, compare outcomes and record your observations.
Interactive lab java_harnessJVM memory budget: expose the non-heap shortfall
Explore the controls, compare outcomes and record your observations.
Interactive lab java_harnessTimeout ownership: inspect work after the caller leaves
Explore the controls, compare outcomes and record your observations.
Interactive lab java_harnessVirtual-thread admission: bound a synthetic tool burst
Explore the controls, compare outcomes and record your observations.
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
Fan one request out to three remote agents, break the stock agent, and see whether the join keeps or throws away the healthy results.
Interactive lab Large language modelsA2A interop: inspect the selected interface contract
Compute ordered interface selection, tenant propagation and version checks from a local card.
Interactive lab Large language modelsA2A load balancing: keep a local task on its owning server
Send eight A2A requests from two clients through a load balancer and see whether each follow-up lands where its task state lives.
Interactive lab Large language modelsADK application overview: check authority at the tool boundary
Let an agent propose six tool calls for a customer and see which ones a system instruction, a before-tool callback or per-tool checks actually stop.
Interactive lab Large language modelsADK code executor: reject a forbidden import
Scan an editable script for static and computed imports, apply an allowlist or denylist, and see whether a file-system effect could run.
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
Write one tenant fact into ADK-style session state and see which sessions, users and tenants can read it under each key prefix.
Interactive lab Large language modelsAfter-tool callback: redact returned content
A customer lookup returns more than the agent needs. Redact it in an after-tool callback and count what still reaches the model, and what the agent can no longer answer.
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
Open an error dialog from the keyboard, follow every Tab stop, close it, and see where focus and announcements end up.
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
Follow one user request through gateway, agent, model, a tool on a worker thread and an inventory service that times out, and see whether the failure stays in the user’s trace.
Interactive lab Large language modelsAgent as tool: cap a delegated child’s permissions
A support agent calls a summarizer agent as a tool. Choose the credential it carries and watch which steps, including injected ones, actually run.
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: 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
A remote agent changes its Agent Card three times in 45 minutes; follow five client calls through a cached card and see which ones go stale.
Interactive lab Large language modelsAgent Card specification: inspect fields and client compatibility
Editable A2A 0.3.0 JSON, exact field failures and explicit client decisions.
Interactive lab Large language modelsAgent chaos gate: survive a regional outage
Take the primary region down for thirty seconds and see whether health checks, routing TTLs, secondary capacity and session replication let the agent keep serving.
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
Push one commit through four integration tests with retries, a quarantine list and a required check, and see whether a real regression reaches release.
Interactive lab Large language modelsAgent code execution: terminate a runaway script
Run a modeled loop against a deadline and compare a supervisor kill, cooperative cancellation, an iteration budget and no limit at all.
Interactive lab Large language modelsAgent context failure: answer unknown when an early fact is evicted
Fill a bounded context window turn by turn, evict the earliest fact, and see whether the agent answers correctly, says unknown, or guesses.
Interactive lab Large language modelsAgent cost control: reject an over-budget call
Admit eight model calls against a session budget and compare after-the-fact checks, input-only estimates and reserved worst-case estimates.
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
Let an opponent search the release evidence, then see whether the judge rule lets one verified counterexample change the decision.
Interactive lab Large language modelsAgent debugging: trace the wrong tool output
Six of twenty quote runs ship a wrong total after a tool update. See whether your traces pin the cause on the tool result, and whether a contract stops it at the boundary.
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
Change the agent event schema in a producer release and see which gate notices that a downstream consumer can no longer parse it.
Interactive lab Large language modelsAgent events: deduplicate a redelivered effect
Deliver eight agent events with a lost acknowledgement or a consumer crash, and see which dedupe key and window keep exactly one ledger effect per event.
Interactive lab Large language modelsAgent feature flags: inspect stable targeting
Evaluate twelve named subjects; inspect allocation, overrides and error fallbacks.
Interactive lab Large language modelsAgent feedback UI: record a versioned, actionable signal
Edit a fictional draft, test duplicate submission and inspect a local review queue.
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
Score four agent framework archetypes for a workload, and see when popularity outvotes a requirement the workload cannot give up.
Interactive lab Large language modelsAgent hierarchy: inspect a broken delegation chain
Send a billing task down a root, lead and specialist chain, break one link and see whether the failure is reported or silently swallowed.
Interactive lab Large language modelsAgent history: inspect committed state changes
Two browser tabs change one agent session at once while the agent streams a tentative discount; inspect which revisions the history really committed.
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
Eight agents call a payments agent with bearer tokens. Tune the receiver’s verification policy and see which forged, replayed or expired tokens get in.
Interactive lab Large language modelsAgent inspection API: query a trace without exposing forbidden fields
Compute object access, response fields and event pages from fictional records.
Interactive lab Large language modelsAgent integration testing: execute four component contracts
Execute isolated in-memory probes and compare expected objects with observed tenant, timeout, storage and callback results.
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
Five structured agent log records carry an e-mail, a bearer token, a card number in free text and a nested phone number; choose where and how they are redacted.
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
Move two statements through working memory, session state and durable memory, then return a week later as the same or a different person.
Interactive lab Large language modelsAgent pipeline: ordered transformations and failure propagation
Push ten invoices through six ordered stages, inject a fault into one, and see whether bad output is stopped, quarantined or published.
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
Hide the same injected instruction in five places in a document, test only some of them, and compare the suite verdict with what production would see.
Interactive lab Large language modelsAgent release train: hold promotion after canary errors
Separate artifact checks, sample sufficiency and canary error-rate gates before promotion.
Interactive lab Large language modelsAgent release: blue/green and rollback
Switch a streaming agent from blue to green, then roll back when green fails, and count dropped streams, lost sessions and rollback time.
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
Run untrusted code that tries six outbound paths and see which ones each egress policy, resolver and loopback setting actually closes.
Interactive lab Large language modelsAgent scoring: threshold and error cost
An agent auto-approves refund requests below a risk score; sweep the threshold and compare the most accurate setting with the cheapest one.
Interactive lab Large language modelsAgent serving scale: compare fixed and elastic capacity
Serve an hour of agent traffic with a load spike and compare fixed replicas with an autoscaler that needs time to start new ones.
Interactive lab Large language modelsAgent shell execution: restrict commands before they run
Six commands proposed by an agent meet a denylist, an executable allowlist or validated arguments, run through a shell or as an argument vector.
Interactive lab Large language modelsAgent simulator: replay the same case before comparing versions
Compare a baseline and a candidate agent on simulated conversations, with fresh or paired scenario seeds and a deterministic or sampling user simulator.
Interactive lab Large language modelsAgent skills: load only trusted instructions for the task
Five skills are installed for a PDF-to-CSV task; choose which bodies enter the context and see what an untrusted or tampered skill can make the agent do.
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
Run a modeled load test for hours, sample the heap, fit a growth rate and see whether a slow leak is exposed or missed.
Interactive lab Large language modelsAgent swarm: elect one owner for a duplicated task
Broadcast one refund task to two workers, stall the first one, and see whether a lease, renewal and a fencing token keep the refund to exactly one.
Interactive lab Large language modelsAgent team: independent specialists and a final check
Have legal, finance and security specialists review an eight-clause contract, and see what shared notes, voting and a final coverage check change.
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
Compose four sub-agents as sequential, parallel or mixed workflows and see which reads find their inputs in shared state.
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
Process actual fictional event records and compare storage with a time-window report.
Interactive lab Large language modelsAgent UX: clarify the report target
Resolve the intended tenant, check permission, then inspect the exact records used in the report.
Interactive lab Large language modelsAgent voting: majority decision with a recorded dissent
Three reviewer agents vote on promoting a prompt; one finds failing safety tests. See which rule, voting order and decision record keep that dissent useful.
Interactive lab Large language modelsAgent web browsing: keep page text out of the instruction channel
Let an agent read three shop pages, one carrying an injected instruction, and see which defence layer, if any, stops it.
Interactive lab Large language modelsAgno-style remote agent: bound the Java adapter wait
Call an Agno-style remote agent from a Java adapter with a small thread pool and watch hung calls pin threads until a timeout frees them.
Interactive lab Large language modelsAnalogical prompting: test whether a pattern transfers
Borrow a design from a packet router or a batch import, map each element onto the real problem, and see whether the release tests notice what did not transfer.
Interactive lab Large language modelsApplication result caching: reuse without changing the answer
Eight questions from five users hit an answer cache while a price changes; see which cache keys and lifetimes change the answers people get.
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
Write a three-section report into a versioned artifact store while another reader loads it, and see which version that reader actually gets.
Interactive lab Large language modelsAsync state: prevent a lost update
Let parallel branches reserve books, stock handling and packing against one shared budget, and watch overlapping awaits erase each other’s debits.
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 masks: permitted query-key pairs
Explore the controls, compare outcomes and record your observations.
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
Run a writer and a critic in round-robin and see which termination condition fires: a keyword, a message cap, a token budget, or none.
Interactive lab Large language modelsBaseLlm interface: normalize a provider response shape
A vendor renames its response fields mid-run. See whether your BaseLlm adapter maps them, leaks the raw JSON to callers, or silently returns blanks.
Interactive lab Large language modelsBeeAI-to-Java bridge: preserve a renamed response field
Rename a field in a Python agent response and see whether the Java client fails loudly, silently returns nothing, or keeps working.
Interactive lab Large language modelsBenchmark audit: inspect reference labels and scores
Grade two agents on twelve items, then apply audit fixes one at a time and watch the leaderboard order change.
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: bounded request and response queues
Follow named requests and acknowledgements through two bounded queues.
Interactive lab Large language modelsBigQuery-style query budget: filter before scanning
Estimate the bytes a BigQuery-style query reads from a partitioned table, then cap it, prune it and drop unneeded columns.
Interactive lab Large language modelsBlue/green observability: measure both versions
Mirror a slice of traffic to the green candidate and see whether the release gate is measuring green or a blended dashboard.
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
Share ten workers between a search tool and a payments tool, slow the search backend down for thirty seconds, and see whether payments keep working.
Interactive lab Large language modelsCalendar boundaries: adjacent is not overlapping
A calendar tool checks five meeting requests against an attendee’s busy events; see how interval ends, time zones and a required gap change the answers.
Interactive lab Large language modelsCalendar tool: detect overlapping intervals
Check a proposed meeting against four existing events and see how time zones, endpoint rules, buffers and tentative events decide the answer.
Interactive lab Large language modelsCanary exposure: speed versus blast radius
A bad candidate goes through a canary ladder; trade the first step’s size, bake time and sample requirement against how many users see failures.
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
Find the saturation boundary and distinguish a longer queue from more service capacity.
Interactive lab Large language modelsChain of verification: catch an unsupported delivery claim
Verify a four-claim delivery answer against the order record, and compare independent questions with a verifier that merely restates the 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
Trip a breaker on a failing tool, then tune its window, wait and probe budget so traffic returns once, without hammering a dependency that is still warming up.
Interactive lab Large language modelsCircuit breaker: recovery verification
Verify a candidate circuit-breaker configuration with a fault-injection drill, then replay the real incident and see whether the gate told the truth.
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
Give an agent service account a role, let an injected instruction ask for destructive calls, and see what the role allows beyond the job.
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 four tool calls on a small thread pool, make one fail, hang or stall, and see what the join returns and when.
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
Trace a release from its registry reference to the exact platform artifact that was tested.
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
Score twelve messages with a fictional harm classifier and see why one threshold blocks reporters and novelists while still missing a politely worded harmful request.
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
Trace a $100 provider bill to tenant invoices, including sub-agent calls, retried attempts and a shared vector database.
Interactive lab Large language modelsCrew-style task assignment: name one owner before work starts
Post six tasks to a crew of agents and count customer emails: broadcast and racing claims send duplicates, a crash without a lease strands work.
Interactive lab Large language modelsCross-session memory: scope before similarity
Two users ask what they decided. A shared memory index ranks everyone’s memories by similarity; see what happens when the user filter comes after ranking.
Interactive lab Large language modelsCustomer credits: offset once and carry the remainder
Apply one service credit across three monthly invoices, crash and re-run a billing job, and check that every dollar of credit is offset exactly once.
Interactive lab Large language modelsData agent: expose a malformed row before aggregation
Parse an editable CSV before aggregating it and compare strict validation with lenient coercion that turns 14.3k into 14.
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: quarantine and redrive
Follow four messages through retry, quarantine, expiry and selective redrive while checking the committed-effect ledger.
Interactive lab Large language modelsDebugging hallucinations: compare a claim with its source
Split an answer into claims, find the best supporting source sentence, and check numbers and citations before the answer ships.
Interactive lab Large language modelsDebugging latency: inspect work and waiting
Four requests arrive together. Inspect the fourth request’s trace and separate the time spent working from the time spent waiting for workers and connections.
Interactive lab Large language modelsDelegated result gate: verify before accepting a report
Six worker agents report back on a release review. Decide what the coordinator checks before a report enters the release decision.
Interactive lab Large language modelsDelegation contract: join only successful artifacts
Delegate a price lookup to three regional sub-agents and decide which returned artifacts a coordinator may join into one answer.
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
Route twenty requests across two workers, send SIGTERM to one, and check that every invocation either commits or is rejected in a way a client can retry.
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: audit a release decision
Bind tests to a candidate, enforce approval and inspect a numerical health gate.
Interactive lab Large language modelsDisaster recovery: test that a backup can restore
Take scheduled backups, inject a hidden defect, lose primary storage and find out which backup actually restores.
Interactive lab Large language modelsDocumentation agent: answer only with a supporting passage
Score eight versioned documentation passages against a question and answer only when a passage for the user’s version supports it.
Interactive lab Large language modelsDSPy-style optimization: do not select on training examples
Score candidate prompt programs, choose one by training or development accuracy, and compare the choice with held-out test accuracy.
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
Place an edge classifier, a JVM agent and its sessions across a Worker isolate, a container and a region, and see what fits, what sleeps and what is lost.
Interactive lab Large language modelsEmail observability: receipt versus repeated delivery
Send four emails through a slow provider with a tool timeout, retries and idempotency keys, then compare reported status with what customers received.
Interactive lab Large language modelsEmail review: invalidate approval after edits
Approve a send_email call, let the agent edit it, and see whether the approval still describes the message that is actually sent.
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
Build an evaluation set from logs and see whether it has enough cases in the intents where a candidate regresses.
Interactive lab Large language modelsEvaluation framework: inspect metric trade-offs
Score ten agent runs by tool trajectory and answer overlap, and compare each verdict with a person’s: strict scorers fail good runs, loose ones ship bad ones.
Interactive lab Large language modelsEvaluation harness: repeat a deterministic run
Run the same ten recorded cases several times and find out whether sampling and a live tool clock make the gate decision change between runs.
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
A candidate agent raises the aggregate pass rate while one group of users gets much worse; decide which gate notices.
Interactive lab Large language modelsExecution plan: dependencies, deadlines and acceptance
Schedule a six-step plan on a few workers, inject one defective artifact, and see whether checking acceptance early or late meets the deadline.
Interactive lab Large language modelsFailure propagation: client state versus server state
Charge one order through an orchestrator and a remote payments agent, inject a fault, and compare what the client believes with what the server committed.
Interactive lab Large language modelsFault injection: lose an acknowledgement after a side effect
Inject a lost response after the server commits, then follow retries, deduplication and the committed-effect ledger.
Interactive lab Large language modelsFew-shot library: select examples that cover the query
Choose prompt examples from a ten-example library by recency, shuffle or similarity, and see when the chosen set covers the ticket.
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
Send six agent requests against users/{uid}/notes paths and compare the path owner with the signed-in caller under each access path and rule.
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
Edit a four-node agent graph, validate reachability before running it, and see what the agent answers when its tool is disconnected.
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
Take one model-proposed function call through a declared schema, the function calling mode and argument validation before a local function runs.
Interactive lab Large language modelsFunction dispatch: inspect a validated file operation
Follow one model-proposed file path through joining, normalisation and symbolic-link resolution, and see which containment check stops it.
Interactive lab Large language modelsFunction tools: validate before dispatch
Send one refund call through a tool with three side effects and compare validating every argument first with checking each one just before it is used.
Interactive lab Large language modelsFunction-call inspection: validate a state mutation
The model asks to change a shipping address. Choose which checks stand between its function call and the order record.
Interactive lab Large language modelsGAIA-style benchmark: keep evaluation answers out of tuning
Tune an agent on a GAIA-style validation set, let it browse and remember, and watch the reported score drift away from what it can really do.
Interactive lab Large language modelsGemini integration: catch missing credentials before request
Validate credentials, backend settings and the model id at startup, or discover the same mistake through rejected calls.
Interactive lab Large language modelsGemini LLM tool call: validate typed arguments before dispatch
The model fills count_items with arguments of the wrong type; compare loose coercion with strict validation and a repair turn.
Interactive lab Large language modelsGemini multimodal input: send pixels when the question needs them
Ask three questions about a chart and decide whether to send OCR text, pixels or both, at what size and crop, and what that costs in tokens.
Interactive lab Large language modelsGemini thinking budgets: an executed search analogy
Execute a bounded graph traversal and distinguish an untested route from a verified answer.
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
Set a threshold for each harm category on a security-awareness tutor and see which legitimate lessons get blocked, which harmful replies get through, and what the learner sees.
Interactive lab Large language modelsGeneralist agent: route a specialized question to a qualified path
Route eight requests by classifier confidence and see which regulated questions end up with an unqualified generalist.
Interactive lab Large language modelsGitOps rollout: validate a desired manifest
Edit the manifest in Git, validate it or not, then watch sync, prune, health and self-heal decide what actually runs.
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: verify the artifacts you combine
Trace two sorting branches into an aggregate and expose a sorted result that lost data.
Interactive lab Large language modelsGriptape-style workflow: honor a parent-output dependency
Two child tasks need a parent task’s summary and risk flags. Launch them on a dependency edge, all at once, or by polling, and see what they read.
Interactive lab Large language modelsGround truth: make the rubric explicit
Build a truth set from two annotators’ labels, measure their agreement with Cohen’s kappa, and see how a policy change makes old labels wrong.
Interactive lab Large language modelsHow an LLM answers a question
Watch Qwen2.5-0.5B-Instruct turn a question into tokens, IDs, scores and an answer, one real token at a time, with probabilities captured from the model on a laptop CPU.
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
Send six requests through input, tool-argument, tool-result and output checks and see which boundary catches each harm, and which benign request is blocked.
Interactive lab Large language modelsInterrupted agent effect: reuse a receipt after a lost ACK
Crash an agent between creating an invoice and recording it, resume, and count how many invoices and emails one order produced.
Interactive lab Large language modelsJudge evaluation: audit recorded quality scores
Compare twelve recorded judge scores with human reference labels, fill the confusion matrix and compute Cohen’s kappa before trusting the judge.
Interactive lab Large language modelsKV cache memory: storage versus recomputation
Size the key/value cache of a fictional 32-layer decoder from heads, precision, context and batch, and compare it with recomputing the prefix every step.
Interactive lab Large language modelsLayered guardrails: compare one check with four boundaries
Five conversations carry defects at the request, a tool call, a tool result and the response; compare one request check with four boundaries.
Interactive lab Large language modelsLlmAgent release gate: approve a high-impact tool action
An agent proposes a lookup, a refund and an email, plus one injected refund; choose which calls run alone and which wait for a person.
Interactive lab Large language modelsLoad testing: throughput and admission outcomes
Drive an agent endpoint with a traffic ramp and see whether overload is rejected at the door, queued, or served after the client has already given up.
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
A user mentioned her city, diet and allergy across three sessions over 200 days. Choose what memory keeps and see what the agent knows on day 230.
Interactive lab Large language modelsMatrix agent organization: resolve dual ownership
Inspect product and domain owner votes, distinguish absence from rejection, and count only the decisions already reviewed.
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
Filter eight stored memories by tenant, kind and age, rank them into a bounded context tray, and find out why the needed evidence is missing.
Interactive lab Large language modelsMiddleware ordering: inspect the stopping gate
Four hooks guard a refund tool: tracing, a cache, an amount normaliser and the refund policy. Reorder them and see which one stops the chain first.
Interactive lab Large language modelsModel fallback: bound attempts and preserve the deadline
Separate an eligible routing failure from an incompatible backup or a request that ran out of time.
Interactive lab Large language modelsModel settings: validate a candidate before activation
Push a candidate model configuration with one defect through schema, catalog and probe checks, and see what happens to live traffic when a check is missing.
Interactive lab Large language modelsModeration release gate: block on the wrong error type
Gate a new moderation policy on its eval results and see an accuracy rule ship a candidate that misses four times as many severe cases.
Interactive lab Large language modelsMulti-agent workflow: explicit handoffs and verified output
Hand research from one agent to a writer as a raw transcript or as a typed, sourced contract, then decide what a reviewer must check before publishing.
Interactive lab Large language modelsMulti-region A2A: resume a task after home-region failure
Commit a ten-step A2A task in a home region, replicate it to a standby, fail the home region and resume: count lost steps and duplicate side effects.
Interactive lab Large language modelsMultimodal agent: align frames before describing an event
Sample video frames, place the audio event on the same clock, and see whether the description keeps cause before effect.
Interactive lab Large language modelsObservability CI: detect a missing tool span
A refactor loses the refund tool’s span. Decide which conversations CI replays and which telemetry check runs, and see what reaches production.
Interactive lab Large language modelsObserve the complete record lifecycle
Follow one customer record through primary storage, a search index, an analytics export and nightly backups, and compare what lineage reports with what exists.
Interactive lab Large language modelsOutput grounding check: inspect every factual sentence
Check every sentence of a cited answer against the passage it cites, and see which verifier catches a dropped condition, an unrelated source and an uncited claim.
Interactive lab Large language modelsPayment operation: inspect attempts, receipts and refunds
A charge times out after the card was taken, a bank asks for 3-D Secure, and a refund is requested twice. Read the provider’s records against what the agent says.
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
Step a defective candidate from 1% to 100% of traffic behind an error-rate gate, and measure how many users it hurts before it is stopped.
Interactive lab Large language modelsRAG grounding: test retrieval, freshness, support, and injection
Retrieve from six documents, filter stale and untrusted ones, and check whether the refund answer is current, supported or injected.
Interactive lab Large language modelsRefunds: never return more cash than was collected
A $100 order paid with a card and a gift card is fully returned; check that each tender gets back no more than it paid, even with a coupon and a retried request.
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 modelsRequest hedging: race a backup against a slow primary
Send a backup request when the primary is slow, and weigh the tail latency saved against extra load and duplicate writes.
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
Retry one payment tool call through a lost response, a temporary outage and a permanent error, and count the charges that really happened.
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
A bad prompt release gives wrong refund answers; choose the alert window and rollback method, and decide what happens to its evidence and sessions.
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
The model proposes six searches over a local document store, two steered by an injected instruction. Validate the limit, the path and the query before anything runs.
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
Add five seats and remove three during a 31-day October, and compare each proration rule with the contract’s daily amount.
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
A client agent for tenant acme asks a server agent for four invoices; choose where the tenant comes from and whether ownership is checked before or after the read.
Interactive lab Large language modelsSession recovery: replay recorded transitions
Record a short ticket-booking conversation as session events, crash the process, and rebuild state by replaying only what was persisted.
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
Keep a cart, a unit preference and a sign-in token across ten turns and a restart, and see which belong in state, which in history, and which nowhere.
Interactive lab Large language modelsShadow deployment: compare without serving v2
Discarding a candidate response does not undo its tool or session effects.
Interactive lab Large language modelsShadow testing: observe isolated candidate failures
Mirror checkout requests to a candidate, compare responses, and check that the shadow neither emails customers nor slows them down.
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
Generate 48 tokens with a draft model and a target verifier, and see how draft length, acceptance rate and draft cost decide whether it is faster.
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
Export a ten-step agent session and replay it: see which bundle contents keep the replay faithful and which make it re-issue a real credit.
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
Process an access or erasure request for Ana Ruiz across four stores, and see what the verification method and search key release, and to whom.
Interactive lab Large language modelsSubscription changes: inspect a prorated downgrade
Separate a seat adjustment from the money already collected and the refund actually requested.
Interactive lab Large language modelsSynthetic monitoring: one-region alert versus quorum
Probe three regions for thirty minutes through a probe-host blip and a real outage, and compare single-region, quorum and dual-vantage alerting.
Interactive lab Large language modelsTask-DAG scheduling: measure the parallel critical branch
A daily report DAG has three parallel branches; choose which task to speed up and how many worker slots run, and see which branch decides the finish time.
Interactive lab Large language modelsTemperature sampling: reshape and inspect probabilities
Scale eight fixture logits by a temperature, compute stable or naive softmax, and draw seeded samples to see when the tail starts to speak.
Interactive lab Large language modelsTenant billing: isolate usage and event identity
Meter eight usage events from two tenants whose clients reuse event ids, and see which tenant each invoice charges.
Interactive lab Large language modelsTenant capacity: scale the constrained partition
Let one tenant burst on a shared partition, then compare uniform scaling, targeted scaling, isolation and a per-tenant rate limit.
Interactive lab Large language modelsTenant configuration: scoped overrides and source tracking
Merge global defaults, the pro plan and one tenant’s overrides into an effective agent configuration, and track which layer set each value.
Interactive lab Large language modelsTenant data: principal versus resource ownership
An agent reads invoices, an HR file and a user’s folder for ana at acme. Decide where the tenant comes from, what is checked and with whose credential.
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
Copy a tenant to a new store while writes continue, compare source and target, and decide whether the cutover may proceed.
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, provision and retry
Inspect the exact resource ledger after validation, allocation and repeated readiness probes.
Interactive lab Large language modelsTenant registry: do not route across scope
Two tenants register agents with the same names as each other and as a platform agent. Resolve five requests and see which reach another tenant.
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
Attribute nine usage events to two tenants for one billing day and see how API keys, missing claims and time zones move usage between tenants.
Interactive lab Large language modelsToken-cost ledger: inspect input and output charges
Split cached input and thinking output, then keep incomplete costs visibly unresolved.
Interactive lab Large language modelsTool callbacks: block before execution
Gate six tool calls with a before-tool hook, and see how its return value decides whether the model explains, retries, lies or the whole turn dies.
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
Filter six next-token distributions, three peaked and three flat, with top-k, top-p or min-p, then draw from what is kept.
Interactive lab Large language modelsTrace integration: follow an outgoing traceparent
Follow one agent request through an HTTP tool call, an inventory service and a queue, and see where its trace context survives.
Interactive lab Large language modelsTraffic shifting: follow each routed request
Shift traffic from v1 to v2 in three steps while four users hold multi-turn sessions, and follow which version serves every turn.
Interactive lab Large language modelsUndo state: append a compensating transition
Undo the last steps of an order that reserved stock, charged a card and sent an email, and compare deleting history with appending its reversal.
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
Run ten October meter records for one tenant through dedupe, validation, unit conversion and period assignment, and compare the invoice with the correct 6,200 tokens.
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
Two parallel researchers write findings into shared session state; see which findings survive to the report step.
Interactive lab Large language modelsWorkflow runtime: inspect ready, running and blocked states
Schedule six dependent tasks on a small worker pool, fail an API task, and watch ready, running, failed, blocked and cancelled states.
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 to MCP: translate, authorize and execute
Map structured messages to real local record operations; inspect grants, revisions and returned envelopes.
Interactive lab Model Context ProtocolMCP capabilities belong to different endpoints
Explore the controls, compare outcomes and record your observations.
Interactive lab Model Context ProtocolMCP message flow: correlate requests and replies
Edit a real local sum, compare reply ordering and expose unmatched or malformed responses.
Interactive lab Model Context ProtocolMCP OAuth: bind the grant, protect the tool
Compute real S256 proofs and inspect local resource, scope, lifetime and one-use-code checks.
Interactive lab Model Context ProtocolMCP server lifecycle: readiness through cleanup
Compute handshake gates, request deadlines and simulated child-process teardown.
Interactive lab Model Context ProtocolMCP tool name collisions: merge policies, prefixes and pinned hashes
Explore the controls, compare outcomes and record your observations.
Interactive lab Model Context ProtocolMCP tool registry: discovery through execution
Run fixed local tools and inspect schema changes, stale discovery and exact-name dispatch.
Interactive lab NetworkingAnycast routing and service health
Observe the route a network sees, not an imaginary nearest-server shortcut.
Interactive lab NetworkingCUBIC and BBR: follow the packets
Separate identical paths. Measured delivery and delay. No preset winner.
Interactive lab NetworkingDNS resolution and cache lifetimes
Separate answer reuse from cached referrals, one message at a time.
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 NetworkingPassive outlier ejection: consecutive errors, success rate and the cap
Explore the controls, compare outcomes and record your observations.
Interactive lab NetworkingPooled connections and idle timeouts: the stale reuse race
Explore the controls, compare outcomes and record your observations.
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 handshake: follow both endpoints
A sent ACK is not yet a received ACK. Inspect the difference.
Interactive lab NetworkingTLS 1.3: keys are not enough
Real cryptography. Explicit teaching boundaries. Change an input and inspect the first failed check.
Interactive lab ObservabilityAgent metrics: count the requests behind the chart
Inspect counters, completed-request windows and real cumulative latency buckets.
Interactive lab ObservabilityAgent observability: trace a failed dependency
Inspect actual span IDs, parent relationships, sampling decisions and a deterministic execution schedule.
Interactive lab ObservabilityAgent SLOs: define good events before judging the target
Compare availability with successful-and-fast service using exact rolling denominators.
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: watch a service saturate and recover
A bounded FIFO, real request outcomes and four measured service signals.
Interactive lab ObservabilityLatency percentiles: what does p99 actually select?
Real editable samples, exact ranks and reproducible synthetic cohorts.
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: when should this alert clear?
Two real rolling windows. Request-weighted counts. An explicit budget projection.
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: what disappeared before the decision?
One reproducible cohort, two policies and explicit resource limits.
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 QuantizationCalibration samples and held-out error
Fit from one list. Measure clipping and rounding on a separate list.
Interactive lab QuantizationFP16, BF16, INT8 and INT4 reconstruction
Inspect encodings, clipping and reconstruction error on the same FP32 reference array.
Interactive lab QuantizationGGUF byte layout and validation
Serialize two small tensors, parse the actual bytes, and find broken offsets.
Interactive lab QuantizationQuantization and computed toy perplexity
Score the same token transitions before and after explicit weight quantization.
Interactive lab QuantizationSmoothQuant: channel scales and output error
Preserve the float product, then measure what rounding and calibration change.
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 SecurityADK plugin ordering and short-circuit lab
Inspect policy, cache, local callback, and backend paths to see how a returned result can skip later checks and release private data.
Interactive lab SecurityAFP detector thresholds and review-capacity lab
Explore synthetic prevalence, true-positive and false-positive rates, precision, missed cases, and the review workload they create.
Interactive lab SecurityAgent abuse budgets and retry-amplification lab
Inspect how child-task fan-out and retries multiply work, then compare request-only admission with atomic job and tenant budgets.
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 SecurityDelegation boundaries: trace privileges across three agents
Follow synthetic credentials through concierge, research, and operations agents, and see which checks stop unauthorized actions.
Interactive lab SecurityDependency injection: where does this handle point?
Actual shared references, mutable tenant context and returned records.
Interactive lab SecuritymTLS: verify both peers, then authorize the request
Real local cryptographic checks. Separate application permissions. Explicit teaching boundaries.
Interactive lab SecurityOAuth authorization code and PKCE
Real challenge computation. Inspectable request bindings. No real credentials.
Interactive lab SecurityPrivacy controls: scope, minimization and recovery
Follow actual fictional records through primary storage, a backup, an export and a restore.
Interactive lab SecurityPrompt injection: inspect the trust boundaries
Compare synthetic cross-tenant reads and data exports while changing model behavior, authorization, egress, and final-output checks.
Interactive lab SecurityPurpose notice versus enforced behavior
Follow actual fictional records through primary storage, a backup, an export and a restore.
Interactive lab SecurityRefund authorization, replay, and ledger-race lab
Compare approval binding, expiry, tenant ownership, idempotency, and atomic reservations using a synthetic 100-unit refund ledger.
Interactive lab SecuritySecure retrieval: permissions, caches, and citations
Revoke synthetic document permissions, then compare retrieval filtering, cache keys, propagation, and citation checks.
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: actual query results
Four fictional records. Two ways to construct a query. Inspect what SQLite really returns.
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
Configure a coding agent's harness and replay its plan to fix a failing test, including a planted instruction that tells AI agents to run a downloaded script.
Tool Standalone toolsChat Template Renderer
Render the same conversation with the chat templates shipped by Qwen2.5, Llama 3.2, Gemma 2 and Phi-3 and see the exact text, special tokens and failures.
Tool Standalone toolsCloud GPU Pricing Comparison
Enter the hourly rate from your own quote and compare a month of on-demand, committed and spot GPU capacity for the hours you actually use.
Tool Standalone toolsCloud Service Matcher
Map a service category from one cloud to another across AWS, Google Cloud, Azure and OCI, and see which pairs differ in ways that break a straight migration.
Tool Standalone toolsGGUF Quantization Chooser
Size a pure GGUF quantization tensor by tensor from a published config, add the KV cache for your context, and find the largest type that fits your memory.
Tool Standalone toolsJSONL Training Data Validator
Validate fine-tuning JSONL line by line for chat, instruction or preference records, with the exact reason each line would be rejected.
Tool Standalone toolsLoRA + QLoRA Memory Calculator
Count the adapter parameters of a published model exactly, then add base weights, optimizer state, activations and logits to see whether training fits your GPU.
Tool Standalone toolsPrompt Injection Scanner
Score text against eight visible injection rules, then see on eight labelled samples which attacks the rules catch, which they miss and which harmless text they flag.
Tool Standalone toolsRAG Chunker Visualizer
Chunk a document four ways and check whether each known answer still sits inside a single chunk, the condition for retrieving it whole.
Tool Standalone toolsSLM Selector
Filter nine published small models by device memory, weight format, context length and licence, and see which ones actually fit and why the others do not.
Tool Streaming systemsBackpressure: account for every record
Integer records, explicit policies and sixty seconds of inspectable history.
Interactive lab Streaming systemsConsumer lag: processed versus committed
Integer records, explicit policies and sixty seconds of inspectable history.
Interactive lab Streaming systemsKafka partition routing and expansion
See where new records go without moving the records already written.
Interactive lab Streaming systemsStream–table duality
Retain the history. Derive the state. Check reconstruction rather than assuming it.
Interactive lab System designAgent command gateway: stale reads, conflicts and duplicate credits
Send credit proposals from an agent through an event-sourced aggregate and see which checks stop stale reads, retries and cap breaches.
Interactive lab System designAgent event consumer: rate limits, poison events and redelivery
Explore the controls, compare outcomes and record your observations.
Interactive lab System designAgent outbox relay: crash points, duplicates and resume
Explore the controls, compare outcomes and record your observations.
Interactive lab System designAgent step behind a callback token: heartbeats, timeouts, retries
Explore the controls, compare outcomes and record your observations.
Interactive lab System designAgent tenants on a shared service: fair queues and re-plans
Explore the controls, compare outcomes and record your observations.
Interactive lab System designAgent-planned saga: catalogue checks, the pivot and who compensates
Run a fulfilment plan proposed by an agent through a saga orchestrator and see which checks keep a failed plan from leaving effects behind.
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: fail fast and recover deliberately
Break a dependency, watch the gate protect it, and decide when traffic can safely return.
Interactive lab System designDesired state and a reconciler: converge, crash, recover
Explore the controls, compare outcomes and record your observations.
Interactive lab System designLoad balancing under uneven service times
See which backend receives each request and whether it has room to accept it.
Interactive lab System designSharding: keys, load and migration
Stable owners and real record movement. Equal row counts do not guarantee equal workload.
Interactive lab System designWrite skew between agent runs: guarding a monthly credit limit
Explore the controls, compare outcomes and record your observations.
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 & SLMsBackpropagation: the Chain Rule
Explore the controls, compare outcomes and record your observations.
Interactive lab Transformer math & SLMsBeam Search: Pruning an Explicit Probability Tree
Explore the controls, compare outcomes and record your observations.
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, Conflict Misses and Reuse
Explore the controls, compare outcomes and record your observations.
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: Executable Tensor Trace
Explore the controls, compare outcomes and record your observations.
Interactive lab Transformer math & SLMsCPU SLM Stack: Trace a Dense Kernel
Explore the controls, compare outcomes and record your observations.
Interactive lab Transformer math & SLMsCross-Entropy Loss Surface
Explore the controls, compare outcomes and record your observations.
Interactive lab Transformer math & SLMsDataLoader Pipeline: Bounded Prefetch and Compute Stalls
Explore the controls, compare outcomes and record your observations.
Interactive lab Transformer math & SLMsDot Product Geometry (2D)
Explore the controls, compare outcomes and record your observations.
Interactive lab Transformer math & SLMsDPO Loss and Reference-Relative Preference
Explore the controls, compare outcomes and record your observations.
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 Recipe: Train, Export, Validate, Serve
Explore the controls, compare outcomes and record your observations.
Interactive lab Transformer math & SLMsFeed-Forward Expansion with Actual Activations
Explore the controls, compare outcomes and record your observations.
Interactive lab Transformer math & SLMsFlashAttention Tiling: Inspect Online Softmax
Explore the controls, compare outcomes and record your observations.
Interactive lab Transformer math & SLMsForward and Backward Arithmetic Counts
Explore the controls, compare outcomes and record your observations.
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 & SLMsGradient Accumulation and Unequal Microbatches
Explore the controls, compare outcomes and record your observations.
Interactive lab Transformer math & SLMsGradient Clipping in Action
Explore the controls, compare outcomes and record your observations.
Interactive lab Transformer math & SLMsInference Latency: Conditional Resource Bounds
Explore the controls, compare outcomes and record your observations.
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
Calculate population statistics, epsilon-stabilized normalization and explicit per-feature affine output.
Interactive lab Transformer math & SLMsLearning-rate schedule: warmup and exact decay
Explore the controls, compare outcomes and record your observations.
Interactive lab Transformer math & SLMsLoss curves: inspect evidence before diagnosis
Explore the controls, compare outcomes and record your observations.
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 & SLMsMatrix multiplication: follow every accumulator
Choose a row and column. Watch their products build one output entry.
Interactive lab Transformer math & SLMsMoE gate arithmetic and capacity accounting
Inspect actual top-k decisions, expert capacity and weighted scalar outputs.
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
Explore the controls, compare outcomes and record your observations.
Interactive lab Transformer math & SLMsOptimizer steps: SGD, momentum and Adam
Explore the controls, compare outcomes and record your observations.
Interactive lab Transformer math & SLMsPerplexity Calculator
Audit target-token likelihoods, counted losses and perplexity without invented model rankings.
Interactive lab Transformer math & SLMsPositional Encoding Curves
Sinusoidal at different dimensions = different frequencies.
Interactive lab Transformer math & SLMsQ4_K Block Layout
Quantize 256 weights into one Q4_K super-block, pack every byte the way llama.cpp does, and see how one outlier coarsens only its own sub-block.
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
Compute signed derivatives through plain and residual scalar chains.
Interactive lab Transformer math & SLMsRoPE Extension Strategies
Compute every rotary frequency before and after context extension and count the pairs that would rotate through angles the model never saw in training.
Interactive lab Transformer math & SLMsSIMD Register — AVX-512 + AMX
Run one u8 x s8 dot product through scalar, AVX-512, AVX2, VNNI and AMX instruction shapes and watch lanes fill, saturate and accumulate.
Interactive lab Transformer math & SLMsSLM Architecture Comparison
Put two published small-model configurations side by side and compute what their choices cost in KV cache at a context length you pick.
Interactive lab Transformer math & SLMsSLM Parameter Breakdown
Count every weight of a published small model from its config, split into embedding, attention, FFN and norms, and check it against a memory budget.
Interactive lab Transformer math & SLMsSpeculative Decoding Acceptance
Watch draft tokens accepted with probability min(1, p/q) or replaced from the residual, and check that the output still follows the target model.
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
Look a token up in an 8-token embedding table, score every token with the same matrix, and size what tying saves in real models.
Interactive lab Transformer math & SLMsTokenizer Compression Comparison
Train a byte-level BPE tokenizer on a short English text right here, encode your own text with it, and see why other languages and code cost more tokens.
Interactive lab Transformer math & SLMsTraining memory allocation ledger
Explore the controls, compare outcomes and record your observations.
Interactive lab Transformer math & SLMsWeight Initialization Distributions
Push a batch of random inputs through a stack of freshly initialised layers and watch whether the activations keep their scale, vanish or explode.
Interactive lab Transformer math & SLMsWeight Layout on Disk (GGUF / SafeTensors)
Lay out a five-tensor model in GGUF v3 or safetensors and read the exact byte offsets of its header, metadata, tensor table, padding and data.
Interactive lab TransformersFeed-forward layers: matrices and gates
Trace each token through real projections, nonlinearities and output sums.
Interactive lab TransformersMoE: route, admit and combine
Inspect actual top-k decisions, expert capacity and weighted scalar outputs.
Interactive lab TransformersMulti-head attention: projections and masks
Compute attention weights and follow every value into the output.
Interactive lab TransformersPositional encoding: addition versus rotation
Edit actual vectors and test what a shared position shift preserves.
Interactive lab Video streamingAdaptive bitrate: follow every segment
Explore the controls, compare outcomes and record your observations.
Interactive lab Video streamingCodec comparison with actual measured files
One synthetic source, nine reproducible encodes. Inspect the evidence and its limits.
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: follow segments from input to playback
Explore the controls, compare outcomes and record your observations.
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: an actual local video pipeline
Explore the controls, compare outcomes and record your observations.
Interactive labNo matching labs. Try another term or clear the filters.