Strata

Strata is an agentic AI system that autonomously searches 3D-printing configurations—layer height, infill, walls—measured by PrusaSlicer, adapting its search to minimize print time or material.

Comment

Strata

Strata isn't an agent that just suggests better 3D-print settings. It tests them itself against a real slicer and uses the results to decide what to try next.

The Inspiration

3D printing today has a real hidden cost: experimentation.

Before a model ever reaches the printer, someone has to painstakingly decide the layer height, infill, wall thickness, and a dozen other settings that trade off print time, material use, and quality. The right configuration depends on the geometry and what the user actually cares about, and finding it usually means grinding through the same loop by hand:

change settings → slice → inspect results → adjust → repeat

For a hobbyist, that process results in wasted time and wasted filament. For a prototyping team or a print farm running hundreds of jobs, that friction quickly compounds into real loss.

Current AI tools can hypothesize optimal print settings, but these hypotheses are oftentimes just that. Educated guesswork. An LLM doesn't know for sure whether a configuration takes 42 minutes or 4.2 grams of filament until the model is actually sliced.

I wanted to build something that didn't guess. Strata is the result.

The Solution

Strata is an autonomous experimentation agent for 3D printing.

The user uploads an STL, states the objective, sets constraints. Strata takes it from there:

  1. Plan — Gemini reads the objective and proposes a diverse batch of candidate configurations.
  2. Execute — Every candidate gets sent through a real PrusaSlicer instance.
  3. Observe — Strata records actual print-time and material numbers from the slicer, not an LLM's estimate of them.
  4. Evaluate — Configurations that break a hard constraint are thrown out; the rest are compared with Pareto optimization.
  5. Replan — Gemini sees what happened and decides what's worth testing next.
  6. Select or escalate — A clear winner gets picked automatically. A genuine tradeoff gets handed to you instead of papered over.

The result isn't an answer to "what settings should I use?" It's the outcome of Strata actually finding out.

Why Strata Is Agentic

I set one rule early and refused to break it: Gemini never gets to invent the measurements that determine the result. It doesn't estimate print time, invent a material number, or crown a winning configuration from guesswork. Every one of those calls has to be grounded in output from a real engineering tool.

What Gemini does instead is plan, inside a loop it doesn't fully control:

Plan → Validate → Slice → Observe → Evaluate → Replan

Each round changes what happens in the next one. Slicer results become observations; observations reshape the search. That's the difference between generating a recommendation once and actually running an experiment.

It also made the system more trustworthy by design, though I didn't fully appreciate that until it was built: deterministic code owns constraint enforcement, Pareto analysis, and validation. Gemini only gets a seat at the table where flexible reasoning earns its keep, deciding what to try next.

Architecture

I built Strata as a modular system, not a wrapper around an API call.

                 ┌─────────────────────┐
                 │      React UI       │
                 │ STL + User Goals    │
                 └──────────┬──────────┘
                            │
                            ▼
                 ┌─────────────────────┐
                 │       FastAPI       │
                 │ Optimization Runs   │
                 └──────────┬──────────┘
                            │
                            ▼
                 ┌─────────────────────┐
                 │   Gemini Planner    │
                 │ Propose Experiments │
                 └──────────┬──────────┘
                            │
                            ▼
                 ┌─────────────────────┐
                 │ Validation / Tools  │
                 │ Scoped Parameters   │
                 └──────────┬──────────┘
                            │
                            ▼
                 ┌─────────────────────┐
                 │     PrusaSlicer     │
                 │ Real Slice Runs     │
                 └──────────┬──────────┘
                            │
                            ▼
                 ┌─────────────────────┐
                 │ Optimization Engine │
                 │ Constraints +       │
                 │ Pareto Analysis     │
                 └──────────┬──────────┘
                            │
                   Results / Observations
                            │
                            └──────────► Gemini

Planning, slicing, optimization, persistence, and API concerns each live behind their own service interfaces. Core abstractions include OptimizationRun, CandidateConfiguration, HardConstraints, OptimizationPreferences, SliceResult, DecisionRecord, SlicerService, StorageService, and RunRepository.

That separation keeps every component testable, and it keeps the agent from ever touching unrestricted system behavior directly.

Failure Tolerance

All agent output is treated as untrusted input.

Before a proposed configuration ever reaches PrusaSlicer, Strata validates it against the expected schema and supported parameter ranges. Duplicate candidates get rejected before they waste a slice operation.

More importantly: an LLM failure doesn't take down the run.

During development, a second-round Gemini response came back malformed and truncated. I didn't want to discard the whole run over it, so Strata logs the planning failure instead and finalizes using the valid results already produced in round one.

LLM planning failure ≠ optimization failure.

Real slicer observations stay authoritative even when a later agent step falls over.

Real Execution, Not Simulation

Strata doesn't ask Gemini to approximate how settings affect a print. It measures it.

Each candidate configuration gets translated into slicer parameters and run against the actual uploaded STL. Strata parses the output for real numbers: print time, filament usage, layer height, infill, wall configuration. The relationship between settings and outcomes depends on the specific geometry being printed, so there's no shortcut around actually slicing it.

Multi-Round Optimization

A single batch of AI-generated settings is still just assisted search. I wanted Strata to go further.

After the first batch is sliced, Gemini gets structured observations describing what actually happened, and proposes a second round shaped by those results. If low-infill configurations are cutting material dramatically without blowing the print-time budget, round two can dig into that region of the space instead of generating another unrelated batch of guesses.

Every candidate from every successful round gets compared together, and Pareto analysis runs again over the combined pool. The agent is learning from the consequences of its own choices, within a single run.

Pareto Optimization

There's rarely one objectively "best" print.

One configuration uses a bit more material but finishes much faster. Another minimizes material while still landing inside the time limit. I didn't want to flatten that into a single arbitrary score, so Strata models the tradeoff directly instead.

Dominated configurations get eliminated. Pareto-optimal ones stick around because they represent a real choice. When your stated priorities make the winner obvious, Strata picks it. When what's left is a genuine judgment call, Strata says so instead of pretending there's a correct answer to fake.

Example Run

Objective: minimize material

Constraints: max 30 min print time, max 10 g material

I ran this myself. Strata generated and actually sliced multiple candidates. Among the results:

Layer Height Infill Walls Print Time Material Result
0.10 mm 5% 2 22m 20s 2.71 g Pareto-optimal / Selected
0.30 mm 5% 2 10m 20s 2.81 g Pareto-optimal
Other candidates Various Various Various 3.88–6.15 g Dominated

The 0.10 mm configuration used the least material. The 0.30 mm configuration cut print time drastically for a fraction of a gram more filament. Neither number came from Gemini guessing. Both came from PrusaSlicer actually running.

What Makes Strata Different

The point isn't that Strata uses AI to talk about 3D printing. It's that AI decides which experiments to run, software executes them against a real engineering tool, and the results, not the model's confidence, determine what happens next.

Recommendation system:

Model → LLM → "Try these settings."


Strata:

Model → Agent plans experiment
      → PrusaSlicer executes it
      → Strata observes real results
      → Optimization engine evaluates them
      → Agent plans the next experiment
      → Best viable configuration is selected

I built Strata to turn an LLM's recommendation into an autonomous, measurable workflow, not just a more confident-sounding guess.

Google Cloud

I built Strata for the Google All Things Agentic Hackathon, with Gemini as the reasoning layer of the optimization agent. The backend is containerized with Docker and built for Google Cloud deployment, so the agent and its slicing environment run consistently outside my local machine. I separated storage, persistence, slicing, and planning deliberately, so each piece can evolve on its own.

Tech Stack

Agent / AI — Google Gemini, Google Agent Development Kit (ADK)

Backend — Python, FastAPI, Pydantic

Optimization — Multi-objective/Pareto optimization, deterministic constraint validation

Manufacturing — PrusaSlicer CLI, STL processing

Frontend — React, Vite, Tailwind CSS

Infrastructure — Google Cloud, Docker

Testing — Automated backend test suite, mocked external model calls for deterministic tests, separate integration/Gemini smoke testing

What I Learned

Building Strata changed how I think about where an LLM belongs in an engineering system. The model was most useful when deciding what to try next, not when estimating results that deterministic software could measure directly.

I also learned that a big part of making an agent reliable is putting boundaries around it. Structured outputs, validation, bounded parameters, retries, deterministic constraint enforcement, and graceful failure handling ended up being just as important as the model itself.

As a whole, Strata showed me that agentic AI becomes much more compelling when it can run experiments and adapt its behavior instead of simply generating a recommendation once.

Built for the All Things Agentic Hackathon

In the end, Strata emerged from one simple question:

What if an AI agent could use engineering software the way a human does, not just to give advice, but to run experiments, observe the results, and decide what to try next?

3D printing is the first application. The broader idea is an agent that reasons through experimentation while keeping deterministic software and objective measurement, not the language model, as the source of truth.

Built With

Share this project:

Updates

Submission history