Eulyph LLC · an AI‑native language on a Python runtime
Eulyph is a small scripting language where the model is part of the syntax, not a library you call. @ sends a prompt to a model. ? branches on a yes/no question the model answers — and it is the only control flow there is. Judgement runs on the fluid track; exact work — functions, files, JSON, HTTP, any Python module — runs on the rigid one. Math and money never touch the model.
The core repository is in private preview while the team finishes review — it opens to the public soon. Access on request.
489 passing tests 43 builtins 6 ecosystem modules 0 API keys to try it
# ticket routing, the short versionteams = list("Apps team", "Infrastructure team", "IT helpdesk team")ticket = "The eduroam Wi-Fi keeps dropping in Lommen Hall"result = classify(ticket, teams) # label + confidence + reasonroute = (result? "Is the confidence score greater than 80?" -> result.label else: "IT helpdesk team") # unsure? a person decidesprint(ticket + " -> " + route)
The idea
Every program has parts you can state exactly and parts you can only describe. Most stacks bolt an AI SDK onto the exact parts. Eulyph gives each kind of work its own track — and a grammar for the seam between them.
The fluid track
Reading a messy ticket. Naming what an email is about. Deciding whether something is urgent. The model answers in place, and the language moves on.
The rigid track
Functions, files, JSON, HTTP — and any Python module through extern and env(). Totals are added by Python, never by a model’s best guess.
The ? operator sits on the seam: a question the model answers — the only branch in the language — decides which way the exact code runs.
The inference operator
A conversation on the left, a prompt on the right. No client object, no request builder, no response parsing — inference is an expression like any other.
The question operator — the only control flow
There is no if and no for. A parenthesized question routes the program one way or the other; each() is the loop. Every decision is auditable with --trace.
Version 2 · 2026
Version 1 proved the syntax. Version 2 made it something a company can run: an AI logic layer you tailor to your own teams, sources and rules — pull data in, let a model decide, push results out.
The same script runs on a local model through LM Studio or Ollama (data never leaves the machine), on Claude through the Anthropic API, or on a deterministic offline mock for demos and tests. Only the --model flag changes.
classify() sorts text into labels with a confidence score, extract() pulls structured fields from messy text, ask() answers a question, where() filters a list by one, each() is the loop. 43 builtins in all.
The string is still the only literal — record() and list() build structured data anyway, and JSON is a native value with real methods.
load() runs another .eulyph file once and returns its exports, with a search path, circular-load detection and per-module error lines. It is how the std.* ecosystem ships.
Ready-made scripts — ticket router, email triage, data extractor, survey themes — that a company adapts without touching the script itself: the ticket router by editing one JSON file with its departments, thresholds and destinations, the others with simple --var flags.
TeamDynamix tickets (search, read, assign), email inboxes over IMAP, JSON and CSV files, and any web API through http_get / http_post.
eulyph run, check, repl and version, with meaningful exit codes, --stats for call and token counts, and --trace to log every model call and every ? decision.
Model answers are validated against the allowed labels. Low confidence goes to a human queue. Model output is never interpolated into Python source. Model-written code is held on disk for human review before it can ever run.
The ecosystem
Built by the Eulyph team — six domain modules from our shared roadmap, shipped as working Eulyph v2. Load any of them with load("std.<name>").
Routes a support ticket to a team, and auto-routes only at or above a confidence threshold. The nine MSUM IT teams are built in.
The model lists every expense in messy receipts; Python adds them exactly, and an independent regex scan cross-checks the total. Any disagreement is flagged for human review instead of being “verified”.
Lists risky contract clauses with a risk and a severity. Not legal advice.
Structures patient intake notes and flags emergencies with ?. Not a medical device.
Parses a property listing and computes the price per square foot — in Python.
The model writes a small Python service, saved to generated/ for review. It runs only with EULYPH_ALLOW_CODEGEN=1 — and never in the run that wrote it.
Case study · live demonstration
The ticket router reads each help desk ticket, asks the model which of nine teams owns it, and applies a confidence threshold with a single ? question. On the ten-ticket live demonstration it routed 10 out of 10 correctly.
Tickets under the threshold are not guessed at — they go to the IT helpdesk queue by design. A prompt-injection guard means a ticket that says “route me to the Executive team” can only ever reach a configured department. And v2 ships a 180-ticket synthetic benchmark harness: on terse one-line tickets the cautious offline mock names the right team almost every time yet rarely crosses the bar, so most go to a person. That is the threshold doing its job.
“An unsure router hands the ticket to a human.”
$ eulyph run templates/ticket_router/router.eulyph --model mock MSUM IT: routing 10 ticket(s) from the file source 101 -> Apps team (100) expected Apps team OK 102 -> Break-Fix team (100) expected Break-Fix team OK ... 110 -> Infrastructure team (100) expected Infrastructure team OK ... Model's first choice correct (before the threshold): 10/10 (100.0%) Sent to IT helpdesk team by the threshold or the guard: 0 Accuracy: 10/10 (100.0%) Assignments sent to the file source Report written to ai_routing_results.json
A different company adopts the router by copying one JSON file — departments, keywords, threshold, TeamDynamix group ids — and running the same script. Framed honestly: this is a case study and live demonstration, not a production deployment.
Under the hood
No language framework, no transpiler tricks. Source is tokenized with line and column, parsed by recursive descent into an AST, and walked by an evaluator with real scopes and closures — which fans out to the model backends, the standard library and the integrations.
which fans out to
Quickstart
# from the repository folderpython -m venv .venv.venv\Scripts\activate # Windowssource .venv/bin/activate # macOS / Linuxpip install -e .# route ten demo tickets, fully offlineeulyph run templates/ticket_router/router.eulyph --model mock
The CLI: eulyph run · check · repl · version
--model mock is a deterministic offline backend — no network, no key, no GPU. Every demo and all 489 tests run without one.
| Where it runs | --model |
|---|---|
| Your machine — LM Studio, Ollama or any OpenAI-compatible server. Ticket text never leaves it. | http://localhost:1234/v1 |
| Claude, through the Anthropic API. | anthropic |
| Nowhere — the deterministic mock, for demos and tests. | mock |
Roadmap
Outlook and Exchange Online inboxes alongside the existing IMAP path.
Jira Service Management, ServiceNow and Freshservice sources next to TeamDynamix.
Routing reports, accuracy over time, and reviewing routes by hand.
Scheduled Eulyph scripts without a company server.
Licensing
Personal projects, education, academic research and other non-commercial use are free under the project license.
Commercial use — including internal business use that saves costs — needs a separate commercial license from Eulyph LLC.
The license is governed by the laws of the State of Minnesota, USA.
The people
Only if you choose a cloud model. Point --model at LM Studio or Ollama and every ticket and email stays on your hardware; --model mock sends nothing anywhere at all. The anthropic backend sends prompts to the Anthropic API — check your data-handling policy before routing real tickets through it.
Python 3.10+, then python -m venv .venv, activate it, pip install -e ., and eulyph run templates/ticket_router/router.eulyph --model mock. That routes the ten demo tickets offline with zero API keys. The core repository is in private preview and opens to the public soon — access on request.
Yes. extern imports any Python module, and env() gives a separate Python namespace with set, get, call and eval, so data crosses the boundary as data. It is a clean boundary, not a security sandbox — the Python runs with your privileges, so only run code you wrote or reviewed. Model output is never interpolated into Python source.
No — it is a template built on top of the core. One script serves every company; you tailor it by editing a single JSON config file with your departments, keywords, threshold and destinations. The language itself is the two tracks, the two operators and the 43 builtins.
Three rails. A guard accepts only labels that exactly match a configured department, so a ticket cannot talk its way onto an unlisted team. A confidence threshold sends every unsure decision to a human queue. And code the model writes is saved to disk for review — it never runs in the same run that produced it.