Roadmap

1. Get familiar with the problems already solved in the literature

Status: Partly done

The first stage is to map the field: planning, LLM+P, SatLM, Logic-LM, LINC, ProSLM, checked policies and LLM-Modulo, and to see what each of them solves and how.

The state-of-the-art survey is published on the Research page. Reproducing the worked problems of that literature with our own engine is the next step, and has not been done yet.

2. Logic by levels

Status: Levels 0–3 built and measured on test benches; shell level to be defined

Level 0 is facts and rules: the electrical circuit written in Prolog. Level 1 is an agent that talks in natural language and translates and validates what it hears. Level 2 uses meta-interpreters that verify, plan, install and learn over the same logic. Level 3 treats context as a program: a meta-interpreter builds the context and wakes a language model.

Above these sits a shell level, where the logic would drive real machine commands. The installer has run real tests on one machine (three conversations, 116 s in total; see Evidence). This is also where Logitration is meant to connect to the house’s shell agent; how, exactly, is to be defined.

Level 3 in detail: context and context loading

Status: Built at level 3; the experiment behind it is on the Evidence page

At level 3 the context is a program. By context we mean the specification that the meta-interpreter builds to wake a language model. When the logic reaches a gap, a fact or a rule that is missing (hueco/3), it assembles the pieces (pieza/3):

• signature of the function it expects, derived from a closed catalogue;
• examples taken from the logic base itself;
• the observed failure;
• the previous attempts, each with the reason the validator rejected it;
• the logical path that led to the gap.

Whoever asks only declares what is wanted; the rest is derived from the logic.

Loading. despierta/2 loads that context into the model piece by piece, and the model starts to work: sonnet up to three times, then opus up to two. A validator checks what comes back. If it rejects, the reason is added to the context and the model tries again. Only if every attempt fails does informe/2 go to a person.

Which pieces matter. In an experiment with 21 tasks and 9 variants of the context, sonnet’s first answer succeeded 0 % of the time with only the request, 87 % with the signature, 52 % with examples alone and 83 % with signature plus examples. The signature is the decisive piece; examples did not add on top of it. In the recipe we measured, signature, examples and previous attempts are sent; the observed failure is sent only when the gap is a fact; the logical path is computed but not sent (it feeds the report).

Limit: three samples per cell and wide intervals; differences below about ten points are not a signal.

3. Rule learning

Status: First experiments

The idea is that the knowledge base learns new facts, with a reason and a version, when something fails; that the client can teach it in plain language; and that a person only intervenes at the end, with a report in hand. A first study has the agent adapt to a foreign database: with sample rows the facts came out exactly right in 27 of 27 runs, without them in 7 of 27. That study is unpublished.

Limit: the validator checks form, not truth. An adapter can be accepted and still be wrong, which is why the human confirmation at the end stays.

Memory as a logical concept

Status: Partly built

What does it mean for memory to be logical? That it is not a separate store: it is facts in the logic base itself. Part of it exists:

• What was learned: each learned fact is added to the same base with its reason, time and version (aprendido/4) and is saved so it reloads on restart.
• What was measured: a cache of measured facts (hay/4, no_hay/4). The first query measures; the second, identical one does not.
• What was programmed: each version is kept per conversation, a new one is created only when something changed, and the previous one is kept.

Because it is logic, memory can be queried, can explain why something is known, and can be withdrawn or versioned with the same rules.

Pending: persisting the conversations and what the agent itself installed, which today live in the server’s memory.

4. Corpus generation by the logic engine

Status: Not started; the ingredients exist

The engine can produce conversations and questions such as “what is lit, why is it lit, why is it not” on randomly generated circuits, with answers that are exact by construction. An independent simulator, written without Prolog, has already agreed with the core on the answers we checked (19 of 19 in real conversations, see Evidence), which gives us a label oracle.

The generator itself is not built, and we give no corpus sizes.

5. Model fine-tuning

Status: Not started

The goal is to use that corpus to fine-tune a small model to translate what a person says into facts and queries, and to phrase the answer, with the validator and the Prolog core as judges.

The baseline is the same model without context, or with the function signature. In a prompt experiment on one model, success was 87 % with the signature and 0 % without. No dates and no promised results.

The parallel research line on neural networks (see below) also feeds this stage: it has measured a much lower energy cost when only the last layer is adjusted, within the limits stated there.

Parallel lines

Status: Both to be migrated; not started

Besides the main path there are two lines that would run alongside it. Which research lines and tools move into Logitration, and who moves them, is not decided yet.

A parallel research line on neural networks (ladder)

To be migrated / Not started. A research line that works with neural networks would be migrated into Logitration as a parallel line. It would give access to neural networks. It connects with stage 5, fine-tuning, but does not depend on it.

This line also feeds fine-tuning. Its work on adjusting only the last layer of a model measured a much lower energy cost in the scenario described: with 1,000 examples and 4 classes, solving only the last layer exactly used between 14 and 90 times less chip energy, 14 to 43 times less time and one eighth of the memory of the Adam optimiser, staying within 1–2 points of the best gradient-descent result (matching or exceeding it at one model size, 1.4B). Limit: with 10,000 examples gradient descent does better, so moving only the last layer has a ceiling. These are measurements from the line’s own research notes, not yet published.

The building: a graphical interface for agent control

To be migrated / Not started. The building is the graphical interface in which the agents are seen and controlled. It would be migrated as Logitration’s graphical interface for agent control. It fits the shell level and the levels of logic, which govern the agents.