Portfolio

The work behind the products.

These are our own builds, not client logos. Each one describes a problem that was genuinely hard, the decision we made, and what it changed. It is the most honest way to show how we work.

012026Security architectureDatalic →

A cloud service that cannot open your database

The challenge

To answer a question about a company's data, something has to see that data. Every AI data tool solves this by taking the customer's database credentials into its cloud. For finance and regulated teams, that single fact ends the conversation.

What we did

We split the product along that line. The cloud brain reads the question, picks the model and writes the native query — and is built with no database driver and no credential-handling code in it at all. The SDK runs inside the customer's network, holds credentials in memory only, connects to the database directly, and calls the brain one stateless step at a time.

What changed

The security claim stops being a promise about our behaviour and becomes a property of the architecture. A fully compromised cloud brain still cannot open a customer database, because it contains nothing that could.

No driver in the cloud tier
Credentials in memory only
Stateless step-by-step protocol

022026AI systemsDatalic →

Answers that check themselves — or abstain

The challenge

A model querying a database is exactly as confident when it is wrong as when it is right. A plausible wrong number in a board pack is worse than no number.

What we did

Results are verified against the source before they are shown, and every figure carries the query and the rows behind it. The same execution path — access guards, query, verification — is used by the chat product, the SDK and the MCP server, so no entry point is a weaker door.

What changed

The product is able to say it cannot answer. That single capability is what makes it safe to point at a live production database.

One governed execution path
Lineage on every figure
Fail-closed by default

032026Semantic layerDatalic →

Teaching a schema what the business means

The challenge

Ask about "monthly recurring revenue" and a model has to guess which table and which sum you meant. In a large schema it guesses wrong often, and it guesses differently each time.

What we did

We built a deterministic semantic layer — metrics, bidirectional synonyms and real column statistics — in plain Python with no embeddings and no model calls inside it. Metrics are declarative data, scoped per connection, and every resolution records which rule matched.

What changed

The agent references a defined metric instead of inventing one, the same question resolves the same way twice, and a wrong answer can be traced to a rule someone can fix.

No embeddings, no LLM
Explainable resolution
Per-connection isolation

042026InteroperabilityDatalic →

One MCP server instead of ten

The challenge

Giving a coding agent access to a company's databases meant installing a separate MCP server per database, each with its own tools, its own auth and its own idea of what an agent may do.

What we did

One server that discovers every installed connector and exposes a single consistent tool set across all of them, running on the same governed runtime as the chat product — so access guards and answer verification are inherited rather than reimplemented.

What changed

An agent gets twenty databases through one server, and an administrator sets the policy in one place instead of ten.

Auto-discovered connectors
Shared governed runtime
Install only what you use

052026ArchitectureDatalic →

One codebase, three deployment shapes

The challenge

The same product had to run fully local on a laptop, self-hosted inside a customer's Docker, and multi-tenant in our own cloud — without becoming three codebases that drift apart.

What we did

Storage became a runtime decision instead of a build-time fork: DuckDB and the filesystem locally, PostgreSQL and S3-compatible storage in the cloud, with schema-per-organisation routing and lazy bootstrap. The desktop app holds both engine URLs at once and routes each request by the active workspace.

What changed

A customer can start on a laptop and move into their own infrastructure with no migration and no different edition of the product.

Runtime storage selection
Schema-per-organisation routing
Local and cloud side by side

062026Developer toolingLopy →

A delivery engine that makes no model calls

The challenge

Coordinating several coding agents needs a controller. If that controller is itself an LLM, you have added a second bill, a second source of non-determinism, and a component that can be wrong about whether work finished.

What we did

The engine is deterministic by rule: it builds command lines, parses output, runs gates and stores artifacts, and makes zero model calls. Each session owns a git worktree for its life, the store holds only metadata and git references, and marking a task done requires the merge to have actually landed.

What changed

A whole board of tasks runs in parallel without collisions, and "done" means something a person can verify rather than something an agent asserted.

Zero LLM calls
Session-owned worktrees
Done means merged

072026Decentralised systemsProject Nobi →

Making the memory belong to the person, not the company

The challenge

A companion is only useful if it remembers your life. That means the most personal record a person owns ends up sitting on a company's servers, under a policy that can change next quarter.

What we did

The memory is encrypted at rest, with end-to-end encryption inside a trusted execution environment, and the whole thing runs on Bittensor rather than on servers we control. Full GDPR rights are built in — see it, export it, delete it — and the code is open source.

What changed

"Belongs to you, not to a corporation" stops being a policy statement. There is no single company in the middle that could change its mind.

Decentralised on Bittensor
Encrypted at rest and in use
Export or delete, any time

082026Product designAika →

An AI tutor that admits when AI is wrong

The challenge

Teaching children about AI with an AI creates an obvious conflict. The easy product is one that always sounds confident, because confidence feels like competence to a child.

What we did

We made honesty a hard rule rather than a tone: content is age-appropriate and truthful, and it deliberately includes the cases where AI gets things wrong. Parents keep full visibility into every conversation, while the child keeps ownership of their own progress.

What changed

A child finishes a module able to question the tool they were taught on. That is the whole point of AI literacy, and it is the part a confident tutor would quietly destroy.

Honesty as a hard rule
Full parent visibility
Six languages

092026Agent runtimeJenOS →

Making an autonomous agent auditable

The challenge

An agent with a shell, a filesystem and a browser can do real work — and real damage. The hard part is not the capability, it is being able to say afterwards what ran, what it cost, and whether anyone checked the result.

What we did

Cost is an append-only ledger enforced by a database trigger, so no code path and no future migration can rewrite it. The verified badge is written only by the checking pass, and a task that was never checked says so explicitly. Produced files are versioned and served through one-use links.

What changed

The cost panel and the invoice are the same number written twice, and an unchecked result can never be mistaken for a checked one.

Append-only ledger
Explicit unchecked state
Versioned artifacts

We would rather show than tell

Bring a problem from your own stack. We will walk through how we would build it, in plain language.

Start a conversation About the company