AI-native development for the edge

Describe the intent. Ship verified code to the metal.

Ferrete turns specifications into production C for embedded hardware — then proves it's correct before a single device is flashed.

Get early access See how verification works
motor-ctrl / saturate.c● verified
Spec

Clamp the PID output to Q15 range. No heap, no recursion, under 64 bytes of flash on Cortex-M4.

static inline int16_t
saturate_q15(int32_t x)
{
  if (x > INT16_MAX) return INT16_MAX;
  if (x < INT16_MIN) return INT16_MIN;
  return (int16_t)x;
}
Memory safetyproved
Spec equivalenceproved
Stack and sizewithin limits
Compiles with -Werrorclean
● Now onboarding design partners: robotics, industrial and connected-device teams. Apply for early access →
Why now

Firmware teams can't adopt AI on trust alone.

01

AI writes code faster than anyone can review it

Coding assistants made writing code cheap. For firmware the bottleneck moved to review: someone still has to trust every line before it reaches a device.

02

In the field, a bug is a recall

You can't refresh a motor controller. One overflow can stop a production line or send a product back in its box, and a failed update can brick it.

03

Regulation now asks for proof

The EU Cyber Resilience Act's reporting duties began on 11 September 2026. From 11 December 2027, connected products need secure updates and technical documentation for their whole support period.

One loop from intent to installed firmware.

Every step leaves an artifact you can review, diff and sign — no black boxes between the requirement and the binary.

01 — Describe

Write the spec in plain language

State behavior, stack and flash budgets, and what must never happen. Forge turns them into precise requirements a person approves.

02 — Generate

Target-aware code generation

C built and measured for your chip and toolchain, inside your stack and flash budgets — not generic desktop code.

03 — Verify

Proofs, not just tests

Every change is cross-compiled with warnings as errors, checked against its limits and proven with bounded model checking. Failures come back with a counterexample.

04 — Deploy

Staged rollout to the fleet

Signed builds roll out canary-first over the air, with automatic rollback when health checks slip.

Watch it fix itself

Two real bugs. Both caught. Both fixed.

This is genuine output from Forge on a saturating add for a motor-current loop. The model doesn't get to argue with the checker: it gets the exact input that breaks its code.

The approved requirements
R1  If the sum fits in 16 bits, return it exactly. R2  Above 32767, return 32767. R3  Below −32768, return −32768. Never wrap.
1
Attempt 1Not verified
return (int16_t)(a + b);

3 of 6 proof obligations failed. The sum wraps around instead of saturating.

2
Attempt 2Not verified
if (s > INT16_MAX)  return INT16_MAX;
if (s < -INT16_MAX) return -INT16_MAX;

Counterexample: a = −32768, b = 0 returned −32767. −32768 is a valid result, so the clamp was off by one.

3
Attempt 3Verified
if (s > INT16_MAX)      s = INT16_MAX;
else if (s < INT16_MIN) s = INT16_MIN;

All 6 proof obligations hold for all 4,294,967,296 input pairs. 10 bytes of flash, no stack.

Already have firmware?

Prove the code you already ship.

No AI involved. Point Forge at existing code and the requirements you approve. This function looks right and passes the tests most teams would write.

Checks every possible input, not the handful a test suite samples
Shows the exact input that breaks the code, ready to replay on a dev board
Works on code written by people, by AI, or inherited from a supplier
Send us a function you don't trust
#include "sat_add_q15.h"

int16_t sat_add_q15(int16_t a, int16_t b)
{
    int16_t s = (int16_t)(a + b);
    if (a > 0 && b > 0 && s < 0) { return INT16_MAX; }
    if (a < 0 && b < 0 && s > 0) { return INT16_MIN; }
    return s;
}
forge checkNot verified
a = −32768, b = −32768 → returned 0, required −32768 The sum wrapped to 0 before the overflow checks ran, so neither branch fired.
Verification engine

If it can't be proved, it doesn't ship.

Generated code is only useful if you can trust it on a device you can't reach. Ferrete attaches an evidence package to every build: what was checked, how, and against which requirement.

Requirements locked by hash, so nobody can quietly weaken them
Counterexamples you can replay in simulation or on a dev board
Cross-compiled for your MCU with warnings as errors; no heap or floating point unless you allow it
Checks on every build sat_add_q15
No out-of-bounds accessbounded model check
Output equals spec for all inputsequivalence proof
Stack and code size within limitsmeasured for target
Largest stack frame under limitcompiler stack report
Coding standardCompiles with -Werror
What your auditor gets

Evidence a reviewer can sign.

Every build produces a report for safety reviews and compliance files. It's honest about its limits, because a report that overclaims is worse than none.

Who approved the requirements, and when
Every check and its result, with the tool versions that ran it
SHA-256 fingerprints tying spec, requirements and code together
What was not proven, stated plainly
Export as JSON for your tools, or Markdown for your files
Evidence packagesat_add_q15 · b-2f9c1a
StatusVERIFIED
Requirements approved byJane Doe, Oct 3, 2026 17:18 UTC
ChecksIntegrity · compile (host, Cortex-M4) · no heap or float · stack · size · proof
ProofAll 6 obligations hold for every input
Not provenExecution time on the chip. Measure on target.
Requirements SHA-256606ca015cc71e4f68b500caf8cb64590…
Code SHA-2568d6e16b34e196eb0dcb982cf0b0a5259…
Toolsgcc 13.3.0 · arm-none-eabi-gcc 13.2.1 · CBMC 5.95.1
Ferrete Edge

Proven code, delivered safely.

A small on-device library, about 4 KB of flash, that installs updates the way you'd want for machines you can't reach.

v3 rolloutRolling
5%
25%
50%
100%
Pauses itself above 5% rollbacks

Signed updates

Devices only install firmware signed with your release key. Ferrete verifies every package but never holds the private key.

Staged rollouts

Release to 5%, then 25%, 50% and everyone. A rollout pauses itself when rollbacks pass the limit you set.

Automatic rollback

New firmware runs on trial first. If it crashes or hangs, the bootloader restores the last good version on its own.

Power-cut safe

Tested against 2,050 simulated power cuts mid-update. The device always comes back running a valid image.

Your silicon, not a sandbox.

Every build is cross-compiled and measured for your target, so generated code compiles cleanly and fits where it has to run. Arm Cortex-M today; more cores as design partners need them.

Arm Cortex-M
Available now: M0+, M4, M33
Arm Cortex-A
Planned
RISC-V
Planned: RV32
Edge GPUs
On the roadmap
DSPs
On the roadmap
FPGAs
On the roadmap
Zephyr · FreeRTOS
Works with: plain C, no RTOS calls needed
Embedded Linux
Planned
How it compares

The only one that writes the code and proves it.

ApproachWrites the codeProves it for every inputChecks your chip's limitsEvidence for audits
General AI coding assistantsYesNoNoNo
Static analysis toolsNoSome bug classesNoFindings reports
Manual review and testingBy handOnly inputs testedBy handBy hand
FerreteYesYesEvery buildEvery build

Ferrete works alongside the tools you have: keep your static analysis and hardware-in-the-loop tests, and use Forge for the code you most need to trust.

Fits your workflow

No new habits required.

Forge runs where your firmware already lives: in the repo, in CI and in code review.

GitHub and GitLab CI

A proof on every pull request. A broken proof fails the build, like a failing test.

Your toolchain

GCC and the Arm GNU toolchain, for Cortex-M0+, M4 and M33.

Slack

Approval requests, failed proofs and rollbacks, in your team's channel.

Single sign-on

Okta, Microsoft Entra ID or Google Workspace, through OpenID Connect.

API and webhooks

Script anything. Every webhook is signed so you can check it came from us.

On-prem

Enterprise runs generation and proofs entirely inside your network.

Where it runs

Robotics

Motor control, sensor fusion and safety interlocks with hard timing budgets.

Automotive

ECU software with traceability that slots into functional-safety workflows.

Aerospace & defense

Air-gapped deployment options and evidence packages for certification review.

Industrial IoT

Long-lived devices that update safely over constrained links.

Built for code you can't afford to leak.

Read how we handle your code
Your code never trains AI models
Your signing key never leaves your machine
Every approval and release in a tamper-proof audit log
On-prem verification on Enterprise
Pricing

Start free. Pay as Forge earns its place.

See full pricing
Builder
Free

One engineer, one board, 50 verified builds a month.

Team
$149per engineer / month, billed annually

Unlimited projects, approvals and audit trail, 500 builds per engineer.

Enterprise
From $60kper year

On-prem, single sign-on, compliance exports and a dedicated engineer.

Fleet updates: $0.20 per active device per month, first 100 devices included on Team. Design partners use Team free during the beta.

Questions

What firmware leads ask us first.

Does Ferrete replace my firmware engineers?

No. Engineers write the spec, approve the requirements and decide what ships. Forge takes over the slow parts: writing routine code and proving it correct.

What if the requirements are wrong?

A proof is only as strong as what it checks. That's why a person reviews and locks every set of requirements against a checklist, and any later edit needs re-approval. Our guide shows how to spot weak requirements.

Does it prove timing?

Not yet. Forge proves behavior for every input and checks stack and code size for your chip. Measure execution time on the target; every evidence report says so.

Which chips and languages?

C for Arm Cortex-M0+, M4 and M33 today, with GCC and the Arm GNU toolchain. Tell us what you ship on: design partners decide what we support next.

Where does my code go?

On Team, into isolated cloud workers, never into AI training, and it's deleted when you delete it. On Enterprise, it never leaves your network.

How long does a proof take?

Small functions usually prove in seconds. Larger ones can take minutes; splitting them into smaller verified functions keeps CI fast.

Can we try it on our own code?

Yes. Join the design-partner program and send one function you don't fully trust. We'll return it proven, or show you the input that breaks it.

Bring a spec. Leave with verified firmware.

Connect a repo and a target board — your first evidence package is one prompt away.

Get early access Talk to sales
For firmware engineers

Spec in. Proven C out.

Forge wraps a frontier model in a loop of checks it can't argue with or game. Nothing reaches your repo until it compiles for your target, fits your limits and is proven against requirements a person approved.

01 — Describe

Write the intent in plain language plus hard limits: stack, code size, no heap, no floating point.

02 — Approve the requirements

Forge drafts a proof harness from your spec. An engineer reviews it and locks it by hash. The AI can read it, never change it.

03 — Generate and repair

The model writes C. Independent tools compile it for your MCU, check limits and prove it with CBMC. Failures go back with the exact input that breaks it.

04 — Ship with evidence

You get the code and an evidence report: who approved what, what was proven, tool versions, and SHA-256 hashes tying it all together.

A spec is a short file.

Plain language for people, hard numbers for the checks.

[module]
name      = "sat_add_q15"
signature = "int16_t sat_add_q15(int16_t a, int16_t b);"
target    = "cortex-m4"
intent    = """
Add two Q15 values. Return the exact sum if it fits;
otherwise saturate to 32767 or -32768. Never wrap.
"""

[limits]
heap = false
float = false
max_stack_bytes = 16
max_code_bytes  = 64

Watch it fix itself.

Real output. The first two attempts had genuine bugs.

$ forge build sat_add_q15.toml
attempt 1  FAIL  proof: 3 of 6 obligations failed
attempt 2  FAIL  proof: 2 of 6 obligations failed
           a = -32768, b = 0 → returned -32767
attempt 3  PASS  compile (host, cortex-m4)
           PASS  no heap · no float · no extra symbols
           PASS  stack 0 B / 16 · code 10 B / 64
           PASS  proof: all 6 obligations, every input
VERIFIED · evidence → build/sat_add_q15/EVIDENCE.md

Built so the AI can't fake a pass.

Requirements are locked by hash before any code is generated. Edit one character and the build stops until someone re-approves.
Generated code may define only the function you asked for. It can't redefine the proof's inputs or reach into the checker.
Every candidate is cross-compiled for your MCU with warnings as errors, and scanned for heap, floating point and stdio.
The evidence report states what was not proven, such as on-chip timing, as plainly as what was.

Already have firmware? Check it first.

Point Forge at code you already ship and the same approved requirements. This saturating add looks right and passes typical unit tests:

$ forge check sat_add_q15.toml legacy_sat_add.c
NOT VERIFIED
  a = -32768, b = -32768 → returned 0
  required -32768 (sum wrapped before the check)

Works with your toolchain.

TargetsArm Cortex-M0+, M4, M33 today. More by request from design partners.
ToolchainGCC and arm-none-eabi-gcc; CBMC for proofs. Runs in CI or on your laptop.
ModelsClaude by default. Your code is never used for training.
DeliveryPairs with Ferrete Edge for signed, rollback-safe updates to the fleet.
Read the quickstart →

Send us one function you don't fully trust.

We'll return it proven, or show you the input that breaks it, with the evidence report.

Join the design partner program
Private

For customers and design partners

Our docs and security details are shared with customers and design partners. Enter your work email and we'll send you a one-time code.

Not a customer or design partner yet? Request access.

Pricing

Priced per engineer. Proven per build.

Start free on one board. Add your team when Forge earns its place in your workflow. Pay for fleet updates only as your devices ship.

Builder

For individual engineers and prototypes.

Free
No credit card
Request access
1 project and 1 target board
50 verified builds per month
C code generation
Memory-safety and requirement proofs
Evidence reports (Markdown)

Team

For product teams shipping devices.

Most teams
$149per engineer / month, billed annually
$179 billed monthly · 14-day free trial
Request a trial
Everything in Builder
Unlimited projects and targets
500 verified builds per engineer / month, pooled
Equivalence proofs and stack/size budgets
Shared spec library, approvals and audit trail
OTA rollouts for up to 100 devices included

Enterprise

For regulated programs and large fleets.

From $60kper year
Annual agreement
Talk to sales
Everything in Team
On-prem verification in your network
Compliance evidence exports for audits
Single sign-on (OpenID Connect) and role-based access
99.9% uptime SLA
Dedicated support engineer

Add-ons

Fleet updates (Ferrete Edge)Signed OTA, staged rollouts, automatic rollback and health gates. First 100 devices included on Team.
$0.20 per active device / month
Extra verified buildsFor teams that run large regression proofs in CI.
$20 per 100 builds
Design partners: Team plan free during the beta, in exchange for a weekly call and honest feedback. Apply

Questions

What counts as a verified build?

One run of the full check suite (compile, limits and proof) that produces an evidence report. Drafts and local previews don't count.

Do design partners pay?

No. Design partners get Team free during the beta in exchange for a weekly call and honest feedback.

Does our code leave our network?

On Team, code runs in isolated cloud workers and is never used for training. Enterprise can run entirely on-prem.

Which toolchains are supported?

GCC and Arm GNU Toolchain today, with CBMC for proofs. IAR and Keil support is planned; tell us what you use.

Can we cancel any time?

Monthly plans cancel at the end of the billing period. Annual plans can be cancelled for the next term.

About Ferrete

AI can write firmware. Someone has to prove it's right.

We're building the tools that let embedded teams use AI without giving up the rigor their products demand.

Why we exist

Code that runs on a robot arm, a drone or a factory line can't be patched by refreshing a page. A single overflow can stop a machine or recall a product. That's why embedded teams have stayed cautious about AI coding tools, even as the rest of software adopted them.

We think the answer isn't less AI. It's AI that has to show its work: requirements a person approves, proofs a machine checks, and evidence anyone can audit.

What we believe

Proof over promises.If we can't prove it, we say so.
Engineers sign off, not algorithms.People approve the requirements; machines check the code against them.
Your silicon, not a sandbox.Code is only done when it fits and runs on the chip you ship.

Team

Akeem EgbeyemiFounderTwo-time fintech founder and product leader with 20+ years building platforms in regulated industries.

We're building the founding team now. See the roles.

We're hiring

Embedded engineers who've shipped firmware to production, and people who know formal methods. Location: Remote-first, across US and European time zones.

See open roles
Contact

Let's prove something together.

Book a 30-minute demo, or join the design partner program: free access while we build, in exchange for honest feedback.

We'll run Forge live on a function from your world.
No sales pitch on the first call. We want to learn how your team ships firmware.
Design partners test on spare dev boards, never production devices.

Prefer email? akeem@ferrete.ai

I'd like to

We reply within one business day and never share your details.

Private

For customers and design partners

Our docs and security details are shared with customers and design partners. Enter your work email and we'll send you a one-time code.

Not a customer or design partner yet? Request access.

Careers

Help make AI firmware trustworthy.

Ferrete is new, and we're hiring the founding team. The first engineers will shape the product, the culture and the company.

Open roles

Founding embedded engineer

Engineering · Full-time

Build the device side of Ferrete: bootloaders, OTA, and ports to new MCU families. You've shipped production firmware on Cortex-M and debugged it with a scope.

Apply

Founding engineer, formal methods

Engineering · Full-time

Make proofs faster and more expressive: CBMC, bounded model checking, and turning plain-language specs into precise properties.

Apply
Apply

Don't see your role? Write to us anyway at akeem@ferrete.ai with what you'd build.

Legal

Privacy Policy

Last updated October 14, 2026

We collect only what we need to run Ferrete, we never sell it, and we never use your code to train AI models. This policy explains what we collect, why, who helps us process it, and the choices and rights you have.

The short version

  • Your code is yours. Specs, requirements, code and evidence you put into Ferrete belong to you and your company. We process them only to provide the service.
  • No AI training. We never use customer content to train or fine-tune AI models, and our AI providers are contractually barred from doing so.
  • No selling, no ad tracking. We don't sell personal data, share it for targeted advertising, or use advertising or analytics cookies.
  • You're in control. You can download your personal data and delete your account yourself, in Settings → Account.
  • Questions? Email akeem@ferrete.ai. We reply within 30 days, usually much sooner.

Who we are and what this covers

Ferrete ("Ferrete", "we", "us") makes tools that generate, verify and deliver firmware: the website at ferrete.ai, the Ferrete Cloud web app and API, the Forge command-line tool, the Ferrete Edge on-device library and the Ferrete extension for Visual Studio Code (together, the "Services").

This policy covers personal data we decide how to use (as a "controller"): visitors to our website, people who contact us, and the people who sign in to the Services.

When a company uses the Services, the content its team puts in, and the personal data inside that content, is processed on that company's behalf. For that data we act as a "processor" (or "service provider") under our Terms of Service and, where applicable, a data processing agreement with the customer. The customer's own privacy notice applies to it, and requests about it go to the customer first; we'll help them answer.

Software you run yourself, such as Forge on your computer, Ferrete Edge on your devices or the Visual Studio Code extension, sends nothing to us unless you connect it to Ferrete Cloud.

What we collect

CategoryWhat it includesWhere it comes from
Account and profileName, work email, company, job title, password (stored only as a salted hash), two-factor settings, single sign-on identifiers, terms acceptanceYou, or your company's identity provider
Customer contentSpecs, approved requirements, source code, generated code, reference files, build logs, evidence reports, release packages and notesYou and your team
Device and fleet dataDevice identifiers, firmware versions, update state, uptime and health counters reported by your devicesYour gateways and devices
AI usageWhich feature was used, the model, token counts and cost. The prompts and replies themselves only if your workspace turns on AI transcriptsThe Services
Usage and technical dataIP address, browser and device type, pages and features used, timestamps, sign-in and security events, audit log entriesCollected automatically when you use the Services
BillingBilling contact, plan, invoices and payment status. Card details go straight to Stripe; we never see or store full card numbersYou and Stripe
CommunicationsMessages from our contact form, emails, support requests and notes from callsYou
Private page accessThe work email you enter to open our private pages, the one-time code (stored only as a hash), and when and from which IP address you opened themYou

We don't ask for sensitive personal data such as health, biometric or financial account information, and you shouldn't put it in specs or code. If your firmware handles such data, keep real records out of the Services and use test values instead.

How we use it, and why

We use personal data only for the purposes below. If you are in the European Economic Area, the United Kingdom or Switzerland, the second column is the legal basis we rely on.

PurposeLegal basis
Provide the Services: accounts, builds, proofs, evidence reports, releases and fleet updatesPerforming our contract with you or your company
Run the AI features you choose to use, by sending the relevant spec, requirements and code to an AI providerPerforming our contract
Send service emails: sign-in codes, invitations, approval requests, alerts, billing notices and changes to these termsPerforming our contract
Keep the Services secure: prevent fraud and abuse, enforce rate limits, keep audit logs, investigate incidentsOur legitimate interest in a secure service; legal obligations
Bill and keep financial recordsPerforming our contract; legal obligations such as tax law
Improve the Services using aggregated, de-identified statistics, such as how often proofs succeed. Never your content itselfOur legitimate interest in improving the product
Answer inquiries, arrange demos and, if you opt in, send product newsOur legitimate interest in replying to business contacts; your consent where the law requires it
Comply with the law and enforce our termsLegal obligations; our legitimate interest in protecting our rights

Where we rely on legitimate interests, we have weighed them against your rights and expectations. You can object at any time; see Your rights.

Your code is not training data

We never use customer content to train, fine-tune or otherwise improve AI models: not ours and not anyone else's. Our AI providers are contractually prohibited from training on it, and we use zero-data-retention terms where the provider offers them.

If your workspace connects its own AI account (Anthropic, Amazon Bedrock or Google Vertex AI), requests go to that provider under your company's own agreement with it, and that agreement governs how the provider handles them.

How the AI features handle your data

  • AI runs only when someone in your workspace uses an AI feature, such as drafting requirements, generating or repairing code, explaining a failed check or proposing a change.
  • For each request we send only what the task needs: the spec, the approved requirements, the code being written or repaired, the checker's results and the most relevant excerpts of your project's reference files.
  • By default requests go to Anthropic. Your workspace can switch to its own Anthropic, Amazon Bedrock or Google Vertex AI account in Settings → AI provider.
  • We record which feature was used, the model and the token count, for billing and your usage reports. We keep the prompts and replies themselves only if an admin turns on AI transcripts, and then for 30 days.
  • Every piece of AI-generated code is checked by independent tools and reviewed by people in your team before it's used. AI doesn't make decisions about you.

Who we share it with

We don't sell personal data, and we don't "share" it for cross-context behavioral advertising, as California law defines those terms. We disclose it only as follows.

Service providers (sub-processors) that run parts of the Services for us, under written contracts that limit them to providing those services and require them to protect the data:

Type of providerWhat they do for usData involvedLocation
Cloud infrastructureHosting, storage, build workers, backups and key managementAll data held in Ferrete CloudUnited States; EU on request for Enterprise
AI model providerDrafting requirements, generating and repairing codeThe content sent with each AI requestUnited States
Payment processor (Stripe)Payments and invoicingBilling contact and payment detailsUnited States
Website hostingServing this website and the contact formWebsite requests and contact-form messagesUnited States
Email and support toolsEmail and customer supportCorrespondence with youUnited States

The named list of our sub-processors is on our Sub-processors page for customers and design partners, and anyone can request it at akeem@ferrete.ai. If your workspace connects its own AI account (Amazon Bedrock, Google Vertex AI or Anthropic), that provider processes your AI requests under your company's agreement with it. We give customers at least 30 days' notice before adding a new sub-processor, and customers may object.

Within your workspace. Owners and admins of your workspace can see its members, their roles and activity, and its audit log.

Integrations you turn on, such as Slack, webhooks, your single sign-on provider or your CI system, receive the data you configure them to receive.

For legal reasons: when required by law, court order or other valid legal process, or to protect the rights, property or safety of our users, the public or Ferrete. Where allowed, we tell the affected customer first so it can respond.

Business transfers: as part of a merger, acquisition or sale of assets, subject to this policy, with notice to you.

With your consent, or at your direction.

Cookies and similar technology

The Ferrete Cloud app uses two cookies, both strictly necessary: one keeps you signed in (fr_session) and one protects forms against cross-site attacks (fr_csrf). Neither is used for tracking.

Our website sets no cookies. When you open our private pages with a one-time code, your browser keeps a key in its local storage for 7 days so you don't need a new code on every page. Clear your browser's site data to remove it.

We use no advertising or third-party analytics cookies, so there is nothing to opt out of. We also honor Global Privacy Control signals.

How long we keep it

DataHow long
Account and profileWhile your account is active. Deleting your account erases it right away from active systems, and from backups within 90 days
Customer contentUntil you delete it or close the workspace. A deleted workspace has a 30-day grace period, then is removed from active systems within 30 days and from backups within 90 days
Build logsAs set by your workspace: 30, 90 or 365 days, or for the life of the workspace
Evidence reports and approvalsFor the life of the workspace, because they are your compliance record
AI transcripts30 days, and only if your workspace turns them on
Security and audit logsFor the life of the workspace. They keep the names of people who took actions, even after those people delete their accounts, so each workspace keeps an accurate record
Billing and tax recordsAs long as tax and accounting law requires, usually 7 years
Contact-form messages and sales correspondenceUp to 24 months after our last contact
Private page access log24 months. One-time codes expire after 10 minutes

Your rights

Depending on where you live, you may have the right to:

  • know what personal data we hold about you and get a copy of it;
  • correct data that is wrong or incomplete;
  • have your data deleted;
  • receive your data in a portable format;
  • object to processing based on our legitimate interests, including direct marketing;
  • restrict how we process your data;
  • withdraw consent you've given, without affecting earlier processing; and
  • complain to your data protection authority. We'd appreciate the chance to help first.

How to use them. Download your personal data and delete your account yourself in Settings → Account, or email akeem@ferrete.ai. We'll confirm your identity, usually by email, before acting, and respond within 30 days (45 days where US state law allows, with notice if we need longer). You can use an authorized agent; we'll ask them for proof that you authorized them. If we decline a request, you can appeal by replying to our decision, and we'll answer the appeal within 45 days.

Content in a customer's workspace. If your data is part of a workspace your employer controls, we'll pass your request to that company and help it respond.

California and other US states. In the last 12 months we collected the categories of personal information listed in What we collect, for the purposes in How we use it, from the sources listed there. We disclosed them only to the recipients in Who we share it with. We don't sell or share personal information, we don't collect sensitive personal information beyond the sign-in credentials you choose, and we won't treat you differently for using your rights.

International transfers

We are based in the United States, and we and our sub-processors process data there. When we transfer personal data from the European Economic Area, the United Kingdom or Switzerland, we use the European Commission's Standard Contractual Clauses, with the UK Addendum and Swiss amendments, or another lawful transfer mechanism. Contact us for a copy. EU data residency is planned for Enterprise customers.

How we protect it

  • Encryption in transit (TLS) and at rest, including stored secrets such as single sign-on settings and AI provider credentials.
  • Each customer's builds run in separate, short-lived workers.
  • Passwords are stored only as salted hashes; two-factor authentication and single sign-on are available, and workspaces can require them.
  • Firmware signing keys stay with you. Ferrete only checks signatures and never holds your private key.
  • Our staff tools never show customer specs or code, require two-factor authentication, and record every action in an append-only log.
  • Backups are encrypted and checked after they're written.

No system is perfectly secure. If a breach affects your personal data, we'll notify affected customers without undue delay, and you where the law requires. To report a vulnerability, email akeem@ferrete.ai.

Children

The Services are professional tools for businesses and aren't directed at children. We don't knowingly collect personal data from anyone under 16. If you believe a child has given us personal data, email akeem@ferrete.ai and we'll delete it.

Changes and contact

We'll post any update here with a new date. For material changes, we'll email account owners at least 30 days before they take effect.

Questions, requests or complaints: akeem@ferrete.ai, Ferrete, United States. Customers who need a data processing agreement can ask the same address.

Questions about this page? Email akeem@ferrete.ai.

Legal

Terms of Service

Last updated October 14, 2026

The plain-language version: your code stays yours, proofs cover what you approved, you decide what ships, and you can leave with your data at any time. The full terms follow.

The short version

  • You own your work. Your specs, code, generated code and evidence belong to you. We use them only to provide the service, and never to train AI models.
  • Proofs have limits. A proof shows code meets the requirements your team approved, within the limits stated in each evidence report. You review requirements, test on your hardware and decide what ships.
  • Fair billing. Paid plans are billed in advance; usage add-ons in arrears. Cancel any time, effective at the end of your billing period.
  • Use it responsibly. No malware, no attacks on the service, and follow export-control law.
  • Liability is capped at the fees paid in the 12 months before a claim, with standard exceptions.

1. Agreement

These Terms of Service ("Terms") are an agreement between Ferrete ("Ferrete", "we", "us") and the company or other organization that uses the Services ("Customer", "you"). They cover our website, the Ferrete Cloud web app and API, Forge, the Ferrete Edge library, the Visual Studio Code extension and related support (the "Services").

By creating an account, clicking to accept, or using the Services, you agree to these Terms. If you accept on behalf of an organization, you confirm you have authority to bind it. If you don't agree, don't use the Services.

If you sign an order form, enterprise agreement or design partner agreement with us, it forms part of this agreement and wins where it conflicts with these Terms. Our Privacy Policy explains how we handle personal data; a data processing agreement is available on request and applies to personal data in Customer Content.

2. Definitions

  • "Customer Content": specs, requirements, source code, reference files, logs, release packages and anything else you or your Users submit to the Services.
  • "Output": code, requirements drafts, explanations and evidence reports the Services produce for you, including with AI.
  • "Users": people you allow to use the Services under your account, such as your employees and contractors.
  • "Workspace": your organization's space in Ferrete Cloud, with its members, projects, devices and billing.
  • "Order": your chosen plan in the app, or a signed order form.

3. Accounts and Users

  • The Services are for business use by people at least 18 years old. Account information must be accurate and kept up to date.
  • You are responsible for your Users, their compliance with these Terms, and activity under your account. Keep passwords, API keys and other credentials confidential.
  • Tell us promptly at akeem@ferrete.ai if you suspect unauthorized access.
  • Workspace owners and admins control membership, roles, security settings and data. If a User leaves your organization, remove their access.

4. Plans, trials and beta features

  • Plans. Builder is free, with the usage limits shown on our pricing page. Team and Enterprise are paid plans. Each plan includes the usage allowances (such as verified builds, active devices and AI usage) shown at sign-up or in your Order.
  • Trials. A free trial lasts the period offered, usually 14 days. At the end, you choose a paid plan or the workspace moves to Builder.
  • Beta and design partner features are provided as-is, may change or end, and may be less reliable. We'll tell you before removing a beta feature you rely on.
  • Free plans may change, be limited or end with 30 days' notice. Your data stays exportable.

5. Your content

As between you and us, you own all Customer Content. You give us a worldwide, non-exclusive, royalty-free license to host, copy, process, transmit and display Customer Content only to provide, secure and support the Services for you, and as you direct, including sending it to AI providers and integrations you use.

We don't use Customer Content to train or fine-tune AI models, and we don't share it except as described in our Privacy Policy. We may produce aggregated, de-identified statistics about how the Services perform, such as proof success rates, that don't identify you or reveal your content.

You confirm that you have the rights needed to submit Customer Content, including third-party and open-source code, and that doing so doesn't violate any law, contract or export restriction. Don't submit health records or other sensitive personal data; use test values instead.

6. AI-generated code and other Output

As between you and us, you own the Output produced for you, and we assign to you any rights we have in it. AI systems may produce similar output for other customers; those outputs aren't yours, and yours aren't theirs.

AI can be wrong. Output may contain errors, may be unsuitable for your purpose, and may resemble existing code. You are responsible for reviewing Output, approving requirements, checking license obligations of any code you ship, and deciding what to use.

7. Proofs, evidence and safety-critical use

Ferrete's proofs show that code meets the requirements your Users approved, for the inputs and within the limits (such as loop bounds) stated in each evidence report. They don't show that the requirements are complete or correct, or that the code meets anything the report lists as not proven, such as execution time on your chip.

You remain responsible for your product: reviewing requirements, testing on your own hardware, meeting the safety, regulatory and certification requirements that apply to it, and deciding what ships.

Unless a signed agreement says otherwise, the Services are not certified as the sole means of meeting a safety standard, and must not be the only safeguard for systems whose failure could lead to death, serious injury or major environmental damage, such as life-support devices, aircraft flight controls or nuclear facilities.

8. Firmware delivery and signing keys

  • Your firmware signing keys stay with you. Ferrete checks signatures but never holds your private signing key, and can't sign firmware for you.
  • You choose which releases go to which devices, the rollout stages and the limits that pause a rollout. Ferrete Edge rolls a device back when new firmware fails its checks, but you are responsible for update decisions and for testing releases before you ship them.
  • Keep your devices' bootloaders and keys secure; if a key is lost or exposed, you are responsible for rotating it.

9. Third-party services and your own AI account

The Services work with third-party products such as AI providers, GitHub, GitLab, Slack and identity providers. Your use of them is governed by their terms, and we aren't responsible for them. If you connect your own AI account (Anthropic, Amazon Bedrock or Google Vertex AI), that provider bills you directly and its agreement with you governs its handling of your requests.

10. Acceptable use

You and your Users won't:

  • use the Services to build malware or software intended to cause unlawful harm, or to break into systems you aren't authorized to test;
  • probe, scan, overload or disrupt the Services, get around rate limits, usage limits or security controls, or access other customers' data;
  • reverse engineer the Services, except where the law or an open-source license allows it;
  • resell, sublicense or provide the Services to third parties as a service without our written permission;
  • use the Services to build a competing product, or to benchmark them for publication without our consent; or
  • violate any law, or anyone's intellectual property, privacy or other rights.

We may suspend access that we reasonably believe breaks this section or threatens the Services or other customers. Where practical we'll tell you first and give you a chance to fix it.

11. Export controls and sanctions

You will comply with all export-control and sanctions laws that apply to you, including those of the United States. You confirm that you and your Users aren't located in, or acting for anyone in, a country or region under comprehensive US sanctions, and aren't on a US government restricted-party list. You won't use the Services for prohibited end uses, such as weapons of mass destruction.

Don't upload technical data controlled under the International Traffic in Arms Regulations (ITAR) or similar regimes to our hosted Services. Customers with such data should use Enterprise on-premises verification under a signed agreement.

12. API and rate limits

API keys are credentials: keep them secret and give each key only the permissions it needs. We apply rate limits and usage limits to keep the Services reliable, and may change them with reasonable notice. Don't share keys outside your organization.

13. Fees, billing and taxes

  • Paid plans are billed in advance, monthly or annually, at the prices shown when you subscribe or in your Order. Seats you add during a term are charged pro rata.
  • Usage add-ons, such as active devices above your allowance, extra verified builds and AI usage above your allowance, are billed monthly in arrears at the published rates.
  • Payments are processed by Stripe. You authorize us to charge your payment method for amounts due. Invoiced Enterprise fees are due within 30 days of the invoice date.
  • Fees exclude taxes. You pay any sales, use, value-added or similar taxes, except taxes on our income.
  • If a payment is more than 15 days overdue, we may suspend paid features after notice. Your data stays intact and exportable.
  • Dispute a charge within 30 days of the invoice. Fees are non-refundable except where required by law or stated in these Terms.
  • We'll give at least 30 days' notice of price changes; they take effect at your next renewal.

14. Term, cancellation and termination

  • Subscriptions renew automatically for the same period unless cancelled. You can cancel at any time from Settings → Billing or by emailing akeem@ferrete.ai; cancellation takes effect at the end of the current billing period.
  • Either party may terminate for a material breach the other doesn't cure within 30 days of written notice. We may suspend or terminate immediately for serious abuse, security threats, or where the law requires.
  • After termination you can export your Customer Content for 30 days. We then delete it as described in our Privacy Policy.
  • Sections that by their nature should survive termination will survive, including those on ownership, payment owed, confidentiality, disclaimers, liability and governing law.

15. Confidentiality

Each party will protect the other's non-public business and technical information, including Customer Content, with at least reasonable care, and use it only to perform under these Terms. Each may share it only with employees, contractors and advisers who need it and are bound by similar duties. These duties don't cover information that is public, already known, independently developed or lawfully received from someone else. If the law requires disclosure, the receiving party will give notice first where allowed.

16. Our intellectual property and feedback

Ferrete owns the Services and everything we build, including improvements. These Terms grant you the right to use the Services during your subscription; they don't transfer ownership of our technology. Open-source components are licensed under their own licenses, which take precedence for those components.

If you give us feedback or suggestions, we may use them without obligation to you, provided we don't disclose your confidential information or name you without permission.

17. Security and data protection

We maintain administrative, technical and physical safeguards appropriate to the Services, described on our Security page and in our Privacy Policy. We'll notify you without undue delay after we confirm a security breach affecting your Customer Content, with the information you reasonably need to respond.

18. Availability and support

We aim to keep the Services available and to give notice of planned maintenance. Uptime commitments, such as the 99.9% service level for Enterprise, apply only where stated in an Order. Support is provided by email at akeem@ferrete.ai and, for Enterprise, as set out in your Order.

19. Warranties and disclaimers

Each party confirms it has the authority to enter into these Terms. We'll provide the Services with reasonable skill and care, in line with their documentation.

Except as expressly stated in these Terms, and to the fullest extent the law allows, the Services and Output are provided "as is" and "as available", and we disclaim all other warranties, express or implied, including merchantability, fitness for a particular purpose, title and non-infringement. We don't warrant that the Services or Output will be error-free or uninterrupted, or that Output will meet requirements you didn't approve in the Services.

20. Indemnities

From us. We will defend you against third-party claims that the Services, as we provide them, infringe their intellectual property rights, and pay resulting damages and costs finally awarded or agreed in settlement. This doesn't cover claims caused by Customer Content, Output you modify, combinations with things we didn't provide, or use that breaks these Terms. If the Services are or may be found infringing, we may modify them, get you a right to keep using them, or end your subscription and refund prepaid fees for the unused period.

From you. You will defend us against third-party claims arising from your Customer Content, your products and devices, or your use of the Services in breach of these Terms or the law, and pay resulting damages and costs finally awarded or agreed in settlement.

The party seeking defense must give prompt notice, let the other control the defense and settlement (no settlement may admit fault for the protected party without consent), and reasonably cooperate.

21. Limitation of liability

To the fullest extent the law allows, neither party is liable for indirect, incidental, special, consequential or punitive damages, or for lost profits, revenue, data or goodwill, even if told they were possible.

Each party's total liability arising out of or relating to these Terms is limited to the greater of the fees you paid or owed for the Services in the 12 months before the event giving rise to the claim, and US$100.

These limits don't apply to your payment obligations, a party's indemnity obligations, breaches of confidentiality, or liability that can't be limited by law.

22. Publicity

We won't use your name or logo to identify you as a customer without your written permission. You may say publicly that you use the Services.

23. Governing law and disputes

These Terms are governed by the laws of the State of Delaware, USA, without regard to its conflict-of-law rules. The UN Convention on Contracts for the International Sale of Goods doesn't apply. Before starting a legal proceeding, each party will first try to resolve the dispute through good-faith discussion for 30 days. The state and federal courts in Delaware have exclusive jurisdiction, but either party may seek urgent injunctive relief in any court with jurisdiction.

24. Changes to these Terms

We may update these Terms. We'll post the new version here and, for material changes, notify account owners by email or in the app at least 30 days before they take effect. If you keep using the Services after that, the updated Terms apply. If you don't agree, you can cancel before they take effect. Changes don't apply to a signed Order until its current term ends, unless it says otherwise.

25. General

  • Assignment. Neither party may assign these Terms without consent, except to a successor in a merger, acquisition or sale of substantially all of its relevant assets, with notice.
  • Force majeure. Neither party is liable for delays caused by events beyond its reasonable control, other than payment obligations.
  • Notices. We send notices by email to the account owner or in the app. Send notices to us at akeem@ferrete.ai.
  • Independent parties. The parties are independent contractors. There are no third-party beneficiaries.
  • Entire agreement. These Terms and any Order are the whole agreement on this subject. If any part is unenforceable, the rest still applies. Not enforcing a right isn't a waiver of it.
  • US government users. The Services are commercial computer software, and government use is subject to these Terms.

26. Contact

Questions about these Terms: akeem@ferrete.ai, Ferrete, United States.

Questions about this page? Email akeem@ferrete.ai.

Private

For customers and design partners

Our docs and security details are shared with customers and design partners. Enter your work email and we'll send you a one-time code.

Not a customer or design partner yet? Request access.

Private

For customers and design partners

Our docs and security details are shared with customers and design partners. Enter your work email and we'll send you a one-time code.

Not a customer or design partner yet? Request access.

Private

For customers and design partners

Our docs and security details are shared with customers and design partners. Enter your work email and we'll send you a one-time code.

Not a customer or design partner yet? Request access.

Private

For customers and design partners

Our docs and security details are shared with customers and design partners. Enter your work email and we'll send you a one-time code.

Not a customer or design partner yet? Request access.

Private

For customers and design partners

Our docs and security details are shared with customers and design partners. Enter your work email and we'll send you a one-time code.

Not a customer or design partner yet? Request access.

404 · VERIFICATION FAILED

This page doesn't exist.

assert(page != NULL);   /* failed */

The link may be old, or the address mistyped. Here's where most people are headed:

Home Docs Pricing Contact