Your stack, without the toxic stuff.

Traditional security assumes breaches can be prevented. Tide assumes they are inevitable, and redesigns the system so that compromise is inconsequential. No user, vendor, admin, or developer ever directly possesses the authority behind your security. It emerges through the Fabric only when needed, in context, under policy, then vanishes.

How Tide Works

An interactive walkthrough of how Tide reshapes a conventional stack: your architecture keeps its shape, TideCloak fits where your identity layer already sits, and the Cybersecurity Fabric removes complete authority from every server, admin and vendor.

The walkthrough

  1. Before Tide, you were the prize

    Breaches are inevitable, and in a conventional stack you hold the authority to authenticate, authorize and decrypt in your own environment. That same power is what attackers exploit when they find a way in. But what if that power was kept out of everyone's reach?

  2. TideCloak fits where IAM sits

    Swap in TideCloak as the identity layer. Your app still uses standard OIDC and OAuth 2.0 flows, but any sensitive powers and data are now locked with keys no one ever holds, in Tide’s Cybersecurity Fabric. Here they exist only as key fragments across independent nodes, so nobody holds the keys to your kingdom.

  3. Same UX, without the secrets

    Familiar password or passwordless authentication, without ever exposing a credential, or you having to hold one. The client SDK handles a zero-knowledge authentication against the Fabric sending proof to your app via a secure channel fingerprinted to their browser session.

  4. Permissions locked to user's device

    TideCloak packages up an authz token based on that user's permissions and the Fabric enforces it, if policy checks out. The token is encrypted to the user's browser session, so that it's only usable on the device the user just authenticated, not anywhere else.

  5. No change to data flow

    The user asks to read data. Your server checks they have permission, then returns a locked record that even it can't open. Sensitive data remains encrypted at rest, in motion and only accessible on the authenticated device, so a backend, MitM, or database breach yields ciphertext.

  6. Readable data appears only at the edge

    In real time, the browser asks the Fabric to open the record. Nodes return partial results from their fragments, and the browser combines the response locally, so plaintext appears only on the approved device. All with no change to the user experience.

  7. AI Agents act with borrowed, scoped authority

    An AI agent can act for the user without becoming a new trust sink. It receives live authority scoped by policy, checks each action against the Fabric and leaves an immutable, auditable trail. It can do the job, but only ever within your comfort zone.

The actors in the architecture

Your user
Same sign-in experience, but now the user owns their identity. Their act of authenticating brings their own authority — enabling your platform to access their data.
Their browser
Runs the TideCloak client SDK: it binds the session to this device, talks to TideCloak and the Fabric directly, and keeps usable results at the edge — so proofs and plaintext never pass through your backend.
Your database
Your data still stays in your database, but sensitive records are encrypted with keys that only exist in the Fabric. An exposed database leaks nothing of value.
App server
Your backend keeps serving your product, without handling any decryption keys or root authority attackers hunt for. It becomes Authority Emergent.
TideCloak
Drop-in, Keycloak-compatible IAM. It looks familiar to your stack, but no credential, token-signing key or access authority exists inside it. User and authorization authority emerges from the Fabric.
AI agent
An agent can act for the user without inheriting permanent power. Each action is scoped by policy, checked with the Fabric and recorded, so the agent has no reusable secret to leak.
Cybersecurity Fabric
Independent nodes hold fragments of authority and compute together only when a valid request arrives. No node, operator, admin or Tide holds a whole key, and one compromise cannot create usable authority.

Focus on features, not breaches

Built for Developers

Your security no longer depends on the quality of your code. Tide removes security and trust dependencies from your code entirely, so the immunity is structural, not implementational. It holds no matter how you build and flows through to every end user without you having to earn it line by line, freeing you to build fast, ship with AI tools, and iterate at speed. It reaches you through TideCloak, a drop-in Keycloak-compatible IAM layer.

Drop-in integration

Standard OIDC and OAuth 2.0. Upgrade your stack without re-architecting it.

Nothing to leak

Your app never holds root keys, so there's no secret left to steal.

Build fearlessly

Hand-written or AI-generated, your security holds regardless of code quality.

Cyber-insurance passthrough

Qualify for passthrough cover from a top global insurer, for you and your users.

Build your first cyber-immune app in minutes

Start from the Quickstart, or hand the AI Agent Pack to Cursor, Claude Code, or VS Code and let it wire up auth, encryption, and deployment for you.

Trusted by organizations from high-growth startups through to Fortune 500 companies. Tide's technology has been peer-reviewed and lab-tested by tier-one universities and global experts, recognized by industry awards, and cited by global policy bodies including the OECD and government agencies in the UK and Australia.

RMIT UniversityDeakin UniversityNTT ResearchOECDUniversity of Wollongong

Beyond Access Control

How it works

When it is clear you can no longer patch your way to security, the only move left is to remove what attackers are targeting once they are in. Tide lifts the power to perform sensitive actions out of your environment entirely, into a place where it can only ever work as intended and nobody holds the keys, eliminating the target itself.

Tide's Cybersecurity Fabric is a decentralized network of independently operated nodes that dissolves authority across four independent surfaces: storage, use, governance, and policy logic. No single entity, not any node, not any administrator, not Tide itself, ever possesses enough information to validate a credential, sign a token, forge an identity, or unilaterally change the rules. So, when your users or server need authentication, approvals, decryption, or authorization, authority emerges for the operation, then ceases to exist, so it can't be attacked. The integrity of that security is now verifiable end to end, for you and for your users.

Want the full picture? The whitepaper below breaks down the cryptography, the consensus, and the threat model in depth.

What Makes Tide Tech Different

Not just key splitting

MPC and threshold systems distribute keys but typically retain centralized control over governance, policy, and administration. Tide dissolves authority across all four. The attack surface does not migrate from the key to its control plane.

No single point of bypass

Passkeys and federated identity still depend on the vendor or server not to bypass the authentication guarantee. Tide removes that dependency entirely. The Fabric enforces security at the cryptographic layer, not the policy layer.

Truly decentralized nodes

Each key is distributed across a swarm of 20 Fabric nodes, each operated by a different organization. This is not 3-of-5 threshold sharing across a single vendor's infrastructure. An attacker would need to simultaneously compromise 14 distinct organizations within the window of a single transient ceremony.

End-to-end verifiability

An authentication layer threads security and verifiability from the user to the server and back. The system does not just verify the user. The infrastructure continuously proves its own integrity to the user through verifiable proofs.

No HSM dependency

Tide's security does not rely on the secrecy of hardware. HSMs are a singular operational authority. Whoever controls the application layer authorized to invoke one effectively possesses the signing authority. Tide eliminates this class of vulnerability.

Familiar UX, superior security

Users experience authentication exactly as they do today, whether with passwords, security keys, or biometrics. Nothing changes on the surface. Underneath, no credential, hash, or verifiable artifact is stored anywhere, by anyone. Offline attacks have no material to attack. The experience stays the same. The security model underneath is fundamentally different.

The Fabric in Action

Use Cases

Identity Management

The centre of your Zero Trust Architecture no longer has to be blindly trusted. TideCloak is a drop-in, Keycloak-compatible IAM layer where no credential, token, or signing key ever exists in complete form.

TideCloak Docs

Infrastructure Management

Your gateway becomes an oblivious proxy instead of a central point of collapse. KeyleSSH replaces static SSH keys with ephemeral, Fabric-backed authentication that no single party can forge or extract.

KeyleSSH on GitHub

Password Management

Put all your secrets in one basket you never have to blindly trust. TideWarden is a password manager where the vault key is dissolved across the Fabric — no master secret for anyone to steal.

TideWarden on GitHub

Multi-Chain Wallet

A multi-chain wallet spanning 16 blockchains where no single party ever holds a complete signing key. Motherlode uses TideCloak and the Fabric to secure authentication and transaction signing.

Motherlode on GitHub

Treasury Management

Treasury management you can trust, because you never have to. SWARM distributes signing authority across the Fabric so no single custodian, device, or insider can move funds unilaterally.

SWARM on GitHub

FAQs

Not at all. Tide's architecture removes the need to trust any single entity, including Tide. Security is enforced by decentralized cryptographic guarantees across independently operated Fabric nodes. No single party has full control or access to your keys or data. The protocol enforces this at the cryptographic layer, not the policy layer - all in a fully verifiable manner.

Some of the underlying cryptographic primitives have existed for decades, but were computationally impractical and existed in isolation. Three things changed: network connectivity became a standard requirement for business operations, computing power made threshold cryptography viable at scale, and Tide developed new cryptographic constructions and consolidated them with existing primitives into a unified scheme (Ineffable Cryptography) that reduced round-trips from minutes to microseconds. Tide's contribution is not just consolidation; it includes novel protocols like PRISM and the Double-Blind Threshold Signature Scheme that did not exist before.

Traditional key management systems still have a master key somewhere that someone has full authority over, whether in an HSM, in memory during operations, or in a secure enclave. That is a singular point of failure, and a proven attack vector. Tide's keys never exist in whole form, not even for a microsecond. More importantly, Tide dissolves authority over the key as well: no single administrator can direct its use, no single policy engine decides when it acts, and no single governance model determines who can change its behaviour.

The Cybersecurity Fabric is decentralized across independent organizations globally, each operating independently of any single organization. For it to go down, you would need simultaneous failures of over 30% of the nodes you use. Unlike most SaaS providers that rely on a single infrastructure provider, Tide's decentralized architecture provides a substantially higher degree of resilience.

They would need to compromise 14 of 20 independently operated nodes (spread across different organizations, jurisdictions, and infrastructure providers) for the specific user. That's after also breaching the organization. Each additional node adds cost and complexity to the attack. Then consider that each user's key is distrubted among a different combination of nodes on the Fabric - making it economically and practically inviable for a mass breach.

No. You can off-board at any time by activating the Ragnarok Protocol, which reconstructs and exports your complete authority keys to your own infrastructure, followed by cryptographic shredding of the Fabric's shards. No business continuity threat.

No. While both use decentralization, Tide does not require consensus on a global ledger. There is no mining, no energy waste, and no public transaction history. It is a pure cryptographic protocol, not a distributed database.

Tide's architecture is quantum-resistant by design. The Fabric can swap in post-quantum algorithms without changing the architecture. But there is a deeper point: when the rest of the industry goes through the painful process of migrating to post-quantum cryptography, they end up back where they started, with a fundamentally broken security paradigm where private keys still exist as extractable objects. Tide does not just swap the algorithm, it advances security and privacy by ensuring that keys cannot be misused, because they never exist in complete form to begin with.

Yes. Tide exceeds most compliance requirements because sensitive authority material never exists in cleartext on your infrastructure. You maintain data sovereignty while achieving higher security than traditional HSM-based approaches. Audit logs are cryptographically verifiable without exposing the underlying secrets.

Still have questions? Read the whitepaper, Access the SDK, or talk to us.