The first agent you build. It builds everything after — and owns it.
Name it, give it hands and rules, and it starts building. Wildmind is everything underneath: the servers, the secrets, the models, the design system, the versions, the record and the proof — so one person with an idea can run software the way a company with a department does.
Soon nobody builds a website. They build an agent, and the agent builds the website.
That inversion is already underway. What follows it is discussed far less: once agents do the building, thousands of changes happen that nobody witnessed. Ability stops being scarce. The account of what was built, by whom, with which model, and why becomes the scarce thing.
An agent that acts and forgets is a demo. An agent that owns — that holds the servers, the keys, the design system, the history, and answers for all of it afterwards — is a company. Wildmind is the infrastructure that makes the second one possible.
Models are hands, and hands get replaced. The agent, its context and its record are what remain when they do.
Eight levels, each one addressable.
Everything in Wildmind nests. Analytics, notes, versions, design tokens, model rules and permissions all exist at every level and inherit downward — so a decision can be made once for an entire workspace, or exactly once for a single button.
One owner, their people and their agents. Members are humans or agents; each carries a role and what it may see.
Sezay Karagyoz · 3 members · 1 agentNamed, coloured, given a capability ladder and a budget. It owns the softwares below it and carries their context.
Wildmind · green · build auto · deploy asks · read customers neverIts own servers, secrets, costs, uptime, releases and dossier. Provisioned here or connected from where it already lives.
Planbrand · Feedbank · Karagözlük · Wildmind itselfEach has its own UI, database view, analytics and notes — and its own inherited slice of the design system.
website · customer dashboard · admin backstage · customer sitesThe unit real work happens in. The panel narrows to it: its analytics, its notes, its rules — while still knowing everything above.
page builder · CRM · journeys · invoicingComposed from components. Carries its own version history and can pin its own model rule.
pricing · onboarding · a customer's own site pageWildmind knows which exist, which are live, which have not been used in sixty days — and which are duplicated somewhere else in the workspace.
41 live · 6 unused · 3 with open notesA note lands here. So does a version. So does a rule saying which model may touch it.
a headline · a price · a submit buttonFront end, back end, servers and money — at the same time.
Most tools see one layer. An agent that owns the software sees the interface, the schema, the server, the costs, the analytics and the entire history of decisions — simultaneously. That is what makes a sentence like this executable:
“Read the last release notes, take the three features customers actually used, and compose a page from the components I marked as favourites — then show it to me before it goes live.”
Design from one side, information from another, permission from a third. No integration to arrange, because all three already belong to the same record.
From an element to a template, without leaving the product.
Design is not a separate stage that happens in another tool and arrives as a picture. It happens on the running product, in layers, and every step is versioned.
Click any element on the live screen. Choose the layer: content, style, logic or data. The dot stays pinned to that element.
The change goes live as a preview and becomes version two of that element. Three versions are kept; the original never disappears.
The same intent is queued as a code change. The repo stays the single truth; the preview retires itself when the deploy lands.
Publishing carries whichever version each element had selected at that moment — element by element, not all-or-nothing.
Elements become components, components become pages, pages become templates that take data and produce many.
Applying a style to one button of forty asks the question openly: this one, or all of them? Change the class and every instance follows; choose “only here” and it becomes a named variant.
Colour, radius, type and spacing live at the software level and flow down. A property may override within what the parent permits — and push to global sends the change back up, or reset drops it.
Because the registry knows the real components, an instruction can say “use the selected elements” and get the actual code — not a lookalike rebuilt from a screenshot.
One structure, many outputs: the same page shape for two clients, with different content and a different argument, produced from data rather than regenerated each time.
Many models. One agent deciding which one, where, and under what conditions.
Code to one model, a market read to another, layout to a third. Providers are connected once at the top and the agent uses them as hands — while rules decide which hand touches what.
Jobs run on Wildmind's metered key and draw from the £10 grant, itemised penny by penny. Nothing to install.
A Claude Code subscription is personal use, so those jobs run on the owner's own machine through a small outbound-only runner — never on our servers. They cost nothing from the grant and never queue behind anyone.
Runs server-side, bills to its owner, works around the clock and takes scheduled and bulk work.
Workspace: code always goes to the strongest coding model. Software: override it. Property: pin design decisions to one model. Page: be more specific still. The narrowest rule wins.
A ban written once — never decide on a light model — cannot be quietly undone three levels deeper. The answer is not just refusal: it names the rule that refused.
Which model, which rule sent it there, which runner executed it, what it cost. Three fields that turn “the AI did it” into an account.
A new model is a row, not a migration. When something better arrives, one rule changes and every future decision follows it.
The part nobody wants to become an expert in.
Where it lives, what it costs, who holds the keys, whether the backup actually restores. Set up properly once, measured continuously, and answerable on demand.
Their hosting account, their card, their console — while Wildmind does the setup, hardening, TLS, backups and monitoring through a scoped token that can be revoked in one click. Nothing to negotiate on the way out, because nothing was ever held.
Full database dump, files, the recipe that built it. A zip file at the end is not an exit — it is a ransom note with better manners, so ownership starts on day one instead.
Storing in Germany does not block UK signups — the EU and UK recognise each other, renewed to 2031. Settings states the rule and recommends the setup, instead of repeating a myth that costs a second server.
Variables inherit workspace → software → environment. Secrets are written once and never displayed again, injected at runtime only, read by scope, and every read is logged. Unclassified defaults to secret.
Nightly, with the restore actually exercised and the age of the last verified copy on screen. A backup nobody has restored is a rumour.
Webhooks and the servers themselves report each release. Shipping works when Wildmind is down — a control plane that becomes a single point of failure has failed already.
Every sixty seconds from more than one place, raw results kept. Charts unlock after ninety days of real measurement, because a number without a method is not proof.
Production work stops if the last backup is unverified. A token wider than the job needs is flagged. A key found in a repository halts everything and reports it first. When in doubt the agent asks — it does not guess.
Every decision becomes a feed.
A note, an apply, a deploy, a probe, a cost, an access — one stream, each entry carrying its actor, its model, the rule that routed it and the runner that ran it.
Stack, servers, domains, deploy lineage and the traps that cost time once already. Loaded before every job, so no session starts cold and no knowledge dies with a window.
Not only what changed, but why, and what was rejected. Six months later that is the difference between a repository and an explanation.
Shipped in the back end — was the front end told? Were the release notes published? Did the customer base hear about it? The record notices the half-finished ones.
The stream can be shipped onward to a system built to make meaning of feeds. Wildmind produces the record; interpreting it at scale is a different job, and it belongs to a different product.
Numbers at every level, and the sentence that follows them.
Analytics exist at the workspace, the software, the property and the entity — each one showing its own slice, all of them adding up. What matters is not the chart; it is the action underneath it.
Cost from provider invoices, revenue from payments, side by side. The cheapest software is often the one carrying the business, and nobody notices until the two numbers sit in the same row.
The people a winning software speaks to, and which of its features they actually use — offered to the others as a move, not a chart.
Two of your softwares converging is not a design flaw; it is duplicated effort. Wildmind names the overlap and offers one button: extract to shared library.
A service that works well in one software becomes a workspace service the others can call. It adapts to wherever it is called from — one implementation, many homes.
What is live, what is unused, what has notes waiting on it. The backstage view that tells you what to retire before it becomes furniture.
The platform holds what it has learned — the residency myth, the unprovable uptime claim, the certificate that cannot be issued by a tool — and flags them the way a form flags a malformed address.
What an invited agent may never see, and what can be proven afterwards.
The owner of a software sees its customers. An agent invited by that owner — an agency, a developer, a friend who builds — never sees them: not in a table, not in an export, not in a download. It is a rule, not a setting, and it cannot be switched off from inside.
The work still runs. When an order lands, email the customer executes with the recipient masked end to end. Capability without visibility.
Every read recorded, reported monthly. That report is the document that answers “did they see our customers?” with a number instead of a promise.
Schemas, counts, events and costs cross the boundary; people never do. The claim survives an audit because it is an architecture rather than an assurance.
Proof, labelled honestly.
Four tiers with locked wording. An account chooses which to show — never what they say. A data centre's certificate is inherited; an uptime record is earned; the difference stays visible.
The output is a dossier an enterprise questionnaire can be answered from: change ledger, verified backups, TLS, data location, subprocessors, a signed agreement. No tool can issue a certificate — but it can make the questions answerable.
Every software has people it has not met yet.
Each software carries its own leads, its own proposals and its own audience — inside the same workspace, attached to the thing they are about rather than scattered across another tool.
A proposal becomes a private page built for one business: what is scattered today, the system that would be built, the work that leaves their desk, and the number. Opens are tracked, so “did they read it?” stops being a guess.
This layer is deliberately second. Proof first, growth after — a claim that cannot be substantiated should not be advertised, and that rule applies to us before anyone else.
Built for its own software before anyone else's.
Planbrand — a SaaS with paying customers — was moved from one cloud to another in two days with an AI in the loop. Running costs fell from four figures a month to two. And the team still could not answer an investor's security questionnaire afterwards.
That gap is the product. Planbrand, Feedbank and Wildmind itself are the first records in the system; a vehicle-service ERP built for a customer is the first workspace where the blindness rule is enforced against its own builder.
Every mistake the platform prevents for one account ships as a rule protecting all of them. The day an account opens is the weakest the product will ever be — which is the only honest reason to pay monthly for anything.
One agent, one software, free. £10 of value with it.
The grant is engineered to last — often months, because the expensive part is optional. Thresholds are published before they bite, and the second software is where a plan begins.
The meter
Runtime, probes and AI jobs itemised daily and attributed to the hand that did them. A projection says how long the grant lasts at the current pace; it warns at half and at ninety per cent.
When it runs out
The record never pauses. Probes keep measuring, the ledger keeps writing, the software keeps running. Only Wildmind-paid AI rests — until a key is connected, credit is added, or a plan starts.
The guide
Advice arrives with the grant: connect a key so jobs cost nothing here, batch the analysis, fill the dossier once so every job afterwards runs cheaper. Nobody should burn ten pounds learning that.
Opens 4 September 2026.
First places go where there is something real to account for — software already in use, or a business that needs one built and kept.