DEV Community: Monika Sadlok

Stellamint — a message to the stars, and proof of the night you looked up

Monika Sadlok — Sun, 12 Jul 2026 09:26:10 +0000

This is a submission for Weekend Challenge: Passion Edition

What I Built

When I was a kid I'd lie in the grass and wonder if someone, somewhere, was looking back.
This weekend I built the thing I wanted then.

The deepest human passion isn't a rivalry or a team — it's the oldest question we have: are we alone, and can we reach out?

Stellamint is a web app about two directions of that one passion for the cosmos:

Reach out — write a message to a real exoplanet, watch how many years your words travel at lightspeed, see an AI-painted vision of that world, and keep the message on-chain — a crowdsourced Voyager Golden Record.
Look up — mark where you are and which real celestial event is overhead right now. When the sky is genuinely open to you, mint an on-chain proof of the moment.

Both fill one personal sky map with achievement badges — and every mint flows into a shared Collective Sky dashboard.

The goal: turn "are we alone?" from a passive wonder into something you can do — reach out, look up, and keep a permanent, honest record of both.

Demo

Live app: https://stellamint.vercel.app

You need a wallet to mint. Install Phantom, switch it to Devnet (Settings → Developer Settings → Devnet), and grab free test SOL from faucet.solana.com. It's a test network — no real money, no financial claims.

Try it in 30 seconds:

Reach out → write a message, hear it in a chorus of Earth (many languages), tap Envision this world for an AI planet image, pick a target, Transmit & mint.
Look up → allow location (or pick a city), and claim a proof of what's above you.
Your sky → watch your constellation + badges fill up. Collective Sky → see what all of humanity is sending.

Code

monsad / stellamint

🌌 Stellamint

A message to the stars, and proof of the night you looked up.

Two directions of one passion for the cosmos, recorded on-chain:

🔭 Look up — mark where you are and which real celestial event is overhead right now (a planet, the Moon, a meteor shower). When the sky is genuinely open to you, mint an on-chain proof of the moment. A logbook of the nights you actually looked up.
🛰️ Reach out — write a message to a real exoplanet, watch how many years your words travel at lightspeed, and keep it on-chain — a crowdsourced Voyager Golden Record.

Both fill one personal sky map, read straight from the blockchain.

Built for the DEV Weekend Challenge: Passion Edition.

🌐 Live: https://stellamint.vercel.app 💻 Runs on Solana devnet — no real money, no financial claims.

How each technology is used

Tech	Role
Solana (mpl-core,

…

View on GitHub

How I Built It

Next.js (App Router) on Vercel, TypeScript, Tailwind. TDD throughout — 25 unit tests over the pure logic; tsc clean, production build green, live mint verified end-to-end.

Solana — the chain is the product. Every message and proof is an mpl-core asset on devnet, with no database at all — your wallet's on-chain assets are your collection, and the sky map is rendered purely by reading them back. A Solana tx caps at 1232 bytes, so the on-chain uri carries a compact ~150-byte seed and the server rebuilds full metadata + image from it.

Snowflake — every mint fire-and-forgets into Snowflake (VARIANT + PARSE_JSON) as a public data lake. The Collective Sky dashboard reads it back (total light-years in flight, most-messaged worlds, recent whispers) and powers Witness Together. The app stays no-DB; Snowflake is the collective layer over on-chain data.

Google Gemini — encodes your message into an Arecibo-style pictogram and writes a one-line interpretation of how an alien might read it.

ElevenLabs — the Voyager Golden Record carried greetings in 55 human languages, so Stellamint speaks your message back in a chorus of Earth.

The gamification — Look Up is a game to catch the sky:

Rarity — a body high overhead is Common; one barely above the horizon is a Legendary catch.
Witness Together — Snowflake tells you "you're one of N who witnessed this." Not my sky — our sky.
Badges — First Contact, Stargazer, Constellation, Voice of Earth, Sky Collector. Collect the sky.

What makes it different (and honest):

Not "buy a star." Nothing fake is sold; every artifact is a real, honest on-chain record.
Not just a sky viewer. Others show the sky — Stellamint turns it into a collective, on-chain, gamified record of humanity looking up together.
Honest by design. Proof of Sky attests the opportunity to observe (real ephemeris math), not that you literally looked — and says so.
Four sponsor techs, each essential to one story, not bolted on.

Prize Categories

Best Use of Solana — no-database, on-chain-as-source-of-truth; compact-seed metadata.
Best Use of Snowflake — the Collective Sky data lake + Witness Together.
Best Use of Google AI — Gemini Arecibo encoding + alien interpretation.
Best Use of ElevenLabs — the multilingual Chorus of Earth.

Thanks for reading — this one was built out of pure love for the night sky. If you're out there: this one's for you.

I Built a 25-Agent Polish Parliament That Drafts Bills With Real Legal Citations

Monika Sadlok — Sat, 30 May 2026 21:59:57 +0000

This is a submission for the Hermes Agent Challenge

TL;DR — Type a one-line bill topic. Twenty-five Hermes agents (1 Speaker, 19 ministries, 5 parties) run a full Polish legislative session in 2 minutes. Vote tally, social impact, party tweets — and a side-by-side "current law vs proposed amendment" with every clause cited to a real statute. Built on delegate_task for parallel ministry consultation.

🌐 Live: https://web-production-53027.up.railway.app/
🎥 Walkthrough: https://www.loom.com/share/b0201270f67745baaa2945c931058b8c
📦 Repo: https://github.com/monsad/ai-politics (MIT)

What I Built

Watch a politician debate a new tax law on TV. They argue whether it's fair, whether it'll work, whether the other side is lying. Nobody ever shows you the diff — which paragraph of which statute actually changes, and from what to what. The conversation is theatre on top of an invisible legal document.

So I built the theatre AND the legal document.

Virtual Parliament is a multi-agent simulation of the Polish Sejm. You type something like "four-day work week" or "flat income tax", and 25 Hermes agents run a full legislative session:

🎯 Marszałek (Speaker) — the orchestrator. Classifies the topic. Picks 2–3 ministries via delegate_task in parallel. Reads their findings. Routes the bill to a party debate.
🏛️ 19 ministry experts — Finance, Climate, Labour & Social Policy, Justice, … Each returns a structured analysis: legal finding · budget impact · top 3 risks · recommendation. Every claim cites a real statute via PageIndex RAG.
🗳️ 5 party agents — CR, NC, AC, Liberty Front, SD. Each one carries the real party's seat count (157, 194, 65, 18, 26 — totalling 460), policy positions and rhetorical style. First reading. Second reading with rebuttals.
📊 Vote — weighted by seats. >230 passes.
📜 Draft bill — produced with explicit "Article 129 §1 of the Labour Code **is amended to read…" diffs against current law.

The frontend surfaces the diff as a Current law vs proposed change panel. Left column: what's in force today, quoted from the statute. Right column: what the AI just proposed. A non-lawyer can finally see the actual edit.

This is the part of legislation that's normally invisible. The whole point is to make it visible.

Demo

🎥 Video walkthrough (~2 min): https://www.loom.com/share/b0201270f67745baaa2945c931058b8c

🌐 Live URL: https://web-production-53027.up.railway.app/

Two buttons:

▶ Open session — fresh AI-generated debate, ~2–3 minutes. Costs ~$0.04 in google/gemini-3.1-flash-lite calls.
⚡ Demo — instant replay of a cached transcript, ~25 s. Useful when you just want to see the UI without burning credits.

Try "four-day work week" (Demo) — it's the demo fixture I ship in the Docker image. SD and Liberty Front vote on opposite sides (pro-labour vs free-market), which is the political-coherence check I built into the acceptance tests.

Local one-command run:

git clone https://github.com/monsad/ai-politics && cd ai-politics && make setup && parliament "four-day work week"

Code

📦 Repo: https://github.com/monsad/ai-politics (MIT)

skills/                         # 25 Hermes Agent skills, validated by skills-ref
  marszalek-sejmu/              # the orchestrator — owns the bill-drafting template
  ministry-finansow/            # 19 ministry experts (Finance, Health, Climate, ...)
  ...
  party-cr/                     # 5 party agents (CR, NC, AC, Liberty Front, SD)
parliament/
  session.py                    # subprocess launcher around `hermes chat -s <skill>`
  transcript_parser.py          # splits orchestrator stdout into per-speaker utterances
  citation_validator.py         # every [node:...] must resolve back to a real statute
  api.py                        # FastAPI: POST /sessions, polling SSE /stream/{id}
  cli.py                        # `parliament "<topic>"` (typer)
web/                            # Next.js 16 static export, served by FastAPI
deploy/                         # Dockerfile entrypoint + Hermes config + demo fixture

My Tech Stack

Layer	Tech	Notes
Agent framework	hermes-agent 0.14.0	the load-bearing piece — `pip install hermes-agent==0.14.0`
Skills spec	Anthropic Agent Skills + `skills-ref@0.1.5`	25 skills, lowercase-hyphen, validated in CI
RAG	PageIndex Cloud via MCP	vectorless retrieval over Polish Constitution + ~50 statutes; every citation traces to a real document
Models	`google/gemini-3.1-flash-lite` via OpenRouter	~$0.04 per full session, fast enough for live demo
Orchestrator	Python 3.11 + FastAPI + uvicorn	subprocess launcher around `hermes chat`
Stream	sse-starlette + polling SQLite	per-speaker utterances pushed as `event: utterance`
Frontend	Next.js 16 (App Router, static export) + Tailwind	served from `/app/*` by the same FastAPI
Deploy	Railway (single Docker container)	public HTTPS, ~$5/month

How I Used Hermes Agent

There's one Hermes property the whole project is built on:

delegate_task lets a parent skill fan out to N child skills in parallel as a single tool call.

Without that, this project isn't tractable. With it, the entire 25-agent pipeline is 24 LLM calls in a tight DAG, runs in 2 minutes, and the orchestrator never has to manage thread pools or async gathers itself.

Here's the shape:

                  ┌─────────────────────────────┐
                  │  marszalek-sejmu (skill)    │
                  │  Topic → ministry selection │
                  └──────────────┬──────────────┘
                                 │ delegate_task(tasks=[...])  ← Hermes batch mode
                ┌────────────────┼────────────────┐
                ▼                ▼                ▼
       ┌────────────────┐ ┌────────────────┐ ┌────────────────┐
       │ ministry-      │ │ ministry-      │ │ ministry-      │
       │ finansow       │ │ klimatu        │ │ rodziny-pracy  │
       └────────┬───────┘ └────────┬───────┘ └────────┬───────┘
                │  PageIndex RAG   │   (cite real statutes)
                └────────┬─────────┴─────────┬───────┘
                         ▼                   ▼
                  Synthesized findings → Marszałek
                         │
                         ▼   5 × party debate, ×2 readings
                  ┌──────────────┐
                  │ CR  NC  AC  │
                  │ LF  SD       │
                  └──────┬───────┘
                         ▼
                  Seat-weighted vote → Draft bill

Why `delegate_task` was the right primitive

Ministries are independent. Finance doesn't need to know what Climate said before doing its own analysis. They both run on the same input bill topic, return findings, get merged by the orchestrator. Classic embarrassingly parallel.
Hermes already handles the thread pool. Batch mode uses ThreadPoolExecutor to spawn AIAgent children. I don't have to mix asyncio with hermes-agent's threaded subagents — a known foot-gun if you roll your own.
Context isolation is free. Each ministry gets its own skill prompt with its own toolsets (pageindex-rag). The Marszałek doesn't pollute their context.
Approval and audit are centralized. When PageIndex is called from a ministry, it goes through Hermes' tool registry. I get the audit trail for free.

The other Hermes pieces that mattered

Skills as the unit of expertise. Every agent is one SKILL.md. The Marszałek has the bill-drafting template (assets/bill-draft-template.md). The parties have their actual policy positions. None of this fits in one big system prompt — but as 25 separate skills, it's maintainable. I can rewrite SD's economic stance without touching Liberty Front.
MCP toolsets for retrieval. Every skill that cites Polish law declares toolsets: ["pageindex-rag"] and gets retrieval for free. Zero Python integration code. The PageIndex MCP server is one config-yaml entry.
Subprocess as the integration surface. Hermes is a CLI first. The cleanest way to embed it in FastAPI is subprocess.Popen(["hermes", "chat", "-s", skill, "-q", topic, "-Q", "--accept-hooks", "--yolo"]). My session.py is essentially that subprocess launcher plus a stdout parser that splits the result into per-speaker utterances for SSE streaming.
Bake-time config for the container. For Railway, the Dockerfile copies hermes-config.yaml to /root/.hermes/config.yaml and skills/* to /root/.hermes/skills/. An entrypoint script materializes OPENROUTER_API_KEY into ~/.hermes/.env at boot. Crucially: disabled_toolsets: [browser, computer-use, voice, terminal-modal] — otherwise Hermes hangs at startup looking for a Chromium binary that isn't in python:3.11-slim. I only found that via a /diag endpoint I added to introspect the running container.

What this combination unlocks

If I had to write the parallel fan-out + tool registry + skill loader by hand, I'd still be debugging deadlocks instead of arguing with my own bill drafts.

Hermes let me spend my time on the simulation design (how does a Marszałek pick ministries? what does each party's house style sound like? how do you parse "Article 129 §1 is amended to read…" out of free-form markdown?) and the legal-diff UX (the Current law vs proposed change panel) — not on the orchestration framework.

That's the right division of labour for a 5-day contest project, and frankly for most agent projects.

What surprised me

Hermes models matter less than you'd think. Most of the quality comes from the skill prompts. Swapping gemini-flash-lite ↔ llama-3.3-70b changes vocabulary, barely changes the structure of the debate.
The frontend is where civic value lives. The pipeline produces a 40 KB markdown blob. Useless to a non-lawyer. The UI panel showing "Czas pracy nie może przekraczać 8 godzin na dobę i przeciętnie 40 godzin…" on the left and the proposed "…32 godzin w przeciętnie czterodniowym…" on the right is what makes this a tool instead of a transcript.
Free OpenRouter tiers are rate-limited into uselessness during contest week. Plan for $5 of paid model credit, or bake a demo fixture into the image. I shipped both.

🇵🇱 Built in Warsaw. MIT-licensed. Educational simulation only — no real Members of Parliament are represented, no hate speech is produced, and a disclaimer is emitted at the top and bottom of every session.

MedScan Assistant — AI medication label reader for seniors, powered by Gemma 4

Monika Sadlok — Thu, 14 May 2026 16:47:08 +0000

This is a submission for the Gemma 4 Challenge: Build with Gemma 4

What I Built

MedScan Assistant helps elderly and visually impaired people understand their medication labels. Half of all medication errors happen because patients misread or misunderstand the label — especially people with low vision or cognitive decline.

Point your phone at any medication label → Gemma 4 reads and interprets it → the app reads the result aloud in plain language.

Two markets supported:

🇺🇸 US Market — FDA Drug Facts panels, OTC/Rx labels
🇵🇱 Polish Market — EU-format labels, Polish TTS

Key features:

📷 Photo scan or manual text input
🔊 Automatic voice readout (Web Speech API, language-matched)
📅 Color-coded expiry status (green / amber / red)
⚠️ Warnings and drug interactions
🏥 "See a doctor if..." — symptoms requiring medical attention
♿ WCAG 2.1 AA accessible (large buttons, aria-live, keyboard nav)

GitHub: https://github.com/monsad/medscan-assistant
Live demo: https://monsad.github.io/medscan-assistant

How I Used Gemma 4

Model: google/gemma-4-31b-it:free via OpenRouter

I chose Gemma 4 31B Dense for three specific reasons:

1. Native multimodal input
Gemma 4 processes label photos directly — no separate OCR step. Medication labels have irregular layouts, rotated text, and small fonts. The model understands the full visual context, not just extracted characters.

2. Structured medical reasoning
The model converts complex pharmaceutical terminology into plain-language JSON. Acidum acetylsalicylicum 500mg becomes "Aspirin — pain reliever and fever reducer." I prompt it to return a strict JSON schema with fields for brand_name, directions, expiry_status, warnings, see_doctor (symptoms requiring a doctor visit), and voice_text for TTS readout.

3. Multilingual in a single model
The same model handles both FDA Drug Facts panels (English) and Polish EU-format labels — switching via market-aware system prompts. No translation APIs, no separate models.

Why 31B Dense over E4B:
For a patient safety application, accuracy matters more than latency. The 31B Dense model gives noticeably better results on complex dosing instructions, drug interaction identification, and expiry date parsing across formats (EXP 04/26 vs 04/2026 vs APR 2026).

const MARKETS = {
  us: { systemPrompt: "You are a medication assistant for Americans...", ttsLang: "en-US" },
  pl: { systemPrompt: "Jesteś aptecznym asystentem dla seniorów...",   ttsLang: "pl-PL" }
};
// One model. Two prompts. Two languages.

What I Learned

The hardest part was making Gemma 4 reliable enough for medical use. I use temperature: 0.2 and a strict JSON schema. The model occasionally wraps JSON in backticks, so parseGemmaResponse() strips those automatically.

Adding a dedicated see_doctor field — symptoms requiring medical attention — was the most impactful UX improvement. Users shouldn't have to parse warning text to figure out when something is serious. Gemma 4 identifies these situations reliably when explicitly prompted.

Test suite: 49 unit tests, zero npm dependencies:

git clone https://github.com/monsad/medscan-assistant
cd medscan-assistant
node tests/app.test.js
# ✓ 49/49 passing

DEV Community: Monika Sadlok

Stellamint — a message to the stars, and proof of the night you looked up

What I Built

Demo

Code

monsad / stellamint

🌌 Stellamint

How each technology is used

How I Built It

Prize Categories

I Built a 25-Agent Polish Parliament That Drafts Bills With Real Legal Citations

What I Built

Demo

Code

My Tech Stack

How I Used Hermes Agent

Why delegate_task was the right primitive

The other Hermes pieces that mattered

What this combination unlocks

What surprised me

MedScan Assistant — AI medication label reader for seniors, powered by Gemma 4

What I Built

How I Used Gemma 4

What I Learned

Why `delegate_task` was the right primitive