Instead of int i = text.length() it should be i = text.length() - 1 because you make an extra loop.

Also, I’ve changed the return state.

#include <iostream>
#include <string>

bool is_palindrome(std::string text) {
    std::string backwards = "";
    for (int i = text.length() - 1; i >= 0; i--) {
        backwards = backwards + text[i];
    }
    std::cout << backwards << " and " << text << std::endl;
    if (text == backwards) {
        std::cout << "they are equal" << std::endl;
        return true;
    } else {
        std::cout << "they are not equal" << std::endl;
        return false;
    }
}

int main() {
    std::cout << is_palindrome("madam") << "n";
}

It can be implemented easier. The easier code usually has less errors and is easy to debug.

bool is_palindrome(std::string text) {
    return text == std::string(text.rbegin(), text.rend());
}

Even better with inclusion <algorithm> library and not creating a temporary string object

bool is_palindrome(std::string text) {
    return std::equal(text.begin(), text.end(), text.rbegin());
}

Optimized for less CPU consumption time, but a longer code (taking into account that the first half matches the reversed second half in a palindrome):

bool is_palindrome(std::string text) {
    return std::equal(text.begin(), text.begin() + (text.size() + 1) / 2,
                      text.rbegin());
}

You issue in the question is int i = text.length() and access out of string bounds, undefined behavior. In particular practice you get "madam" in backwards, the unprintable first char.

    #include<iostream>
    #incldue<string>
    bool is_palindrome(std::string text) {
        int length = text.length();
        for (int i = 0; i < length / 2; i++) {
            if (text[i] != text[length - i - 1]) {  
                return false;
            }
        }
        return true;
    }
    
    int main() {
        std::string word = "madam";
        if (is_palindrome(word)) {
            std::cout << word << " is a palindromen";
        } else {
            std::cout << word << " is not a palindromen";
        }
        return 0;
    }

I think you are taking string indexes wrong. The above maybe corrected and optimized solution.

You can use a forward and backward iterator to compare the characters front/back to middle like this too.
And better you can test correctness at compile time

#include <string>
#include <string_view>

constexpr bool is_palindrome(std::string_view sv)
{
    auto front = sv.begin();
    auto back = sv.rbegin();

    for (;front < back.base(); ++front,++back)
    {
        if (*front != *back) return false;
    }

    return true;
}

int main()
{
    
    static_assert(is_palindrome("a"));
    static_assert(is_palindrome("aaa"));
    static_assert(is_palindrome("tacocat"));
    static_assert(!is_palindrome("ab"));
}