diff --git a/src/main/kotlin/no/nav/syfo/KafkaModule.kt b/src/main/kotlin/no/nav/syfo/KafkaModule.kt
index 617cf620..8e384edc 100644
--- a/src/main/kotlin/no/nav/syfo/KafkaModule.kt
+++ b/src/main/kotlin/no/nav/syfo/KafkaModule.kt
@@ -4,6 +4,7 @@ import no.nav.syfo.aktivitetskrav.VurderStansService
 import no.nav.syfo.aktivitetskrav.kafka.launchKafkaTaskAktivitetskravExpiredVarsel
 import no.nav.syfo.aktivitetskrav.kafka.launchKafkaTaskAktivitetskravVurdering
 import no.nav.syfo.arbeidsuforhet.VurderAvslagService
+import no.nav.syfo.arbeidsuforhet.kafka.ArbeidsuforhetVurderingConsumer
 import no.nav.syfo.arbeidsuforhet.kafka.ExpiredForhandsvarselConsumer
 import no.nav.syfo.behandler.kafka.sykmelding.launchKafkaTaskSykmelding
 import no.nav.syfo.behandlerdialog.AvvistMeldingService
@@ -128,13 +129,21 @@ fun launchKafkaTasks(
         personOppgaveRepository = personOppgaveRepository,
     )
 
+    val vurderAvslagService = VurderAvslagService(
+        database = database,
+        personOppgaveRepository = personOppgaveRepository
+    )
+
     val expiredForhandsvarselConsumer = ExpiredForhandsvarselConsumer(
         kafkaEnvironment = environment.kafka,
         applicationState = applicationState,
-        vurderAvslagService = VurderAvslagService(
-            database = database,
-            personOppgaveRepository = personOppgaveRepository
-        )
+        vurderAvslagService = vurderAvslagService
     )
     expiredForhandsvarselConsumer.launch()
+    val arbeidsuforhetVurderingConsumer = ArbeidsuforhetVurderingConsumer(
+        kafkaEnvironment = environment.kafka,
+        applicationState = applicationState,
+        vurderAvslagService = vurderAvslagService,
+    )
+    arbeidsuforhetVurderingConsumer.launch()
 }
diff --git a/src/main/kotlin/no/nav/syfo/arbeidsuforhet/VurderAvslagService.kt b/src/main/kotlin/no/nav/syfo/arbeidsuforhet/VurderAvslagService.kt
index b1ea5577..f71a0806 100644
--- a/src/main/kotlin/no/nav/syfo/arbeidsuforhet/VurderAvslagService.kt
+++ b/src/main/kotlin/no/nav/syfo/arbeidsuforhet/VurderAvslagService.kt
@@ -1,11 +1,16 @@
 package no.nav.syfo.arbeidsuforhet
 
 import io.micrometer.core.instrument.Counter
+import no.nav.syfo.arbeidsuforhet.kafka.ArbeidsuforhetVurdering
 import no.nav.syfo.arbeidsuforhet.kafka.ExpiredForhandsvarsel
+import no.nav.syfo.arbeidsuforhet.kafka.behandler
 import no.nav.syfo.database.PersonOppgaveRepository
 import no.nav.syfo.database.DatabaseInterface
+import no.nav.syfo.domain.PersonIdent
 import no.nav.syfo.metric.METRICS_NS
 import no.nav.syfo.metric.METRICS_REGISTRY
+import no.nav.syfo.personoppgave.domain.PersonOppgaveType
+import no.nav.syfo.personoppgave.domain.behandleAndReadyForPublish
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
 
@@ -35,6 +40,32 @@ class VurderAvslagService(private val database: DatabaseInterface, private val p
         }
     }
 
+    fun processArbeidsuforhetVurdering(vurderingList: List<ArbeidsuforhetVurdering>) {
+        database.connection.use { connection ->
+            vurderingList.forEach { vurdering ->
+                log.info("Received vurdering with uuid=${vurdering.uuid} and type=${vurdering.type}")
+                val oppgaveType = PersonOppgaveType.ARBEIDSUFORHET_VURDER_AVSLAG
+                val ubehandledeOppgaver = personOppgaveRepository.getUbehandledePersonoppgaver(
+                    connection = connection,
+                    personIdent = PersonIdent(vurdering.personident),
+                    type = oppgaveType,
+                )
+                if (ubehandledeOppgaver.size > 1) {
+                    log.error("Found more than one ubehandlet $oppgaveType oppgave for person")
+                }
+
+                ubehandledeOppgaver.forEach { oppgave ->
+                    if (vurdering behandler oppgave) {
+                        val behandletOppgave = oppgave.behandleAndReadyForPublish(veilederIdent = vurdering.veilederident)
+                        personOppgaveRepository.updatePersonoppgaveBehandlet(personOppgave = behandletOppgave, connection = connection)
+                        COUNT_PERSONOPPGAVE_UPDATED_FROM_ARBEIDSUFORHET_VURDERING.increment()
+                    }
+                }
+            }
+            connection.commit()
+        }
+    }
+
     companion object {
         private val log: Logger = LoggerFactory.getLogger(this::class.java)
         private const val ARBEIDSUFORHET_EXPIRED_FORHANDSVARSEL_PERSON_OPPGAVE_CREATED =
@@ -43,5 +74,11 @@ class VurderAvslagService(private val database: DatabaseInterface, private val p
             Counter.builder(ARBEIDSUFORHET_EXPIRED_FORHANDSVARSEL_PERSON_OPPGAVE_CREATED)
                 .description("Counts the number of personoppgaver created from arbeidsuforhet expired forhandsvarsel")
                 .register(METRICS_REGISTRY)
+        private const val PERSONOPPGAVE_UPDATED_FROM_ARBEIDSUFORHET_VURDERING =
+            "${METRICS_NS}_arbeidsuforhet_vurdering_mottatt_count"
+        val COUNT_PERSONOPPGAVE_UPDATED_FROM_ARBEIDSUFORHET_VURDERING: Counter =
+            Counter.builder(PERSONOPPGAVE_UPDATED_FROM_ARBEIDSUFORHET_VURDERING)
+                .description("Counts the number of personoppgaver updated from incoming arbeidsuforhet vurdering")
+                .register(METRICS_REGISTRY)
     }
 }
diff --git a/src/main/kotlin/no/nav/syfo/arbeidsuforhet/kafka/ArbeidsuforhetVurdering.kt b/src/main/kotlin/no/nav/syfo/arbeidsuforhet/kafka/ArbeidsuforhetVurdering.kt
new file mode 100644
index 00000000..964b82a3
--- /dev/null
+++ b/src/main/kotlin/no/nav/syfo/arbeidsuforhet/kafka/ArbeidsuforhetVurdering.kt
@@ -0,0 +1,28 @@
+package no.nav.syfo.arbeidsuforhet.kafka
+
+import no.nav.syfo.personoppgave.domain.PersonOppgave
+import no.nav.syfo.util.toLocalDateTimeOslo
+import java.time.OffsetDateTime
+import java.util.*
+
+data class ArbeidsuforhetVurdering(
+    val uuid: UUID,
+    val personident: String,
+    val createdAt: OffsetDateTime,
+    val veilederident: String,
+    val type: VurderingType,
+    val begrunnelse: String,
+)
+
+enum class VurderingType {
+    FORHANDSVARSEL, OPPFYLT, AVSLAG
+}
+
+infix fun ArbeidsuforhetVurdering.behandler(personOppgave: PersonOppgave): Boolean =
+    this.isFinal() && this.createdAt.toLocalDateTimeOslo().isAfter(personOppgave.opprettet)
+
+private fun ArbeidsuforhetVurdering.isFinal(): Boolean = when (type) {
+    VurderingType.FORHANDSVARSEL -> false
+    VurderingType.OPPFYLT -> true
+    VurderingType.AVSLAG -> true
+}
diff --git a/src/main/kotlin/no/nav/syfo/arbeidsuforhet/kafka/ArbeidsuforhetVurderingConsumer.kt b/src/main/kotlin/no/nav/syfo/arbeidsuforhet/kafka/ArbeidsuforhetVurderingConsumer.kt
new file mode 100644
index 00000000..a7705eab
--- /dev/null
+++ b/src/main/kotlin/no/nav/syfo/arbeidsuforhet/kafka/ArbeidsuforhetVurderingConsumer.kt
@@ -0,0 +1,56 @@
+package no.nav.syfo.arbeidsuforhet.kafka
+
+import no.nav.syfo.ApplicationState
+import no.nav.syfo.EnvironmentKafka
+import no.nav.syfo.arbeidsuforhet.VurderAvslagService
+import no.nav.syfo.kafka.KafkaConsumerService
+import no.nav.syfo.kafka.kafkaAivenConsumerConfig
+import no.nav.syfo.kafka.launchKafkaTask
+import org.apache.kafka.clients.consumer.ConsumerRecords
+import org.apache.kafka.clients.consumer.KafkaConsumer
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
+import java.time.Duration
+
+class ArbeidsuforhetVurderingConsumer(
+    private val kafkaEnvironment: EnvironmentKafka,
+    private val applicationState: ApplicationState,
+    private val vurderAvslagService: VurderAvslagService,
+) : KafkaConsumerService<ArbeidsuforhetVurdering> {
+    override val pollDurationInMillis: Long = 1000
+
+    override fun pollAndProcessRecords(kafkaConsumer: KafkaConsumer<String, ArbeidsuforhetVurdering>) {
+        val records = kafkaConsumer.poll(Duration.ofMillis(pollDurationInMillis))
+        if (records.count() > 0) {
+            log.info("ArbeidsuforhetVurderingConsumer trace: Received ${records.count()} records")
+            processRecords(records)
+            kafkaConsumer.commitSync()
+        }
+    }
+
+    private fun processRecords(records: ConsumerRecords<String, ArbeidsuforhetVurdering>) {
+        val (tombstoneRecords, validRecords) = records.partition { it.value() == null }
+
+        if (tombstoneRecords.isNotEmpty()) {
+            val numberOfTombstones = tombstoneRecords.size
+            log.warn("Value of $numberOfTombstones ConsumerRecord are null, most probably due to a tombstone. Contact the owner of the topic if an error is suspected")
+        }
+
+        vurderAvslagService.processArbeidsuforhetVurdering(vurderingList = validRecords.map { it.value() })
+    }
+
+    fun launch() {
+        val consumerProperties = kafkaAivenConsumerConfig<ArbeidsuforhetVurderingDeserializer>(environmentKafka = kafkaEnvironment)
+        launchKafkaTask(
+            applicationState = applicationState,
+            kafkaConsumerService = this,
+            consumerProperties = consumerProperties,
+            topics = listOf(ARBEIDSUFORHET_VURDERING_TOPIC),
+        )
+    }
+
+    companion object {
+        const val ARBEIDSUFORHET_VURDERING_TOPIC = "teamsykefravr.arbeidsuforhet-vurdering"
+        val log: Logger = LoggerFactory.getLogger(this::class.java)
+    }
+}
diff --git a/src/main/kotlin/no/nav/syfo/arbeidsuforhet/kafka/ArbeidsuforhetVurderingDeserializer.kt b/src/main/kotlin/no/nav/syfo/arbeidsuforhet/kafka/ArbeidsuforhetVurderingDeserializer.kt
new file mode 100644
index 00000000..c9efda67
--- /dev/null
+++ b/src/main/kotlin/no/nav/syfo/arbeidsuforhet/kafka/ArbeidsuforhetVurderingDeserializer.kt
@@ -0,0 +1,10 @@
+package no.nav.syfo.arbeidsuforhet.kafka
+
+import no.nav.syfo.util.configuredJacksonMapper
+import org.apache.kafka.common.serialization.Deserializer
+
+class ArbeidsuforhetVurderingDeserializer : Deserializer<ArbeidsuforhetVurdering> {
+    private val mapper = configuredJacksonMapper()
+    override fun deserialize(topic: String, data: ByteArray): ArbeidsuforhetVurdering =
+        mapper.readValue(data, ArbeidsuforhetVurdering::class.java)
+}
diff --git a/src/test/kotlin/no/nav/syfo/arbeidsuforhet/kafka/ArbeidsuforhetVurderingConsumerSpek.kt b/src/test/kotlin/no/nav/syfo/arbeidsuforhet/kafka/ArbeidsuforhetVurderingConsumerSpek.kt
new file mode 100644
index 00000000..90b4df3a
--- /dev/null
+++ b/src/test/kotlin/no/nav/syfo/arbeidsuforhet/kafka/ArbeidsuforhetVurderingConsumerSpek.kt
@@ -0,0 +1,278 @@
+package no.nav.syfo.arbeidsuforhet.kafka
+
+import io.mockk.clearMocks
+import io.mockk.every
+import io.mockk.mockk
+import io.mockk.verify
+import no.nav.syfo.arbeidsuforhet.VurderAvslagService
+import no.nav.syfo.database.PersonOppgaveRepository
+import no.nav.syfo.personoppgave.domain.*
+import no.nav.syfo.personoppgave.getPersonOppgaver
+import no.nav.syfo.testutil.ExternalMockEnvironment
+import no.nav.syfo.testutil.UserConstants
+import no.nav.syfo.testutil.dropData
+import no.nav.syfo.testutil.generators.generateArbeidsuforhetVurdering
+import no.nav.syfo.testutil.generators.generatePersonoppgave
+import no.nav.syfo.testutil.mock.mockPollConsumerRecords
+import no.nav.syfo.util.toOffsetDateTimeUTC
+import org.amshove.kluent.*
+import org.apache.kafka.clients.consumer.KafkaConsumer
+import org.spekframework.spek2.Spek
+import org.spekframework.spek2.style.specification.describe
+import java.time.LocalDateTime
+import java.time.temporal.ChronoUnit
+import java.util.*
+
+private val vurderingOppfylt = generateArbeidsuforhetVurdering(type = VurderingType.OPPFYLT)
+private val vurderingForhandsvarsel = generateArbeidsuforhetVurdering(type = VurderingType.FORHANDSVARSEL)
+private val vurderingAvslag = generateArbeidsuforhetVurdering(type = VurderingType.AVSLAG)
+
+val oppgaveOpprettet: LocalDateTime = LocalDateTime.now().minusDays(1)
+private val ubehandletVurderAvslagOppgave = generatePersonoppgave(
+    type = PersonOppgaveType.ARBEIDSUFORHET_VURDER_AVSLAG,
+    opprettet = oppgaveOpprettet
+)
+
+class ArbeidsuforhetVurderingConsumerSpek : Spek({
+
+    val externalMockEnvironment = ExternalMockEnvironment()
+    val database = externalMockEnvironment.database
+    val kafkaConsumer = mockk<KafkaConsumer<String, ArbeidsuforhetVurdering>>()
+    val personOppgaveRepository = PersonOppgaveRepository(database = database)
+    val vurderAvslagService = VurderAvslagService(
+        database = database,
+        personOppgaveRepository = personOppgaveRepository
+    )
+
+    val arbeidsuforhetVurderingConsumer = ArbeidsuforhetVurderingConsumer(
+        kafkaEnvironment = externalMockEnvironment.environment.kafka,
+        applicationState = externalMockEnvironment.applicationState,
+        vurderAvslagService = vurderAvslagService,
+    )
+
+    beforeEachTest {
+        every { kafkaConsumer.commitSync() } returns Unit
+    }
+
+    afterEachTest {
+        database.dropData()
+        clearMocks(kafkaConsumer)
+    }
+
+    describe("pollAndProcessRecords") {
+        it("Behandler existing ubehandlet vurder avslag-oppgave when vurdering is OPPFYLT") {
+            personOppgaveRepository.createPersonoppgave(personOppgave = ubehandletVurderAvslagOppgave)
+            kafkaConsumer.mockPollConsumerRecords(
+                recordValue = vurderingOppfylt,
+                topic = ArbeidsuforhetVurderingConsumer.ARBEIDSUFORHET_VURDERING_TOPIC,
+            )
+
+            arbeidsuforhetVurderingConsumer.pollAndProcessRecords(kafkaConsumer = kafkaConsumer)
+
+            verify(exactly = 1) {
+                kafkaConsumer.commitSync()
+            }
+
+            val personOppgave = database.getPersonOppgaver(
+                personIdent = UserConstants.ARBEIDSTAKER_FNR,
+            ).toPersonOppgaver().first()
+            personOppgave.type shouldBeEqualTo PersonOppgaveType.ARBEIDSUFORHET_VURDER_AVSLAG
+            personOppgave.personIdent.value shouldBeEqualTo vurderingOppfylt.personident
+            personOppgave.publish.shouldBeTrue()
+            personOppgave.behandletTidspunkt.shouldNotBeNull()
+            personOppgave.behandletVeilederIdent shouldBeEqualTo vurderingOppfylt.veilederident
+        }
+        it("Behandler existing ubehandlet vurder avslag-oppgave when vurdering is AVSLAG") {
+            personOppgaveRepository.createPersonoppgave(personOppgave = ubehandletVurderAvslagOppgave)
+            kafkaConsumer.mockPollConsumerRecords(
+                recordValue = vurderingAvslag,
+                topic = ArbeidsuforhetVurderingConsumer.ARBEIDSUFORHET_VURDERING_TOPIC,
+            )
+
+            arbeidsuforhetVurderingConsumer.pollAndProcessRecords(kafkaConsumer = kafkaConsumer)
+
+            verify(exactly = 1) {
+                kafkaConsumer.commitSync()
+            }
+
+            val personOppgave = database.getPersonOppgaver(
+                personIdent = UserConstants.ARBEIDSTAKER_FNR,
+            ).toPersonOppgaver().first()
+            personOppgave.type shouldBeEqualTo PersonOppgaveType.ARBEIDSUFORHET_VURDER_AVSLAG
+            personOppgave.personIdent.value shouldBeEqualTo vurderingAvslag.personident
+            personOppgave.publish.shouldBeTrue()
+            personOppgave.behandletTidspunkt.shouldNotBeNull()
+            personOppgave.behandletVeilederIdent shouldBeEqualTo vurderingOppfylt.veilederident
+        }
+        it("Will not behandle when vurdering is FORHANDSVARSEL") {
+            personOppgaveRepository.createPersonoppgave(personOppgave = ubehandletVurderAvslagOppgave)
+            kafkaConsumer.mockPollConsumerRecords(
+                recordValue = vurderingForhandsvarsel,
+                topic = ArbeidsuforhetVurderingConsumer.ARBEIDSUFORHET_VURDERING_TOPIC,
+            )
+
+            arbeidsuforhetVurderingConsumer.pollAndProcessRecords(kafkaConsumer = kafkaConsumer)
+
+            verify(exactly = 1) {
+                kafkaConsumer.commitSync()
+            }
+
+            val personOppgave = database.getPersonOppgaver(
+                personIdent = UserConstants.ARBEIDSTAKER_FNR,
+            ).toPersonOppgaver().first()
+            personOppgave.type shouldBeEqualTo PersonOppgaveType.ARBEIDSUFORHET_VURDER_AVSLAG
+            personOppgave.personIdent.value shouldBeEqualTo vurderingForhandsvarsel.personident
+            personOppgave.publish.shouldBeFalse()
+            personOppgave.behandletTidspunkt.shouldBeNull()
+            personOppgave.behandletVeilederIdent.shouldBeNull()
+        }
+
+        it("Will not behandle when no existing vurder avslag-oppgave") {
+            kafkaConsumer.mockPollConsumerRecords(
+                recordValue = vurderingOppfylt,
+                topic = ArbeidsuforhetVurderingConsumer.ARBEIDSUFORHET_VURDERING_TOPIC,
+            )
+
+            arbeidsuforhetVurderingConsumer.pollAndProcessRecords(kafkaConsumer = kafkaConsumer)
+
+            verify(exactly = 1) {
+                kafkaConsumer.commitSync()
+            }
+
+            val pPersonOppgaver = database.getPersonOppgaver(
+                personIdent = UserConstants.ARBEIDSTAKER_FNR,
+            )
+            pPersonOppgaver.size shouldBeEqualTo 0
+        }
+
+        it("Will not behandle when vurder avslag-oppgave already behandlet") {
+            personOppgaveRepository.createPersonoppgave(personOppgave = ubehandletVurderAvslagOppgave)
+            val behandletOppgave = ubehandletVurderAvslagOppgave.behandle(veilederIdent = UserConstants.VEILEDER_IDENT)
+            personOppgaveRepository.updatePersonoppgaveBehandlet(personOppgave = behandletOppgave)
+
+            kafkaConsumer.mockPollConsumerRecords(
+                recordValue = vurderingOppfylt,
+                topic = ArbeidsuforhetVurderingConsumer.ARBEIDSUFORHET_VURDERING_TOPIC,
+            )
+
+            arbeidsuforhetVurderingConsumer.pollAndProcessRecords(kafkaConsumer = kafkaConsumer)
+
+            verify(exactly = 1) {
+                kafkaConsumer.commitSync()
+            }
+
+            val personOppgaver = database.getPersonOppgaver(
+                personIdent = UserConstants.ARBEIDSTAKER_FNR,
+            ).toPersonOppgaver()
+            personOppgaver.size shouldBeEqualTo 1
+            val personOppgave = personOppgaver.first()
+            personOppgave.type shouldBeEqualTo PersonOppgaveType.ARBEIDSUFORHET_VURDER_AVSLAG
+            personOppgave.personIdent.value shouldBeEqualTo vurderingOppfylt.personident
+            personOppgave.behandletTidspunkt?.truncatedTo(ChronoUnit.MILLIS)!! shouldNotBeGreaterThan behandletOppgave.behandletTidspunkt?.truncatedTo(ChronoUnit.MILLIS)!!
+            personOppgave.behandletVeilederIdent shouldBeEqualTo behandletOppgave.behandletVeilederIdent
+        }
+
+        it("Will not behandle when vurdering is older than existing oppgave") {
+            personOppgaveRepository.createPersonoppgave(personOppgave = ubehandletVurderAvslagOppgave)
+            kafkaConsumer.mockPollConsumerRecords(
+                recordValue = vurderingAvslag.copy(
+                    createdAt = oppgaveOpprettet.minusDays(1).toOffsetDateTimeUTC()
+                ),
+                topic = ArbeidsuforhetVurderingConsumer.ARBEIDSUFORHET_VURDERING_TOPIC,
+            )
+
+            arbeidsuforhetVurderingConsumer.pollAndProcessRecords(kafkaConsumer = kafkaConsumer)
+
+            verify(exactly = 1) {
+                kafkaConsumer.commitSync()
+            }
+
+            val personOppgave = database.getPersonOppgaver(
+                personIdent = UserConstants.ARBEIDSTAKER_FNR,
+            ).toPersonOppgaver().first()
+            personOppgave.type shouldBeEqualTo PersonOppgaveType.ARBEIDSUFORHET_VURDER_AVSLAG
+            personOppgave.personIdent.value shouldBeEqualTo vurderingAvslag.personident
+            personOppgave.publish.shouldBeFalse()
+            personOppgave.behandletTidspunkt.shouldBeNull()
+            personOppgave.behandletVeilederIdent.shouldBeNull()
+        }
+
+        it("Will not behandle when vurdering personident differs from ubehandlet oppgave personident") {
+            personOppgaveRepository.createPersonoppgave(personOppgave = ubehandletVurderAvslagOppgave)
+            val vurderingOtherPerson = vurderingOppfylt.copy(personident = UserConstants.ARBEIDSTAKER_3_FNR.value)
+            kafkaConsumer.mockPollConsumerRecords(
+                recordValue = vurderingOtherPerson,
+                topic = ArbeidsuforhetVurderingConsumer.ARBEIDSUFORHET_VURDERING_TOPIC,
+            )
+
+            arbeidsuforhetVurderingConsumer.pollAndProcessRecords(kafkaConsumer = kafkaConsumer)
+
+            verify(exactly = 1) {
+                kafkaConsumer.commitSync()
+            }
+
+            val personOppgave = database.getPersonOppgaver(
+                personIdent = UserConstants.ARBEIDSTAKER_FNR,
+            ).toPersonOppgaver().first()
+            personOppgave.type shouldBeEqualTo PersonOppgaveType.ARBEIDSUFORHET_VURDER_AVSLAG
+            personOppgave.personIdent.value shouldNotBeEqualTo vurderingOtherPerson.personident
+            personOppgave.publish.shouldBeFalse()
+            personOppgave.behandletTidspunkt.shouldBeNull()
+            personOppgave.behandletVeilederIdent.shouldBeNull()
+        }
+
+        it("Will not behandle if existing oppgave is not vurder avslag") {
+            val ubehandletVurderStansOppgave = generatePersonoppgave(
+                type = PersonOppgaveType.AKTIVITETSKRAV_VURDER_STANS,
+                opprettet = oppgaveOpprettet
+            )
+
+            personOppgaveRepository.createPersonoppgave(personOppgave = ubehandletVurderStansOppgave)
+            kafkaConsumer.mockPollConsumerRecords(
+                recordValue = vurderingOppfylt,
+                topic = ArbeidsuforhetVurderingConsumer.ARBEIDSUFORHET_VURDERING_TOPIC,
+            )
+
+            arbeidsuforhetVurderingConsumer.pollAndProcessRecords(kafkaConsumer = kafkaConsumer)
+
+            verify(exactly = 1) {
+                kafkaConsumer.commitSync()
+            }
+
+            val personOppgave = database.getPersonOppgaver(
+                personIdent = UserConstants.ARBEIDSTAKER_FNR,
+            ).toPersonOppgaver().first()
+            personOppgave.type shouldBeEqualTo PersonOppgaveType.AKTIVITETSKRAV_VURDER_STANS
+            personOppgave.publish.shouldBeFalse()
+            personOppgave.behandletTidspunkt.shouldBeNull()
+            personOppgave.behandletVeilederIdent.shouldBeNull()
+        }
+
+        it("Behandler all ubehandlet vurder avslag-oppgaver for person") {
+            personOppgaveRepository.createPersonoppgave(personOppgave = ubehandletVurderAvslagOppgave)
+            personOppgaveRepository.createPersonoppgave(
+                personOppgave = ubehandletVurderAvslagOppgave.copy(
+                    uuid = UUID.randomUUID(),
+                    referanseUuid = UUID.randomUUID(),
+                )
+            )
+
+            kafkaConsumer.mockPollConsumerRecords(
+                recordValue = vurderingOppfylt,
+                topic = ArbeidsuforhetVurderingConsumer.ARBEIDSUFORHET_VURDERING_TOPIC,
+            )
+
+            arbeidsuforhetVurderingConsumer.pollAndProcessRecords(kafkaConsumer = kafkaConsumer)
+
+            database.getPersonOppgaver(
+                personIdent = UserConstants.ARBEIDSTAKER_FNR,
+            ).toPersonOppgaver().forEach {
+                it.type shouldBeEqualTo PersonOppgaveType.ARBEIDSUFORHET_VURDER_AVSLAG
+                it.personIdent.value shouldBeEqualTo vurderingOppfylt.personident
+                it.publish.shouldBeTrue()
+                it.behandletTidspunkt.shouldNotBeNull()
+                it.behandletVeilederIdent shouldBeEqualTo vurderingOppfylt.veilederident
+            }
+        }
+    }
+})
diff --git a/src/test/kotlin/no/nav/syfo/testutil/generators/ArbeidsuforhetVurderingGenerator.kt b/src/test/kotlin/no/nav/syfo/testutil/generators/ArbeidsuforhetVurderingGenerator.kt
new file mode 100644
index 00000000..0fbd8919
--- /dev/null
+++ b/src/test/kotlin/no/nav/syfo/testutil/generators/ArbeidsuforhetVurderingGenerator.kt
@@ -0,0 +1,21 @@
+package no.nav.syfo.testutil.generators
+
+import no.nav.syfo.arbeidsuforhet.kafka.ArbeidsuforhetVurdering
+import no.nav.syfo.arbeidsuforhet.kafka.VurderingType
+import no.nav.syfo.domain.PersonIdent
+import no.nav.syfo.testutil.UserConstants
+import java.time.OffsetDateTime
+import java.util.*
+
+fun generateArbeidsuforhetVurdering(
+    type: VurderingType,
+    personident: PersonIdent = UserConstants.ARBEIDSTAKER_FNR,
+    createdAt: OffsetDateTime = OffsetDateTime.now(),
+) = ArbeidsuforhetVurdering(
+    uuid = UUID.randomUUID(),
+    personident = personident.value,
+    createdAt = createdAt,
+    veilederident = UserConstants.VEILEDER_IDENT,
+    type = type,
+    begrunnelse = "En begrunnelse"
+)