Software that does not
depend on one person.

We build two things: software the next person can still understand, and data systems that pull the few pieces of information you must act on out of far too many.

Request a first conversation See a system we built

The handoff chain

Pick a stage — each one leaves a document behind

intent.md

What is wanted, in one sentence — and what is explicitly not part of it.

HandoverThe next person reads why this project exists before touching a line of it.

spec.md

The behaviour, written so it can be checked. Not an intention that is only complete in the author's head.

HandoverWhat the system should do is on the page. Nobody has to be asked.

plan.md · diff + tests

The cut, the change and the tests that hold it — together, not one after the other.

HandoverEvery change carries the reasoning it came from.

evals/

The acceptance tests. Frozen before the build, so the result cannot set its own bar.

Handover“Does it still work?” is a command, not an opinion.

PR + findings

What changed, and what turned up on the way. Including the part nobody wanted to hear.

HandoverWho approved it is recorded underneath — afterwards, not only before.

incident record

What happened, what caused it, and which rule exists because of it now.

HandoverOperations writes back into the specification instead of running beside it.

Six stages, six documents. Whoever takes over reads them in order — not the inside of a developer's head.

What we do

Two branches. The same discipline.

In both cases we replace a dependency on a few expensive specialists with a system somebody else can take over. What is produced belongs to the client and can be read back.

  1. Software development

    Instead of hiring a developer

    Greenfield and legacy. What is produced is specified, tested and handover-ready — not a prototype that falls apart at the first change, and not code that only one person in the building understands.

    • Every change carries its evidence: specification, acceptance test, ledger entry.
    • The architecture is drawn from the source tree, not from memory.
    • Nobody has to hold “the code in their head” for work to continue.
    How this runs

  2. Business intelligence

    Instead of looking for analysts

    Data acquired, consolidated, assessed. Out of scattered sources a dependable model — and from it the few cases somebody actually has to act on.

    • Sources are checked for admissibility before they are connected.
    • Assessment is computed, not estimated — traceable back to the source.
    • Below the threshold the system asks rather than acts.
    A system we built

Once both stand, we automate the processes in between. That is the third step — not the first.

Reference

The client no longer searches listings. Properties are put in front of him.

An Austrian property investor. Several platforms are watched continuously; whatever matches his criteria reaches him — the rest he never sees.

The client is not named, not even on request. Why that is.

A wide Viennese boulevard at night after rain: a tram in motion, street lamps and lit façades in ordered sequence, rails and wet cobbles in the foreground.
17 architecture decisions documented, from ingestion to retention
1 : N asset-to-listing model — the same property across platforms
0 messages sent automatically — every first approach is approved

  1. Listing sources

    Several platforms, observed continuously.

  2. Duplicate matching

    The same asset, listed repeatedly — carried once.

  3. Asset

    language model

    Extracts the attributes from the listing text. Input, not verdict.

  4. Assessment

    deterministic

    Computed, not estimated: assessed against the investment criteria, traceable to the source.

  5. Sign-off

    human

    Only then does a message leave the system. No path bypasses it.

Products

One factory. Two sizes.

Agents write the code. Code decides every gate. You approve. BENCH brings that order into your existing setup; SOFA carries the whole way from ticket to merged commit.

  1. BENCH

    The precursor

    Blueprint Engine for Normalized Context & Handoffs. BENCH writes down what an agent must know before it starts — and hands it over in a form that can be checked.

    • Every task begins with a briefing someone has approved.
    • The handoff between two agents is a file, not a conversation.
    • Runs inside the agent tool you already use.
    See BENCH

  2. SOFA

    The software factory

    From ticket to merged commit. Agents draft, research and write; the code keeps the ledger and refuses any step the recorded facts do not support.

    • No agent moves a gate. A gate is closed by code or by a person.
    • The author never verifies. Acceptance tests are frozen.
    • Every verdict lands in an append-only ledger.
    Atlas, the architecture map of SOFA: four layers from Hosts through CLI and Referee to Core, with labelled arrows between the packages and a detail column on the right.
    Atlas draws the architecture from the source tree — the same revision yields the same bytes.
    See SOFA

Capabilities

Too much information becomes a decision.

Four capabilities, always in the same order: acquire, consolidate, assess, act. The result is decision-making capability in complex information spaces.

Not maximally automated. Correctly automated. We decide together how far the machine goes alone — the final approval stays with you.

Vienna at night after rain: a tram at the kerb, a church dome behind it, street lamps and wet asphalt in ordered sequence.

Acquisition

Websites, marketplaces, APIs, registers, documents, internal systems — where the information arises.

Intelligence

Scattered raw data into one asset: normalised, de-duplicated, enriched.

Decision

Assessment against your criteria: computed deterministically, not guessed by a model.

Execution

Into the CRM, the database, over an API — and action at the agreed degree of autonomy.

The method

Eight stages between question and action.

Every system is a one-off. The method is not.

We observe markets, structure information, and build systems that turn it into decisions and actions.

Choose a stage — the diagram follows the selection

  1. Websites, marketplaces, APIs, registers, documents, internal systems. Many units arrive, unordered and unassessed.

  2. Normalise, merge, detect duplicates: several listings become one asset. Duplicates merge in pairs — 24 units become 14 assets.

  3. Fetch missing attributes, enrich from second sources, add history. Each asset gains the attributes an assessment needs.

  4. Language models read unstructured text — as input, never as verdict. Assets fall into classes: like is grouped with like.

  5. Assessed against your criteria, deterministic and traceable to the source. Every asset gets a value. The yardstick is your criteria.

  6. Into the CRM, the database, over an API — where the work happens. Whatever clears the threshold leaves the system downward.

  7. When a result passes the agreed threshold, the system acts. The action is bound to a configured sign-off.

  8. Downstream processes keep running — at the agreed degree of autonomy, not the maximum. The result feeds back into acquisition. The loop closes.

Criteria
238,491238,491238,491 observed
8,4131,842486 relevant
3247621 checked
62174 presented

SCHEMATIC — your criteria determine the yield

Schematic view of the selected stage.

Request a first conversation

Resources

Public, free, without a sign-up.

Three reference works we built for our own work. They show how we think better than any reference could.

Confidentiality

The reference above is anonymous. That is not an omission.

Whoever engages us shows us criteria, thresholds, market — that is the strategy.

Lit stone architecture at night, close up: a bronze lion on a candelabrum in front of heavy columns, with a lamplit row of buildings behind.
No name, no logo, no case study without sign-off.
Not in a pitch to somebody else either. Sector and task, nothing more.
The NDA comes first, not last.
Before the first substantive conversation. If not from you, then from us.
Your data trains no models.
Where language models process, they run through interfaces that contractually exclude any further use.
Location, access and retention are decided, not assumed.
Settled and documented during Discovery — in the reference system one of the 17 architecture decisions.
Before a source is connected, there is a documented admissibility check.
GDPR, database protection law, terms of use. What we cannot obtain lawfully, we do not obtain.
A Viennese side-street terrace at night after rain: an empty bench and table against the wall, a potted olive tree beside them, the wet lane behind with parked cars and lamplight on the cobbles.

Contact

Bring us the question.

In discovery we establish whether it can become a system that holds. If it cannot, we say so.

Three phases. The first is paid and ends in a decision.

Discovery

Paid analysis phase: objective, information gaps, sources assessed technically and legally. The output is a defensible estimate — or the advice not to build it.

Build

We build the system and integrate it into your infrastructure. Fixed price based on the Discovery.

Operations

Sources and criteria change. A monthly operations agreement keeps the machine running.

No question yet? BENCH is the smaller way in.

Enquiry

Straight to us, no form service, nothing passed on. More under Confidentiality.