zelnica
zelnica@silicon:~$ whoami

SI that designs SI chips.

Zelnica builds custom SI chips end to end, from product definition to tested chips. Our SI agents connect every design step and run 24/7, cutting handoff delays, human error and stacked margin, and guide each project along the shortest path from spec to silicon. Every chip is shaped around your training and inference workloads.

die_view --livecompute tiles 1,024 · HBM 4 · NoC active
Compute tiles SRAM HBM PHY NoC traffic
$ zelnica path --spec-to-silicon

Spec to silicon, on the shortest path.

Six steps, one company. An agent runs each step and an engineer signs off. The agents connect the steps around the clock and steer every project away from the detours that cost months.

  1. Define

    Turn your models and traffic into a product spec with power, cost and latency targets.

    spec-agent
  2. Architect

    Search compute, memory and interconnect options against your real workload traces.

    arch-agent
  3. Design

    Generate and refine RTL for tensor engines, memory systems and the on-chip network.

    rtl-agent
  4. Verify

    Write tests, chase coverage holes and compare against reference models.

    verif-agent
  5. Implement

    Floorplan, place, route and close timing and power on advanced nodes.

    pd-agent
  6. Silicon

    Signoff, tapeout, packaging with HBM, and bring-up of the first chips.

    signoff-agent
flow_map --shortest-pathagents online 24/7
handoff wait rework loop margin added late bug, back to RTL Define Architect Design Verify Implement Silicon knowledge base · every run adds to it silicon results, signoff data and fixes flow back so the next project starts closer to the shortest path

Dim dashed arcs are the detours a conventional flow takes. The bright line is the shortest path the agents guide each project toward.

$ zelnica fix --handoffs --errors --margin --data

What we take out of chip design.

Chip projects lose time and performance in the gaps between steps. These are the four losses our agents remove on every run, and every fix is saved so the next project starts better.

Handoff delays

no waiting at handoffs

Spec changes, constraints and results move between steps automatically. Agents check each handoff and pass it on in minutes, instead of days of email, meetings and buffer time.

Human error

checked on every run

Agents review every setup and result: constraint gaps, missing timing exceptions, wrong corners, mismatched files, odd result diffs. Mistakes are caught at the step that made them, with a fix proposed.

Stacked margin

one margin budget, not six

Each step usually adds its own guardband on top of the last. We manage margin as one budget across the flow and tighten it path by path using signoff and silicon correlation, so performance is not lost to stacked pessimism.

Mixed up data

no contamination between steps

Every PDK, library, IP, constraint, netlist and ECO carries its version and origin. Runs with inputs that do not match the release manifest are blocked, and data never leaks between projects or customers.

Conventional flow
design workhandoff waitreworkstep marginsre-spin risk
Zelnica flow
design workwaitreworkmargintime returned to the project

Illustrative only. Shows where time and margin go in a chip project, not measured results.

$ zelnica services --list

Three ways to work with us.

Bring us an idea, a single step, or your own team. Pick the model that fits where you are.

turnkey

Turnkey

From idea to chips in hand.

You bring the workload and the targets. We take it through spec, architecture, design, verification, physical design, tapeout, packaging, test and supply.

Best for
AI model and product companies without a chip team
You get
Qualified chips, delivered
design-service

Design Service

Hand us the steps you need.

Your team keeps what it does best. Our agents and engineers take the steps you choose, such as physical design and signoff, and deliver on a fixed scope.

Best for
Chip teams that need speed or capacity on a project
You get
Signoff clean results for the steps you choose
flow-license

Flow License

Our agents, inside your walls.

We install the SI agent flow and knowledge base in your environment. Your engineers run it on your own tools, and your design data never leaves your network.

Best for
Large chip companies with strict data rules
You get
The connected 24/7 flow on an annual subscription
$ zelnica examples --chip-types

What you can build with us.

Every Zelnica chip starts from a workload. These are the kinds of SI chips our flow is built to deliver.

training

Frontier training chip

For teams training large models at cluster scale. Built around dense tensor math, high HBM bandwidth and fast chip to chip links.

Fits: Turnkey

inference

Low latency serving chip

For LLM serving where every millisecond per token counts. Large on-chip SRAM keeps weights and KV cache close to compute.

Fits: Turnkey or Design Service

agentic

Agentic AI chip

For agents that run long contexts and many model calls in a row. Balances memory capacity for long KV cache with fast switching between requests.

Fits: Turnkey

edge

Edge inference chip

For on-device AI in cameras, vehicles and robots. Small area, low power and 4 bit or 8 bit math, tuned to one model family.

Fits: Design Service or Flow License

Example chip types, not delivered products.

$ zelnica run --demo

Agents at work.

Pick a workload and watch the agents take a chip from spec to GDS. Switch modes to see how the architecture changes for training, inference, or both.

session: zelnica-agents

      

Pipeline

    Chip config

    Highlighted lines come from guard-agent, which watches handoffs, margin, errors and data lineage across every stage. learn lines feed the knowledge base.

    Simulated demo. Values are illustrative.

    $ zelnica console

    Every project, live.

    The Zelnica Console shows where each chip stands, what the agents fixed and how much margin they returned, any hour of the day.

    Agents running24
    Issues caught this week137
    Blocked stale inputs9
    Knowledge base entries4,812
    ProjectWorkloadStageMargin returnedStatus
    proj-atlasTrainingImplement6.8%on track
    proj-swiftInferenceVerify4.1%on track
    proj-dualBothArchitectpendingspec review
    proj-edgeInferenceSilicon7.5%tapeout ready

    Illustrative console. Project names and figures are examples, not customer data.

    $ zelnica explain --training --inference

    Built for how your model runs.

    Training and inference stress a chip in different ways. We customize for the one you need, or design a single chip that handles both.

    TrainingBF16 / FP8 · HBM · scale outthroughput per watt InferenceINT8 / FP8 / 4 bit · SRAMlatency per token Zelnica chiptuned to both trained weights serving traces and feedback

    Your models train and serve in a loop. We profile both sides of that loop and design the chip for the mix you actually run.

    Training

    throughput at scale

    BottleneckLarge matrix math and moving gradients between chips
    PrecisionBF16 and FP8 tensor cores
    MemoryMultiple HBM stacks for bandwidth and capacity
    InterconnectHigh speed chip to chip links for scale out
    GoalShorter time to train per dollar and per watt

    Inference

    latency and cost per token

    BottleneckPrefill is compute bound, decode is memory bound
    PrecisionINT8, FP8 and 4 bit formats
    MemoryLarge on-chip SRAM and KV cache aware data paths
    InterconnectSized to the model, not the cluster
    GoalLow latency per token at the lowest power
    Both on one chip. When you need training and serving on the same part, we balance HBM and SRAM, support mixed precision in the same tensor engine, and let firmware shift the chip between modes.
    $ zelnica deploy --options

    Your data stays where you want it.

    Chip designs are among the most sensitive data a company owns. Choose where the agents run.

    Zelnica Cloud

    fastest start

    We run the full flow on our secured infrastructure, with each customer isolated in its own environment and data never shared across projects.

    On premises

    inside your walls

    The same agents, flow and console run on your own servers and EDA licenses. Your design data never leaves your network.