Divisão de engenharia do grupo ATUO

We build the intelligence that runs the operation.

Engenharia que sustenta operação. Inteligência que opera antes da pergunta existir.
Sistemas, produto e inteligência aplicada, em um mesmo time técnico.

Falar com engenharia→Ver cases→

async def handler(event, ctx):
    body = json.loads(event["body"])
    profile = await profiles.upsert(
        body["profile_id"],
        traits=body.get("traits"),
        tenant=ctx.tenant,
    )
    await events.append(
        profile_id=profile.id,
        kind=body["kind"],
        payload=body.get("payload", {}),
        ts=now(),
    )
    await rules.evaluate(profile, body)
    return {"statusCode": 202}

def evaluate(profile, event):
    rules = registry.for_tenant(profile.tenant)
    for rule in rules:
        if rule.condition.match(event, profile):
            dispatch(
                action=rule.action,
                target=rule.target,
                payload=rule.render(profile, event),
                retry=rule.retry_policy,
                dlq=rule.dlq,
            )
            audit.append(rule.id, profile.id, event.id)

def score_churn(window=90):
    profiles = store.scan(tenant=tenant)
    for batch in chunks(profiles, 500):
        feats = features.build(
            batch,
            recency=True,
            frequency=True,
            trend=True,
        )
        scores = model.predict(feats)
        for profile, score in zip(batch, scores):
            profile.predictions.churn = score
            store.put(profile)

async def assist(query, ctx):
    plan = await planner.draft(query, ctx)
    if plan.requires_approval:
        return plan.to_response()
    docs = await retriever.search(query, k=8)
    answer = await llm.complete(
        prompt=template(query, docs),
        model=ctx.model or "claude-haiku-4-5",
        stream=True,
    )
    return stream(answer, evidence=docs)

def lock_lines(order_id, lines):
    with table.transaction() as tx:
        for line in lines:
            tx.put_item(
                Item={
                    "pk": f"order#{order_id}",
                    "sk": f"line#{line.id}",
                    "locked_at": now(),
                    "stripe_pi": line.payment_intent,
                },
                ConditionExpression="attribute_not_exists(sk)",
            )

def watchdog():
    metrics = registry.active()
    for m in metrics:
        recent = stream.read(m.id, window="5m")
        if anomaly.detect(recent, m.baseline):
            notify(
                tenant=m.tenant,
                metric=m.id,
                severity=anomaly.severity(recent),
            )

async def handler(event, ctx):
    body = json.loads(event["body"])
    profile = await profiles.upsert(
        body["profile_id"],
        traits=body.get("traits"),
        tenant=ctx.tenant,
    )
    await events.append(
        profile_id=profile.id,
        kind=body["kind"],
        payload=body.get("payload", {}),
        ts=now(),
    )
    await rules.evaluate(profile, body)
    return {"statusCode": 202}

def evaluate(profile, event):
    rules = registry.for_tenant(profile.tenant)
    for rule in rules:
        if rule.condition.match(event, profile):
            dispatch(
                action=rule.action,
                target=rule.target,
                payload=rule.render(profile, event),
                retry=rule.retry_policy,
                dlq=rule.dlq,
            )
            audit.append(rule.id, profile.id, event.id)

def score_churn(window=90):
    profiles = store.scan(tenant=tenant)
    for batch in chunks(profiles, 500):
        feats = features.build(
            batch,
            recency=True,
            frequency=True,
            trend=True,
        )
        scores = model.predict(feats)
        for profile, score in zip(batch, scores):
            profile.predictions.churn = score
            store.put(profile)

async def assist(query, ctx):
    plan = await planner.draft(query, ctx)
    if plan.requires_approval:
        return plan.to_response()
    docs = await retriever.search(query, k=8)
    answer = await llm.complete(
        prompt=template(query, docs),
        model=ctx.model or "claude-haiku-4-5",
        stream=True,
    )
    return stream(answer, evidence=docs)

def lock_lines(order_id, lines):
    with table.transaction() as tx:
        for line in lines:
            tx.put_item(
                Item={
                    "pk": f"order#{order_id}",
                    "sk": f"line#{line.id}",
                    "locked_at": now(),
                    "stripe_pi": line.payment_intent,
                },
                ConditionExpression="attribute_not_exists(sk)",
            )

def watchdog():
    metrics = registry.active()
    for m in metrics:
        recent = stream.read(m.id, window="5m")
        if anomaly.detect(recent, m.baseline):
            notify(
                tenant=m.tenant,
                metric=m.id,
                severity=anomaly.severity(recent),
            )

async def handler(event, ctx):
    body = json.loads(event["body"])
    profile = await profiles.upsert(
        body["profile_id"],
        traits=body.get("traits"),
        tenant=ctx.tenant,
    )
    await events.append(
        profile_id=profile.id,
        kind=body["kind"],
        payload=body.get("payload", {}),
        ts=now(),
    )
    await rules.evaluate(profile, body)
    return {"statusCode": 202}

def evaluate(profile, event):
    rules = registry.for_tenant(profile.tenant)
    for rule in rules:
        if rule.condition.match(event, profile):
            dispatch(
                action=rule.action,
                target=rule.target,
                payload=rule.render(profile, event),
                retry=rule.retry_policy,
                dlq=rule.dlq,
            )
            audit.append(rule.id, profile.id, event.id)

def score_churn(window=90):
    profiles = store.scan(tenant=tenant)
    for batch in chunks(profiles, 500):
        feats = features.build(
            batch,
            recency=True,
            frequency=True,
            trend=True,
        )
        scores = model.predict(feats)
        for profile, score in zip(batch, scores):
            profile.predictions.churn = score
            store.put(profile)

async def assist(query, ctx):
    plan = await planner.draft(query, ctx)
    if plan.requires_approval:
        return plan.to_response()
    docs = await retriever.search(query, k=8)
    answer = await llm.complete(
        prompt=template(query, docs),
        model=ctx.model or "claude-haiku-4-5",
        stream=True,
    )
    return stream(answer, evidence=docs)

def lock_lines(order_id, lines):
    with table.transaction() as tx:
        for line in lines:
            tx.put_item(
                Item={
                    "pk": f"order#{order_id}",
                    "sk": f"line#{line.id}",
                    "locked_at": now(),
                    "stripe_pi": line.payment_intent,
                },
                ConditionExpression="attribute_not_exists(sk)",
            )

def watchdog():
    metrics = registry.active()
    for m in metrics:
        recent = stream.read(m.id, window="5m")
        if anomaly.detect(recent, m.baseline):
            notify(
                tenant=m.tenant,
                metric=m.id,
                severity=anomaly.severity(recent),
            )

async def handler(event, ctx):
    body = json.loads(event["body"])
    profile = await profiles.upsert(
        body["profile_id"],
        traits=body.get("traits"),
        tenant=ctx.tenant,
    )
    await events.append(
        profile_id=profile.id,
        kind=body["kind"],
        payload=body.get("payload", {}),
        ts=now(),
    )
    await rules.evaluate(profile, body)
    return {"statusCode": 202}

def evaluate(profile, event):
    rules = registry.for_tenant(profile.tenant)
    for rule in rules:
        if rule.condition.match(event, profile):
            dispatch(
                action=rule.action,
                target=rule.target,
                payload=rule.render(profile, event),
                retry=rule.retry_policy,
                dlq=rule.dlq,
            )
            audit.append(rule.id, profile.id, event.id)

def score_churn(window=90):
    profiles = store.scan(tenant=tenant)
    for batch in chunks(profiles, 500):
        feats = features.build(
            batch,
            recency=True,
            frequency=True,
            trend=True,
        )
        scores = model.predict(feats)
        for profile, score in zip(batch, scores):
            profile.predictions.churn = score
            store.put(profile)

async def assist(query, ctx):
    plan = await planner.draft(query, ctx)
    if plan.requires_approval:
        return plan.to_response()
    docs = await retriever.search(query, k=8)
    answer = await llm.complete(
        prompt=template(query, docs),
        model=ctx.model or "claude-haiku-4-5",
        stream=True,
    )
    return stream(answer, evidence=docs)

def lock_lines(order_id, lines):
    with table.transaction() as tx:
        for line in lines:
            tx.put_item(
                Item={
                    "pk": f"order#{order_id}",
                    "sk": f"line#{line.id}",
                    "locked_at": now(),
                    "stripe_pi": line.payment_intent,
                },
                ConditionExpression="attribute_not_exists(sk)",
            )

def watchdog():
    metrics = registry.active()
    for m in metrics:
        recent = stream.read(m.id, window="5m")
        if anomaly.detect(recent, m.baseline):
            notify(
                tenant=m.tenant,
                metric=m.id,
                severity=anomaly.severity(recent),
            )

def watchdog():
    metrics = registry.active()
    for m in metrics:
        recent = stream.read(m.id, window="5m")
        if anomaly.detect(recent, m.baseline):
            notify(
                tenant=m.tenant,
                metric=m.id,
                severity=anomaly.severity(recent),
            )

def lock_lines(order_id, lines):
    with table.transaction() as tx:
        for line in lines:
            tx.put_item(
                Item={
                    "pk": f"order#{order_id}",
                    "sk": f"line#{line.id}",
                    "locked_at": now(),
                    "stripe_pi": line.payment_intent,
                },
                ConditionExpression="attribute_not_exists(sk)",
            )

async def assist(query, ctx):
    plan = await planner.draft(query, ctx)
    if plan.requires_approval:
        return plan.to_response()
    docs = await retriever.search(query, k=8)
    answer = await llm.complete(
        prompt=template(query, docs),
        model=ctx.model or "claude-haiku-4-5",
        stream=True,
    )
    return stream(answer, evidence=docs)

def score_churn(window=90):
    profiles = store.scan(tenant=tenant)
    for batch in chunks(profiles, 500):
        feats = features.build(
            batch,
            recency=True,
            frequency=True,
            trend=True,
        )
        scores = model.predict(feats)
        for profile, score in zip(batch, scores):
            profile.predictions.churn = score
            store.put(profile)

def evaluate(profile, event):
    rules = registry.for_tenant(profile.tenant)
    for rule in rules:
        if rule.condition.match(event, profile):
            dispatch(
                action=rule.action,
                target=rule.target,
                payload=rule.render(profile, event),
                retry=rule.retry_policy,
                dlq=rule.dlq,
            )
            audit.append(rule.id, profile.id, event.id)

async def handler(event, ctx):
    body = json.loads(event["body"])
    profile = await profiles.upsert(
        body["profile_id"],
        traits=body.get("traits"),
        tenant=ctx.tenant,
    )
    await events.append(
        profile_id=profile.id,
        kind=body["kind"],
        payload=body.get("payload", {}),
        ts=now(),
    )
    await rules.evaluate(profile, body)
    return {"statusCode": 202}

def watchdog():
    metrics = registry.active()
    for m in metrics:
        recent = stream.read(m.id, window="5m")
        if anomaly.detect(recent, m.baseline):
            notify(
                tenant=m.tenant,
                metric=m.id,
                severity=anomaly.severity(recent),
            )

def lock_lines(order_id, lines):
    with table.transaction() as tx:
        for line in lines:
            tx.put_item(
                Item={
                    "pk": f"order#{order_id}",
                    "sk": f"line#{line.id}",
                    "locked_at": now(),
                    "stripe_pi": line.payment_intent,
                },
                ConditionExpression="attribute_not_exists(sk)",
            )

async def assist(query, ctx):
    plan = await planner.draft(query, ctx)
    if plan.requires_approval:
        return plan.to_response()
    docs = await retriever.search(query, k=8)
    answer = await llm.complete(
        prompt=template(query, docs),
        model=ctx.model or "claude-haiku-4-5",
        stream=True,
    )
    return stream(answer, evidence=docs)

def score_churn(window=90):
    profiles = store.scan(tenant=tenant)
    for batch in chunks(profiles, 500):
        feats = features.build(
            batch,
            recency=True,
            frequency=True,
            trend=True,
        )
        scores = model.predict(feats)
        for profile, score in zip(batch, scores):
            profile.predictions.churn = score
            store.put(profile)

def evaluate(profile, event):
    rules = registry.for_tenant(profile.tenant)
    for rule in rules:
        if rule.condition.match(event, profile):
            dispatch(
                action=rule.action,
                target=rule.target,
                payload=rule.render(profile, event),
                retry=rule.retry_policy,
                dlq=rule.dlq,
            )
            audit.append(rule.id, profile.id, event.id)

async def handler(event, ctx):
    body = json.loads(event["body"])
    profile = await profiles.upsert(
        body["profile_id"],
        traits=body.get("traits"),
        tenant=ctx.tenant,
    )
    await events.append(
        profile_id=profile.id,
        kind=body["kind"],
        payload=body.get("payload", {}),
        ts=now(),
    )
    await rules.evaluate(profile, body)
    return {"statusCode": 202}

def watchdog():
    metrics = registry.active()
    for m in metrics:
        recent = stream.read(m.id, window="5m")
        if anomaly.detect(recent, m.baseline):
            notify(
                tenant=m.tenant,
                metric=m.id,
                severity=anomaly.severity(recent),
            )

def lock_lines(order_id, lines):
    with table.transaction() as tx:
        for line in lines:
            tx.put_item(
                Item={
                    "pk": f"order#{order_id}",
                    "sk": f"line#{line.id}",
                    "locked_at": now(),
                    "stripe_pi": line.payment_intent,
                },
                ConditionExpression="attribute_not_exists(sk)",
            )

async def assist(query, ctx):
    plan = await planner.draft(query, ctx)
    if plan.requires_approval:
        return plan.to_response()
    docs = await retriever.search(query, k=8)
    answer = await llm.complete(
        prompt=template(query, docs),
        model=ctx.model or "claude-haiku-4-5",
        stream=True,
    )
    return stream(answer, evidence=docs)

def score_churn(window=90):
    profiles = store.scan(tenant=tenant)
    for batch in chunks(profiles, 500):
        feats = features.build(
            batch,
            recency=True,
            frequency=True,
            trend=True,
        )
        scores = model.predict(feats)
        for profile, score in zip(batch, scores):
            profile.predictions.churn = score
            store.put(profile)

def evaluate(profile, event):
    rules = registry.for_tenant(profile.tenant)
    for rule in rules:
        if rule.condition.match(event, profile):
            dispatch(
                action=rule.action,
                target=rule.target,
                payload=rule.render(profile, event),
                retry=rule.retry_policy,
                dlq=rule.dlq,
            )
            audit.append(rule.id, profile.id, event.id)

async def handler(event, ctx):
    body = json.loads(event["body"])
    profile = await profiles.upsert(
        body["profile_id"],
        traits=body.get("traits"),
        tenant=ctx.tenant,
    )
    await events.append(
        profile_id=profile.id,
        kind=body["kind"],
        payload=body.get("payload", {}),
        ts=now(),
    )
    await rules.evaluate(profile, body)
    return {"statusCode": 202}

def watchdog():
    metrics = registry.active()
    for m in metrics:
        recent = stream.read(m.id, window="5m")
        if anomaly.detect(recent, m.baseline):
            notify(
                tenant=m.tenant,
                metric=m.id,
                severity=anomaly.severity(recent),
            )

def lock_lines(order_id, lines):
    with table.transaction() as tx:
        for line in lines:
            tx.put_item(
                Item={
                    "pk": f"order#{order_id}",
                    "sk": f"line#{line.id}",
                    "locked_at": now(),
                    "stripe_pi": line.payment_intent,
                },
                ConditionExpression="attribute_not_exists(sk)",
            )

async def assist(query, ctx):
    plan = await planner.draft(query, ctx)
    if plan.requires_approval:
        return plan.to_response()
    docs = await retriever.search(query, k=8)
    answer = await llm.complete(
        prompt=template(query, docs),
        model=ctx.model or "claude-haiku-4-5",
        stream=True,
    )
    return stream(answer, evidence=docs)

def score_churn(window=90):
    profiles = store.scan(tenant=tenant)
    for batch in chunks(profiles, 500):
        feats = features.build(
            batch,
            recency=True,
            frequency=True,
            trend=True,
        )
        scores = model.predict(feats)
        for profile, score in zip(batch, scores):
            profile.predictions.churn = score
            store.put(profile)

def evaluate(profile, event):
    rules = registry.for_tenant(profile.tenant)
    for rule in rules:
        if rule.condition.match(event, profile):
            dispatch(
                action=rule.action,
                target=rule.target,
                payload=rule.render(profile, event),
                retry=rule.retry_policy,
                dlq=rule.dlq,
            )
            audit.append(rule.id, profile.id, event.id)

async def handler(event, ctx):
    body = json.loads(event["body"])
    profile = await profiles.upsert(
        body["profile_id"],
        traits=body.get("traits"),
        tenant=ctx.tenant,
    )
    await events.append(
        profile_id=profile.id,
        kind=body["kind"],
        payload=body.get("payload", {}),
        ts=now(),
    )
    await rules.evaluate(profile, body)
    return {"statusCode": 202}

def watchdog():
    metrics = registry.active()
    for m in metrics:
        recent = stream.read(m.id, window="5m")
        if anomaly.detect(recent, m.baseline):
            notify(
                tenant=m.tenant,
                metric=m.id,
                severity=anomaly.severity(recent),
            )

def lock_lines(order_id, lines):
    with table.transaction() as tx:
        for line in lines:
            tx.put_item(
                Item={
                    "pk": f"order#{order_id}",
                    "sk": f"line#{line.id}",
                    "locked_at": now(),
                    "stripe_pi": line.payment_intent,
                },
                ConditionExpression="attribute_not_exists(sk)",
            )

async def assist(query, ctx):
    plan = await planner.draft(query, ctx)
    if plan.requires_approval:
        return plan.to_response()
    docs = await retriever.search(query, k=8)
    answer = await llm.complete(
        prompt=template(query, docs),
        model=ctx.model or "claude-haiku-4-5",
        stream=True,
    )
    return stream(answer, evidence=docs)

def score_churn(window=90):
    profiles = store.scan(tenant=tenant)
    for batch in chunks(profiles, 500):
        feats = features.build(
            batch,
            recency=True,
            frequency=True,
            trend=True,
        )
        scores = model.predict(feats)
        for profile, score in zip(batch, scores):
            profile.predictions.churn = score
            store.put(profile)

def evaluate(profile, event):
    rules = registry.for_tenant(profile.tenant)
    for rule in rules:
        if rule.condition.match(event, profile):
            dispatch(
                action=rule.action,
                target=rule.target,
                payload=rule.render(profile, event),
                retry=rule.retry_policy,
                dlq=rule.dlq,
            )
            audit.append(rule.id, profile.id, event.id)

async def handler(event, ctx):
    body = json.loads(event["body"])
    profile = await profiles.upsert(
        body["profile_id"],
        traits=body.get("traits"),
        tenant=ctx.tenant,
    )
    await events.append(
        profile_id=profile.id,
        kind=body["kind"],
        payload=body.get("payload", {}),
        ts=now(),
    )
    await rules.evaluate(profile, body)
    return {"statusCode": 202}

def watchdog():
    metrics = registry.active()
    for m in metrics:
        recent = stream.read(m.id, window="5m")
        if anomaly.detect(recent, m.baseline):
            notify(
                tenant=m.tenant,
                metric=m.id,
                severity=anomaly.severity(recent),
            )

def lock_lines(order_id, lines):
    with table.transaction() as tx:
        for line in lines:
            tx.put_item(
                Item={
                    "pk": f"order#{order_id}",
                    "sk": f"line#{line.id}",
                    "locked_at": now(),
                    "stripe_pi": line.payment_intent,
                },
                ConditionExpression="attribute_not_exists(sk)",
            )

async def assist(query, ctx):
    plan = await planner.draft(query, ctx)
    if plan.requires_approval:
        return plan.to_response()
    docs = await retriever.search(query, k=8)
    answer = await llm.complete(
        prompt=template(query, docs),
        model=ctx.model or "claude-haiku-4-5",
        stream=True,
    )
    return stream(answer, evidence=docs)

def score_churn(window=90):
    profiles = store.scan(tenant=tenant)
    for batch in chunks(profiles, 500):
        feats = features.build(
            batch,
            recency=True,
            frequency=True,
            trend=True,
        )
        scores = model.predict(feats)
        for profile, score in zip(batch, scores):
            profile.predictions.churn = score
            store.put(profile)

def evaluate(profile, event):
    rules = registry.for_tenant(profile.tenant)
    for rule in rules:
        if rule.condition.match(event, profile):
            dispatch(
                action=rule.action,
                target=rule.target,
                payload=rule.render(profile, event),
                retry=rule.retry_policy,
                dlq=rule.dlq,
            )
            audit.append(rule.id, profile.id, event.id)

async def handler(event, ctx):
    body = json.loads(event["body"])
    profile = await profiles.upsert(
        body["profile_id"],
        traits=body.get("traits"),
        tenant=ctx.tenant,
    )
    await events.append(
        profile_id=profile.id,
        kind=body["kind"],
        payload=body.get("payload", {}),
        ts=now(),
    )
    await rules.evaluate(profile, body)
    return {"statusCode": 202}

def watchdog():
    metrics = registry.active()
    for m in metrics:
        recent = stream.read(m.id, window="5m")
        if anomaly.detect(recent, m.baseline):
            notify(
                tenant=m.tenant,
                metric=m.id,
                severity=anomaly.severity(recent),
            )

def lock_lines(order_id, lines):
    with table.transaction() as tx:
        for line in lines:
            tx.put_item(
                Item={
                    "pk": f"order#{order_id}",
                    "sk": f"line#{line.id}",
                    "locked_at": now(),
                    "stripe_pi": line.payment_intent,
                },
                ConditionExpression="attribute_not_exists(sk)",
            )

async def assist(query, ctx):
    plan = await planner.draft(query, ctx)
    if plan.requires_approval:
        return plan.to_response()
    docs = await retriever.search(query, k=8)
    answer = await llm.complete(
        prompt=template(query, docs),
        model=ctx.model or "claude-haiku-4-5",
        stream=True,
    )
    return stream(answer, evidence=docs)

def score_churn(window=90):
    profiles = store.scan(tenant=tenant)
    for batch in chunks(profiles, 500):
        feats = features.build(
            batch,
            recency=True,
            frequency=True,
            trend=True,
        )
        scores = model.predict(feats)
        for profile, score in zip(batch, scores):
            profile.predictions.churn = score
            store.put(profile)

def evaluate(profile, event):
    rules = registry.for_tenant(profile.tenant)
    for rule in rules:
        if rule.condition.match(event, profile):
            dispatch(
                action=rule.action,
                target=rule.target,
                payload=rule.render(profile, event),
                retry=rule.retry_policy,
                dlq=rule.dlq,
            )
            audit.append(rule.id, profile.id, event.id)

async def handler(event, ctx):
    body = json.loads(event["body"])
    profile = await profiles.upsert(
        body["profile_id"],
        traits=body.get("traits"),
        tenant=ctx.tenant,
    )
    await events.append(
        profile_id=profile.id,
        kind=body["kind"],
        payload=body.get("payload", {}),
        ts=now(),
    )
    await rules.evaluate(profile, body)
    return {"statusCode": 202}

def watchdog():
    metrics = registry.active()
    for m in metrics:
        recent = stream.read(m.id, window="5m")
        if anomaly.detect(recent, m.baseline):
            notify(
                tenant=m.tenant,
                metric=m.id,
                severity=anomaly.severity(recent),
            )

def lock_lines(order_id, lines):
    with table.transaction() as tx:
        for line in lines:
            tx.put_item(
                Item={
                    "pk": f"order#{order_id}",
                    "sk": f"line#{line.id}",
                    "locked_at": now(),
                    "stripe_pi": line.payment_intent,
                },
                ConditionExpression="attribute_not_exists(sk)",
            )

async def assist(query, ctx):
    plan = await planner.draft(query, ctx)
    if plan.requires_approval:
        return plan.to_response()
    docs = await retriever.search(query, k=8)
    answer = await llm.complete(
        prompt=template(query, docs),
        model=ctx.model or "claude-haiku-4-5",
        stream=True,
    )
    return stream(answer, evidence=docs)

def score_churn(window=90):
    profiles = store.scan(tenant=tenant)
    for batch in chunks(profiles, 500):
        feats = features.build(
            batch,
            recency=True,
            frequency=True,
            trend=True,
        )
        scores = model.predict(feats)
        for profile, score in zip(batch, scores):
            profile.predictions.churn = score
            store.put(profile)

def evaluate(profile, event):
    rules = registry.for_tenant(profile.tenant)
    for rule in rules:
        if rule.condition.match(event, profile):
            dispatch(
                action=rule.action,
                target=rule.target,
                payload=rule.render(profile, event),
                retry=rule.retry_policy,
                dlq=rule.dlq,
            )
            audit.append(rule.id, profile.id, event.id)

async def handler(event, ctx):
    body = json.loads(event["body"])
    profile = await profiles.upsert(
        body["profile_id"],
        traits=body.get("traits"),
        tenant=ctx.tenant,
    )
    await events.append(
        profile_id=profile.id,
        kind=body["kind"],
        payload=body.get("payload", {}),
        ts=now(),
    )
    await rules.evaluate(profile, body)
    return {"statusCode": 202}

NewsroomSinais recentes da operação.

Ver todos→

Em produção01

Última entrega

Motor de retenção comportamental Ōkami entrou em operação, com inferência em janela curta.

Intervenção automática em operação · set/2026→

Reconhecimento02

Ecossistema técnico

Code and Soul atua em arranjo direto com parceiros AWS, Odoo e Drupal em projetos de alta escala.

Parcerias técnicas ativas→

Press03

Grupo ATUO

Code and Soul consolida a divisão de engenharia do grupo ATUO em arranjo de quatro divisões.

atuo.com.br→

Manifesto

Engenharia, não promessa.

Quando afirmamos algo, ou tem prova ao lado, ou é manifesto declarado como tal.

Problemas reais raramente são puramente técnicos. Atravessam estratégia, experiência e engenharia.

Operamos nos três eixos que o mercado mantém separados.

Operamos a partir de Itapetininga, interior de São Paulo. Plataforma que entende safra, fluxo de balcão e turno de produção não nasce em coworking de Pinheiros. Nasce no campo.

Tese

“

O sistema é a tese. O resto é vitrine.
Code and Soul · método

Onde essa engenharia já rodou.

Clube de Criação · 2026

O que fazemos

Três disciplinas. Uma engenharia.

01Systems Engineering

Arquitetamos sistemas que não podem falhar.

Construímos plataformas robustas, ecossistemas escaláveis e sistemas que operam sob pressão. Do backend à infraestrutura, criamos fundações que permitem crescimento real.

Arquitetura distribuída

API-first / Headless

Integrações profundas (ERP, CRM, POS, OMS)

Cloud-native, observabilidade, segurança

02Product Engineering

Transformamos problemas em produtos vivos.

Design, engenharia e propósito trabalhando juntos. Criamos produtos digitais que funcionam na prática, e não só na tela.

UX técnico

Design de sistemas

Prototipação avançada

Aplicações corporativas e operacionais

03Autonomous Intelligence

Sistemas que aprendem, antecipam e executam.

Criamos inteligências aplicadas que combinam regras, comportamento, dados e aprendizado contínuo. A automação deixa de ser estática e se torna dinâmica.

Detecção de intenção

Modelos híbridos (rules + ML)

Ações automáticas

Personalização contínua

Grupo ATUO

Code and Soul é a divisão de engenharia do grupo ATUO, fundado em 2015.

A Code and Soul é contratada de três formas. Em arranjo com ATUO.agency, ATUO.digital e SYNQi³, quando o problema atravessa estratégia, produto e plataforma, porque separar essas frentes custa mais do que integrá-las. Sozinha, em mandato puramente técnico: refatoração crítica, arquitetura de plataforma, dados, observabilidade. Ou como engenharia dentro de um time que já tem produto e precisa de profundidade para escalar sem refazer.

Núcleo de direção

ATUO

Garante que marca, produto, engenharia e inteligência evoluam na mesma lógica.

Fundado em 2015 · Itapetininga, SP

ATUO.agency

Estratégia, posicionamento, narrativa de marca.

ATUO.digital

Produto, design, experiência.

03Aqui

Code and Soul

Engenharia aplicada e arquitetura de sistemas.

SYNQi³

Produto proprietário do grupo. Inteligência operacional em produção.

Conhecer o grupo ATUO→Ver as marcas que o grupo opera→

Engenharia 24/7
Multi-tenant
Event-driven
AWS Partner
Odoo Ecosystem
Drupal Association
SYNQi³
Real Estate
Hospitalidade
Telecom
Publicidade Global
Inteligência operacional
Retenção
Edge computing
Observabilidade
Serverless
Cloud-native
ETL contínuo
Inferência em produção
Arquitetura defensiva

Engenharia em ação

Engenharia em camadas.

Dependendo do problema, o grupo ATUO ativa as divisões que ele exige. Engenharia pura, engenharia com inteligência, ou operação completa.

Cortar por vertical

Camada 01

Engenharia técnica direta

Quando o problema é arquitetural.

ArranjoCode and Soul direto

Telecom01 · 01

Ecossistema digital de operadora nacional, sustentado em produção 24/7.

Canais, APIs e integrações críticas para milhões de usuários ativos. Entrega técnica em arranjo com parceiro de ecossistema.

Milhões de usuários · 24/7 em produção

Ler case completo →

Publicidade global01 · 02

Plataformas digitais para campanhas multi-país de marca global.

Audiência em escala internacional, pipelines de publicação e governança de conteúdo. Engenharia direta com agência global parceira.

Múltiplos mercados · pipeline editorial em produção

Ler case completo →

Hospitalidade · Ativação F&B01 · 03

Plataforma serverless de palpites da Copa 2026 para a Fabrik7.

Real-time scoring para 104 jogos em 38 dias. Ledger imutável, anti-fraude embarcado, simulador end-to-end. Construída para escalar e desligar barato.

25 Lambdas · 21 DynamoDB · 3h50 de Copa simulada

Ler case completo →

Camada 02

Engenharia + Inteligência aplicada

Quando o problema exige decisão em tempo real.

ArranjoCode and Soul + SYNQi³

Imobiliário · AgoraFecha02 · 01

Marketplace serverless, multi-tenant, event-driven, com camada de inteligência.

Arquitetura cloud-native com isolamento de tenants e escalabilidade por evento. Camada SYNQi³ acoplada para leitura comportamental em tempo real.

Multi-tenant isolado · custo por tenant previsível

Ler case completo →Ver camada de inteligência no SYNQi³ →

Mídia indoor · Fire TV02 · 02

Telas que leem o catálogo do ponto de venda e mudam por evento.

Plataforma offline-first em Fire TV. A grade é por aparelho, o conteúdo nasce do catálogo entregue pelo SYNQi³, e um webhook muda o que está na tela.

Offline-first · grade por aparelho · muda por webhook

Ler case completo →Ver camada de inteligência no SYNQi³ →

Retenção · Ōkami02 · 03

Motor de retenção comportamental sustentado por inteligência operacional.

Detecção de risco de churn em janela curta, com gatilhos automáticos de intervenção. Captura de eventos em produção contínua; o motor de intervenção entrou em operação em setembro de 2026.

203 perfis com risco classificado · intervenção automática em operação

Ler case completo →Ver camada de inteligência no SYNQi³ →

Camada 03

Operação completa

Quando o problema é o negócio todo.

ArranjoCode and Soul + SYNQi³ + Valfredo + Odoo

Hospitalidade · Fabrik703 · 01

Operação contínua de cervejaria e gastrobar, sustentada de ponta a ponta pelo grupo.

Venture própria do grupo ATUO. Engenharia (Code and Soul), inteligência operacional (SYNQi³), operação e gestão (Valfredo) e backbone ERP (Odoo) em arranjo único, em produção real.

Operação 7×24 em produção · engenharia, inteligência, produto e ERP no mesmo arranjo

Ler case completo →Ver operação no Valfredo →Ver inteligência no SYNQi³ →

Imprensa e trabalhos referenciados

Engenharia por trás de campanhas premiadas.

Quando agências e marcas precisam que a ideia funcione em produção.

Mão segurando celular com o jogo Chevrolet Zap Racing rodando no WhatsApp

Foto: Forbes Brasil / Divulgação

Forbes Tech2022

Chevrolet

Zap Racing

Construímos e implementamos o jogo completo no WhatsApp para a campanha do Maio Amarelo: motor do jogo, chatbot, integrações e toda a infraestrutura em cloud.

AgencyCommonwealth//WMcCann

C&SConstrução técnica e infraestrutura cloud

Ler a matéria↗

Plataforma TIM On Stage

Clube de Criação2026

TIM

TIM On Stage

Mais que um site: uma nova forma de operar plataformas digitais. Arquitetura serverless em AWS (Lambda, API Gateway, DynamoDB, CloudFront + WAF), sistema próprio de extensões, security gate automatizado (ZAP + Nuclei + TLS) e pipeline CI/CD com promoção controlada entre ambientes. Escalabilidade e resiliência como padrão.

AgencyBETC Havas

C&SEngenharia completa: infraestrutura, plataforma e operação

Ler a matéria↗

Em produção

Engenharia como prova.

Não é portfolio curado. É operação contínua. Cada peça abaixo está em produção real, sustentada por engenharia do grupo.

Plataforma de telecom em produção — Telecom · canais críticosOperação 24/7

Marketplace serverless AgoraFecha — Imobiliário · AgoraFechaMulti-tenant event-driven

SYNQi³ decisões em tempo real — SYNQi³ · decisõesInferência em produção

Fabrik7 · cervejaria e gastrobar — Fabrik7 · operação real7×24 em produção

Operação Ōkami · motor de retenção — Retenção · ŌkamiRisco classificado em 203 perfis

Time de engenharia em operação — Engineering · em campoEngenharia direta

SYNQi³

SYNQi³ — Where engineering becomes intelligence.

O SYNQi³ não organiza dados.
Ele altera como decisões são tomadas.

Eventos deixam de ser registros. Passam a ser gatilhos de execução.

Opera como infraestrutura contínua, independente de vertical.

SYNQi³

O sistema em uma linha

Passe sobre cada estágio para abrir a descrição.

O SISTEMA

Eventos entram. Padrões emergem. Desvios são identificados.

Decisões são avaliadas. Ações são executadas.

Resultados retornam como novos dados.

Sem interrupção. Sem dependência de leitura humana.

A maioria observa.

O SYNQi³ opera.

EM NÚMEROS

Lambdasdo SYNQi³ em produção · us-east-1

Jobsagendados · todos ativos

5min

Watchdogjanela contínua de checagem

TabelasDynamoDB do SYNQi³ · isolamento por tenant

SYNQi³ · exemplo de fluxo

eventos reais · valores ilustrativos

14:43:51rag.querytokens=1925· model=claude-haiku-4-5

14:43:52kpi.updatedmrr_delta=+R$ 916· tenant=δ

CAPABILITIES

Briefing Diário

Receita do dia, perfis em risco, oportunidades abertas, ações recomendadas. Composto a partir dos KPIs, das regras e dos resumos diários no instante em que você abre o painel. Leitura pronta, não relatório para rodar.

Assistente S³

Conversacional com contexto ativo. Faz pergunta, propõe caminho, responde com evidência citada. RAG sobre store vetorial S3 Vectors, embedding Bedrock Titan e geração Anthropic Claude via Bedrock, com streaming por WebSocket.

Padrões e vigilância

Watchdog roda a cada 5 minutos sobre métricas e eventos. Descoberta automática de KPI sobre dado bruto e padrões comportamentais em janela contínua, gravados como atributo do perfil. Alerta via WebSocket e webhook.

Motor de regras

Event-triggered. Avalia condição e dispara ação. Webhook, contador, notificação, fan-out de personalização. Com retry, dead-letter, agendador que opera em janela de minuto e auditoria imutável por execução. Orquestração em Step Functions onde a regra exige.

Inteligência preditiva

Churn por recência, frequência e tendência. Clusters K-means de comportamento, scoring diário de aquisição, atribuição cross-channel em waterfall, cada um com a janela de apuração declarada. Pipelines batch orquestrados, resultado gravado como atributo do perfil 360°. Sinal, não relatório.

Marketing assistido

Sync diário de Meta Ads e Google Ads. Cohorts e atribuição sobre o gasto real, e geração de ativo de campanha na mesma camada, criativo, copy e segmento saem do comportamento observado, não de template. A leitura e a peça são do sistema; o ajuste da campanha é decisão sua.

FLUXO DE TRANSFORMAÇÃO

Eventos→sinais comportamentais acionáveis

Interações→contexto operacional

Decisões→execução em tempo real

Resultados→aprendizado contínuo

Perfis→estado consolidado

EM PRODUÇÃO

Arquitetura serverless operando em escala.

Processamento de eventos em tempo real.

Inferência de modelos comportamentais contínua.

Execução via integrações e webhooks.

Memória distribuída para decisões imediatas.

Isolamento multi-tenant por design.

Não é conceito.

É operação.

EM CAMPO

Na Fabrik7, cada interação gera contexto. Pedidos influenciam recomendações. Comportamento dispara ações. A operação se ajusta em tempo real.

O sistema pode ser consultado em linguagem natural.

Respostas são baseadas em dados reais.

Mas o valor não depende da pergunta. O SYNQi³ opera antes dela existir.

Inteligência não é camada adicional.
É parte da operação.

Conhecer o SYNQi³→

Pesquisa & Desenvolvimento

R&D — Onde engenharia se torna invenção.

Exploramos o limite do que é tecnicamente possível: sistemas distribuídos, arquitetura autônoma, camadas de decisão orientadas por IA, novos modelos de interação e métodos de engenharia que antecipam a próxima década de produtos digitais.

Arquitetura Experimental

Prototipamos sistemas distribuídos e padrões computacionais inovadores antes de se tornarem padrão de indústria.

Sistemas Autônomos

Infraestrutura auto-reparável e motores de decisão que operam sem intervenção humana.

Interfaces Humano-máquina

Modelos de interação de próxima geração que borram a linha entre operador e sistema.

Inteligência Aplicada

Pipelines de machine learning projetados para confiabilidade e explicabilidade em produção.

Engenharia de Alta Performance

Otimização em escala: redução de latência, maximização de throughput, eficiência de recursos.

Ler o que publicamos sobre isso

Engineering Residency

Engenheiros seniores integrados em times de produto, entregando clareza, arquitetura e execução que não podem falhar.

Nosso modelo de residência traz engenheiros experientes para times de missão crítica. Não é staff augmentation. É liderança de engenharia dentro do seu produto.

Backend EngineeringSenior / Lead

Frontend EngineeringSenior / Lead

Cloud & DevOpsSenior / Lead

Data EngineeringSenior / Lead

AI EngineeringSenior / Lead

QA & AutomationSenior / Lead

Times guiados pelos padrões de arquitetura, cultura de engenharia e direção técnica da Code and Soul.

Falar sobre residência

Ecossistema técnico

Parcerias e ecossistemas que sustentam a operação.

Operamos dentro de ecossistemas técnicos reconhecidos. Não como vitrine, e sim como compromisso de método com padrões já validados em escala.

012024 → ativo

Cloud · Infraestrutura

AWS Partner Network

Operação cloud-native em projetos enterprise, com práticas de Well-Architected aplicadas em produção.

022023 → ativo

ERP · Backbone operacional

Odoo Ecosystem

Implementações Odoo em produção em ventures do grupo, com integrações sob desenho próprio.

032022 → ativo

CMS · Plataformas críticas

Acquia · Drupal

Arquitetura Drupal aplicada a portais de alta escala e ambientes editoriais com governança técnica.

04Em operação

SYNQi³

Inteligência operacional

SYNQi³ Product

Produto proprietário do grupo ATUO, em produção contínua sustentando decisões em tempo real.

Como trabalhamos

Como transformamos complexidade em clareza.

Nossa metodologia combina estratégia (ATUO.agency), experiência (ATUO.digital) e engenharia (Code and Soul) para construir soluções que sobrevivem ao tempo, ao crescimento e à realidade operacional.

Diagnóstico profundo de sistemas e operação

Arquitetura orientada a dados e comportamento

Desenho de produto baseado em objetivos reais

Engenharia contínua + inteligência evolutiva

O que acreditamos

Tecnologia sem engenharia é frágil.

Engenharia sem inteligência é incompleta.

Sistemas existem para resolver problemas reais, não para exibir interface.

O futuro não é predito, ele é arquitetado.

A inteligência não substitui pessoas. Ela libera pessoas.

Conteúdo & Pensamento

Insights mais recentes

Engenharia23 de abril de 2026

Se você chegou até aqui

já passou da camada de promessa.
A próxima conversa é técnica.

Operamos em arranjo direto com áreas de produto, engenharia e operação dos nossos clientes. Sem briefing institucional, sem ciclo de descoberta longo. Vamos para o problema.

Falar com engenharia→Voltar para os cases↑

Ler o manifesto completo

Contato

We build the intelligence that runs the operation.

Motor de retenção comportamental Ōkami entrou em operação, com inferência em janela curta.

Code and Soul atua em arranjo direto com parceiros AWS, Odoo e Drupal em projetos de alta escala.

Code and Soul consolida a divisão de engenharia do grupo ATUO em arranjo de quatro divisões.

Engenharia, não promessa.

Onde essa engenharia já rodou.

Três disciplinas. Uma engenharia.

Arquitetamos sistemas que não podem falhar.

Transformamos problemas em produtos vivos.

Sistemas que aprendem, antecipam e executam.

Code and Soul é a divisão de engenharia do grupo ATUO, fundado em 2015.

ATUO

ATUO.agency

ATUO.digital

Code and Soul

SYNQi³

Engenharia em camadas.

Engenharia técnica direta

Ecossistema digital de operadora nacional, sustentado em produção 24/7.

Plataformas digitais para campanhas multi-país de marca global.

Plataforma serverless de palpites da Copa 2026 para a Fabrik7.

Engenharia + Inteligência aplicada

Marketplace serverless, multi-tenant, event-driven, com camada de inteligência.

Telas que leem o catálogo do ponto de venda e mudam por evento.

Motor de retenção comportamental sustentado por inteligência operacional.

Operação completa

Operação contínua de cervejaria e gastrobar, sustentada de ponta a ponta pelo grupo.

Engenharia por trás de campanhas premiadas.

Zap Racing

TIM On Stage

Engenharia como prova.

SYNQi³ — Where engineering becomes intelligence.

Briefing Diário

Assistente S³

Padrões e vigilância

Motor de regras

Inteligência preditiva

Marketing assistido

R&D — Onde engenharia se torna invenção.

Arquitetura Experimental

Sistemas Autônomos

Interfaces Humano-máquina

Inteligência Aplicada

Engenharia de Alta Performance

Engineering Residency

Parcerias e ecossistemas que sustentam a operação.

AWS Partner Network

Odoo Ecosystem

Acquia · Drupal

SYNQi³ Product

Como transformamos complexidade em clareza.

Tecnologia sem engenharia é frágil.

Engenharia sem inteligência é incompleta.

Insights mais recentes

Quando hospedagem vira infraestrutura

O silêncio estrutural do Drupal no Brasil

Quando a operação começa a responder

O Fim dos "Usuários"

já passou da camada de promessa.A próxima conversa é técnica.

Vamos construir algo que faça sentido para o seu futuro tecnológico.

já passou da camada de promessa.
A próxima conversa é técnica.