mimeric powers advanced AI applications at scale. Mimerworks builds it, and the method behind it.

mimeric is for building advanced AI applications at scale. It is AI-native and built entirely with AI, on firm principles of scalability, flexibility, security and accessibility.

We also advise companies on product, technology and AI product development.

mimeric: the method

The mimeric method is how mimeric and mimeric-based applications are built. AI operates and builds the platform, and the request path is plain code.

A fleet of AI agents works in parallel across several machines. Conductors plan the work and hand it out, and workers carry it out against written specs and report back.

One rule outranks every other: always do what is right in the long term, and never take the shortcut that only saves effort.

The platform is audited continuously, and every finding goes back into the queue as work.

Each change carries the record of why it was made. The roadmap lives as issues on federated boards.

mimeric: the platform

mimeric is a platform for building rich experiences and applications with AI, at scale. It provides what they all need underneath: real-time data flows, multi-tenant and multi-dimensional configuration with inheritance, content management and dynamic layout, a design system, delivery, and data and access control.

Each new application builds on top of it, and mimeric is fully domain-agnostic. A sportsbook experience is the first product built on it, and applications in other domains are in the works.

What it does

Configuration.

Configuration in mimeric runs along many dimensions at once. Brand, jurisdiction, language, currency and sales channel are each a dimension of their own, with their own hierarchy and inheritance. A setting is made once, at the level where it belongs, and everything below inherits it.

What a user sees is resolved across all the dimensions when the experience is requested, whether it runs in a browser, in a native app or inside a partner's product. One brand, licensed in a US state, shown in Spanish, on a phone, is the answer to a query. Nothing is hard-coded for that combination, and the next combination needs no new code.

Some more examples of what this allows:

  • A rule set for a jurisdiction applies to every brand licensed there, and it outranks the brand's own settings.
  • An existing brand goes into a new country by adding that country's jurisdiction. Its look and content come with it.
  • Prices follow the market's currency, whatever the language.
  • A campaign can go out on every brand at once, or on one brand in one country.

Nothing about the structure is hard-coded. The dimensions themselves are defined in configuration, along with how their hierarchies are shaped and what each level is called. Settings that must not drift can be locked, so changing them takes a review.

Content and layout.

mimeric includes a content management system and a dynamic layout engine. Every screen is built from slots, and each slot holds a module and its content. Which module goes where, and what it says, is configuration like everything else. Layout and content are dimensions of their own, so one layout can carry different content per brand, market or language.

Editors work in a dedicated authoring tool that shows where every value is inherited from. The same authoring is open through an API and to AI agents, so people and agents manage content side by side. Modules are defined by a channel-neutral contract, so a layout is defined once and renders on every channel.

Design system.

The look of every client experience is fully provided by design tokens: colour, typography, spacing and theme. Tokens are configuration, so they follow the same dimensions and inheritance as everything else. A brand sets its palette once, and every screen below it picks it up.

Dark mode, high contrast, compact density and reduced motion are dimensions of their own, and high contrast wins over the brand's colours wherever a user turns it on. Right-to-left languages are handled in the same structure. A design change reaches open screens live, with no rebuild and no redeploy. Automated checks keep styling out of the components themselves.

Runtime.

A screen loads in one step and then stays current. The first request returns the look, the layout, the content and the live subscriptions together, in a single response the edge can cache. From then on, changes arrive as they happen. If the connection drops, the screen picks up where it left off.

Delivery.

A mimeric experience can run inside a partner's website or app, on the partner's own login, so the user never creates a second account. The sites allowed to embed it are set in configuration and inherited down the hierarchy, and a lower level can only narrow that list. The server stays in charge of what an embedded screen may do.

Data and access.

Nothing is visible until access is granted, at every level of the hierarchy. Content is open to anonymous visitors only when every level above it allows it. Every action is written to an audit trail that is never rewritten, and personal data in it can still be erased on request. Storage sits behind a provider interface, and the database schema moves forward through versioned, checked migrations.

How it is built to perform

The whole backend is written in Rust. Memory use stays predictable and there are no garbage-collection pauses, which matters when live data changes constantly and every screen has to keep up.

Live updates.
Each screen holds one connection that carries all of its live data, pushed in real time. Only what changed is sent, and a screen that falls behind catches up without slowing anyone else.
Configuration as events.
Every configuration change is stored as an event in an append-only log, so the full history is kept and a known-good state can be restored.
Separate workers.
Ingest and processing run as separate workers that hand data on over a durable message stream, so each part scales out across nodes on its own.
Changes while running.
Modules plug in, swap and roll back while the platform runs. A health check guards each switch, and work in flight is drained on a timer.
Caching at the edge.
Responses are cached by class. A configuration change clears the cache only for the branch it touches, then warms the busiest content again.
Portable.

mimeric ships as a container and is host-agnostic: any cloud, any Postgres database, and a content delivery network behind a provider interface.

Observable.
Telemetry is built into the data pipeline, with optional export to standard monitoring tools.

mimeric: the technology

The technologies and concepts mimeric is built on, for readers who want the detail.

Languages and runtimes.
Rust on the Tokio async runtime for the whole backend, with axum and tower for HTTP. TypeScript, React and Next.js on the web. Progressive web app (PWA) delivery, with native shells for iOS, Android and desktop.
Architecture.
Event sourcing for configuration. Hierarchical multi-tenancy. Multi-dimensional configuration as directed acyclic graphs (DAGs), resolved by label matching across dimensions. Slot-based composition with a channel-agnostic module contract and a self-describing component registry. Modules swapped live behind health checks, with timed drain and rollback.
Real-time data.
Server-Sent Events (SSE), one multiplexed stream per client. Snapshots stamped with a stream cursor, and resume from that cursor after a reconnect. Delta-only feed adapters. Bounded fan-out with lag recovery. NATS JetStream as the durable message stream between workers.
Data.
PostgreSQL through sqlx, with TimescaleDB for telemetry time series. Versioned, checksummed migrations. Append-only audit log with erasure of personal data. Storage behind provider interfaces.
Design system.
Design tokens in the Design Tokens Community Group (DTCG) format, resolved through the configuration hierarchy and delivered live. Semantic token names. Right-to-left (RTL) layout and accessibility encoded in the token architecture.
Edge and delivery.
Containers, host-agnostic. Class-based HTTP caching with Cache-Control, entity tags (ETag), stale-while-revalidate and purge tags. Edge fan-out on Cloudflare Workers and Durable Objects, behind a provider interface.
Security.
Deny-by-default authorisation across the hierarchy. OAuth 2.0 token exchange for embedding on a partner's login. JSON Web Tokens (JWT). Argon2 password hashing. Envelope encryption of secrets at rest, with all cryptography through one client.
AI and integration.
A Model Context Protocol (MCP) server, held at parity with the REST API, so AI agents manage the platform through the same operations as people.
Observability and quality.
OpenTelemetry and Prometheus export. Continuous integration that enforces architectural invariants, validates tokens and renders modules in a real browser.

Advisory

We also work with companies directly, on mimeric or on the stack they already run.

  • Product and technology advisory.

    Strategy, platform choices and how the organisation around them is set up.

  • AI product development.

    From the first idea and the business driver behind it, through to a product in use.

  • Hands-on build.

    We write the software ourselves, on mimeric or off it.

Contact

Write to us at hello@mimerworks.com.

mimerworks

Mimerworks AB, Stockholm