Gemini 4 Argon: DeepMinds neues multimodales LLM mit bis zu 1,6 Billionen Parametern
DeepMind hat Gemini 4 Argon veröffentlicht, das neueste Modell der Gemini-Familie. Das multimodale, instruction-getunte LLM ist über eine REST-API und einen gRPC-Endpoint verfügbar.
DeepMind hat soeben Gemini 4 Argon veröffentlicht, die neueste Iteration seiner Gemini-Familie großer Sprachmodelle. Argon ist ein multimodales, instruction-tuned LLM mit bis zu 1,6 Billionen Parametern, das über eine RESTful-API und einen gRPC-Endpunkt zugänglich ist. Kurz gesagt handelt es sich um das ChatGPT-Modell der nächsten Generation, das Text, Code und Bilder verstehen kann, und es steht Entwicklern jetzt nach einem Pay-as-you-go-Preismodell zur Verfügung.
Aus ingenieurstechnischer Sicht gibt es drei Gründe, sich das Thema jetzt genauer anzusehen:
Wer bereits LLM-gestützte Funktionen betreibt, etwa Code-Assistenten, Zusammenfassungswerkzeuge oder Chatbots, kann mit Argon bessere Ergebnisse erzielen, ohne eine umfangreiche Umgestaltung der Infrastruktur vornehmen zu müssen.
Nachfolgend ein minimales End-to-End-Beispiel, das ich auf einer frisch installierten Ubuntu-22.04-VM ausgeführt habe. Die Schritte setzen voraus, dass ein DeepMind-API-Schlüssel (zu finden in der Gemini-Konsole) sowie Python 3.10 oder neuer installiert sind.
DeepMind liefert ein offizielles pip-Paket namens google-gemini aus, das die HTTP-Aufrufe abstrahiert.
python -m venv.venv && source.venv/bin/activate pip install --upgrade pip pip install google-gemini Enter fullscreen mode Exit fullscreen mode Schritt 2 – Einen Hilfs-Wrapper schreiben Ich halte den Client gern schlank und füge die Retry-Logik über tenacity ein. Dieser Ausschnitt zeigt auch, wie man eine Bild-Payload sendet.
import os from google_gemini import GeminiClient from tenacity import retry, stop_after_attempt, wait_exponential API_KEY = os. getenv ( " GEMINI_API_KEY " ) client = GeminiClient ( api_key = API_KEY, model = " gemini-4-argon " ) @retry ( stop = stop_after_attempt ( 3 ), wait = wait_exponential ( multiplier = 1, min = 2, max = 10 )) def ask_gemini ( prompt: str, image_path: str | None = None ): if image_path: with open ( image_path, " rb " ) as f: img_bytes = f. read () response = client. generate ( prompt = prompt, images = [{ " bytes ": img_bytes, " mime_type ": " image/png " }], temperature = 0.2, max_output_tokens = 512, ) else: response = client. generate ( prompt = prompt, temperature = 0.2, max_output_tokens = 512, ) return response. text # Beispielverwendung if __name__ == " __main__ ": q = " Explain the architecture shown in the diagram and generate a Terraform snippet that provisions the described resources. " print ( ask_gemini ( q, image_path = " arch.png " )) Enter fullscreen mode Exit fullscreen mode Schritt 3 – Im großen Maßstab deployen Für den Produktivbetrieb sollte man dies hinter einem Kubernetes-Service mit Autoscaling auf Basis der Anfragelatenz betreiben. In der Regel verwende ich ein Deployment mit einem Sidecar, das Prometheus-Metriken aus der Client-Bibliothek exportiert.
Hier ein gekürztes Manifest:
apiVersion: apps/v1 kind: Deployment metadata: name: gemini‑proxy spec: replicas: 2 selector: matchLabels: app: gemini‑proxy template: metadata: labels: app: gemini‑proxy spec: containers: - name: api image: myregistry.com/gemini‑proxy:latest env: - name: GEMINI_API_KEY valueFrom: secretKeyRef: name: gemini‑secret key: api-key resources: limits: cpu: " 2" memory: " 4Gi" ports: - containerPort: 8080 readinessProbe: httpGet: path: /healthz port: 8080 initialDelaySeconds: 5 periodSeconds: 10 Enter fullscreen mode Exit fullscreen mode Ein paar Tipps:
Da ich die Inferenz-Schicht für das Produkt Code-Assist von Griffin AI Tech aufgebaut habe, jongliere ich ständig mit Latenz, Kosten und Zuverlässigkeit. Gemini 4 Argon trifft einen sweet spot, der es uns ermöglicht, unseren älteren Open-Source-LLM-Stack (ein auf Code fine-tuned 7B-Modell) durch einen Managed Service zu ersetzen, der die Kosten pro Token um etwa 0,15 Cent senkt und die Latenz im 99. Perzentil von 850 ms auf rund 420 ms reduziert.
Allerdings ist es kein Allheilmittel. Die multimodalen Fähigkeiten des Modells befinden sich noch in einem frühen Stadium; die Bild-zu-Text-Pipeline liefert gelegentlich übermäßig ausführliche Beschreibungen. Für geschäftskritische Pipelines kombiniere ich Argon mit einem leichten Verifikationsmodell (beispielsweise einem destillierten 3B-LLM), das Halluzinationen prüft, bevor wir die Ausgabe an nachgelagerte Dienste weitergeben.
Aus Betriebssicht ist der größte Vorteil die verwaltete Sicherheitsschicht. Zuvor verbrachten wir Wochen mit eigenen Prompt-Engineering-Tricks, um zu verhindern, dass das Modell unsichere Code-Snippets erzeugt. Die integrierten Guardrails von Argon ermöglichen es uns, unsere Prompt-Templates zu vereinfachen und uns auf die Skalierung des API-Gateways zu konzentrieren.
Wer LLM-Anbieter für ein neues Produkt bewertet, sollte Argon ganz oben auf die Shortlist setzen, insbesondere wenn Bildverständnis oder engere Kostenkontrolle benötigt werden. Meine Empfehlung ist, mit einem isolierten POC zu beginnen (der obige Code führt in weniger als einer Stunde dorthin), Latenz und Token-Verbrauch unter realistischen Lasten zu messen und dann zu entscheiden, ob man es in den zentralen Microservice integriert oder als reine Burst-Fallback-Lösung vorhält.
Automatisch übersetzt. Das Original auf Englisch ist unten aufklappbar.
Original (Englisch) anzeigen
DeepMind just opened up Gemini 4 Argon, the latest iteration of their Gemini family of large language models. Argon is a multimodal, instruction‑tuned LLM with up to 1.6 trillion parameters, accessible via a RESTful API and a gRPC endpoint. In short, it’s the next‑generation “ChatGPT‑style” model that can understand text, code, and images, and it’s now available to developers under a pay‑as‑you‑go pricing model.
From an engineering standpoint there are three reasons this is worth a look right now:
If you’re already running LLM‑driven features—code assistants, summarizers, or chat‑bots—Argon lets you get better results without a massive infrastructure overhaul.
Below is a minimal end‑to‑end example that I ran on a fresh Ubuntu 22.04 VM. The steps assume you have a DeepMind API key (found in the Gemini console) and Python 3.10+ installed.
DeepMind ships an official google‑gemini pip package that abstracts the HTTP calls.
python -m venv.venv && source.venv/bin/activate pip install --upgrade pip pip install google-gemini Enter fullscreen mode Exit fullscreen mode Step 2 – Write a helper wrapper I like to keep the client thin and inject retry logic via tenacity. This snippet also shows how to send an image payload.
import os from google_gemini import GeminiClient from tenacity import retry, stop_after_attempt, wait_exponential API_KEY = os. getenv ( " GEMINI_API_KEY " ) client = GeminiClient ( api_key = API_KEY, model = " gemini-4-argon " ) @retry ( stop = stop_after_attempt ( 3 ), wait = wait_exponential ( multiplier = 1, min = 2, max = 10 )) def ask_gemini ( prompt: str, image_path: str | None = None ): if image_path: with open ( image_path, " rb " ) as f: img_bytes = f. read () response = client. generate ( prompt = prompt, images = [{ " bytes ": img_bytes, " mime_type ": " image/png " }], temperature = 0.2, max_output_tokens = 512, ) else: response = client. generate ( prompt = prompt, temperature = 0.2, max_output_tokens = 512, ) return response. text # Example usage if __name__ == " __main__ ": q = " Explain the architecture shown in the diagram and generate a Terraform snippet that provisions the described resources. " print ( ask_gemini ( q, image_path = " arch.png " )) Enter fullscreen mode Exit fullscreen mode Step 3 – Deploy at scale For production you’ll want to run this behind a Kubernetes service with autoscaling based on request latency. I typically use a Deployment with a sidecar that exports Prometheus metrics from the client library.
Here’s a trimmed manifest:
apiVersion: apps/v1 kind: Deployment metadata: name: gemini‑proxy spec: replicas: 2 selector: matchLabels: app: gemini‑proxy template: metadata: labels: app: gemini‑proxy spec: containers: - name: api image: myregistry.com/gemini‑proxy:latest env: - name: GEMINI_API_KEY valueFrom: secretKeyRef: name: gemini‑secret key: api-key resources: limits: cpu: " 2" memory: " 4Gi" ports: - containerPort: 8080 readinessProbe: httpGet: path: /healthz port: 8080 initialDelaySeconds: 5 periodSeconds: 10 Enter fullscreen mode Exit fullscreen mode Couple of tips:
Having built the inference layer for Griffin AI Tech’s “Code‑Assist” product, I’m constantly juggling latency, cost, and reliability. Gemini 4 Argon hits a sweet spot that lets us replace our older open‑source LLM stack (a 7B model fine‑tuned on code) with a managed service that reduces per‑token cost by ~0.15 ¢ and cuts 99‑th‑percentile latency from 850 ms to ~420 ms.
That said, it’s not a silver bullet. The model’s multimodal capabilities are still early‑stage; the image‑to‑text pipeline sometimes returns overly verbose descriptions. For mission‑critical pipelines I pair Argon with a lightweight verification model (e.g., a distilled 3B LLM) that checks for hallucinations before we commit the output to downstream services.
From an ops perspective, the biggest win is the managed safety layer. Previously we spent weeks building custom prompt‑engineering tricks to keep the model from generating insecure code snippets. Argon’s built‑in guardrails let us simplify our prompt templates and focus on scaling the API gateway.
If you’re evaluating LLM providers for a new product, I’d put Argon at the top of the shortlist—especially if you need image understanding or tighter cost controls. My recommendation is to start with a sandboxed POC (the code snippet above gets you there in under an hour), measure latency and token usage under realistic loads, and then decide whether to bake it into your core micro‑service or keep it as a “burst‑only” fallback.