Astra-Braille Errata Relay

Catch the correction before the next copy.

Comment

Inspiration

I started Astra by looking at a part of Braille production that is easy to overlook: what happens when the source changes after the Braille work has already been approved or production has started.

Braille production is not simply “convert text, then print.” A source document is transcribed and formatted, professionally reviewed, approved as a production master, and then used downstream for embossing and physical production. That process can involve different people, tools, queues, machines, and evidence of what was actually produced.

A late erratum breaks the trust chain.

The corrected source may differ by one sentence, but that sentence can change Braille contractions, line wrapping, pagination, and potentially the scope of physical rework. At that point, the real question is no longer just:

“Can I regenerate the Braille?”

It becomes:

“Which previously approved artifact is now stale? Exactly what changed downstream? Has production already used it? What can still be trusted, and what should the responsible professional do next?”

I built Astra around that question.

Before implementing the final workflow, I researched how actual Braille-production organizations operate. One of the most important findings was that there is no universal production stack: sources may come from publisher files, NIMAS packages, secure uploads, scanned material, Word/PDF/EPUB, or local systems; transcription may use Duxbury, BrailleBlaster, Braille 2000, Liblouis-backed tools, or other workflows; and production can involve direct embossers, network queues, plate-based systems, proofreading, finishing, and distribution.

That research changed the design. Google Drive and CUPS are not treated as “the Braille industry.” They are the two concrete adapters I used to prove one complete, reproducible vertical slice.

What Astra does

Astra is a change-control and recovery layer for Braille production.

It runs in the background and watches an authoritative source. In the hackathon implementation, that source is a Google Drive file or simple native Google Doc.

When the source changes, the user does not have to tell Astra to investigate.

A private Google Cloud Scheduler job wakes the Cloud Run service. Astra uses the Drive change feed only as a signal that something may have changed, then independently re-fetches the authoritative source metadata and bytes before accepting a new revision.

From there Astra autonomously:

  1. verifies immutable source lineage;
  2. determines the exact source change;
  3. regenerates the complete candidate Braille artifact with a pinned Liblouis configuration;
  4. creates deterministic hashes, manifests, source maps, and pagination;
  5. calculates the exact Braille page impact;
  6. sends only bounded persisted evidence to Gemini through Google ADK for semantic assessment;
  7. correlates the result with fresh read-only production observations;
  8. detects stale, missing, or ambiguous evidence and fails closed when necessary;
  9. constructs an incident and recovery report;
  10. presents the result to the appropriate human professional.

The important architectural boundary is that Gemini does not own production truth.

Gemini evaluates the meaning of the source correction. It does not generate the authoritative BRF, decide page numbers, invent production state, approve a master, or control a printer.

Deterministic code owns the things that need to be reproducible.

The demo case

For the live demonstration I created an entirely original synthetic educational source large enough to behave like a real production artifact rather than a one-page toy example.

The baseline renders to 46 Braille pages.

One sentence near the middle originally says:

“The nucleus stores water and dissolved minerals for the cell.”

The authoritative correction changes it to:

“The vacuole stores water and dissolved minerals for the cell.”

Astra regenerates the complete Braille candidate.

The deterministic impact calculation then proves:

  • the baseline is 46 pages;
  • the candidate is still 46 pages;
  • only page 24 changes;
  • the unchanged suffix resynchronizes immediately afterward.

That is one of the main reasons I built the project around full deterministic regeneration rather than asking an LLM to estimate what a text change “probably” affects.

A small source correction can have a small ripple—or it can shift everything downstream. Astra computes which case actually happened.

Human authority

Astra is autonomous where software can safely hold authority, but it deliberately stops where professional or physical-production authority begins.

The demo models distinct human responsibilities.

A production coordinator reviews the recovery case and records a professional disposition.

A machine operator owns the actual external production controls and physical facts.

A Braille proofreader owns approval of the corrected candidate.

Astra has no route that can submit, hold, release, cancel, restart, pause, or stop a CUPS job or embosser.

That was a deliberate design choice, not a missing integration.

For example, a queue saying “canceled” does not prove that physical Braille already produced has been isolated. Those are separate facts and should remain separate in the evidence model.

Human decisions are therefore stored as attributable, append-only records rather than being inferred from machine state.

How I built it

The system uses Gemini 3.5 Flash through Google Agent Development Kit for the bounded semantic-assessment step.

The main backend runs privately on Google Cloud Run.

Firestore stores durable workflow state, leases, idempotency information, incident checkpoints, and human records.

Google Cloud Storage stores immutable content-addressed artifacts such as source evidence, candidate BRF data, manifests, page-impact evidence, and reports.

Google Cloud Scheduler provides the background automatic wake-up path.

The source-authority adapter uses the Google Drive API in read-only mode.

The Braille pipeline uses a pinned Liblouis configuration so candidate output and page impact are reproducible.

A local CUPS bridge provides read-only production observation. It maintains a canonical hash-chained observation journal and publishes observations through a separate authenticated telemetry path. The final physical embossing endpoint in the hackathon environment is simulated; the queue and observation path itself is real.

The application is built primarily in Python, with FastAPI, Pydantic models, explicit state machines, local loopback presentation surfaces, server-side credential handling, signed sessions, CSRF protection, and sanitized server-sent events.

One design decision I care about

I did not want the architecture to become:

“Send everything to Gemini and trust whatever comes back.”

The semantic model is intentionally surrounded by deterministic boundaries.

The source correction is persisted first.

Gemini receives only bounded evidence and a closed output schema.

The response is validated before it can influence the workflow.

The model has no production tools.

The deterministic layer owns translation, pagination, hashes, artifact identity, policy, recommendations, retry behavior, and state transitions.

If model output is malformed or evidence is insufficient, Astra fails closed into human review instead of manufacturing confidence.

That separation became one of the central ideas of the project.

Challenges

The hardest part was not calling Gemini.

It was making all the different kinds of truth coexist without quietly collapsing them together.

A source-system notification is not source truth.

A model assessment is not deterministic production truth.

A CUPS scheduler state is not physical containment.

A generated candidate is not an approved production master.

A professional recommendation is not a machine action.

Building those distinctions into code required immutable lineage, content hashes, idempotent workflows, explicit state versions, retries, leases, stale-evidence handling, and separate human records.

The other major challenge was making the project genuinely asynchronous.

The first version could reconcile Drive correctly, but required a human to invoke reconciliation. That was not the workflow I wanted. I replaced that hero path with a private background Scheduler cycle so a human can edit the authoritative source and then stop interacting: Astra wakes itself and begins the investigation.

Finally, the live-demo environment exposed issues that static tests did not. Rehearsing the actual Drive → Scheduler → Cloud Run → Gemini → dashboard → professional-review path uncovered timing, observation-freshness, credential, baseline-arming, and presentation-state problems. I fixed those rather than hiding them behind prerecorded fixture data.

What I learned

The biggest thing I learned is that the interesting problem is not Braille translation itself.

It is propagation of trust.

An approved artifact exists because somebody trusted a particular source revision, translation profile, proofing state, and production context.

When an upstream fact changes, every downstream artifact derived from it needs a way to answer:

“Am I still valid?”

That led me to think of Astra less as a Drive watcher and more as a provenance and recovery system.

I also learned that useful agent autonomy does not require giving a model every available actuator.

In this problem, I think the stronger architecture is the opposite: let the agent autonomously do the expensive investigation, correlation, regeneration, evidence gathering, and routing, but make the boundary around irreversible human-controlled actions extremely explicit.

Another important lesson came from researching real production environments. Facility-specific software will change. The durable concepts are source authority, approved artifact lineage, production observation, human authority, and recovery evidence. That is why the current Drive and CUPS integrations sit behind boundaries intended to be replaceable.

What Astra is today

Astra is a production-minded hackathon prototype, not a claim that it can be installed unchanged in every Braille-production facility.

The demonstrated topology is intentionally concrete:

Google Drive → automatic Google Cloud workflow → deterministic Liblouis Braille pipeline → Gemini semantic assessment → Firestore/GCS evidence → read-only CUPS observation → human professional gate.

That is enough to prove the core idea end to end.

The next work would be adapting the same recovery semantics to additional real facility source and production systems rather than replacing those systems.

The part I wanted to prove in this hackathon was the invariant underneath all of them:

When an authoritative source changes after downstream work has already been approved, an agent can autonomously determine what can no longer be trusted, calculate the scope of the damage, construct the recovery evidence, and hand control back at the correct human boundary.

That is Astra.

Built With

Share this project:

Updates

Submission history