How Tiles works
Building the future of software personalization with decentralized memory networks.
We’re building open-source technology for local-first models to make personalized software experiences possible without compromising on accessibility or privacy. We believe identity and memory are two sides of the same coin, and Tiles makes that coin yours: your user-agent. Our first product is an on device memory management solution for privacy conscious users, paired with an SDK that enables developers to securely access a user’s memory and customize agent experiences.
We plan to offer the consumer application as a one-time license for each generation, with future generations requiring a new license to access additional features.
Philosophy
Our goal with Tiles is to co-design both fine-tuned models and the underlying infra and dev tooling to maximize efficiency in local and offline systems for inference and training.
The project is defined by four design choices¹ that support and reinforce one another:
Device-anchored identity with keyless ops: Clients must be provisioned through the device key chain and cannot access the registry by identity alone². Keyless operations are enabled only after an identity is verified and linked to the device key, allowing third-party agent access under a user-defined policy³.
Immutable model builds: Every build is version-locked and reproducible, ensuring consistency and reliability across updates and platforms.
Content-hashed model layers: Models are stored and referenced by cryptographic hashes of their layers, guaranteeing integrity and enabling efficient deduplication and sharing.
Verifiable transparency and attestations: Every signing and build event is recorded in an append-only transparency log, producing cryptographic attestations that can be independently verified. This ensures accountability, prevents hidden modifications, and provides an auditable history of model provenance across devices and registries.
Implementation
Our software stack includes a macOS app and a Modelfile⁴ based SDK. The Tiles app functions as a transparent, protocol-based proxy between the user and AI agents, leveraging a fine-tuned model to manage context and memories locally on-device with hyperlinked markdown files. In the next phase of our development, we will focus on our sync system built with Iroh and our identity system based on public key cryptography and verifiable attestations.
Our first-generation prototype is packaged as a single-file executable CLI, and a Modelfile based SDK, lets developers customize local models and agent experiences within Tiles. Our goal is to evolve Modelfile in collaboration with the community and establish it as the standard for model customization.
Through the registry users can download open weights models fine-tuned for memory. Right now we use a mem-agent, a memory model from Dria based on qwen3-4B-thinking-2507, and we are in process of training our first set of in-house memory models.
These models use a human-readable external memory stored as markdown and learned policies trained via reinforcement learning on synthetically generated data to decide when to call Python functions that retrieve, update, or clarify that memory so the agent can maintain and refine persistent knowledge across sessions.
We are actively adding support for memory extensions with LoRA adapters, allowing users and organizations to bring their own data and augment the base memory models with the personality they want their memory to reflect.
On the inference side, we use LM Studio’s mlx-engine as our backend on the Mac platform., and will add support for server-side LLMs through Mozilla’s any-llm as the second inference backend.
This backend will ship after we set up our AT Proto DID based identity system in Q1 2026, since it is currently blocked by the public and private crypto components required for zero-knowledge security. The system keeps the unencrypted private key and chat logs on the client side, inspired by Mozilla’s architecture for their managed platform described here.
On the SDK front, we are collaborating with the Darkshapes team to support the MIR (Machine Intelligence Resource) model naming scheme for our Modelfile implementation. Learn more about our proposal for extending Modelfile spec here. We support Hugging Face today and plan to build our own decentralized registry later, using the open source xet-core implementation for model layering.
As part of our research on private software personalization infrastructure, we are investigating sparse memory finetuning, text diffusion models, Trusted Execution Environments (TEEs), and Per-Layer Embeddings (PLE) with offloading to flash storage.
We are seeking design partners for training workloads that align with our goal of ensuring a verifiable privacy perimeter. If you’re interested, please reach out to us at hello@tiles.run.