New OpenAI models in Cursor: GPT-5.1, Codex, and Codex Mini

🚨 ➜ GPT-5.1 is now available in the API ➜ Pricing remains the same as GPT-5 ➜ New coding models released: gpt-5.1-codex gpt-5.1-codex-mini (optimized for long, complex coding tasks) ➜ Prompt caching extended to 24 hours for faster, cheaper repeated calls

OpenAI released GPT‑5.1 to the API with adaptive reasoning: fewer tokens on simple tasks, deeper thinking on complex ones. It adds 24‑hour prompt caching, faster responses for Priority Processing, and a switch to disable reasoning via reasoning_effort=‘none’. Coding quality is improved with partner input. New tools: apply_patch for structured diffs and a shell interface. Pricing matches GPT‑5, plus gpt‑5.1‑codex variants for agentic coding.

Be careful when you use LLMs because they can make you lazy. The same advice is applicable to OpenAI engineers, who believe that GPT-5 has the potential to resolve problems that have been addressed by mathematics for decades. Everything should be checked twice.

OpenAI and I have one thing in common: we both fail to deliver. But I've finally fulfilled my promise from a year ago. I've simulated the flocking behavior seen in birds and fish. Key takeaways: * Despite how much the C++ community shuns them, macros have their place (especially X macros!). I used them for loading OpenGL procedures (I understand that there are OpenGL loading libraries. I’ll use them when I lose my curiosity). Generally, use of macros indicates an issue with the language. This issue should be fixed with C++26’s reflection; but we all know that C++26 won’t be fully implemented this decade, so we should learn to make do with macros. * You can’t write win32 without emotions. That’s why I’m confident that AI won’t replace me. It can’t replicate the feeling you get when the feature you want is locked behind an undocumented function (SetWindowCompositionAttribute 😠). I’ll be posting again soon! I’ve been developing something of value finally, so stay updated... 🙈

Why PyTorch Won (and why TensorFlow & JAX still matter) PyTorch didn’t "beat" others overnight—it compounded advantages that mattered to researchers and product teams. 1) It felt like Python, not a DSL. Eager execution + clean autograd made iteration and debugging natural. 2) Research first → ecosystem later. Papers, repos, tutorials, and talent created unstoppable gravity. 3) The right abstractions. Tensors → nn.Module → optimizers → dataloaders: simple, composable, scalable. 4) Speed without contortions. PyTorch 2.x’s torch.compile brings large wins with minimal code change. 5) Real paths to prod. TorchScript/TorchServe/ONNX/quantization/mobile: ship without a painful rewrite. 6) Broad hardware support. Great CUDA from day one, plus Apple/AMD/accelerator backends. 7) Open governance & community. Fast fixes, great examples, vibrant OSS culture. Where TensorFlow still shines Mature production stack: TFX, TF Serving, TFMA, TF Data Validation—tight MLOps integration end-to-end. Edge & mobile: TF Lite is battle-tested across devices and chipsets. Keras ergonomics: High-level APIs for teams standardizing training loops quickly. Enterprise scale: Multi-lang bindings and long-standing infra support in large orgs. Where JAX is a superpower Composable transforms: jit, vmap, pmap, grad stack elegantly; write math once, scale from laptop to pods. Performance via XLA: Aggressive compilation + SPMD sharding (pjit) for state-of-the-art training speed. Functional clarity: Pure functions reduce hidden state; great for novel optimizer/algorithm research. Lean, modern ecosystems: Flax/Haiku/Equinox + strong TPU integration. Pragmatic take Research velocity & hiring: PyTorch. Mobile/edge & enterprise pipelines: TensorFlow/TFX + TF Lite. Large-scale training & algorithmic tinkering: JAX (especially with TPUs). The real win is choosing the stack that minimizes cognitive overhead and maximizes iteration speed for your team. What did each framework make easier—or harder—for you?👇 #PyTorch #TensorFlow #JAX #DeepLearning #MachineLearning #AI #MLOps #DataScience #Engineering

#OpenAI just published a great example on building a coding agent with GPT-5.1. With Context7 and its MCP server, the model can work with much larger codebases, deeper reasoning, and longer workflows. I think, making it perfect for serious development work. https://lnkd.in/gwBurBaX

Another lesson in AI rendering: Get to know your coding skills. What you think might be really easy generally isn't. LLMs tend to publish in JSON streams, so rendering results for additional action takes some extra code.

If you're looking to transition into the world of LLMs and foundation models, understanding the core Transformer architecture is non-negotiable. Building ViT is a perfect way to do it, as it applies the Transformer—originally designed for text—to images. By coding it layer by layer, you solidify concepts like: ➡️ Multi-Head Self-Attention: How the model focuses on different image patches. ➡️ Patch Embeddings: Turning images into a sequence of tokens, just like words. ➡️ Layer Normalization & MLP Blocks: The essential components for stable training. ➡️ The [CLS] Token: How we get a single representation for classification. I built it with a modular design, making it easy to tinker with and understand each component's role. This foundational knowledge is directly transferable to understanding BERT, GPT, and the latest large language models. If you're on a similar learning path, I highly recommend this exercise. It turns abstract papers into tangible, runnable code. Check out the code in the repo below and star ⭐ if you find it helpful! #VisionTransformer #ViT #TransformerArchitecture #AIFromScratch #DeepLearning #ComputerVision #ArtificialIntelligence #MachineLearning #LLM #LargeLanguageModels #GPT #BERT #AIEngineering #MLOps #LearnAI #CodeNewbie #Python #PyTorch #TensorFlow #NeuralNetworks #SelfAttention #TechLearning #BuildInPublic

HOSTKEY Launches GPT-OSS:120B - OpenAI's Open-Weight Reasoning Model We've deployed GPT-OSS:120B on our infrastructure - OpenAI's first open-weight model since GPT-2, featuring 117B parameters with 5.1B active via Mixture-of-Experts architecture. The model achieves near-parity with OpenAI o4-mini on reasoning benchmarks while running efficiently on a single 80GB GPU. Key capabilities: configurable reasoning effort (low/medium/high) for latency-performance tradeoffs, full chain-of-thought visibility for debugging and native support for tool use, web browsing and Python execution. The model excels at competition coding (Codeforces), general problem solving (MMLU), and even outperforms o4-mini on health queries and competition mathematics (AIME 2024/2025). Apache 2.0 license enables unrestricted commercial deployment. 🚀 Ready to deploy OpenAI-grade reasoning on your infrastructure? HOSTKEY's implementation offers: 🔹 Dedicated H100 80GB servers with instant deployment 🔹 Pre-configured environments with vLLM optimization 🔹 Supported 24/7 - we are always ready to help Get started with GPT-OSS:120B: https://lnkd.in/etWiY-wK Other pre-installed LLMs are available here: : https://lnkd.in/e7abXAr3 #AI #OpenAI #GPT #OpenSource #MixtureOfExperts #MLOps

"Our in-house models now generate more code than almost any other LLMs in the world." For awhile, I thought Cursor was going to get disrupted by the big AI labs who are vertically integrating their own coding models and browser/CL tools. But this line and how delightful Cursor's Composer model is reveals that they're not slowing down at all.