diff --git a/include/evaluator.h b/include/evaluator.h
index d176bd2..78c5730 100644
--- a/include/evaluator.h
+++ b/include/evaluator.h
@@ -2,7 +2,6 @@
 #define EVALUATOR_H
 
 #include "lexer.h"
-#include "arena.h"
 #include <stdint.h>
 
 int64_t evaluate(ASTNode *tree);
diff --git a/include/parser.h b/include/parser.h
index 03d5443..edae5fb 100644
--- a/include/parser.h
+++ b/include/parser.h
@@ -14,6 +14,11 @@ typedef struct {
     size_t pos;
 } ASTNodeSlice;
 
+typedef struct {
+    Arena *arena;
+    AST tree;
+} ParseResult;
+
 ASTNode ASTNodeSlice_peek(ASTNodeSlice *slice);
 ASTNode ASTNodeSlice_next(ASTNodeSlice *slice);
 bool ASTNodeSlice_is_valid(ASTNodeSlice *slice);
@@ -24,7 +29,7 @@ ASTNode *led(ASTNodeSlice *slice, size_t right_precedence);
 uint8_t node_lbp(ASTNode node);
 uint8_t node_rbp(ASTNode node);
 
-AST parse(ASTNodeArray *arr);
-ASTNode *parse_expr(ASTNodeSlice *slice, uint8_t min_bp);
+ParseResult parse(ASTNodeArray *arr);
+ASTNode *parse_expr(ASTNodeSlice *slice, Arena *arena, uint8_t min_bp);
 
 #endif // !PARSER_H
diff --git a/src/evaluator.c b/src/evaluator.c
index 219f854..754fefd 100644
--- a/src/evaluator.c
+++ b/src/evaluator.c
@@ -1,7 +1,7 @@
 #include "evaluator.h"
 #include "lexer.h"
 #include <stdint.h>
-#include <stdlib.h>
+
 
 int64_t evaluate(ASTNode *tree) {
     if (tree->type == NODE_BINARY_OP) {
@@ -9,8 +9,6 @@ int64_t evaluate(ASTNode *tree) {
         ASTNode *left = tree->data.binary.left;
         ASTNode *right = tree->data.binary.right;
         
-        free(tree);
-
         switch (op) {
             case OP_ADD:
                 return evaluate(left) + evaluate(right);
@@ -24,7 +22,6 @@ int64_t evaluate(ASTNode *tree) {
         }
     } else {
         int64_t return_val = tree->data.integer;
-        free(tree);
         return return_val;
     }
 }
diff --git a/src/main.c b/src/main.c
index 26053e9..b85197e 100644
--- a/src/main.c
+++ b/src/main.c
@@ -1,3 +1,4 @@
+#include "arena.h"
 #include "evaluator.h"
 #include "lexer.h"
 #include "parser.h"
@@ -21,8 +22,10 @@ int main(void) {
     ASTNodeArray context;
     tokenize(buf, &context);
 
-    AST tree = parse(&context);
+    ParseResult par = parse(&context);
+    AST tree = par.tree;
     int64_t result = evaluate(tree.head);
+    arena_destroy(par.arena);
 
 
     printf("El resultado es: %" PRIi64 "\n", result);
diff --git a/src/parser.c b/src/parser.c
index 6803508..4d42001 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -1,6 +1,7 @@
 #include "parser.h"
 #include "lexer.h"
 #include "arena.h"
+#include <stdalign.h>
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdlib.h>
@@ -61,19 +62,33 @@ bool ASTNodeSlice_is_valid(ASTNodeSlice *slice) {
     return true;
 }
 
-AST parse(ASTNodeArray *arr) {
+ParseResult parse(ASTNodeArray *arr) {
     AST tree;
     ASTNodeSlice context = {
         .arr = arr,
         .pos = 0,
     };
+    Arena arena = arena_init(sizeof(ASTNode) * arr->len).arena;
 
-    tree.head = parse_expr(&context, 0);
-    return tree;
+    tree.head = parse_expr(&context, &arena, 0);
+    return (ParseResult) {.arena = &arena, .tree = tree};
 }
 
-ASTNode *parse_expr(ASTNodeSlice *slice, uint8_t min_bp) {
-    ASTNode *left_side = malloc(sizeof(ASTNode));
+ASTNode *parse_expr(ASTNodeSlice *slice, Arena *arena, uint8_t min_bp) {
+    arena_ensure_capacity(
+        arena,
+        sizeof(ASTNode),
+        alignof(ASTNode)
+    );
+
+    ASTNode *left_side = arena_unwrap_pointer(
+        arena_alloc(
+            arena,
+            sizeof(ASTNode),
+            alignof(ASTNode)
+        )
+    );
+
     *left_side = ASTNodeSlice_next(slice);
 
     while (true) {
@@ -90,7 +105,7 @@ ASTNode *parse_expr(ASTNodeSlice *slice, uint8_t min_bp) {
         }
 
         ASTNodeSlice_next(slice);
-        ASTNode *right_side = parse_expr(slice, rbp);
+        ASTNode *right_side = parse_expr(slice, arena, rbp);
 
         ASTNode *new_node = malloc(sizeof(ASTNode));
         *new_node = operator;
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 62e14d1..b48356f 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -3,6 +3,7 @@ find_package(cmocka REQUIRED)
 add_executable(test_nodeArray test_ASTNodeArray.c)
 add_executable(test_lexer test_lexer.c)
 add_executable(test_parser test_parser.c)
+add_executable(test_evaluator test_evaluator.c)
 
 target_link_libraries(test_nodeArray
     calculator_lib
@@ -19,6 +20,12 @@ target_link_libraries(test_parser
     cmocka::cmocka
 )
 
+target_link_libraries(test_evaluator
+    calculator_lib
+    cmocka::cmocka
+)
+
 add_test(NAME nodeArray_tests COMMAND test_nodeArray)
 add_test(NAME lexer_tests COMMAND test_lexer)
 add_test(NAME parser_tests COMMAND test_parser)
+add_test(NAME evaluator_tests COMMAND test_evaluator)
diff --git a/test/test_evaluator.c b/test/test_evaluator.c
index cf97930..5fe4114 100644
--- a/test/test_evaluator.c
+++ b/test/test_evaluator.c
@@ -16,7 +16,8 @@ static void test_basic_evaluation(void** state) {
     ASTNodeArray context;
 
     tokenize(expr, &context);
-    AST tree = parse(&context);
+    ParseResult result = parse(&context);
+    AST tree = result.tree;
     uint64_t value = evaluate(tree.head);
 
     assert_int_equal(value, 82);
diff --git a/test/test_parser.c b/test/test_parser.c
index 83a6592..7b1f36c 100644
--- a/test/test_parser.c
+++ b/test/test_parser.c
@@ -1,3 +1,4 @@
+#include "arena.h"
 #include "lexer.h"
 #include "parser.h"
 #include <stdarg.h>
@@ -17,7 +18,8 @@ static void test_parsing_basic_expression(void **state) {
     assert_int_equal(tokenize(expr, &tokens), LEXER_OK);
     assert_int_equal(tokens.len, 7);
 
-    AST tree = parse(&tokens);
+    ParseResult result = parse(&tokens);
+    AST tree = result.tree;
     // Assert head is +
     assert_int_equal(tree.head->type, NODE_BINARY_OP);
     assert_int_equal(tree.head->data.binary.op, OP_ADD);
@@ -68,6 +70,7 @@ static void test_parsing_basic_expression(void **state) {
             tree.head->data.binary.right->data.binary.left->data.binary.left->data.integer, 
             3
             );
+    arena_destroy(result.arena);
 }
 
 int main(void) {