diff --git a/naive-nlu/tree_nlu/knowledge_base.py b/naive-nlu/tree_nlu/knowledge_base.py
index 15355a3..931801f 100644
--- a/naive-nlu/tree_nlu/knowledge_base.py
+++ b/naive-nlu/tree_nlu/knowledge_base.py
@@ -22,63 +22,67 @@ class KnowledgeBase(object):
 
     def train(self, examples):
         knowledge_before = copy.deepcopy(self.knowledge)
+        with session().log('Train'):
+            # Parse everything
+            for example in examples:
+                # If there's parsed data, leverage it ASAP
+                if 'parsed' in example:
+                    with session().log('parsed information integration'):
+                        result = knowledge_evaluation.integrate_information(self.knowledge, {
+                            "parsed": example['parsed'],
+                        })
+                        self.act_upon(result)
 
-        # Parse everything
-        for example in examples:
-            # If there's parsed data, leverage it ASAP
-            if 'parsed' in example:
-                result = knowledge_evaluation.integrate_information(self.knowledge, {
-                    "parsed": example['parsed'],
-                })
-                self.act_upon(result)
+                with session().log("language integration"):
+                    tokens, decomposition, inferred_tree = parsing.integrate_language(self, example)
+                    session().annotate(tokens)
 
-            session().annotate("Example: {}".format(example))
-            tokens, decomposition, inferred_tree = parsing.integrate_language(self, example)
-            session().annotate(tokens)
-            result = knowledge_evaluation.integrate_information(self.knowledge, {
-                "elements": tokens,
-                "decomposition": decomposition,
-                "parsed": inferred_tree,
-            })
+                with session().log("full information integration"):
+                    result = knowledge_evaluation.integrate_information(self.knowledge, {
+                        "elements": tokens,
+                        "decomposition": decomposition,
+                        "parsed": inferred_tree,
+                    })
 
-            session().annotate("Result: {}".format(self.get_value(result)))
-            self.act_upon(result)
-            session().annotate("Set: {}".format(self.get_value(result)))
-            self.examples.append((decomposition, inferred_tree))
-            self.originals.append(example['text'])
+                    session().annotate("Result: {}".format(self.get_value(result)))
+                    self.act_upon(result)
+                    session().annotate("Set: {}".format(self.get_value(result)))
+                    self.examples.append((decomposition, inferred_tree))
+                    self.originals.append(example['text'])
 
-            # Reduce values
-            self.trained = parsing.reprocess_language_knowledge(self, self.examples)
+                # Reduce values
+                with session().log("reprocessing"):
+                    self.trained = parsing.reprocess_language_knowledge(self, self.examples)
 
-        knowledge_after = copy.deepcopy(self.knowledge)
-        knowledge_diff_getter = lambda: diff_knowledge(knowledge_before,
+            knowledge_after = copy.deepcopy(self.knowledge)
+            knowledge_diff_getter = lambda: diff_knowledge(knowledge_before,
                                                        knowledge_after)
 
-        return knowledge_diff_getter
+            return knowledge_diff_getter
 
     def process(self, row):
         row = row.lower()
         knowledge_before = copy.deepcopy(self.knowledge)
-        session().annotate("Process: {}".format(row))
-        tokens = parsing.to_tokens(row)
-        fit = parsing.get_fit(self, tokens)
-        if fit is None:
-            return None
+        with session().log("Process: {}".format(row)):
+            tokens = parsing.to_tokens(row)
+            fit = parsing.get_fit(self, tokens)
+            if fit is None:
+                return None
 
-        tokens, inferred_tree = fit
-        result = knowledge_evaluation.integrate_information(self.knowledge,
-                                                          {
-                                                              "elements": tokens,
-                                                              "parsed": inferred_tree,
-                                                          })
-        self.act_upon(result)
-        session().annotate("Result: {}".format(result))
+            tokens, inferred_tree = fit
+            result = knowledge_evaluation.integrate_information(self.knowledge,
+                                                                {
+                                                                    "elements": tokens,
+                                                                    "parsed": inferred_tree,
+                                                                })
+            self.act_upon(result)
+            session().annotate("Result: {}".format(result))
 
-        knowledge_after = copy.deepcopy(self.knowledge)
-        knowledge_diff_getter = lambda: diff_knowledge(knowledge_before,
-                                                       knowledge_after)
+            knowledge_after = copy.deepcopy(self.knowledge)
+            knowledge_diff_getter = lambda: diff_knowledge(knowledge_before,
+                                                           knowledge_after)
 
-        return result, inferred_tree, knowledge_diff_getter
+            return result, inferred_tree, knowledge_diff_getter
 
     def get_value(self, result):
         if is_modifiable_property(result):
diff --git a/naive-nlu/tree_nlu/session/org_mode.py b/naive-nlu/tree_nlu/session/org_mode.py
index e25600c..b2e0d88 100644
--- a/naive-nlu/tree_nlu/session/org_mode.py
+++ b/naive-nlu/tree_nlu/session/org_mode.py
@@ -41,8 +41,15 @@ class OrgModeSession:
     def __init__(self, fname):
         self.f = open(fname, 'wt')
         self.level = 0
+        self.dirty = False
 
     def annotate(self, annotation):
+        if self.dirty:
+            self.f.write("{indentation} {data}\n".format(
+                indentation='*' * (self.level + 2),
+                data="---"))
+            self.dirty = False
+
         self.f.write("{indentation} {data}\n".format(
             indentation=' ' * (self.level + 2 + 1),
             data=annotation))
@@ -51,6 +58,7 @@ class OrgModeSession:
         self.f.write("{indentation} {data}\n".format(
             indentation='*' * (self.level + 1),
             data=string))
+        self.dirty = False
 
         return LevelContext(self.inc_level, self.dec_level)
 
@@ -59,6 +67,7 @@ class OrgModeSession:
 
     def dec_level(self):
         self.level -= 1
+        self.dirty = True
 
     def close(self):
         self.f.close()
diff --git a/naive-nlu/tree_nlu/tests/gac_100.py b/naive-nlu/tree_nlu/tests/gac_100.py
index 2a7b259..acfe23e 100644
--- a/naive-nlu/tree_nlu/tests/gac_100.py
+++ b/naive-nlu/tree_nlu/tests/gac_100.py
@@ -711,7 +711,7 @@ def main():
                 differences = knowledge.train([question])
                 session().annotate(differences())
 
-            result, _, _ = knowledge.process(data['text'])
+                result, _, _ = knowledge.process(data['text'])
 
             if "after_execution" in data:
                 for f in data["after_execution"]: