Bygg med CometAPITrenger du ett API for flere modeller?Test arbeidsflyten i Playground, og opprett deretter en API-nøkkel når modellen og kostnaden passer bruksområdet ditt.
Google Antigravity vs. Cursor 2.0: Hvilken IDE bør du velge i 2025? - CometAPI
Google Antigravity vs. Cursor 2.0: Hvilken IDE bør du velge i 2025?
Sent i 2025 tok det AI-assisterte utviklingslandskapet et nytt stort skritt: Google lanserte Antigravity, en «agent-først» utviklingsplattform bygget rundt
Sent i 2025 tok det AI-assisterte utviklingslandskapet et nytt stort skritt: Google lanserte antigravitasjon, en «agent-først» utviklingsplattform bygget rundt Gemini 3 Pro, og Cursor ble levert Markør 2.0 med Composer-modellen og et nytt grensesnitt for flere agenter. Begge lover å endre hvordan programvareteam bygger programvare med AI – men de tar forskjellige designbeslutninger, avveininger og retter seg mot litt forskjellige arbeidsflyter.
Hva er Google Antigravity, og hva er kjernefunksjonene?
Google-posisjoner som en full utvikling snarere enn bare en assistent: en IDE + «Manager»-overflate hvor autonome agenter kan genereres, observeres og orkestreres på tvers av editorer, terminaler og innebygde nettlesere. Designmålet er å la agenter planlegge, utføre, verifisere og iterere på flertrinnsoppgaver samtidig som de produserer menneskevennlige artefakter som beviser hva de gjorde og hvorfor. Antigravity leveres i en offentlig forhåndsvisning på tvers av Windows, macOS og Linux og inkluderer modellvalg (Gemini 3 Pro som standard, pluss valgfrie Sonnet-/tredjepartsmodeller).
Gjennomgått for klarhet, kildeangivelse og gjeldende API-terminologi.
antigravitasjon
plattform
Viktige funksjoner (i korte trekk)
Agent-først Manager-overflate — et brukergrensesnitt for oppdragskontroll for å starte, orkestrere og observere flere agenter på tvers av arbeidsområder (samtidige, langvarige jobber).
Redigeringsvisning + agentsidepanel – en kjent IDE-opplevelse med tett agentintegrasjon for synkrone arbeidsflyter.
Artefakter (bevis på arbeid) — agenter genererer strukturerte leveranser (oppgaveplaner, implementeringsplaner, skjermbilder, nettlesergjennomganger) slik at mennesker raskt kan validere resultater i stedet for å analysere lange rålogger.
Nettleserautomatisering og DOM-fangst – agenter kan kontrollere en innebygd nettleser, ta opp opptak og samhandle med side-DOM for verifisering og ende-til-ende-testing.
Modellvalg og kvoter – Gemini 3 Pro er flaggskipmodellen, med alternativer for andre modeller; Google tilbyr «sjenerøse» prisgrenser i den offentlige forhåndsvisningen.
Arkitektur og ergonomi for utviklere
Antigravity er ment som en plattform med egne meninger: agenter er førsteklasses borgere, som har tilgang til editoren, terminalen og nettleseren på en kontrollert måte. Plattformen eksponerer autonomikontroller – terminalutførelsesregler (Av / Auto / Turbo) og gjennomgå retningslinjer (Fortsett alltid / Agent bestemmer / Be om gjennomgang) – slik at team kan justere hvor mye fullmakt de gir agenter før menneskelig godkjenning. Brukergrensesnittet vektlegger artefakter og kommenterbar tilbakemelding, og speiler en gjennomgangsflyt i dokumentstil i stedet for rå verktøylogger.
Hva er Cursor 2.0, og hva er kjernefunksjonene?
Cursor startet som en AI-først kodeeditor bygget rundt ideen om «vibe coding» – å holde ingeniører i flyt med en editor som forstår hele kodebaser. Markør 2.0 (utgitt sent i oktober 2025) er en evolusjon: et nytt agentgrensesnitt + Komponer, Cursors første innebygde kodemodell designet spesielt for agentinteraksjoner. Viktige påstander inkluderer betydelig lavere latens, utførelse av flere agenter og integrert nettlesertesting.
Kjerneevner
KomponistmodellCursor utviklet Composer som en modell for grensekoding optimalisert for lav latens og de «korte, iterative svingene» som er typiske for interaktiv koding. Cursor hevder at Composer er omtrent 4 ganger raskere enn tilsvarende kapable modeller på arbeidsbelastningene deres; den er trent med verktøytilgang som semantisk kodesøk og redigeringsprimitiver (deres publiserte materialer legger vekt på RL-stil trening på ingeniøroppgaver).
MultiagentgrensesnittCursor 2.0 introduserer en sidefelt og planleggingsfunksjon der du kan kjøre opptil åtte agenter parallelt mot isolerte arbeidstrær eller eksterne maskiner for å unngå sammenslåingskonflikter. Brukergrensesnittet er bygget rundt lett parallellisme, slik at agenter kan jobbe med separate oppgaver samtidig.
Innebygd nettleserverktøyCursor la til en innebygd nettleser som lar agenter inspisere DOM-en, kjøre ende-til-ende frontend-tester og iterere til den produserte utdataen tilfredsstiller interaktive kontroller – i likhet med Antigravitys nettleserintegrasjoner, men implementert i Cursors skrivebords-/VS Code-miljø.
Hvordan er de to plattformene sammenlignet med agentorkestrering og skala?
Hvilken plattform håndterer arbeidsflyter med flere agenter bedre?
Antigravitasjon: Utviklet fra grunnen av som «agent-først». Den gir oppdragskontroll for potensielt mange agenter, muligheten til å gi agenter tilgang til verktøyflater (editor, terminal, nettleser) og generering av artefakter for sporbarhet. Det gjør den sterk for stor, tverrfunksjonell agentorkestrering og komplekse automatiseringsrørledninger.
Markør 2.0: Støtter også arbeidsflyter med flere agenter, men med sterkere vekt på sikkerhet gjennom isolerte arbeidstrær og tett Git-integrasjon. Markørens parallellitet (f.eks. kjøring av flere agenter på tvers av isolerte kodekopier) er konstruert for å unngå filkonflikter og gjøre eksperimentering med flere agenter trygg og rask.
Verdict: Hvis ditt primære krav er agentorkestrering på oppdragsnivå på tvers av mange verktøyflater med rik artefaktsporing, heller Antigravity mot den visjonen. Hvis du i stedet ønsker rask iterativ eksperimentering med flere agenter begrenset til utviklerarbeidsflyter og Git-sikkerhet, er Cursors tilnærming mer konservativ og praktisk.
Antigravitasjon vs. markør 2.0 – Funksjonssammenligning
Aspekt / Funksjon
Google Antigravitasjon
Markør 2.0 (Komponist + Agenter)
Kjernemotor / modell
Bruker Gemini 3 Pro (med et veldig stort kontekstvindu)
Bruker den proprietære «Composer»-modellen optimalisert for koding + støtter veksling mellom flere modeller (Composer, andre LLM-er)
Agent-/multigentstøtte
Agent-først-plattform: sentralt «Agent Manager»-grensesnitt for å opprette/orkestrere agenter på tvers av oppgaver, arbeidsområder og kontekster. Agenter opererer autonomt via redigeringsprogram, terminal og nettleser.
Støtte for flere agenter med opptil ~8 parallelle agenter (isolert via git-arbeidstrær eller sandkassede arbeidsområder) for parallelle oppgaver: koding, testing, refaktorering osv.
Arbeidsflytstil / filosofi
Mer «agent-først»: du delegerer oppgaver på høyt nivå, og agenter planlegger + utfører + tester + produserer eventuelt visuelle/nettleserartefakter. Du fører tilsyn.
Mer «utviklerassistert/hybrid»: AI akselererer koding, refaktorering og tester, men mennesket er fortsatt sentralt; bedre for trinnvise redigeringer, rask prototyping eller manuelle gjennomgangsarbeidsflyter.
Nettleser / Testing / Verktøyintegrasjon
Sterk automatisering: agenter kan bruke nettleseren (via utvidelse), kjøre terminalkommandoer, utføre tester, starte webapper – fullstendige «bygg → kjør → valider»-løkker i miljøet. Artefakter som skjermbilder/nettleseropptak støttes for verifisering.
Innebygd nettleser + sandkasseterminal, som tillater inspeksjon av brukergrensesnitt (f.eks. DOM-inspeksjon), gjennomgang av resultater i redigeringsprogrammet. Bra for raskere iterasjon og innebygde redigeringer + tester.
Synlighet, revisjon og artefaktutdata
Agenter produserer omfattende artefakter: utførelsesplaner, testresultater, nettleseropptak/skjermbilder, differanser – som gir åpenhet og enklere gjennomgang av hva agenten gjorde.
Fokuset er på kodedifferanser og git-stil gjennomgang. Endringer er synlige via diff-utganger; mindre «visuelle bevis» (ingen automatiske opptak).
Hvordan er de sammenlignet med modell- og beregningsvalg?
Hvilke modeller bruker de, og kan man koble til sine egne?
antigravitasjon er tett koblet til Gemini 3 Pro i design (Googles flaggskip), med førsteklasses støtte, men også muligheten til å utnytte andre modeller. Det gir Google fordelen når du ønsker dype Gemini-optimaliseringer (forsinkelse, verktøytilgang, spesialiserte funksjoner).
Markør 2.0 leverer sin egen Composer-modell – optimalisert for koding og agentoppgaver – og vektlegger rask inferens og praktisk gjennomstrømning for utvikleroppgaver. Cursor forblir også modelluavhengig i mange integrasjoner, slik at team kan velge modellen som passer best til kostnads- og nøyaktighetskrav.
Verdict: Forvent at Antigravity vil skinne når Gemini-spesifikke funksjoner er viktige (verktøysynergi, LLM-native grensesnitt). Cursors Composer sikter mot kostnadseffektiv hastighet og et mindre latensavtrykk, justert for kodeoppgaver.
Hvordan er de sammenlignet med utviklererfaring og integrasjoner?
Hvordan er følelsen i redigeringsprogrammet og de eksterne integrasjonene?
Antigravitasjon: Editoren ligner et kjent IDE, men med sidefelt for agenter og artefaktoppretting. Den tar sikte på dyp integrasjon på tvers av editor, terminal og nettleser, slik at agenter kan operere på tvers av hele utviklingsstakken. Dette kan redusere kontekstbytte dramatisk når agenter er klarert til å kjøre tester, oppdatere filer og demonstrere atferd via innspilte nettleserøkter.
Markør 2.0: Føles som en AI-drevet IDE bygget spesielt for team som ønsker å beholde vanlige utviklingsverktøy og Git-flyter først. Multiagent-editoren bruker isolerte arbeidstrær og integrerer AI-kodegjennomgang, noe som gjør det enklere å integrere agentresultater via standard PR-flyter. Markøren vektlegger sikkert samarbeid mellom mennesker og agenter.
Hvilken integreres bedre med eksisterende CI/CD og bedriftsverktøy?
Begge plattformene er eksplisitt utformet for å bli integrert:
Markøren legger vekt på integrasjoner med Git-leverandører og kodegjennomgangsfunksjoner på redigeringsnivå som integreres direkte i utviklerpipeliner.
Antigravitys artefaktsystem og bredere verktøytilgang gjør det konseptuelt kraftig for å automatisere ende-til-ende-flyter (f.eks. automatisert E2E-testing, nettleserinteraksjoner), men det krever også nøye styring på bedriftsnivå.
Verdict: For team som ønsker lavfriksjonsintegrasjon i eksisterende Git/CI-flyter, er Cursor 2.0 mer umiddelbart plug-and-play. Antigravity tilbyr mer transformativt automatiseringspotensial, men med høyere styrings- og integrasjonskostnader.
Praktiske eksempler: bruk av antigravitasjon og markør (illustrativ kode)
Nedenfor er illustrerende eksempler som viser hvordan team kan samhandle med hver plattform. Disse eksemplene er pseudo / konseptuelle utdrag ment å demonstrere typiske arbeidsflyter; se de offisielle dokumentene når du implementerer produksjonsautomatisering. (Refererte dokumenter og kodelabber er lenket i kildene.)
Eksempel 1 – Definisjon av antigravitasjonsoppdrag (illustrativ JSON)
Dette eksemplet viser hvordan en utvikler kan definere et oppdrag som instruerer en Antigravity-agent til å legge til et nytt API-endepunkt, kjøre tester og produsere artefakter.
{
"mission_name": "add_user_endpoint_v1",
"description": "Create POST /api/users endpoint, unit tests, and run CI.",
"agents": [
{
"name": "PlanAgent",
"role": "create a step-by-step plan",
"prompt": "Create tasks to add a users API: router, handler, tests, docs."
},
{
"name": "CoderAgent",
"role": "implement code",
"permissions": ,
"model": "gemini-3-pro"
},
{
"name": "VerifierAgent",
"role": "run tests and verify results",
"permissions":
}
],
"artifact_policy": {
"capture_screenshots": true,
"record_terminal": true,
"log_level": "verbose"
}
}
Merknader: Antigravitys artefaktgenerering er en eksplisitt funksjon som er utviklet for å gjøre agenthandlinger inspiserbare og dokumenterbare.
Eksempel 2 – parallelle agenter i Cursor Composer (illustrativ Python)
Cursor 2.0 vektlegger isolerte arbeidstrær slik at parallelle agenter ikke kommer i konflikt. Følgende pseudokode demonstrerer oppstart av to agenter for å implementere en funksjon og en test parallelt, og deretter sammenslåing av resultater via git.
# Pseudocode - illustrative only
from cursor_sdk import CursorClient
client = CursorClient(api_key="CURSOR_API_KEY", model="composer-v1")
# create isolated worktrees for each agent
agent_a = client.spawn_agent(name="feature_impl", worktree="worktree-feature")
agent_b = client.spawn_agent(name="tests_impl", worktree="worktree-tests")
# send tasks
agent_a.run("Add POST /api/users handler and update router. Create basic validation.")
agent_b.run("Create unit and integration tests for POST /api/users.")
# wait for agents to finish and fetch patches
patch_a = agent_a.get_patch()
patch_b = agent_b.get_patch()
# apply patches to local branches, run tests locally, open PRs
apply_patch_to_branch("feature/users", patch_a)
apply_patch_to_branch("feature/users-tests", patch_b)
# run CI locally
run_command("pytest -q")
# create PRs for human review
create_pr("feature/users", base="main", title="feat: add users endpoint")
create_pr("feature/users-tests", base="main", title="test: add users tests")
Merknader: Cursors isolerte arbeidstrær og Git-integrasjon er sentrale i designet – dette reduserer sammenslåingskonflikter og gjør endringer reviderbare i standard PR-arbeidsflyter.
Konklusjon
Antigravity og Cursor 2.0 representerer to fornuftige svar på det samme problemet: hvordan integrerer vi kraftige LLM-agenter i daglig programvareutvikling? Antigravity har en bredere, målrettet visjon som behandler agenter som autonome lagkamerater på tvers av editorer, terminaler og nettlesere. Cursor 2.0 velger en målrettet, utviklersentrisk tilnærming som setter Git og kodegjennomgang i sentrum, samtidig som den muliggjør rask eksperimentering med flere agenter.
Begge deler er betydelige fremskritt. For team vil avgjørelsen avhenge av om dere ønsker transformasjonsautomatisering (og kan absorbere styringskostnadene) eller trinnvise, tett integrerte produktivitetsgevinster. Uansett, æraen med agentutvikling er her – og det vil belønne team som behandler sikkerhet, observerbarhet og verifisering av mennesker i loopen som førsteklasses bekymringer.
Utviklere kan få tilgang til det nyeste LLM API-et, for eksempel Claude Opus 4.5 og Gemini 3 Pro osv. gjennom CometAPI, den nyeste modellversjonen er alltid oppdatert med den offisielle nettsiden. For å begynne, utforsk modellens muligheter i lekeplass og konsulter API-veiledning for detaljerte instruksjoner. Før du får tilgang, må du sørge for at du har logget inn på CometAPI og fått API-nøkkelen. CometAPI tilby en pris som er langt lavere enn den offisielle prisen for å hjelpe deg med å integrere.
Hvis du vil vite flere tips, guider og nyheter om AI, følg oss på VK, X og Discord!
Hastighet / Latens / Responsivitet
På grunn av den agent-fokuserte, tunge verktøyorkestreringen kan det føles mer tungt; oppgaver kan ta lengre tid enn veldig raske autofullføringslignende redigeringer (spesielt for komplekse oppgaver). Tidlige rapporter advarer om sporadiske nedbremsinger eller «agentkrasj/frakoblinger».
Optimalisert for hastighet: Parallellitet mellom komponist og multiagent er finjustert for rask iterasjon og raske kodesykluser. Bra for rask prototyping og trinnvise redigeringer.
Ideelle brukstilfeller / Beste passform
Passer for store, komplekse oppgaver: fullstack-funksjonsgenerering, flertrinns arbeidsflyter, nettleserbaserte brukergrensesnitt + integrasjonsoppgaver, der du ønsker ende-til-ende-automatisering og testing. Også nyttig når du ønsker revideringsmuligheter og artefaktspor.
Bra for mindre team, rask prototyping, trinnvise kodeendringer, hyppige refaktoreringer – når du ønsker raske resultater og redigering med fokus på menneskelig innsats. Fungerer spesielt bra når du ønsker minimal forstyrrelse og samtidig opprettholder kontroll.
