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 "gpt-4o-mini",
        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 "gpt-4o-mini",
        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 "gpt-4o-mini",
        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 "gpt-4o-mini",
        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 "gpt-4o-mini",
        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 "gpt-4o-mini",
        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 "gpt-4o-mini",
        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 "gpt-4o-mini",
        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 "gpt-4o-mini",
        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 "gpt-4o-mini",
        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 "gpt-4o-mini",
        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 "gpt-4o-mini",
        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}

Divisão de engenharia do grupo ATUO

We build the intelligence behind the next decade of business.

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→

NewsroomSinais recentes da operação.

Ver todos→

Em produção01

Última entrega

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

Churn −36% · 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. Frases curtas, densidade técnica antes de fluidez de copy, ponto no fim.

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.

Tese

“

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

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.

Operamos em arranjo integrado com ATUO.agency, ATUO.digital e SYNQi³, e também de forma independente em mandatos puramente técnicos. Modelo comparável, em estrutura e não em escala, a Code and Theory Network, R/GA e Frog.

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→

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 →

Camada 02

Engenharia + Inteligência aplicada

Quando o problema exige decisão em tempo real.

ArranjoCode and Soul + SYNQi³

Real estate · 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³ →

Retenção · Ōkami02 · 02

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. Engenharia de dados e inferência em produção contínua.

Churn −0% · inferência em janela curta

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 · 4 divisões em arranjo único

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

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 — Real estate · 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 · ŌkamiChurn −36%

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

Lambdasem produção · us-east-1

Jobsagendados · cron + rate

0min

Watchdogjanela contínua de checagem

TabelasDynamoDB · isolamento por tenant

synqi3 · live · us-east-1

0.4 ev/stail -f /events

10:07:44attribution.resolvedchannel=meta_ads· weight=0.74

10:07:44event.receivedprofile=p_2psjqh· rule=upsell_signal · tenant=δ

CAPABILITIES

Briefing Diário

Toda manhã às 8h, antes do primeiro clique. Receita do dia, perfis em risco, oportunidades abertas, ações recomendadas. Gerado em background pelo motor de relatórios, entregue por e-mail e em painel. Versão semanal consolidada nas segundas.

Assistente S³

Conversacional com contexto ativo. Faz pergunta, propõe plano de execução, age sob aprovação. RAG sobre base vetorial Qdrant com evidência citada e streaming via WebSocket. OpenAI e Bedrock conviventes, troca por configuração.

Detecção e anomalias

Watchdog roda a cada 5 minutos sobre métricas e eventos. Detecção estatística de anomalia, descoberta automática de KPI sobre dado bruto, padrões comportamentais em janela contínua. Alerta via WebSocket e webhook, sinaliza antes do impacto.

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. Pipelines batch orquestrados, resultado gravado como atributo do perfil 360°. Sinal, não relatório.

Marketing em loop

Sync diário de Meta Ads e Google Ads. Cohorts, atribuição, motor de experimentos A/B e creative agents na mesma camada. Loop horário fecha o ciclo entre gasto, métrica e ajuste de campanha. Ciência aplicada, não dashboard.

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.

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.

Reconhecimento 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

O silêncio estrutural do Drupal no Brasil

Plataformas22 de abr. 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↑

Contato

We build the intelligence behind the next decade of business.

Motor de retenção comportamental Ōkami em operação contínua, 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.

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.

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.

Engenharia + Inteligência aplicada

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

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 como prova.

SYNQi³ — Where engineering becomes intelligence.

Briefing Diário

Assistente S³

Detecção e anomalias

Motor de regras

Inteligência preditiva

Marketing em loop

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

O silêncio estrutural do Drupal no Brasil

Quando a operação começa a responder

O Fim dos "Usuários"

A Arquitetura das Experiências

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.