DEV Community: Bruno Fernandes

Ecos: A Memory Can Be Incomplete and Still Be Worth Keeping

Bruno Fernandes — Tue, 27 Oct 2026 02:41:19 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine.

What I Built

A family archive has a difficult failure mode: it can become more certain than the people it is supposed to remember.

Someone says a trip happened in 1987. Someone else remembers 1989. A tidy generated biography could quietly choose one. The result would read beautifully, and part of the family’s voice would be gone.

I built Ecos, a small, browser-based archive for written memories. It finds passages by meaning, keeps them attached to the original words, and gives uncertain dates somewhere to stay.

For Ghost in the Machine, I chose the remembrance side of the theme. The “ghost” is a voice still present in a phrase, a recipe or a contradictory account. Ecos retrieves that voice. It does not impersonate the person or write a more polished life for them.

The public collection is entirely fictional: eight short Duarte-family memories, including a repaired coat, a birthday power cut, a recipe measured by touch and an undated letter. These are not my family records or interviews with real people.

Demo

Open Ecos · English / Português

You can read the fictional collection immediately. To try the open model:

Choose Enable private search. First use downloads about 135 MB of model files. Story text stays in your browser.
Try a celebration by candlelight. The query asks for “A celebration without electric lights”; the returned source begins with an electricity failure during a birthday supper.
Open Read original. The highlighted words are an exact slice of the source, with the original line and character range.
Choose Keep this passage, then open the Remembrance shelf and download a plain-text keepsake.
Compare the two first river crossing accounts. Clara says 1987; Rui says 1989. Both remain visible. The letter with no date stays undated.

You can also add your own written memory, download a portable JSON archive, reopen it later, or explicitly save an unencrypted copy in this browser. The interface never silently saves your stories to an account.

Code

GitHub repository · MIT application code and original illustration

The repository includes the locked dependencies, fictional collection, source-integrity tests, actual retrieval experiment and a build/deployment workflow. The project and repository were started on October 26, inside the Week 4 window.

How I Built It

The important separation is between finding a passage and deciding what it proves.

For finding, I used Transformers.js 3.8.1 and the open multilingual MiniLM model, pinned to revision 2c4055b12046f11709e9df2c122e59ffbdc2f900. Its q8 ONNX weights run in a browser worker through ONNX Runtime WASM, using one CPU thread.

Each story is split into short passages while retaining offsets into its unmodified source. Mean-pooled, normalized embeddings compare the query with the story body only. Titles, dates and expected test labels are excluded from inference. Results below a cosine similarity of 0.30 are omitted; this cutoff is a heuristic, not a confidence score. Results are explicitly called possible echoes.

The model is essential to this search. If it cannot load, you can still read and export, but the app does not quietly substitute keyword matches and call them model results.

For preservation, ordinary code does the work. It keeps original text, computes citation ranges, sorts contributor-supplied dates and identifies differing years only when contributors supplied the same event label. It cannot decide whether Clara or Rui is right. That limitation is intentional.

I measured the misses, too

I ran the pinned q8 model against 12 authored English/Portuguese queries over the eight fictional stories, alongside a simple stopword-filtered exact-token overlap baseline.

Method	Expected memory at rank 1	Expected memory in top 3 distinct memories
Actual open-model embeddings	10/12	10/12
Exact-token overlap baseline	1/12	2/12

The complete results include the failures.

Two related queries returned no close result. One was a broad request about keeping an object to remember someone who died. A more specific description of the grandmother’s apron worked in the browser, so I made the sample prompt more specific. The original evaluation still includes the miss.

I also tried three unrelated queries. Two returned nothing; a fictional question about a chess tournament on Mars incorrectly retrieved the coat memory. That is a useful warning about treating similarity as truth.

This is a tiny authored experiment, not a held-out benchmark or a general accuracy claim. The CPU experiment and actual browser WASM checks are recorded separately. Eight deterministic tests cover source fidelity, uncertain dates, archive validation, untrusted citation metadata and retrieval guards; those tests do not measure model quality.

Why Does Open Innovation Matter?

Here, the practical benefit is control over a very personal input.

The open model lets the browser compare meanings without sending family stories to an inference service. I can pin the weights, inspect the retrieval behavior and ship the same search without a private model key or per-query bill. That choice also makes its limitations reproducible.

It does not make the app magically private. The host receives normal app requests. Hugging Face and its download CDN receive normal request metadata when the model is fetched. A locally saved archive is unencrypted, and downloaded archives contain the stories, names, supplied dates, selected passages and a bounded recent-search receipt. Shared devices and shared downloads still require care.

Offline operation is conditional: the user must cache the app, finish the model download and keep both browser caches. Browser storage can be evicted. A downloaded JSON archive is the portable backup; a text keepsake remains readable even if Ecos disappears.

The Spirit of It

The decisive example is the disagreement about the boat trip. Ecos could have produced one confident sentence. Instead, it shows two accounts with two names and two years.

That leaves the archive a little less neat. It also leaves more of the people in it.

The current scope is deliberately small: written text, up to 40 memories, English and Portuguese search. There is no audio transcription, photo recognition, cloud sync, generated biography or claim of historical verification. I have not tested it with real families or measured a benefit to them.

For this theme, the most useful thing I could build was a place where an incomplete memory does not need to become a complete fiction.

Prize Categories

Best Use of GitHub Copilot — GitHub Actions automation. The challenge page explicitly includes automating a project with GitHub Actions in this category. Ecos uses Actions to install the locked dependencies, run the source-integrity tests, build the app and deploy GitHub Pages. This is the automation being submitted; I do not claim Copilot generated the code.

Built solo by Bruno Fernandes, an Accounting graduate with intermediate programming experience. Codex assisted implementation, documentation and testing. Open components and licenses are credited in the third-party notices.

Sossego: A Local Model Sorts the Files You Keep Putting Off

Bruno Fernandes — Mon, 19 Oct 2026 22:50:06 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady.

What I Built

download.txt is not much of a filing system.

Neither is scan-01.txt, or the folder full of documents that can wait until next weekend. Opening each one, deciding where it belongs, making the folders and checking for copies is a small job with enough little decisions to become a permanent chore.

I built Sossego, a browser-local document organizer that takes a first pass at those decisions. Add a batch, let an open multilingual model suggest folders from the contents, then download an organized copy. Sossego is Portuguese for peace and quiet. The goal is to leave a smaller task behind.

It provides five destinations—Money, Work, Home, Learning and Travel—and a Review pile. You can change any folder. Exact-byte copies are initially omitted, with their originals identified. The downloaded ZIP contains the kept documents and a plan recording their original names, hashes and destinations. Files in Review are included too.

Your originals stay exactly where they were. Sossego does not need permission to reorganize your filesystem, and document content is not uploaded for inference.

Demo

Open Sossego · English and Portuguese · no account or API key.

Try “Try the messy folder”, then “Find their places.” The sample creates twelve clearly fictional files: ten substantive documents, one ambiguous note and one exact copy. The first run downloads roughly 125 MB of model data; subsequent use can reuse the browser cache.

The files are not preassigned model answers. They go through the actual inference worker. In the recorded browser run:

Outcome	Files	What made the decision
Suggested a named folder	7	Open-model embeddings plus similarity/margin gates
Kept in Review	4	Three low/close model matches; one short-text guard
Omitted exact copy	1	SHA-256 byte identity, independent of the model

For example, download.txt contains a hotel confirmation and is suggested for Travel. The model classifies its text; the filename is excluded from its input.

The invoice scan-01.txt is more revealing. Its top matches were Work at approximately 0.216 and Money at 0.193. The application keeps it in Review rather than automatically accepting the top match. A SQL lesson and Portuguese study note also stayed in Review. The demo therefore shows seven useful suggestions and the remaining decisions, rather than hiding the difficult examples.

Change the invoice to Money yourself, run sorting again, and your choice remains. Download the ZIP: it includes the Review pile, a readable note and sossego-plan.json. You can inspect what happened without relying on this article.

Code

GitHub repository · Verification record · Actual browser plan · CPU evaluation.

This is a new MIT-licensed project, begun on October 19 inside the Week 3 window. Substantive application code was written for this entry. Open dependencies and model licenses are credited in the repository. Codex assisted implementation, documentation and testing; the article's authorship disclosure reflects the automated workflow.

How I Built It

The core is paraphrase-multilingual-MiniLM-L12-v2, an Apache-2.0 sentence embedding model. Transformers.js 3.8.1 runs the pinned Xenova ONNX conversion with q8 weights in a browser worker, using ONNX Runtime WASM on one CPU thread.

The worker embeds document text and two authored bilingual descriptions per folder. It compares normalized, mean-pooled vectors using cosine similarity. A top similarity below 0.28 or a top-two margin below 0.045 routes the document to Review. Those are product heuristics; they are not calibrated probabilities. The model does not receive the sample answer key or filenames.

Ordinary code handles the surrounding tasks: PDF.js extracts text, SHA-256 identifies exact copies, and fflate packages the original bytes. Names are sanitized and collisions receive suffixes. There is no keyword fallback pretending to be model inference. If the model fails to download, the page reports that failure and manual filing remains available.

The scope is deliberately bounded: UTF-8 TXT, Markdown, CSV, JSON and text-based PDFs; at most 24 files, 6 MB each, 40 MB per batch. PDFs use the first five pages, text is capped at 12,000 characters, and longer texts use short excerpts from the start, middle and end. Scanned or unreadable PDFs need a manual folder. Documents are handled as inert text.

I checked more than whether a download button worked. A verification script opened the actual browser-generated ZIP and compared all eleven kept files with their original sample contents and SHA-256 hashes. All matched, including the four Review files. A text PDF was read and suggested for Travel; an invalid PDF remained visible for manual filing. Seven deterministic checks cover uncertainty, duplicates, path safety, filename collisions, excerpt limits, escaped previews and archive integrity.

Why Does Open Innovation Matter?

An organizer needs to read the things you have not organized yet. Sending that entire pile to a hosted model would make a routine chore depend on a content-upload decision and a running service.

Here the model and runtime are open and inspectable. Inference happens in the browser worker, with no inference server, token bill or account. The model revision is pinned, the folder descriptions are ordinary source data, and the thresholds are visible. Someone can replace the model or change the filing policy without rebuilding an integration around a closed endpoint.

There are still network and resource costs. The host serves the app; Hugging Face and its CDN serve model files and see normal download-request metadata. The initial download is substantial. Documents remain in page memory, while the chosen language and app/model caches can persist. Offline use needs those caches to survive; browser storage eviction or memory limits can interrupt it. The downloaded archive itself contains the selected documents and should be shared deliberately.

The Lazy Payoff

In the synthetic twelve-file run, seven documents already had a suggested destination and one exact copy was identified. Four files remained to look at. One download produced the organized copy and its plan, while the original folder stayed intact.

The recorded browser classification loop took about 0.66 seconds after loading the model and preparing the folder descriptions. That excludes initial downloads and document reading, and it is one observed runtime—not a claim about how many minutes a person saves. The examples were authored during development, so their results are a demonstration, not a representative accuracy study.

For this week's theme, the useful part is the change in the chore: start with twelve loose files, finish with a copy in folders and a visible review pile. A little less sorting, with the unfinished decisions still easy to find.

Prize Categories

Overall and Best Use of GitHub Copilot, through the challenge's explicitly listed GitHub Actions pathway. Actions runs the locked dependency installation, deterministic checks and static build before deploying the demo to Pages. I am not claiming Copilot code generation.

Confere: Local Receipt Reading With a Paper Trail

Bruno Fernandes — Tue, 13 Oct 2026 22:44:56 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle.

What I Built

A receipt photo is not yet an expense you should trust.

It might be the same photo sent twice. A number might be a subtotal rather than the amount paid. A perfectly readable total can still belong to a different date or currency. For a freelancer handing expenses to a bookkeeper, the useful outcome is a reviewed list with a way back to the source.

I built Confere, a bilingual receipt workspace for Brazilian freelancers. An open neural OCR model reads photos on the device. The user compares the original image, recognized text and suggested fields, then approves each expense. Only approved receipts count toward the total or appear in the exports.

The workflow is intentionally small:

Add PNG, JPG or WebP images.
Inspect the source, correct the merchant/date/BRL amount and choose a category.
Resolve possible duplicates before approval.
Export a CSV or a self-contained evidence packet containing the original images, recognition text, corrections, source-image hashes and review timestamps.

My background is in accounting, so I wanted the handoff to be inspectable instead of stopping at a neat-looking number. A freelancer or small bookkeeping practice could plausibly pay to reduce receipt re-entry and organize that handoff. The prototype is free; local deployment, tailored exports and support are possible service offerings. That is a business hypothesis, not evidence of paying demand. I have not claimed customers, revenue, interviews or measured time savings.

Demo

Open Confere — English and Portuguese interfaces, no account or API key required.

For a reproducible walkthrough, click Try 3 samples. That creates three clearly marked fictional receipt images and actually runs the recognition model on them. Two are distinct receipts; the third is a byte-identical copy of the café receipt. They are not prefilled OCR responses.

Try approving the duplicate first: it is blocked. Exclude the copy, inspect and approve the two originals, and the approved total becomes R$ 159,80. Download the evidence packet to see what remains attached to those numbers. The packet contains its own images and opens independently of the app.

Code

Source repository · Verification record · Actual sample exports

The application is MIT licensed. All substantive application code was started from scratch on October 13, inside this challenge's window. It is a new project, separate from my earlier submissions. Codex assisted implementation, documentation and testing; third-party code and model licenses are credited in the repository.

How I Built It

The open AI component is Tesseract's LSTM neural recognition engine, running through Tesseract.js 6.0.1 and tesseract.js-core 6.1.2 in a browser worker. The Portuguese and English model files are open and ship alongside the application. Pixels become text locally; there is no closed inference API.

The path is:

Receipt pixels → local neural OCR → conservative field suggestions → human review → approved expense → export with evidence.

The deterministic parts enforce the boundaries:

A candidate amount needs a total label. Subtotals, discounts, tender and change are not substituted for the final total.
Conflicting labeled totals leave the amount blank for review. Missing dates are not invented.
Recognized foreign-currency markers block approval; this version handles BRL and does not convert currencies.
Duplicate checks use the image's SHA-256 hash or the combination of merchant, date and amount. A match is a warning, not proof of fraud. Keeping both requires explicit acknowledgement and a reason.
Amounts are integer cents. Pending and excluded records do not contribute to the sum.
Editing an approved record invalidates its approval. It must be reviewed again before it counts.
CSV export neutralizes spreadsheet formula prefixes; receipt text is escaped in the HTML packet.

What I actually checked

In real browser inference on clean synthetic images, the café's source total 34,90 and stationery shop's 124,90 were both read and parsed correctly. Recorded reading times were 0.76 s and 0.68 s on the test device, excluding worker/model startup. These are individual observations, not a performance or accuracy guarantee.

The duplicate failed approval until resolved. Two approved originals produced exactly 159,80. A one-cent edit removed the café's approval and reduced the approved total to 124,90; reviewing the original amount restored the total. The actual downloaded CSV had exactly two expense rows, and the HTML packet embedded both source images. Reloading restored the records.

I also prepared the offline cache, stopped the local app/model HTTP server, reloaded and ran the three images again. A new worker still recognized them. That verifies this cache path without a live app/model server; it is not an OS-wide airplane-mode test. Browser storage eviction can still require another download.

Eleven unit tests cover the calculation and validation boundaries. Those tests do not establish OCR accuracy. Real photographed receipts, glare, skew, faded thermal paper and handwriting need a separate evaluation before claims about production reliability. This version does not read PDFs, validate fiscal authenticity, connect banks or make tax decisions.

Why Does Open Innovation Matter?

Local recognition changes the operating model. Receipt images and text do not need to leave the device for inference, and each recognition does not incur a hosted-model fee. All runtime and model assets are served from the same origin; the first visit needs downloads, then the explicit offline preparation action can cache them.

This does not make the host anonymous: GitHub still receives normal page and asset requests. Nor does it make an export private after somebody shares it. The benefit is narrower and concrete: the app does not upload receipt contents to an inference service.

An open engine also leaves a replaceable boundary. A future model can improve recognition while the same review, duplicate and exact-cents rules remain. I chose OCR rather than a general-purpose text generator because the job is to read evidence, not invent a plausible expense.

The next validation would be consented real receipts from a freelancer, measuring field errors, correction effort and whether the exported packet fits their actual bookkeeping workflow. Until then, this is a working prototype with a business hypothesis and documented limits.

Prize Categories

Best Use of GitHub Copilot — GitHub Actions automation. The category description explicitly includes automating a project with GitHub Actions. My workflow installs locked dependencies, runs the unit tests and syntax checks, builds the self-hosted model/runtime bundle and publishes the resulting artifact to GitHub Pages. The deployment depends on the successful build job. I am claiming this Actions integration; I did not use Copilot itself.

I am also entering the overall category. No other partner technology is claimed.

Cents Matter: Does a Model Notice When One Financial Fact Changes?

Bruno Fernandes — Thu, 08 Oct 2026 02:54:45 +0000

This is a submission for the Kaggle Benchmarking Challenge.

What I Benchmarked

A financial check can fail while looking almost right. A model might recognize an error but give the wrong correction, round at the wrong stage, or confidently decide that two identical amounts are duplicate payments without the evidence to support that conclusion.

I have a degree in Accounting, and I wanted a small, inspectable test of these distinctions. Cents Matter / Centavos Importam contains 40 original synthetic cases written in Brazilian Portuguese. It tests exact monetary reasoning under explicitly stated rules, rather than knowledge of regulations or tax law.

The cases form 20 minimal pairs. Each pair keeps the scenario and recorded amount fixed while changing one material fact. A source locale changes from pt-BR to en-US; a tariff changes from an outflow to a returned fee; two notifications either share a capture ID or represent distinct captures. The correct answer must change with that fact.

The model reports three fields:

{"status":"erro","esperado_centavos":1013,"diferenca_centavos":-1}

That example corresponds to a recorded R$ 10.12 and a correct R$ 10.13: the discrepancy is recorded minus expected, so it is negative. The model must get all three fields right to pass the case. Where evidence is insufficient, the correct response is indeterminado and two nulls, not a guessed amount.

Family	What the eight cases test
Numeric locale	Decimal and grouping separators under an explicit source convention
Rounding and allocation	Line versus total rounding, half-up versus half-even, negative ties and remainder cents
Event identity	Capture/refund identifiers, failed attempts and cancelled invoices
Signed cash flows	Fee direction, discount order and whether a refund already includes shipping
Evidence sufficiency	Missing fees, unaccepted quotes, unidentified captures and missing contractual exchange rates

There are 18 correct records, 18 demonstrably incorrect records and four cases requiring abstention. The model does not see case IDs, pair membership or the answer key. Each case gets a separate conversation.

Scoring is deterministic. Reference arithmetic uses Python Decimal and integer cents. The answer key includes derivations. No second model judges the first model's answer. Structured outputs are parsed by the Kaggle SDK; this benchmark is about the parsed financial decision, not raw JSON typography.

Models Tested

I tested three models through Kaggle Benchmarks SDK 0.6.1: Gemini 3.7 Flash (google/gemini-3.7-flash), gpt-oss-20b (openai/gpt-oss-20b) and Claude Haiku 4.5 (anthropic/claude-haiku-4-5@20251001). This is a deliberately limited comparison across three available model families, including an open-weight model. It does not represent every provider's strongest model.

All three completed the same 40 cases on October 7, 2026, with zero execution errors. Each case received one attempt, no calculator or search tool, requested temperature zero and requested seed zero. Reasoning used provider defaults; support for those controls can differ. This compares the configurations exposed by Kaggle, rather than equalized reasoning budgets.

The table uses the registered task's runs. Before registration, I used a six-case Gemini pilot to check the pipeline and one full interactive Gemini check. Saving the task triggered a full Gemini run again; the registered and interactive runs returned identical parsed answers. No cases, prompts or reference answers were changed after observing model outputs, and no best-of-run selection was made. The other models were added to that frozen task.

Dataset 1.0.0, SHA-256: 0db671bf5687ec711caa7e55b31d0e61ce2fe374fb029070d44c0a6ce8746d3c.

Findings

Model	Exact cases	Both members of a pair correct	Correct required abstention
Gemini 3.7 Flash	39/40 (97.5%)	19/20 (95%)	4/4
gpt-oss-20b	38/40 (95%)	18/20 (90%)	4/4
Claude Haiku 4.5	19/40 (47.5%)	2/20 (10%)	4/4

1. A correct warning can still contain the wrong correction. All three missed cashflow-01-B. The scenario has a completed R$159.90 receipt, a R$30.00 refund and a R$2.99 fee movement. In variant A the fee leaves the balance. In B it is returned and enters the balance. The recorded net remains R$126.91.

The correct B calculation is 15990 - 3000 + 299 = 13289 cents, with discrepancy 12691 - 13289 = -598 cents.

Answer for variant B	Status	Expected cents	Discrepancy cents
Reference	erro	13289	-598
Gemini	erro	12990	-299
gpt-oss-20b	ok	12691	0
Claude Haiku	ok	12691	0

Gemini recognized that the record was wrong, but its answer matched the receipt minus refund while omitting the returned fee. The other two returned the same answer as variant A. This is why the benchmark checks the proposed amount and discrepancy, not just the warning label. These observations describe the outputs; they do not reveal the models' internal reasoning.

2. Pair scores expose answers that fail to follow the changing fact. Haiku passed 19 individual cases but only two complete pairs. Fifteen pairs had one correct member, three had neither, and eight received identical parsed answers on both sides. gpt-oss-20b repeated an answer across two pairs; Gemini did so across none. Pair accuracy is a stricter complement to case accuracy, not an independent set of 20 extra tests.

The second shared failure was numeric locale. In locale-04-A, the quoted unit price is 9,876, explicitly in en-US notation, with quantity three and a 12.5% discount. The correct total is 9876 × 3 × 0.875 = 25924.50 BRL, or 2,592,450 cents. The recorded total is only 2,592 cents. GPT OSS accepted that record; Haiku returned 2,600 cents. Both passed the paired pt-BR case. Gemini passed both. The scenarios explicitly say that the source convention applies only to the quoted price, so the discount's notation should not change with it.

3. Returning all the fields does not guarantee consistency. Haiku produced three internally inconsistent answers: an ok status with a nonzero discrepancy, or an erro status with zero discrepancy. These were parsed structured responses, not JSON parsing failures. The deterministic validator counted them as failed cases. Haiku also returned some correct expected amounts alongside wrong discrepancies. For example, in evidence-04-B it correctly returned 51,000 expected cents but a discrepancy of -10 instead of -1,000. Field-level correctness can therefore overstate complete-answer usefulness.

4. All models abstained correctly when evidence really was missing. Each passed the four deliberately underspecified cases. However, Haiku also abstained on duplicates-01-A, where the shared capture ID made the answer determinate. Correct abstention on the missing-information subset should not be read as perfect evidence handling, or proof that a model will avoid guessing in less direct real-world documents.

Family (8 cases each)	Gemini	gpt-oss-20b	Claude Haiku
Numeric locale	8/8	7/8	4/8
Rounding and allocation	8/8	8/8	2/8
Event identity	8/8	8/8	4/8
Signed cash flows	7/8	7/8	3/8
Evidence sufficiency	8/8	8/8	6/8

I recomputed the scores from all 120 registered-run responses and checked full coverage, dataset version and prompt hashes. No failed cases were dropped. The pipeline refuses to issue a complete aggregate score for a service or parsing error.

This is a small, synthetic, deliberately constructed test, not a representative sample of accounting work. A 39-versus-38 result is a one-case difference and should not be treated as a robust general ranking. One registered run per model, with the additional Gemini pipeline checks described above, does not estimate variability. Public answer keys can also contaminate future evaluations. High scores here support a narrow conclusion about these explicit cases, not professional competence or production readiness.

A useful next version would add more independent pairs, repeat runs with a fixed protocol and compare tool-free responses with a verified calculator. The shared fee-direction failure suggests testing whether models can first extract signed cash-flow events before performing arithmetic.

My Benchmark

Open the Cents Matter / Centavos Importam benchmark collection.

The collection contains task version 1. Its source includes every prompt, reference derivation and the deterministic scorer. The execution notebooks include predictions and metrics in their Output tabs:

Gemini registered run, execution 20261007T220903366536Z.
gpt-oss-20b registered run, execution 20261007T221533122434Z.
Claude Haiku registered run, execution 20261007T221511948876Z.

Implementation uses the official Kaggle Benchmarks SDK, including its documented nested-task evaluation pattern. To inspect a claim, find its case ID in cases-*.json or cases-*.csv, compare the three parsed answer fields with the reference, and verify the run's dataset hash in metrics-*.json.

Outside in 20: open AI that gives your phone a stopping point

Bruno Fernandes — Wed, 07 Oct 2026 06:11:50 +0000

Entry for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass.

What I Built

You have twenty minutes and somewhere familiar to go: a courtyard, a nearby park, or another outdoor place you already know. Opening your phone to decide what to do can become the activity itself.

I built Outside in 20, or Saia em 20 in Portuguese, to give that interaction a stopping point. Enter your preferences, mobility constraints, and a place you know. Get a short outdoor activity, an instruction card, and a timer. Prepare the card, put the phone away, and return when you want to reflect.

The app asks for no GPS access and does not discover destinations. An optional reflection stays on the device. English and Portuguese instructions come from a curated catalogue; open AI matches your preference to an eligible activity.

Demo

Open Outside in 20.

Browser demonstration. Forest photograph: Wolfgang Hasselmann, Unsplash.

Try a preference about noticing colours, listening to birds, or taking a gentle walk. You can inspect the matching details, save a self-contained HTML pocket card, and start the timer. Reloading restores the selected plan and its original end time.

The first AI setup needs an internet connection and a substantial download. Prepare it before heading outside. The saved pocket card has no scripts or external assets.

Code

Public repository.

Ten automated tests pass. They check meaningful application boundaries, including activity eligibility and safe handling of text. The public GitHub Actions run completed successfully. It installs locked dependencies, runs tests, builds and checks the app, uploads the browser bundle, and publishes the verified result to GitHub Pages.

Actual model execution has separate browser evidence.

How I Built It

My first approach used SmolLM2-135M with constrained output. It produced valid activity IDs, but repeatedly chose A, even when the preference described a different activity. A successful format check was hiding a recommendation failure.

I switched to multilingual-e5-small, an open embedding model that turns text into comparable numerical representations. The original intfloat model uses the MIT licence. The app runs its Xenova q8 conversion through Transformers.js, using WebAssembly on the person's device.

The flow has four steps:

Filter activities by mobility and goal using deterministic rules.
Encode the preference with query: and eligible descriptions with passage:.
Average and normalize the representations, then rank by cosine similarity.
Resolve the selected ID into curated bilingual instructions.

The model cannot override the eligibility filters or invent a route. Displayed scores describe similarity; they are not confidence percentages or guarantees that an activity suits a particular place.

On October 7, browser checks distinguished Portuguese requests about colours and bird/leaf sounds, and English requests about textures and gentle walking. A conflicting walking request also stayed within the seated filter.

After switching the deployment to a WASM-only runtime, I repeated the Portuguese colour check. It selected B with 144 ms of inference and 2,500 ms total, with model assets already cached. The evidence records the model revision and ranking. These are observations from one test environment, not cross-browser benchmarks or a broad quality evaluation.

The model and tokenizer require approximately 135.4 MB, plus application/runtime assets. Cached inference depends on completed setup and browser storage that has not been cleared or evicted. The downloadable card provides a simpler way to carry the selected activity offline.

Why Does Open Innovation Matter?

Openness changes where this decision happens. Preferences are processed locally rather than sent to a remote model API. The model, filters, and catalogue can be inspected and changed independently.

That separation made the engineering correction possible: I could replace the generator that kept selecting A with a model designed for matching descriptions, while keeping the activity flow. The repository pins the model revision so that choice is reproducible.

This suits Touch Grass: prepare briefly, then carry an activity instead of an ongoing conversation. I have not conducted an outdoor trial, user study, or interviews. Whether it actually helps people spend less time on their phones still needs testing outside the browser.

My Agent Session

I used Codex for implementation, interface iteration, documentation, validation, and writing support. The development log explains the model change, timer persistence fix, cache decisions, and real browser checks.

Prize Categories

Overall prize, and Best Use of GitHub Copilot through GitHub Actions.

The published category explicitly includes automating a project with GitHub Actions. My entry uses that route: the linked successful workflow verifies and packages the application. Development assistance came from Codex; the sponsor integration is GitHub Actions.