Engineering division of the ATUO group

We build the intelligence behind the next decade of business.

Engineering that sustains operation. Intelligence that operates before the question exists.
Systems, product and applied intelligence, in a single technical team.

Talk to engineering→See 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}

NewsroomRecent signals from the operation.

See all→

In production01

Latest delivery

Ōkami behavioral retention engine in continuous operation, with short-window inference.

Churn −36% · 2026→

Recognition02

Technical ecosystem

Code and Soul operates in direct arrangement with AWS, Odoo and Drupal partners on high-scale projects.

Active technical partnerships→

Press03

ATUO Group

Code and Soul consolidates the engineering division of the ATUO group in a four-division arrangement.

atuo.com.br→

Manifesto

Engineering, not promise.

When we state something, either proof stands beside it or it is a declared manifesto.

Real problems are rarely purely technical. They cut across strategy, experience and engineering.

We operate across the three axes the market keeps apart.

Thesis

“

The system is the thesis. The rest is window dressing.
Code and Soul · method

What we do

Three disciplines. One engineering.

01Systems Engineering

We architect systems that can't fail.

We build robust platforms, scalable ecosystems, and systems that operate under pressure. From backend to infrastructure, we create foundations that enable real growth.

Distributed architecture

API-first / Headless

Deep integrations (ERP, CRM, POS, OMS)

Cloud-native, observability, security

02Product Engineering

We transform problems into living products.

Design, engineering, and purpose working together. We create digital products that work in practice, not just on screen.

Technical UX

System design

Advanced prototyping

Corporate and operational applications

03Autonomous Intelligence

Systems that learn, anticipate, and execute.

We create applied intelligences that combine rules, behavior, data, and continuous learning. Automation stops being static and becomes dynamic.

Intent detection

Hybrid models (rules + ML)

Automatic actions

Continuous personalization

ATUO Group

Code and Soul is the engineering division of the ATUO group.

We operate in three modes. In an arrangement with ATUO.agency, ATUO.digital and SYNQi³, when the problem cuts across strategy, product and platform. Separating the layers costs more than integrating them. Independent, on purely technical mandates: critical refactoring, platform architecture, data, observability. As an engineering layer inside teams that already have a product but need the depth to scale without rebuilding.

ATUO.agency

Strategy, positioning, brand narrative.

ATUO.digital

Product, design, experience.

03Here

Code and Soul

Applied engineering and systems architecture.

SYNQi³

Proprietary product of the group. Operational intelligence in production.

Explore the ATUO group→

Engineering 24/7
Multi-tenant
Event-driven
AWS Partner
Odoo Ecosystem
Drupal Association
SYNQi³
Real Estate
Hospitality
Telecom
Global Advertising
Operational intelligence
Retention
Edge computing
Observability
Serverless
Cloud-native
Continuous ETL
Inference in production
Defensive architecture

Engineering in action

Engineering in layers.

Depending on the problem, the ATUO group activates the divisions it demands. Pure engineering, engineering with intelligence, or complete operation.

Cut by vertical

Layer 01

Direct technical engineering

When the problem is architectural.

ArrangementCode and Soul direct

Telecom01 · 01

Digital ecosystem of a national carrier, sustained in 24/7 production.

Channels, APIs and critical integrations for millions of active users. Direct technical delivery in arrangement with an ecosystem partner.

Millions of users · 24/7 in production

Read full case →

Global advertising01 · 02

Digital platforms for multi-country campaigns of a global brand.

Audience at international scale, publishing pipelines and content governance. Direct engineering with a partner global agency.

Multiple markets · editorial pipeline in production

Read full case →

Hospitality · F&B Activation01 · 03

Serverless 2026 World Cup picks platform for Fabrik7.

Real-time scoring across 104 matches in 38 days. Immutable ledger, embedded anti-fraud, end-to-end simulator. Built to scale up and shut down cheap.

25 Lambdas · 21 DynamoDB · 3h50 of simulated Cup

Read full case →

Layer 02

Engineering + Applied intelligence

When the problem demands real-time decision.

ArrangementCode and Soul + SYNQi³

Real estate · AgoraFecha02 · 01

Serverless, multi-tenant, event-driven marketplace, with an intelligence layer.

Cloud-native architecture with tenant isolation and event-based scalability. SYNQi³ layer attached for behavioral reading in real time.

Isolated multi-tenant · predictable per-tenant cost

Read full case →See the intelligence layer in SYNQi³ →

Retention · Ōkami02 · 02

Behavioral retention engine sustained by operational intelligence.

Short-window churn risk detection with automatic intervention triggers. Data engineering and inference in continuous production.

Churn −36% · short-window inference

Read full case →See the intelligence layer in SYNQi³ →

Layer 03

Complete operation

When the problem is the whole business.

ArrangementCode and Soul + SYNQi³ + Valfredo + Odoo

Hospitality · Fabrik703 · 01

Continuous operation of brewery and gastrobar, sustained end-to-end by the group.

Group's own venture. Engineering (Code and Soul), operational intelligence (SYNQi³), operation and management (Valfredo) and ERP backbone (Odoo) in a single arrangement, in real production.

7×24 operation in production · 4 divisions in a single arrangement

Read full case →See the operation in Valfredo →See intelligence in SYNQi³ →

Featured in industry press

Engineering behind award-winning work.

When agencies and brands need the idea to actually work in production.

Hand holding a phone running the Chevrolet Zap Racing game on WhatsApp

Photo: Forbes Brasil / handout

Forbes Tech2022

Chevrolet

Zap Racing

We built and shipped the entire WhatsApp game for the Maio Amarelo road safety campaign: game engine, chatbot, integrations and the full cloud infrastructure.

AgencyCommonwealth//WMcCann

C&STech build & cloud infrastructure

Read the story↗

TIM On Stage platform

Clube de Criação2026

TIM

TIM On Stage

More than a website: a new way to operate digital platforms. Serverless AWS architecture (Lambda, API Gateway, DynamoDB, CloudFront + WAF), a custom extension system, automated security gate (ZAP + Nuclei + TLS), and CI/CD pipeline with controlled environment promotion. Scalability and resilience by default.

AgencyBETC Havas

C&SFull engineering: infrastructure, platform & operations

Read the story↗

In production

Engineering as proof.

Not a curated portfolio. Continuous operation. Each piece below is in real production, sustained by the group engineering.

Telecom platform in production — Telecom · critical channels24/7 operation

AgoraFecha serverless marketplace — Real estate · AgoraFechaMulti-tenant event-driven

SYNQi³ real-time decisions — SYNQi³ · decisionsInference in production

Fabrik7 · brewery and gastrobar — Fabrik7 · real operation7×24 in production

Ōkami operation · retention engine — Retention · ŌkamiChurn −36%

Engineering team in operation — Engineering · in the fieldDirect engineering

SYNQi³

SYNQi³ — Where engineering becomes intelligence.

SYNQi³ does not organize data.
It changes how decisions are made.

Events stop being records. They become execution triggers.

It operates as continuous infrastructure, independent of vertical.

SYNQi³

The system in one line

Hover over each stage to open the description.

THE SYSTEM

Events enter. Patterns emerge. Deviations are identified.

Decisions are evaluated. Actions are executed.

Results return as new data.

No interruption. No dependency on human reading.

Most observe.

SYNQi³ operates.

IN NUMBERS

Lambdasin production · us-east-1

Jobsscheduled · all active

5min

Watchdogcontinuous check window

TablesDynamoDB · per-tenant isolation

SYNQi³ · sample flow

real event types · illustrative values

18:45:21event.receivedprofile=p_kijkre· rule=churn_watch · tenant=β

CAPABILITIES

Daily Briefing

Revenue for the day, at-risk profiles, open opportunities, recommended actions. Composed from KPIs, rules and daily summaries the moment you open the panel. A reading that is ready, not a report to run.

Assistant S³

Conversational with active context. Asks the question, proposes a path, answers with cited evidence. RAG over an S3 Vectors store, Bedrock Titan embeddings and Anthropic Claude generation via Bedrock, streamed over WebSocket.

Patterns and watch

Watchdog runs every 5 minutes over metrics and events. Automatic KPI discovery over raw data and behavioral patterns on a rolling window, written as profile attributes. Alerts via WebSocket and webhook.

Rule engine

Event-triggered. Evaluates condition and dispatches action. Webhook, counter, notification, personalization fan-out. With retry, dead-letter, a scheduler that operates on a minute window, and immutable per-execution audit. Step Functions orchestration where the rule demands it.

Predictive intelligence

Churn by recency, frequency and trend. Behavioral K-means clusters, daily acquisition scoring, cross-channel attribution waterfall, each with its measurement window declared. Batch pipelines orchestrated, results written as 360° profile attributes. Signal, not report.

Assisted marketing

Daily sync from Meta Ads and Google Ads. Cohorts and attribution over real spend, and campaign asset generation in the same layer — creative, copy and segment come from observed behavior, not from a template. The reading and the asset are the system's; the campaign adjustment is your call.

TRANSFORMATION FLOW

Events→actionable behavioral signals

Interactions→operational context

Decisions→real-time execution

Results→continuous learning

Profiles→consolidated state

IN PRODUCTION

Serverless architecture operating at scale.

Real-time event processing.

Continuous behavioral model inference.

Execution via integrations and webhooks.

Distributed memory for immediate decisions.

Multi-tenant isolation by design.

Not a concept.

It is operation.

IN THE FIELD

At Fabrik7, every interaction generates context. Orders influence recommendations. Behavior triggers actions. The operation adjusts in real time.

The system can be queried in natural language.

Responses are based on real data.

But the value does not depend on the question. SYNQi³ operates before it exists.

Intelligence is not an additional layer.
It is part of the operation.

Explore SYNQi³→

Research & Development

R&D: Where engineering becomes invention.

We explore the edge of what's technically possible: distributed systems, autonomous architecture, AI-driven decision layers, new models of interaction and engineering methods that anticipate the next decade of digital products.

Experimental Architecture

Prototyping distributed systems and novel computational patterns before they become industry standard.

Autonomous Systems

Self-healing infrastructure and decision engines that operate without human intervention.

Human-machine Interfaces

Next-generation interaction models that blur the line between operator and system.

Applied Intelligence

Machine learning pipelines designed for production-grade reliability and explainability.

High-performance Engineering

Optimization at scale: latency reduction, throughput maximization, resource efficiency.

Read what we publish on this

Engineering Residency

Senior engineers embedded inside product teams — delivering clarity, architecture and execution that cannot fail.

Our residency model brings experienced engineers into mission-critical teams. It's not staff augmentation. It's engineering leadership inside your product.

Backend EngineeringSenior / Lead

Frontend EngineeringSenior / Lead

Cloud & DevOpsSenior / Lead

Data EngineeringSenior / Lead

AI EngineeringSenior / Lead

QA & AutomationSenior / Lead

Teams guided by Code and Soul's architecture standards, engineering culture and technical direction.

Talk about the residency

Technical ecosystem

Partnerships and ecosystems that sustain the operation.

We operate within recognized technical ecosystems. Not as showcase, but as a method commitment to standards already validated at scale.

012024 → active

Cloud · Infrastructure

AWS Partner Network

Cloud-native operation in enterprise projects, with Well-Architected practices applied in production.

022023 → active

ERP · Operational backbone

Odoo Ecosystem

Odoo implementations in production at the group ventures, with custom-designed integrations.

032022 → active

CMS · Critical platforms

Acquia · Drupal

Drupal architecture applied to high-scale portals and editorial environments with technical governance.

04In operation

SYNQi³

Operational intelligence

SYNQi³ Product

Proprietary product of the ATUO group, in continuous production sustaining real-time decisions.

How we work

How we transform complexity into clarity.

Our methodology combines strategy (ATUO.agency), experience (ATUO.digital), and engineering (Code and Soul) to build solutions that survive time, growth, and operational reality.

Deep diagnosis of systems and operations

Data and behavior-oriented architecture

Product design based on real objectives

Continuous engineering + evolutionary intelligence

What we believe

Technology without engineering is fragile.

Engineering without intelligence is incomplete.

Systems exist to solve real problems, not to display interfaces.

The future is not predicted. It's architected.

Intelligence doesn't replace people. It frees people.

Content & Thought

Latest insights

EngineeringApril 23, 2026

If you made it this far

you have already cleared the layer of promise.
The next conversation is technical.

We operate in direct arrangement with product, engineering and operations teams at our clients. No institutional briefing, no long discovery cycle. Straight to the problem.

Talk to engineering→Back to the cases↑

Read the full manifesto

Contact

We build the intelligence behind the next decade of business.

Ōkami behavioral retention engine in continuous operation, with short-window inference.

Code and Soul operates in direct arrangement with AWS, Odoo and Drupal partners on high-scale projects.

Code and Soul consolidates the engineering division of the ATUO group in a four-division arrangement.

Engineering, not promise.

Three disciplines. One engineering.

We architect systems that can't fail.

We transform problems into living products.

Systems that learn, anticipate, and execute.

Code and Soul is the engineering division of the ATUO group.

ATUO.agency

ATUO.digital

Code and Soul

SYNQi³

Engineering in layers.

Direct technical engineering

Digital ecosystem of a national carrier, sustained in 24/7 production.

Digital platforms for multi-country campaigns of a global brand.

Serverless 2026 World Cup picks platform for Fabrik7.

Engineering + Applied intelligence

Serverless, multi-tenant, event-driven marketplace, with an intelligence layer.

Behavioral retention engine sustained by operational intelligence.

Complete operation

Continuous operation of brewery and gastrobar, sustained end-to-end by the group.

Engineering behind award-winning work.

Zap Racing

TIM On Stage

Engineering as proof.

SYNQi³ — Where engineering becomes intelligence.

Daily Briefing

Assistant S³

Patterns and watch

Rule engine

Predictive intelligence

Assisted marketing

R&D: Where engineering becomes invention.

Experimental Architecture

Autonomous Systems

Human-machine Interfaces

Applied Intelligence

High-performance Engineering

Engineering Residency

Partnerships and ecosystems that sustain the operation.

AWS Partner Network

Odoo Ecosystem

Acquia · Drupal

SYNQi³ Product

How we transform complexity into clarity.

Technology without engineering is fragile.

Engineering without intelligence is incomplete.

Latest insights

When hosting becomes infrastructure

The Structural Silence of Drupal in Brazil

When Operations Start Responding

The End of "Users"

you have already cleared the layer of promise.The next conversation is technical.

Let's build something that makes sense for your technological future.

you have already cleared the layer of promise.
The next conversation is technical.