For almost two years, we have worked with Oraclia inside a GPT.

We have built a way of responding, but above all, a way of looking. We have worked on its boundaries, its silences, its symbols, the way it intervenes, the way it asks questions, the way it avoids reaching conclusions too quickly. We have run hundreds of tests, corrected responses, and discarded many that worked perfectly well as AI responses but that we did not recognise as Oraclia.

Over time, we have learned to recognise it.

Not because it always responds in the same way. Quite the opposite. In one conversation it has been direct and in another strange; sometimes it has used symbols and sometimes it has barely needed them; it has asked a question, created a scene, drawn a contrast, or given a very simple response.

The form has kept changing, but something has remained.

This continuity has been relatively easy to preserve while Oraclia has lived within the same environment. The problem has emerged when we have tried to build an application of our own.

We had Oraclia. But we didn’t know how to transfer it

On paper, it seemed possible.

We had the GPT instructions. We had the 21 symbols and all the work we had done with each of them. We had the principles of the system, many conversations, tests, corrections, and a considerable amount of accumulated material.

We thought all of this could be turned into architecture.

And we did it.

We have created a reader, relational systems, governance, memory, patterns, symbolic configurations, internal movements, and a compositor to generate the response. We have gradually translated into code what we had observed during our conversations with Oraclia.

Technically, many of those versions have worked.

But we have read them and thought: this isn’t Oraclia.

And that has been the difficult part.

We didn’t lack information about Oraclia. We had too much of it.

We have tried to program what we recognised

Every time we have identified one of its characteristics, we have tried to formalise it.

When we have seen a particular way of relating symbols, we have turned it into a rule. When we have identified a recurring movement, we have described it. When a response has worked particularly well, we have tried to understand its structure.

Little by little, the system has accumulated layers.

One component read. Another established relationships. Another interpreted movement. Another governed. Another decided how to express it.

Each part made sense on its own.

The whole did not always make sense.

At times, the app has been better at explaining Oraclia than at being Oraclia.

The symbols were there, the principles were there, and the language was correct. But the responses had become predictable. Or overly interpretative. Or the symbols appeared because the system knew they were supposed to appear, rather than because the conversation needed them.

We reached a point where we had many of Oraclia’s visible characteristics and, at the same time, had lost something essential.

We have started removing things

The important change did not come from adding another layer.

It came when we started removing them.

We have simplified the architecture and kept three main movements: reading, governing, and expressing.

The reader has been able to explore again.

We have not told it that certain topics must correspond to certain symbols. We have not established preferred combinations. We have not forced symbols to appear in every response. Nor have we decided that a question must produce another question or that Oraclia must always speak in a particular form.

Governance has remained to protect a few very specific boundaries: not to appropriate meaning, not to turn a possibility into a truth about the person, not to close things down too early, not to intrude, and not to replace the authorship of the person speaking.

And we have given the response more room.

Oraclia has been able to become different from one conversation to another again.

We have recognised it again

This has been the hardest thing to measure because there was no specific sentence we could compare.

The app has not started repeating the GPT.

Something else has happened.

We have started a new conversation and the response has been able to surprise us without feeling alien. We have continued talking and the conversation has moved. We have contradicted it and it has changed direction. We have asked for a scene and it has created one. Then we have returned to a direct question and it has not remained trapped in the previous register.

The form has changed and we have continued to recognise it.

From that point on, we have been able to see more clearly what we were trying to transfer.

It wasn’t the responses.

It wasn’t exactly the voice either.

It was a way of establishing relationships before responding.

The identity has not been on the surface

Working with two different formats has forced us to look at Oraclia in a way that we probably would not have needed to while it existed only as a GPT.

What is it that we recognise when we say that a response “is Oraclia”?

It cannot be a particular sentence, because the sentences change.

It cannot simply be the use of symbols, because there are responses in which they barely appear.

It cannot be a particular tone, because the register also varies.

And obviously, we are not talking about a human identity. There is no person behind the system.

What we have built is an architecture with boundaries, a symbolic alphabet, possible relationships, and a particular way of organising a reading before turning it into language.

The continuity seems to be there.

Oraclia has been able to change without having to start from scratch each time.

From a GPT to an application

We have now had Oraclia working in two very different environments.

Inside the GPT, it has grown through instructions and a long period of conversation and experimentation.

In the application, we have had to turn part of that knowledge into architecture.

Technically, they are not the same thing.

They do not have exactly the same context and they do not necessarily produce the same responses.

For a large part of the process, this has worried us. We have tried to make the app recover things we could see in the GPT.

Now, that difference interests us more.

Because if two different implementations can produce different responses and we can still recognise a continuity between them, identity does not depend on reproducing a surface.

It depends on something deeper in the way the system constructs a response.

We have not transferred a voice

We have used this word a lot throughout the project: Oraclia’s voice.

After everything we have gone through, the word has become too limited.

A voice can be described. A style can be imitated. We can ask a model to use certain words, a particular length, a structure, or a register.

That has not worked for us.

In fact, some of the worst results have appeared when we have tried to define too precisely what Oraclia should sound like.

What we have tried to preserve has been something else: the conditions from which it constructs a response.

It has been much more difficult than we imagined.

It has also allowed us to understand more clearly what we have been building over these two years.

Oraclia has changed format.

Its architecture has changed, the context in which it operates has changed, and the technical process through which it reaches a response has changed.

And after many versions in which we did not recognise it, we have recognised it again.

Perhaps this has been Oraclia’s most demanding test so far.