These are the terms of the private beta, not of a product you're buying: there isn't one to buy yet. They take about ten minutes end to end, which is longer than we'd like and still shorter than the thing you'd otherwise sign without reading. Terms nobody reads protect nobody.
Last updated 3 August 2026. Written in plain English by the people who will actually do the work, so that what it says and what happens are the same thing. Where something genuinely isn't settled yet, it says so in the section it belongs to rather than hiding in a definition.
A document that binds nobody in particular binds nobody. This one names both sides first, including the part that is awkward for us.
us
Oceantic is an unincorporated venture at the date on this page, so the
party on our side is the founders, and every commitment here is one they give
personally rather than behind a company.
That cuts our way, not yours: a promise from a person is harder to walk away from
than one from an entity that can be wound up. On incorporation this page is
re-dated, the company is named here with its registered address, and the
obligations transfer to it. Ask for the individual's registered details and
we'll give them to you.
you
The last one is not boilerplate suspicion: software crosses borders and sanctions
regimes apply to it.
You take the beta, and anything built from it, only where you're lawfully
allowed to take it.
how you agree
By ticking the box on the access form before you send it. That tick, and the time of it, are written into the message itself, so the record of what you agreed to sits in your sent folder as well as in our inbox, and neither side has to take the other's word for what the page said that day. A link in a footer that nobody clicks is not an agreement, and we would rather have the version that is.
If you'd rather not agree to something, don't tick it and don't send it: there is no other gate on the site, and nothing else you can do here needs your assent.
the words
Four terms do the work on this page, so they are pinned here rather than left to context. Your brief is the description you write. The compiler is our build system, the thing that reads it. The output, the artifact, is everything it hands back: source, images, tests and deployment files. The receipt is the one-page record of what was built and what was tested. Where the product pages say "we build it" and these terms say "compile", they mean the same act: the compiler doing it, not a person.
The beta is an exchange: you bring a real brief, your judgement, and your feedback; we give you the compiler, and we stand behind what it produces. Starting is free, and where you want more, paid packages are quoted in writing before anything is charged.
we do
Free builds cost nothing. Anything more is quoted in writing before it starts,
and the figure doesn't change half-way through.
No charge ever appears that you did not agree to first.
you do
Paid packages are agreed per engagement, and your feedback matters as much as
any invoice.
No exclusivity, no minimum term, no notice required to stop.
You can walk away at any point and keep everything you compiled.
That isn't generosity: it's the same trade the product is built around.
The beta is free to start. Beyond that, paid packages cover more, and what they cost depends on what you're asking for, so the number is agreed with you directly rather than printed here. How the number behaves is the same for everyone, and that is what this section is.
the number
For anything paid, you get the figure in writing before it starts, with what it covers and what it doesn't. Nothing is charged until you've agreed it. We don't publish a price list, because the packages aren't uniform yet and a page of tiers we'd contradict in the first conversation would be worse than no page at all.
no surprises
It doesn't move half-way through because the work turned out harder than we thought: that risk is ours, and mispricing it is how we learn to price it. If the scope changes because you changed it, we re-quote and you agree again before any of it is built.
how you pay
Method, currency, timing and instalments are settled per engagement rather than dictated here: at this size we would rather fit how you actually buy things than make you fit us. Whatever is agreed is written down before it applies.
Refunds concern paid packages, and before one starts, you get all of it back: no questions, and no window to miss. Once a package is underway, what's refundable is whatever hasn't been done yet. That is how work like this is normally handled, and it's the only split that stays fair in both directions. Free builds cost nothing, so there is nothing to refund.
If we can't deliver what we quoted, or we stop, you get your money back in full: not a credit, not a partial, and you keep anything already built. Changing your mind mid-package is not a refund, and we'd rather say so here than at the point it matters.
Tell us what's wrong and we fix it. That's the first move and usually the only one needed: a build isn't finished because we say so, it's finished when it does what the brief said.
What paying for a package does not buy is a warranty. Everything under what we don't promise still applies at full strength: a package fee makes us accountable for the work and for the refund, not for outcomes we have said all along we cannot guarantee. Worth reading before you agree a number, not after.
The short version: your brief and the application compiled from it are yours, the compiler is ours, and paying for a build changes neither of those.
yours
Your description, the application compiled from it, the source tree, the images and the receipt are yours to use, modify, ship and sell, with no licence back to us and no claim on the business logic you write in the owned edge. We don't need a copy of your repository for any of this to work.
ours
The compiler, its component library and the proof machinery stay ours. The beta gives you the right to use it and to keep what it produced, not to redistribute the compiler.
The output also carries third-party open-source components, each under its own licence. Those licences run to you directly and complying with them is yours to do. We list what was included so the list is never a surprise. The compiler is not open source today and nothing here commits us to opening it. If that ever changes it can only widen what you're allowed to do, never narrow it, and the licence you already had on everything you have built is not affected either way.
shared
We will use what breaks to fix the compiler, and a fix reaches every user, and that is the point of a shared core. We won't name you, quote you, or use your logo anywhere public unless you say yes in writing first.
We treat your brief and anything you show us as confidential and don't share it outside the few people who operate the compiler. If you need that on paper before you send anything, ask and we'll sign an NDA. It's a normal request and it doesn't slow anything down.
In return, please don't publish benchmark numbers, screenshots of unreleased behaviour, or the receipt of a build we did together without telling us first. Not to control the story, but so we can tell you if the number changed.
This is the part where most terms go quiet and legal. Ours is the same point the product page makes, in the same words.
as-is
The beta is provided as-is. There is no uptime commitment, no support response time, and no guarantee that a compile you ran last week runs the same way after an upgrade: determinism holds for a given compiler version, which is exactly why the receipt records the compiler identity.
read first
The limits are terms of this agreement, not marketing copy: the beta's receipts are unsigned, it ships no SBOM, nothing keeps watching after the build, offline builds need a local advisory mirror, and the compiled shape is a production SaaS form, and outside it we don't claim coverage. If one of them is a dealbreaker, it's a dealbreaker before you start, not after.
the honest limit
We prove the application is built correctly. We do not and cannot prove your access policy says what you meant. Declare a resource organization-scoped when you meant owner-scoped and we will compile that faithfully and hand you a green report for the wrong policy. Reviewing that declaration stays your job.
Our total liability to you is capped at what you actually paid us for the package in question. For free builds the cap is nil: nothing was charged, and that is the honest number. For anything paid it is what you paid, which is the ordinary limit once money changes hands. Beyond that cap we are not liable for lost profit, lost data, lost time, business interruption, or any indirect or consequential loss.
Two things are carved out of that and always will be, because no honest agreement excludes them and most jurisdictions won't let one try: death or personal injury caused by our negligence, and our own fraud or fraudulent misrepresentation. Nothing here limits any right you have that cannot lawfully be limited.
Some countries limit how far a supplier may exclude liability, even for something given away. Where local law gives you a right we cannot lawfully exclude, that right wins over the paragraph above and we won't argue otherwise.
No governing law is named here yet, because there is no registered company for one to attach to and naming a country we have no connection to would be worse than naming none. On incorporation, the law of the place of incorporation applies and this section says which it is.
Until then: if something goes wrong, the first step is an email and a conversation, and both sides give it thirty days before doing anything more formal. Nothing in that waives any right either side has to go to its own local courts. It just means neither of us goes there first.
Where a paid package is involved this clause matters more, which is why the cap above is what you paid rather than nil, and why the law gets named the day there is a company to name it for.
The output is yours with no strings, so this list is short and it is about the compiler, not about what you build. Everything not named here is allowed.
don't
Use it, keep everything it produces, ship that to your customers: all fine, and it's the point. What the beta doesn't grant is the right to redistribute, resell, sublicense or host the compiler as a service of your own, or to reverse-engineer it to rebuild one.
don't
The proof step attacks a running application on purpose. Run it against applications you own or are authorised to test, and nothing else. Using it to probe a third party's system is not something we can license you to do, and it ends your access immediately.
don't
The ordinary one: no unlawful use, no infringing content in your brief, and no taking it into a jurisdiction that sanctions or export controls put out of bounds. We'd rather say this in one sentence than in a page of sub-clauses.
Feedback is the price of the beta, so it needs stating properly rather than implying. When you tell us something is broken, you give us a perpetual, worldwide, royalty-free right to act on it: to fix the compiler, and to keep the fix.
That right covers the lesson, not your material. It gives us no claim on your brief, your code or your business, and no right to your name or logo. A fix reaches every user. That is what a shared core is for, and it is why paid packages are priced the way they are rather than as bespoke work.
Ending the beta ends the obligations that are about doing the work. Four things outlive it because they'd be meaningless otherwise: confidentiality both directions, who owns what, the liability position, and your licence to keep and use everything you have already built.
Housekeeping, in one breath: if a clause here turns out to be unenforceable the rest still stands; this page plus the privacy page are the whole agreement and replace anything said in a call; neither side may hand its side of it to someone else without the other agreeing, except that we may transfer ours to the company on incorporation; not enforcing something once doesn't waive it; and nothing here makes us partners, agents or anyone's employer. Notices go by email, both ways.
Either side can stop at any time, for any reason, with no notice period. What matters is what you're left holding, and the answer doesn't change.
Everything you have already compiled stays yours and keeps working. It runs on your infrastructure, there is no Oceantic runtime in your production, and the application makes no call back to us, so there is no licence server to expire and nothing for us to switch off.
Export is not a paid feature and never will be. If we disappeared tomorrow you would still have a working application and the means to rebuild it.
We'll update this page as the beta becomes a product, and the date at the top changes with it. If a change is material, whether it touches ownership, confidentiality or cost, we email the people in the beta rather than quietly editing the page and hoping.
Questions about any of this go to hello@oceantic.dev and reach a founder. See also what we store.