OpenAI: gpt-oss-120b

Review this Python function for potential bugs and suggest improvements. Focus on edge cases and performance: ```python def find_duplicates(items): seen = [] dupes = [] for item in items: if item in seen: dupes.append(item) seen.append(item) return dupes ```

This function has a critical performance issue: using `item in seen` on a list creates O(n²) complexity. For large inputs, this becomes prohibitively slow. Edge case: if `items` contains unhashable types like dictionaries, the code works but remains inefficient. Suggested fix: replace `seen = []` with `seen = set()` for O(1) lookups. Also consider whether you want to return duplicate values once or multiple times—current implementation returns each duplicate every time it reappears after first occurrence.

Demonstrates code review capability with attention to algorithmic complexity. The 131K token context window means this model can review entire codebases in one pass, though without public benchmarks we can't verify how it performs against specialized code models on standardized tests.

Summarize the key regulatory changes in this 40-page compliance document, highlighting what our fintech startup needs to action by Q2. [document text follows...]

The model would parse the full document and produce a structured summary identifying: (1) three new KYC verification requirements taking effect April 15th, with specific data retention periods; (2) updated transaction monitoring thresholds that require system configuration changes; (3) new customer communication obligations around fee disclosures. Each point would include the relevant section reference, effective date, and a plain-English explanation of the compliance gap versus current practices.

The 131K context window handles long documents without chunking—useful for legal, compliance, and research work where full-document context matters. At $0.17/Mtok output, summarizing a 40-page doc costs roughly $0.02-0.04, making this economical for document analysis workflows.

I'm explaining our API architecture to a new developer. Rewrite this technical description to be clearer for someone with 2 years of experience: 'The ingestion pipeline leverages a distributed event-driven architecture with eventual consistency guarantees, utilizing CQRS patterns across bounded contexts.'

Our data ingestion system works like this: when data comes in, it triggers events that different services listen for and process independently. This means the system doesn't wait for everything to finish before moving on—services update their own data stores at their own pace, so there's a brief delay before all parts of the system reflect the same information. We separate write operations (commands) from read operations (queries) to optimize each differently, and we keep related business logic grouped together in separate modules.

Shows the model's ability to adjust technical depth for specific audiences. The output pricing ($0.17/Mtok) is higher than some alternatives, so this works best for scenarios where the 131K context window or specific model characteristics justify the cost over cheaper options.

When gpt-oss-120b runs your employee handbook bot for pennies

A 50-person startup wants a Slack bot that answers benefits and PTO questions by searching a 60-page handbook. gpt-oss-120b fits because you can load the entire handbook into the 131k context window alongside the employee's question, and the $0.04 input rate means each query costs a fraction of a cent even with the full document in-context. You'll handle 500 questions a month for under $5 in API costs. The model won't hallucinate policy details if the answer is in the provided text, and it writes clear two-paragraph responses that feel human enough for internal use. If your team asks fewer than 20 questions daily and you're embedding the source material in every prompt, this model is the correct economic choice over anything with a higher input rate.