Family Neural Architecture.

Your feed

A working copy of the synthesis layer below, running entirely in this browser tab — same 64-gate wheel, same 36-channel map, computed against today's real planetary positions. Add a profile for each of you and it turns your birth data into a personalized daily feed.

Full chart

The feed above uses one moment and 10 bodies — enough for a daily signal. A full chart uses two: Personality (conscious, the exact birth moment) and Design (unconscious, the moment the Sun was exactly 88° of ecliptic arc earlier — solved numerically here, not approximated as a flat "88 days", since Earth's orbital speed varies enough across the year to shift that by several days). Together, 13 points each side reveal Type, Strategy, Authority, Profile, and which of the 9 centers are defined — drawn below as an actual bodygraph, not just a list.

Glossary

Scope

The brain model

Seven layers, each with one job and one module. Naming them after brain regions is not decoration — it forces the boundary. Physics never reaches the API, and the API never does math.

1. Brain stem core/ephemeris.py — pyswisseph over NASA JPL ephemeris data. Datetime to Julian day, Julian day to ecliptic longitude for ten bodies. Pure numbers, no interpretation.
2. Cerebellum core/hd_math.py — the pattern map. 360° of longitude onto 64 hexagrams at 5.625° apiece, following a fixed wheel sequence. One function, no state.
3. Hippocampus models/profiles.py — fixed natal baselines for each family member, schema-enforced with Pydantic. Written once, read every day.
4. Prefrontal services/synthesis.py — the delta between today's transits and natal memory, then a branch on age. An adult gets metrics; a child gets a parenting instruction.
5. Autonomic workers/cron.py — Ray actors run the whole chain at midnight and cache the result. Nothing is computed inside a request.
6. Motor main.py — FastAPI serves the precomputed payload. The endpoint is a cache read, which is why it stays fast under a toddler's tapping.
7. Network Second brain — a graph database and embedding pipeline that correlates what the family actually experienced against what the sky was doing. The only layer that learns.

The wheel

The whole symbolic system reduces to one integer division. The Human Design wheel starts at Gate 41 sitting at 302.25° of the zodiac, and the 64 gates are distributed evenly from there — so mapping a longitude to a gate is an offset, a modulo, and an index into a fixed sequence.

HD_START_DEGREE = 302.25
GATE_WIDTH = 360 / 64  # 5.625 degrees

WHEEL_SEQUENCE = [
    41, 19, 13, 49, 30, 55, 37, 63, 22, 36, 25, 17, 21, 51, 42, 3,
    27, 24,  2, 23,  8, 20, 16, 35, 45, 12, 15, 52, 39, 53, 62, 56,
    31, 33,  7,  4, 29, 59, 40, 64, 47,  6, 46, 18, 48, 57, 32, 50,
    28, 44,  1, 43, 14, 34,  9,  5, 26, 11, 10, 58, 38, 54, 61, 60,
]

def calculate_gate(longitude: float) -> int:
    adjusted_long = (longitude - HD_START_DEGREE) % 360
    index = int(adjusted_long // GATE_WIDTH)
    return WHEEL_SEQUENCE[index]

Longitudes come from the layer below it. swe.julday() converts the timestamp, swe.calc_ut() returns the ecliptic position, and the first element of that result is the only number the cerebellum ever sees.

def get_daily_planets(dt: datetime.datetime) -> Dict[str, float]:
    """Calculates precise ecliptic longitudes for a given timestamp."""
    fractional_hour = dt.hour + (dt.minute / 60.0) + (dt.second / 3600.0)
    jd = swe.julday(dt.year, dt.month, dt.day, fractional_hour)

    longitudes = {}
    for name, planet_id in PLANETS.items():
        calc_result, _ = swe.calc_ut(jd, planet_id)
        longitudes[name] = calc_result[0]

    return longitudes

Daily run

The same four steps every night, off the request path entirely. By the time anyone opens the app, the day's answer already exists.

@ray.remote
def process_daily_transits():
    today_longitudes = get_daily_planets(datetime.datetime.utcnow())

    today_gates = {
        planet: calculate_gate(lon)
        for planet, lon in today_longitudes.items()
    }

    daily_cache = {}
    for member in db.get_family("family_id_1"):
        daily_cache[member.name] = generate_insights(
            member.natal_gates, today_gates, member.age
        )

    db.save_daily_weather(daily_cache)

Profiles

Four people, two output shapes. An adult reads their own weather and decides what to do with it. A child never sees theirs — it is written for the parent, as an instruction about the environment, not a label about the kid.

CHANNELS = {
    frozenset([1, 8]):   "Inspiration",
    frozenset([2, 14]):  "The Beat",
    frozenset([3, 60]):  "Mutation",
    frozenset([43, 23]): "Structuring",
}

def generate_insights(natal_gates, transit_gates, age) -> dict:
    """Detects chart activations and generates age-specific daily weather."""
    activations = []
    natal = set(natal_gates.values())
    transit = set(transit_gates.values())

    for pair, name in CHANNELS.items():
        a, b = list(pair)
        if (a in natal and b in transit) or (b in natal and a in transit):
            activations.append(name)

    if age >= 18:
        return {
            "focus": "Deep Work" if "Structuring" in activations else "Adaptive",
            "communication_friction": "Low" if "Inspiration" in activations else "Moderate",
            "activations": activations,
        }

    return {
        "parenting_focus": parenting_copy(age, activations),
        "activations": activations,
    }

The payload

One endpoint. GET /api/v1/daily-weather returns the whole family in a single read, already split by output shape so the frontend does no branching of its own.

{
  "date": "2026-07-30",
  "family_weather": {
    "adults": [
      {
        "focus": "Deep Work",
        "communication_friction": "Low",
        "activations": ["Structuring", "Inspiration"]
      }
    ],
    "kids": [
      {
        "focus": "High creative drive today; good for structured projects.",
        "gates_activated": ["Inspiration"]
      }
    ]
  }
}

The second brain

A calculator that says the same thing every year is not worth building. The graph layer is what turns this from a lookup into something that accumulates — it records what actually happened alongside what the sky was doing, and lets the two be queried together.

Output layer

The frontend consumes the daily payload and the graph history to build something age-appropriate to actually do — a dashboard for the adults, an adaptive game for everyone else.

Stack