What happens when you take a centuries-old symbolic decision system and try to implement it as software?
Not a chatbot that imitates its language.
Not an AI prompt that produces something that sounds traditional.
A system that actually executes the underlying rules.
That is the engineering problem behind SAGE — the School of Ancient Geomantic Education.
SAGE is building a growing portfolio of specialized decision tools based on Western Geomancy and Indian Ramal. The three newest additions are Temporal Engineering (Muhurta), Idea Validation (Prashna), and Venture Viability Oracle.
They are different modules for different problems, but they reveal a common architectural principle:
The deterministic engine calculates. The tradition constrains. AI explains.
This post looks at how that works.
The problem with asking an LLM to "do geomancy"
A large language model is remarkably good at producing plausible language.
That is also the problem.
Suppose you ask an LLM to perform a geomantic reading. It can generate figure names, describe planetary associations, interpret houses and produce a convincing narrative.
But convincing is not the same as canonical.
A model can accidentally mix Western geomancy with Indian Ramal. It can assign an incorrect planetary ruler to a figure. It can invent a relationship between houses. It can produce an elegant explanation of a calculation that was never actually performed.
For a system like SAGE, that is unacceptable.
The calculation therefore happens before the language model enters the process.
The AI receives a structured symbolic result and is instructed to interpret that result within the appropriate tradition.
The distinction is fundamental.
The basic pipeline
The architecture can be summarized as:
Real-world question
↓
Use-case-specific model
↓
Canonical geomantic calculation
↓
Structured judicial evaluation
↓
AI synthesis
↓
Human-readable guidance
The three latest modules demonstrate three different implementations of that pipeline.
Muhurta works backwards from a desired outcome.
Prashna converts an inquiry into a deterministic chart.
Venture Viability applies a Western judicial model to a proposed undertaking.
The underlying principle remains the same: the LLM is downstream of the calculation.
1. Muhurta: solving the chart backwards
Temporal Engineering is the most algorithmically unusual of the three.
A normal reading starts with a chart and interprets it.
An electional system asks a different question:
What configuration would be desirable for the event I want to perform?
SAGE therefore treats Muhurta as an inverse problem.
The implementation defines all four-bit binary figure patterns and enumerates their combinations, producing the complete 65,536-chart possibility space.
Instead of repeatedly constructing arbitrary charts, the system pre-indexes the results according to the desired H15 and H10 outcomes.
That makes it possible to search for charts satisfying a particular event objective.
The engine then applies additional structural filters.
It checks, for example, for an antagonistic elemental relationship between the 1st and 7th houses and for specified shield-breach conditions.
Only suitable candidates are retained.
The event itself becomes part of the model
The system does not treat every action as equivalent.
The event dictionary maps practical activities to different H10/H15 targets. Current mappings include business or project launches, housewarming, marriage, vehicle purchase, investment, travel, contract signing, professional consultation, wellness, property purchase, job changes, education, lawsuits and resignation.
That creates an important software pattern:
User describes an event
↓
Event classified
↓
Geomantic target selected
↓
Inverse search
↓
Candidate charts filtered
↓
Best configuration selected
The user sees a simple timing tool.
Underneath, the system is solving a constrained search problem across a finite symbolic state space.
The resulting candidate chart provides the required first-house figure, elemental context and planetary ruler.
Only then does the AI generate the natural-language explanation.
The prompt itself explicitly tells the model not to expose the internal matrix terminology and instead provide a practical timing prescription, including the relevant planetary hour and elemental guidance.
That is a useful general design pattern:
keep implementation complexity inside the engine; expose the useful result through the interface.
2. Prashna: making an open-ended inquiry deterministic
Prashna presents a different problem.
A user can ask almost anything.
How do you ensure that the same inputs lead through the same computational process?
SAGE creates a deterministic canonical signature.
The implementation normalizes the querent's name and event name, combines them with the supplied question, hashes the composite string and uses that result to create the seed for the Ramal chart.
The important part is not the hash itself.
It is the architectural separation between:
input → deterministic symbolic state → interpretation
The chart is then evaluated through predefined judicial dimensions.
The implementation extracts:
- 1st House — querent readiness
- 4th House — foundation and stability
- 7th House — external factors and opposition
- 9th House — auspiciousness
- 10th House — public outcome and career impact
- 11th House — realization, success and gains
- 15th House — Judge / final verdict
This turns a vague question into a structured diagnostic.
The output is similarly structured before AI synthesis begins.
For example, the system separately constructs explanations for the timing/auspiciousness dimension, readiness, foundation, success factors and final verdict.
The language model then receives those computed values and is explicitly told to preserve doctrinal purity and use only the Indian Ramal figure names.
Again:
the model does not calculate the chart.
It explains the chart.
3. Venture Viability: same architecture, different canon
The Venture Viability Oracle demonstrates another important software principle:
shared architecture does not require shared doctrine.
This module is explicitly Western-exclusive and uses the Agrippan Geomantic Judicial Canon.
Its input is transformed into a deterministic signature in the same general manner as Prashna, but the resulting chart is generated with:
generate_chart(mothers, tradition="western")
rather than the Ramal tradition.
The judicial dimensions are again explicit:
1st House — readiness
4th House — foundation
7th House — external factors
9th House — fortune and favour
10th House — public outcome
11th House — gains
15th House — Judge
The synthesis layer is then given the computed Western figures, elements and planetary rulers.
It is also explicitly instructed not to mix in Indian Ramal figure names.
This separation is deliberate.
A common software abstraction might tempt us to create one generic "geomancy" vocabulary and let the model fill in the differences.
We chose the opposite approach.
The architecture can be shared.
The canon cannot be casually merged.
Why deterministic computation matters
The word "AI" tends to make people assume that the entire system is probabilistic.
That does not have to be true.
In SAGE, the symbolic calculation can be deterministic even though the final narrative is generated by an AI model.
That creates an interesting hybrid architecture:
Deterministic layer
↓
Canonical figures
↓
Judicial structure
↓
Probabilistic language layer
The deterministic portion establishes what was calculated.
The language model determines how that result is communicated.
That division gives us several advantages.
Reproducibility
The underlying symbolic calculation follows an explicit computational pathway.
Doctrinal control
Figure properties and house meanings can come from structured canonical data rather than model memory.
Tradition separation
Western and Ramal calculations can use distinct datasets and generation rules.
Better AI behavior
The model receives a constrained symbolic state rather than being asked to invent one.
This is particularly visible in the prompts used by the new modules, which provide the model with the computed figure, element and planetary ruler information before requesting synthesis.
The broader SAGE architecture
These three modules are not the whole SAGE platform.
They are the latest additions to a much larger and growing portfolio of specialized decision tools.
That distinction matters.
The objective is not to build one giant geomantic engine that tries to answer every question.
It is to develop a reusable computational foundation and then build specialized modules around different categories of uncertainty.
That means a use case can determine:
- which tradition is appropriate,
- which inputs matter,
- which houses deserve emphasis,
- which judicial rules apply,
- what constitutes the relevant outcome,
- and how the final result should be translated into practical guidance.
The architecture therefore looks more like a platform than a single oracle:
SAGE
│
┌───────────────┼───────────────┐
│ │ │
Use Case A Use Case B Use Case C
│ │ │
Canon / Model Canon / Model Canon / Model
│ │ │
Deterministic Deterministic Deterministic
Engine Engine Engine
│ │ │
└───────────────┼───────────────┘
│
AI Synthesis
│
User Guidance
The reusable part is the infrastructure.
The specialized part is the decision model.
That is how an ancient symbolic system can gradually become a modern software platform.
The engineering lesson
There is a broader software-engineering lesson here that goes beyond geomancy.
When a system contains domain-specific rules, it can be tempting to put those rules inside an LLM prompt.
That is often the fastest way to produce a demo.
It is not necessarily the best way to produce a dependable system.
A stronger pattern can be:
formalize the domain → execute the rules deterministically → pass structured results to the LLM → constrain the narrative layer
The same architecture could be useful in many domains where rules are explicit but explanations are naturally expressed in human language.
The model becomes a communication layer rather than an authority on the underlying calculation.
That is the distinction we are trying to preserve at SAGE.
The ancient system is the specification
One of the most interesting consequences of this work is that implementation forces ambiguity into the open.
A manuscript may say something that sounds perfectly clear to a human reader.
A program cannot work with "something like this."
The software needs to know:
What is the input?
What is the transformation?
What are the legal states?
What is the relationship between positions?
What happens when a condition conflicts with another condition?
Which tradition does a figure belong to?
Which properties are authoritative?
What constitutes an impossible configuration?
In the Muhurta engine, for example, the software explicitly handles impossible H15/H10 combinations and refunds the transaction when no valid chart can satisfy the requested conditions.
Encoding the doctrine therefore becomes a form of doctrinal clarification.
The computer is unforgiving.
And that can be useful.
Building a Silicon Oracle
The phrase we use internally for this broader vision is the Silicon Oracle.
Not because silicon somehow replaces the ancient oracle.
Because the computer can perform the repetitive, formal and combinatorial work that would be difficult to execute manually, while preserving the symbolic logic of the original system.
The result is a new division of labor:
Ancient doctrine provides the model.
Software executes the model.
AI communicates the result.
And the user brings the actual decision.
That last part matters.
SAGE is not designed to remove human agency.
The purpose of the system is to create a structured perspective around uncertainty.
The final decision still belongs to the person asking the question.
Where this goes next
Muhurta, Prashna and Venture Viability are only the latest additions to SAGE.
The more ambitious project is the growing portfolio itself.
As additional decision categories are modeled, the same underlying principles can be reused:
identify the decision problem,
select the appropriate tradition and canon,
encode the relevant rules,
generate the symbolic state deterministically,
evaluate it through the appropriate judicial framework,
and let AI turn the structured result into understandable guidance.
That is the direction in which we are building SAGE.
Not a chatbot that pretends to know ancient divination.
Not a generic AI oracle.
But a growing collection of specialized decision tools built from ancient geomantic systems and engineered for modern questions.
Ancient systems.
Structured logic.
Modern engineering.
That is the experiment.
Explore the platform at dotsofdestiny.com.
Top comments (0)