IBM: Granite 4.0 Micro

Review this Python function for potential bugs. Focus on edge cases: def calculate_discount(price, percentage): return price - (price * percentage)

The function has a critical issue: it assumes `percentage` is a decimal (0.0-1.0) but typical user input is 0-100. If someone passes `50` for 50%, they'd get a negative result. Add validation: `if percentage > 1: percentage /= 100`. Also consider: what if `price` is negative? What if `percentage` exceeds 100? The function silently produces nonsense in both cases. Add bounds checking or raise `ValueError` for invalid inputs.

Granite 4.0 Micro's 131k token context window lets it handle substantial codebases, but this example shows its strength in focused code review. The model identifies the percentage-scale ambiguity and suggests defensive programming. At $0.02/$0.11 per Mtok, it's positioned for high-volume internal tooling where cost per call matters more than cutting-edge reasoning.

Summarise this customer support transcript into three bullet points for our CRM. Highlight the core issue, what we promised, and next steps.

• **Core issue**: Customer's API key expired mid-integration, causing 401 errors across their staging environment. They weren't notified before expiry. • **Our commitment**: Issued a new key immediately; enabled email alerts 7 days before future expirations on their account. • **Next steps**: Engineering will review why the expiry notification didn't fire. Follow up with customer in 48 hours to confirm staging is stable.

This example demonstrates Granite 4.0 Micro's utility for routine business text processing. The model extracts structure from conversational data without over-elaborating. The 131k context means it can ingest long transcripts or email threads in one pass. Trade-off: for nuanced sentiment analysis or complex multi-party negotiations, a larger model would capture subtler dynamics.

Explain how a bloom filter works to a junior developer who understands hash tables but hasn't seen probabilistic data structures before.

A bloom filter is like a hash table that trades accuracy for space. Instead of storing keys, it uses multiple hash functions to set bits in a fixed-size array. To check membership, hash the item with those same functions — if all corresponding bits are 1, the item *might* be in the set. If any bit is 0, it's *definitely not*. False positives are possible (bits collide), but false negatives aren't. Use case: quickly ruling out non-members before hitting a slow database.

Granite 4.0 Micro handles technical explanations with appropriate scaffolding, building on the user's stated knowledge (hash tables). The analogy and use-case grounding make the concept accessible. However, the explanation stays surface-level — a model with stronger reasoning might walk through a concrete bit-array example or discuss tuning parameters (number of hash functions, array size). For quick onboarding docs, this depth is often sufficient.

When Granite 4.0 Micro handles first-pass ticket routing for sub-50-ticket-per-day teams

A 6-person support team triaging 35 inbound tickets daily, each 200-400 tokens, into four routing buckets (billing, technical, sales, escalation). Granite 4.0 Micro at $0.02/Mtok input costs $0.006 per ticket to classify; output is a single category tag (10 tokens, $0.001). Monthly cost for 700 tickets: $5. The 131k context window is overkill here, but the price floor makes it viable even at low volume. The catch: classification accuracy matters—if 15% of tickets misroute, you're burning support hours on re-triage. Without public benchmarks, you're running a two-week pilot to measure precision before going live. If your ticket language is straightforward and you can tolerate a 10% misroute rate that gets caught in the first human reply, Granite 4.0 Micro is the cheapest entry point. If you're above 100 tickets/day or misroutes create customer-facing delays, the lack of benchmark transparency is a deal-breaker until you validate accuracy in production.