Forem: Caspar Bannink

Building an AI email composer because copy-paste rental inquiries have a 12% response rate

Caspar Bannink — Fri, 15 May 2026 14:07:27 +0000

The Dublin rental market has a response rate problem. The average renter sends a generic inquiry to 20+ properties and hears back from maybe 2 or 3. I measured this through user interviews and it tracks with what academic research on UK/Irish rental markets has found: response rates for cold rental inquiries sit somewhere between 12% and 20% depending on the area and season.

This is a signal quality problem wrapped in a UX problem. And it's exactly the kind of thing you can build against.

What the data actually looks like

When a listing goes live on Daft.ie (the dominant Irish rental portal), it typically receives 50-150 inquiries in the first 48 hours. There's no landlord-side inbox tooling beyond email forwarding. No status tags, no filtering, no templates for responses.

The landlord opens it, skims a subset, replies to whoever seems credible and convenient, and moves on. The inquiry that lands in position #78 in their inbox could be from a perfect tenant. They'll never see it.

On the applicant side, the constraint is symmetric. Renters know supply is short and competition is high. Rational strategy is to apply wide. So they send the same message to 20 places. Landlords recognize this pattern and deprioritize anything that sounds like a blast email. The market equilibrium is low signal on both sides.

The technical problem: generic text is detectable

From a signal processing standpoint, a landlord reading 150 emails is doing a classification task. "Does this person seem like they actually want THIS property, or are they spamming everything?" Generic emails fail that classifier.

What passes the classifier:

Mentions something specific from the listing (the garden, the commute distance to a named workplace, the pet policy)
Answers the implicit screening questions (move-in date, lease length preference, employment type)
Has a coherent reason for wanting that specific location

Writing this for each of 20 properties manually is O(n) effort. Most people won't do it. That's the gap to build against.

What we built and how it works

HomeScout has an AI email composer that generates property-specific inquiry drafts. The flow:

User finds a listing they want to apply to
They click "Generate inquiry"
The system reads the listing data (title, description, location, price, landlord-specified requirements if any)
It generates a draft that references specifics from the listing and includes answers to the standard screening questions
User reviews and edits before sending

A few things we got wrong in early versions:

Too formal. First drafts sounded like legal correspondence. Real inquiry emails are conversational. People don't write "I would like to express my interest in the aforementioned property." They write "I'd love to come view this, I work nearby and the commute would be ideal."

Hallucinating specifics. Early versions made up details that weren't in the listing. "I noticed the property has a south-facing garden" when the listing said nothing about the garden's orientation. That's a problem when the landlord reads it. We added a strict constraint: only reference what's explicitly in the listing data.

Missing the implicit screening questions. The questions landlords actually care about (when can you move, how long do you want, are you employed) aren't always in the listing. We built a user profile layer so those answers get included from the renter's saved preferences rather than being generated per-inquiry.

The model choice question

This is one of those tasks where the quality delta between models matters more than the cost delta. The difference between a mediocre and a good inquiry email is meaningful, and the output is user-facing in a context where the stakes are real (someone might get or not get a viewing based on this).

We use GPT-4o for this feature. We tested smaller models. The failure modes were too common: hallucinated specifics, wrong tone, missing context from the listing. 4o is measurably better on this specific task. The cost is acceptable given the feature's value.

We also considered fine-tuning on successful inquiry emails, but our dataset isn't large enough to make that worthwhile yet. It's on the roadmap once we have more throughput.

Prompt engineering notes

The prompt structure that works best for this:

System prompt establishes the persona (renter, not an AI assistant) and the tone (conversational, specific, not corporate)
Listing data is passed as structured context, not raw HTML scrape
User profile answers are included as a short bullet list for the model to draw from
Explicit negative instructions: don't fabricate specifics, don't use formal register, don't mention that this is AI-generated
Output format: plain text, no subject line, 3-4 short paragraphs

The negative instructions matter more than the positive ones. The default model behavior drifts toward formality and generic language. You have to actively constrain it away from those patterns.

What comes next

The honest answer is that email composer is a partial fix. The underlying problem is that landlord inboxes have no structure, so even a good inquiry can get lost. The complete solution involves building tools on the landlord side too: structured applicant pipelines, automated first-response, viewing scheduler. That's a different product scope.

For now, improving inquiry quality is the lever we can pull on the renter side. And it does move the needle. Users who use the composer report better outcomes than users who don't.

I wrote a longer breakdown of the full response rate problem and its market context here: https://homescout.io/guide/why-landlords-never-reply-dublin-rental

Caspar Bannink. Founder of HomeScout.io. Building AI-powered rental search for Dublin.

Architecture of a Rental Aggregator: Scraping and Normalizing 90+ Sources

Caspar Bannink — Thu, 14 May 2026 09:54:51 +0000

Building a rental aggregator for Dublin means pulling data from a fragmented market: one dominant portal, a handful of mid-tier sites, dozens of letting agency websites, property management company portals, and a long tail of small sources. Here's how the system is structured and where the interesting problems are.

Why existing portals aren't enough

The standard answer for finding Dublin rentals is Daft.ie. It has good coverage and solid search. The problem is that coverage isn't complete. Letting agencies list exclusively on their own websites. Some landlords use smaller portals. A non-trivial share of listings never hits Daft at all.

If you're only searching Daft, you're seeing maybe 60-70% of what's available. For a renter in a tight market, that gap matters.

An aggregator's value proposition is simple: search everything, show results in one place. The technical challenge is that "everything" means 90+ sources with no shared API, no standard format, and varying levels of scraping difficulty.

Source taxonomy

I classify sources into tiers based on scraping approach:

Tier 1: Structured APIs or feeds. A small number of sources expose RSS feeds or have semi-public JSON endpoints. These are easy. Pull, parse, done.

Tier 2: Consistent HTML structure. Most mid-tier portals have stable enough HTML that a straightforward scraper works reliably. BeautifulSoup or Playwright depending on whether the content is server-rendered or JS-generated.

Tier 3: Letting agency sites. These are the hardest. Each one is different. Some run on estate agent CMSes (Property Hive, Agentbox, PropertyBase), which gives you a consistent structure within a platform family. Others are custom-built or use generic CMS platforms with property listings bolted on. I maintain source-specific extractors for each one.

Tier 4: Social and informal. Facebook Marketplace, some WhatsApp community channels that get scraped via publicly accessible links. Lower data quality, higher volume of noise.

The scraping layer

Each source has a scraper that handles:

Discovery: Finding listing URLs. Pagination, sitemap traversal, or feed parsing depending on source type.
Extraction: Pulling raw data from a listing page. Structured fields where available, falling back to HTML parsing.
Change detection: Tracking whether a listing we've already seen has changed (price update, status change, taken down).

For JS-heavy sources I use Playwright with a headless Chromium instance. The overhead is significant compared to simple HTTP requests, so I only use it where necessary. Most letting agency sites are server-rendered and much cheaper to scrape.

Rate limiting is handled per source. I track request timestamps per domain and enforce minimum intervals. The last thing you want is to get blocked from a source because you hammered it.

`python
class RateLimiter:
def init(self, requests_per_minute: int):
self.min_interval = 60.0 / requests_per_minute
self.last_request: dict[str, float] = {}

async def wait(self, domain: str):
    now = time.time()
    last = self.last_request.get(domain, 0)
    elapsed = now - last
    if elapsed < self.min_interval:
        await asyncio.sleep(self.min_interval - elapsed)
    self.last_request[domain] = time.time()

The normalization layer

Every extractor produces a raw record. The normalization pipeline converts raw records to canonical form. I covered this in detail in the data normalization post, but the key fields are:

Price: always monthly EUR, with a qualifier (exact/from/on_application)
Bedrooms: integer, separated from "box room" counts
Location: normalized to neighborhood + postal district + lat/lng
Pet policy: boolean or null (not inferred when absent)
Available date: ISO 8601 or null
Source provenance: which extractor, when fetched, source URL

The normalization step is where most of the bugs live. Edge cases in source formatting surface constantly. A source starts using a new price format. A letting agency relaunches their website with different HTML structure. I run normalization in a separate pass from extraction so I can reprocess raw records when normalization logic changes without re-scraping.

Deduplication

Cross-source deduplication is essential. The same property often appears on multiple sources. Without deduplication, a user would see the same listing three times with slightly different data.

The deduplication approach is blocking plus similarity scoring:

Block by price band (+/- 10%) and geographic area (same district or adjacent)
Within blocks, score similarity on address string, price, beds, baths, available date
Pairs above the threshold get merged. The canonical record keeps the richest data from all matching sources.

This runs as a batch job after normalization completes for a crawl cycle.

Storage and freshness

Listings go into Postgres. I keep full history: every time a listing changes, the previous state is preserved with a timestamp. This lets me track price changes over time, which surfaces useful signals (listings that drop in price are often still available and motivated to rent).

Each listing has a freshness_score that decays over time. The score starts high when a listing is first seen or updated, and drops on a schedule tuned to how frequently that source typically updates. Stale listings get surfaced to users with a staleness label rather than hidden completely, because they might still be available.

The crawl cycle runs on a schedule per source. High-value sources (the main portals) run every 15-30 minutes. Long-tail sources run every few hours. The full catalog is refreshed within a 24-hour window at minimum.

Where this breaks down

A few honest failure modes:

Listings that go fast. A listing can be posted and let within hours. If a source is on a 4-hour crawl cycle, the user might never see it. For the highest-priority sources I push the crawl frequency as high as the site tolerates. But there's no fix for a source that updates infrequently.

Data accuracy. Scraped data is only as accurate as the source. Listings sometimes have wrong prices, wrong bed counts, or outdated availability dates. There's no reliable way to independently verify these without viewings. I surface source data as-is with the provenance visible.

CAPTCHAs and bot detection. Some sources actively block scraping. I don't fight these. If a source blocks me, I either find a publicly accessible feed or exclude that source.

I wrote a more user-facing view of how the aggregation works at https://homescout.io/guide/tools-find-apartment-dublin. This post is the technical layer underneath that.

Caspar Bannink. Founder of HomeScout.io. Building AI-powered rental search for Dublin.

I Moved to Dublin Without a Clue — So I Built a Tool to Fix Renting

Caspar Bannink — Wed, 13 May 2026 17:58:23 +0000

Two years ago I packed up my life in Amsterdam and moved to Dublin. I had a job offer, a suitcase, and zero understanding of how hard finding accommodation in Dublin actually is.

I thought I knew rental markets. Amsterdam is expensive. London is expensive. But Dublin is a different kind of broken.

Within a week of arriving I was spending three hours a day refreshing Daft.ie during work meetings, writing the same inquiry email over and over.

HomeScout is what came out of that experience. Not because I had a startup idea. Because I was an expat in Dublin who could not believe how bad the system was.

What moving to Dublin as an expat actually looks like

You land. You open Daft.ie. The first five pages are luxury new-builds. The normal places are buried on page eight.

You find a two-bed in Rathmines for €1,800. Is that a good price? You have no idea. You are making a €21,600-a-year decision completely blind.

What I actually built

AI-powered natural language search. Type what you want. HomeScout understands natural language and returns exactly what you described.

Area intelligence. Every listing shows average rent, price comparisons, and trends.

AI contract review. Upload your lease. HomeScout flags unusual clauses and checks RPZ compliance.

AI rental agent. Writes personalised inquiry emails, schedules viewings, follows up.

Five languages. English, Dutch, Spanish, French, and Portuguese.

What I learned

Build what you need. Remove more than you add. AI is only useful when it saves real time.

If you are moving to Dublin — HomeScout is free to start. No credit card, no trial period.

Caspar Bannink — founder of HomeScout, built in Dublin after moving from Amsterdam in 2024.

I built an agentic coding harness across three CLI hosts. Here is what actually works.

Caspar Bannink — Wed, 13 May 2026 13:44:36 +0000

I built an agentic coding harness across three CLI hosts. Here is what actually works.

This article is a work in progress. I will keep updating it as the kit evolves.

Last spring, an agent rebuilt my email-templating system for the third time. Same logic, different repo, no memory of the previous two attempts. The speed of vibecoding was getting taxed by the cost of the agent forgetting what I had already shipped.

The fix was not a smarter prompt. It was a smaller vocabulary.

I built agentic-coding-kit. 17 agents, 12 slash commands, 35+ PowerShell tools, a Playwright visual pipeline, and a memory system that compounds across sessions. It installs across Claude Code, OpenCode, and GitHub Copilot CLI from one canonical source. This post explains the full architecture.

The core idea: slash commands are workflows, agents are leaves

Anthropic's own docs say it plainly: "the main agent writes code, edits files, and runs commands itself, dispatching subagents in the background." Every successful open-source kit I surveyed follows this pattern. I learned it the hard way by building 21 wrapping orchestrator agents and killing them all.

The kit has 12 commands: 8 workflows plus 4 utility commands (/bootstrap-harness, /kit-init, /wiki-init, /analyze).

Command	What it does	Typical spawns
`/build`	Scope, explore, implement, review, verify	3-5 agents
`/review`	Surface, specialist, adversarial, false-positive verifier	4-9 agents
`/investigate`	Hypothesis-driven debugging, evidence collection	2-4 agents
`/plan`	Clarify scope, map files, stop for approval	1-2 agents
`/refactor`	Principle-driven restructuring with consequence tracing	2-4 agents
`/redesign`	Aesthetic lock, capture, per-component design, visual diff	4-8 agents
`/security-review`	Adversarial audit by attack class	3-6 agents
`/analyze`	Multi-angle research with claim verification	4-8 agents
`/bootstrap-harness`	Detect repo conventions, write to conventions.md	1-2 agents
`/kit-init`	Initialize .kit/context/ in a new repo	0 agents
`/wiki-init`	Bootstrap .wiki/ from code evidence	1-2 agents

These commands run differently on each host. In Claude Code and OpenCode, they run as slash commands where the main session acts as orchestrator and spawns leaf agents via the Task tool. In Copilot CLI (which does not support custom slash commands or orchestrator-style spawning), each workflow is a shell script: kit-build.sh chains copilot --agent workflow-explorer -p "..." followed by copilot --agent workflow-implementer -p "..." as direct sequential commands. Different host architecture, same leaf agents, same phases.

How the workflows actually work

Every workflow starts the same way: scope-classifier.ps1 reads the git diff and classifies the task as ISOLATED (single file, 0 spawns), SHARED (multi-file, 3 spawns typical), or CRITICAL (auth, schema, migrations: 5 spawns, adversarial pass included). This determines the ceremony tier before anything else runs.

/build is the most common. Phase 1 spawns workflow-explorer to map files, trace dependencies, and return a structured brief (with wiki and specialist memory injected via resolvers). Phase 2 spawns workflow-implementer, which writes code using edit-with-lint.ps1 for every change (atomic syntax check, revert on failure). Phase 3 spawns workflow-reviewer (one reviewer, not seven, the adversarial pass only runs at CRITICAL tier). Phase 4 runs test-loop.ps1 and verify-writeback.ps1. If verification fails, the session cannot claim completion. This is the Iron Law.

/investigate runs hypothesis-driven debugging. It collects symptoms, generates ranked hypotheses, runs the cheapest test first, collects evidence, and outputs a build brief. The output is a diagnosis, not a fix. If the diagnosis warrants code changes, it hands off to /build.

/review fans out to specialist reviewers in parallel: code-quality-reviewer, security-reviewer, api-reviewer, testing-reviewer, and optionally performance-reviewer, adversarial-reviewer, data-migration-reviewer. A false-positive-verifier filters noise before the final report. Findings update handoffs.md (active items), memory.md (recurring patterns), and reflections.md (workflow improvements).

/analyze is for research, not code. It spawns 4 explorers in parallel (architecture-explorer, surface-explorer, risk-explorer, ops-explorer), then 4 theorists (pragmatist, skeptic, security-reliability, product-wedge), then a claim-verifier that checks claims against actual code. Useful for "what is this codebase and where would I extend it."

/redesign activates the Playwright visual pipeline (covered below). /refactor does principle-driven restructuring with consequence tracing. /security-review runs adversarial audit by attack class. /bootstrap-harness detects git workflow, architecture preferences, and PR review conventions from a repo and writes them to .kit/context/conventions.md so other agents implement per the repo's actual style.

goal-orchestrator is different from all of these. It is the only agent that runs as a true autonomous loop. You give it a goal ("make all tests pass", "deploy to staging"), and it iterates until the goal is reached or it hits the convergence cap (6 iterations). It has mechanical stuck detection (same file, same line, same rule blocking for 3 iterations triggers rollback), an empty-diff watchdog, and a rollback gate that reverts iterations that worsen verification. It outputs a machine-parseable GOAL_STATUS first line. This is for autonomous work, not interactive sessions.

The three agent layers

Layer	Count	Purpose
Workflow agents	5	Generic transport: `workflow-explorer`, `workflow-implementer`, `workflow-reviewer`, `workflow-skeptic`, `workflow-ui-qa`
Specialist agents	10	Domain experts spawned on demand: `code-quality-reviewer`, `security-reviewer`, `modularity-expert`, `adversarial-reviewer`, `final-verifier`, `qa-agent`, `spec-agent`, `playwright-navigator`, `ux-driver`, `ui-driver`
Orchestrators	2	`goal-orchestrator` (autonomous convergence loops with stuck detection) and `pr-reviewer` (holistic PR verdict per Google's Code Review Guide)

Each specialist has its own memory at .kit/context/agent-memory/{role}.md, lazy-loaded by specialist-memory-resolver.ps1. Only the memory relevant to the spawned role gets embedded. This is the difference between an agent that burns 8000 tokens orienting itself and one that starts working immediately.

The Playwright design pipeline

When /redesign or a frontend /build runs, the kit activates a visual pipeline that separates aesthetic direction from code.

Step 1: Aesthetic lock. aesthetic-director reads .wiki/features.md (the product context), proposes 2-3 named aesthetics (Swiss Minimalism, Glassmorphism, etc.), and writes DESIGN.md with locked typography, palette, density, and motion rules. This creates consensus on what "looks right" before any code runs.

Step 2: Capture. playwright-explorer reads .agents/screen-flows.yaml (screens, auth, selectors with multi-fallback arrays), starts the dev server, and captures numbered PNGs at 2x device scale (3840x2160). It never edits code.

Step 3: Structure critique. ux-driver reads the screenshots against DESIGN.md and judges hierarchy, scannability, cognitive load, a11y, and empty/error/loading states. Returns structure_ok=true/false. If false, ui-driver is blocked and a restructure plan is returned first.

Step 4: Visual polish. ui-driver (only if structure_ok=true) judges color, spacing, typography, and AI-slop patterns. It emits one change at a time, the code is updated, playwright-explorer recaptures, and visual-diff.ps1 pairs before/after screenshots with pixel-level diff PNGs and a regression threshold of 5%.

The key insight: structure before visuals. Polishing a bad layout wastes everyone's time.

Wiki and memory: how agents remember across sessions

The kit splits context into two systems that compound across sessions.

Wiki (.wiki/) is the repo's structural documentation: index.md, architecture.md, codebase.md, features.md, and per-section pages in sections/. Each section has size budgets (150 lines max) and a standard template: purpose, key files, inputs, outputs, interactions, non-obvious notes. wiki-resolver.ps1 lazy-loads only sections whose key files overlap with the current task. Agents never bulk-load the wiki tree.

Memory (.kit/context/) is the operational state: memory.md for durable repo facts. handoffs.md for what was built, what tests passed, what is next. reflections.md for suggested workflow improvements. agent-memory/{role}.md for role-specific guidance ("in this repo, X is intentional, skip flagging").

When I sit down Tuesday wondering what I worked on Friday, I open the handoff and have my answer in 30 seconds: task description, files touched, gates marked, what is left.

The self-improvement loop

post-session.ps1 runs at session end with failure detectors: verification gate unmarked? Writeback skipped? Tests not logged? Each writes a structured entry to reflections.md.

auto-apply-reflect.ps1 processes these entries in tiered safe buckets. Specialist memory accretion (3+ consistent false-positives auto-append to agent-memory). conventions.md refinements. Spawn-budget tweaks. These auto-apply. Slash command body changes and tool logic rewrites are gated for manual /reflect approval. Every auto-applied change is snapshotted and audit-logged.

One canonical, three hosts

Each CLI host wants agent files in a different format and silently rejects the others. Claude Code rejects BOM-prefixed files. OpenCode rejects Claude's tools: A, B, C comma-string. Copilot rejects Unicode in descriptions over 300 characters.

The kit maintains one canonical source at ~/.agents/global-instructions.md. sync-all-hosts.ps1 distributes it into each host's instruction file between  markers, preserving anything outside the markers. Per-host sanitizers translate agent files at install time. All 17 agents load on all 3 hosts from one shared definition.

The tools that enforce discipline

35+ PowerShell scripts take discipline out of the prompt and put it in code.

Tool	What it enforces
`edit-with-lint.ps1`	Syntax check on every edit, atomic revert on failure
`test-loop.ps1`	Marks verification gate on pass, detects stuck loops (3 same-signature failures)
`verify-writeback.ps1`	Checks docs updated alongside code changes
`scope-classifier.ps1`	Determines ceremony tier from git diff
`frontend-detector.ps1`	Flags greenfield UI for aesthetic-director
`wiki-resolver.ps1`	Lazy-loads only relevant wiki sections into agent prompts
`specialist-memory-resolver.ps1`	Injects role-specific repo memory into subagent prompts
`visual-diff.ps1`	Pixel-level before/after comparison with regression threshold
`auto-apply-reflect.ps1`	Closes the self-improvement loop with tiered safe auto-apply

The bash-dispatcher hook enforces at the protocol layer: dangerous filesystem ops blocked, git push --force on main blocked, git commit gated on verification evidence. Test success auto-marks the verification gate. The agent does not need to remember any of these rules. The harness does.

What is next

The kit runs on Claude Code today. In the next article, I will write about the hybrid setup I am testing: Claude Code as orchestrator, OpenCode Go at $10/month with DeepSeek V4 API keys for the fan-out layer. DeepSeek V4 Flash at $0.14/$0.28 per million tokens is 35x cheaper than Opus on input. A /build with 3 reviewer spawns costs under $0.01.

Fork it: github.com/CBannink/agentic-coding-kit. Open an issue if something breaks.

I am Caspar Bannink, founder of HomeScout (AI rental search for Dublin) and Bannink Software Development.

Side project: homescout.io
Personal LinkedIn: linkedin.com/in/caspar-bannink-719440217
HomeScout LinkedIn: linkedin.com/company/homescout-io
Repo: github.com/CBannink/agentic-coding-kit

How AI is fixing the Dublin rental nightmare for expats in 2026

Caspar Bannink — Mon, 11 May 2026 22:00:35 +0000

How AI is fixing the Dublin rental nightmare for expats in 2026

I moved from Amsterdam to Dublin two years ago. I spent four weeks in a co-living space burning through money while trying to decode a rental market I knew nothing about.

Not because the tools did not exist. Because every tool was built for people who already knew the city.

That is the expat problem in one sentence. You land in a country where you do not know the neighborhoods, cannot read the social norms in a listing, have no instinct for what a price should be, and sometimes cannot even communicate clearly in the language the forms are written in. The market does not slow down for any of that.

In 2026, AI search is starting to fix parts of this. Not all of it. But enough that the experience is meaningfully different.

Why Daft.ie is not built for you

Daft.ie is Ireland's dominant rental portal. It is useful if you grew up here.

Type "2-bed apartment Dublin" and you get a list sorted by price. What you do not get: any context on which areas those results are in, what the commute times look like, whether a neighborhood is quiet or loud, or what €1,900/month actually means relative to local norms. The portal assumes you already have all of that in your head.

If you have lived in Dublin your whole life, you do. If you flew in from Bangalore, São Paulo, or Rotterdam last Tuesday, you do not.

There is no multilingual support. There is no explanation of what RPZ compliance means, or why some listings mention "HAP" and others do not, or what the difference is between a letting agent posting and a private landlord posting. You either know or you do not.

The result is that expats make decisions with radically less information than locals. They apply to apartments in areas that look cheap on a map but have reasons for being cheap. They miss listings because they searched with the wrong terminology. They sign leases with clauses that would make an Irish renter laugh.

This is not a complaint about Daft. It is a product that works well for its intended audience. Expats are not that audience.

What changes when the search is AI-native

The first thing that changes is the input layer.

Instead of working out the right filter settings, you describe what you want in your own terms. "I need something close to the tech quarter in the south docks, quiet enough to work from home, under €2,200, not on a main road." That search, in natural language, runs across Daft.ie, Rent.ie, and MyHome simultaneously and returns results ranked by match quality, not just price.

For expats, this matters because you do not know the right Daft filters yet. You do not know that "Docklands" and "Grand Canal Dock" are the same area. You do not know that "city centre" on Daft spans everything from premium Ballsbridge to places you would not want to live. Natural language cuts through that.

The second thing that changes is area context.

HomeScout's Area Explorer shows commute time to a work address, walkability scores, average rent per square metre, and a plain-language description of what the neighborhood is like. For someone who has never been to Dublin before, this is the difference between applying blindly and applying with a real opinion.

I wish I had had that. I spent a Saturday in my first week walking Stoneybatter, Phibsborough, and Drumcondra just to form opinions I could have read in two minutes.

The third is value scoring. Each listing gets a price-relative-to-area score so you can see whether €1,850 in Rathmines is above or below what that area commands. For expats who have no local price intuition, this replaces the 6 months of market watching it normally takes to develop one.

The AI Rental Agent: monitoring from a different timezone

The single biggest structural disadvantage expats have is timezone.

If you are in Singapore making a decision about a Dublin rental, you are 7 to 9 hours ahead. The best listings go live during Dublin business hours. By the time you wake up and check, 40 people have applied.

HomeScout's AI Rental Agent runs 24/7 and matches new listings against your saved search criteria the moment they appear. When a match lands, you get a push notification immediately, not on the next refresh cycle.

The auto-apply feature goes further. You pre-approve a cover letter template and set the criteria under which the agent can apply on your behalf. It is not automatic spam. There are 5 safeguards: you approve the template, you opt in per search, a scam filter blocks suspicious listings, a daily cap prevents overreach, and a kill switch lets you stop it instantly. Within those limits, the agent applies within seconds of a listing going live, not after your morning coffee.

For expats searching from abroad, this changes the competitive position completely. You are no longer automatically at a disadvantage because of where you are sleeping.

Contract review when the law is unfamiliar to you

Irish lease law has specific rules that most expats do not know before they arrive.

RPZ (Rent Pressure Zone) caps mean rent inside most Dublin areas can only rise 2% per year. Notice periods run from 28 days for tenancies under 6 months to 196 days for tenancies over 7 years. The deposit maximum is one month's rent. Any lease clause that contradicts Irish tenancy law is unenforceable, regardless of what the paper says.

HomeScout's contract review tool reads a lease and flags clauses that are unusual, potentially unenforceable, or worth questioning before you sign. It also checks RPZ compliance: if a listing is in an RPZ area and the rent history looks off, the review surfaces that.

For non-native English speakers, this is especially useful because legal language in a second language is genuinely hard. A clause that a native speaker parses in 10 seconds can take a non-native speaker several minutes to decode, and sometimes they still get it wrong. The review tool outputs plain-language summaries of each flagged clause, not legalese.

This does not replace a solicitor for high-value or unusual situations. But for a standard Dublin tenancy agreement, it catches the things worth catching.

Five languages, because Dublin is international

Dublin's rental market is filled with people who moved there from everywhere. The tech sector alone brings in workers from 40 or 50 countries. A significant number of them are searching for rentals in their second or third language.

HomeScout supports English, Spanish, Hindi, Dutch, and Portuguese. Search, area context, value explanations, and contract review all work in all five languages. You can run your entire rental search in the language you think most clearly in.

I built Dutch support partly for selfish reasons. My Dutch colleagues in Dublin had the same problem I did, and "just use English" is a real but unsatisfying answer when you are already under stress from a move.

Spanish and Portuguese together cover most of Latin America and the Iberian Peninsula. Hindi covers one of the largest sending communities in Dublin's tech workforce. These are not token additions.

What is still limited

Honest disclosure: AI search does not fix the supply problem.

Dublin has roughly 1,500 active rental listings at any given moment against demand that far exceeds that. No tool closes the supply gap. What AI search does is make sure that in a competitive market, you are competing with full information and optimal timing instead of one hand tied behind your back.

The auto-apply feature does not guarantee viewings. It guarantees that your application arrives at a competitive time. Agents and landlords still choose.

Area Explorer data is updated weekly, not in real-time. Rent prices shift faster than the underlying data does in fast-moving periods.

The contract review tool flags issues; it does not give legal advice. If a landlord pushes back on a flagged clause, you still need a human conversation.

Try it before you land

The 7-day free trial requires no payment card. If you are planning a move to Dublin in the next 3 months, running a few test searches before you arrive is worth the 10 minutes. You will understand the market and the neighborhoods faster than any amount of Googling will give you.

Start your free trial at homescout.io

Dublin-first today. Cork, Galway, and Limerick coverage is in progress for later in 2026.

I am Caspar Bannink, founder of HomeScout (AI rental search for Dublin) and Bannink Software Development. I moved from Amsterdam to Dublin two years ago and built the tool I wish I had.

Check out my side project: homescout.io
Personal LinkedIn: linkedin.com/in/caspar-bannink-719440217
HomeScout LinkedIn: linkedin.com/company/homescout-io

Everything HomeScout Can Do (And Why I Built It After Moving to Dublin)

Caspar Bannink — Fri, 01 May 2026 21:38:37 +0000

Everything HomeScout Can Do (And Why I Built It After Moving to Dublin)

Originally published on Medium.

I moved from the Netherlands to Dublin about two years ago. I had a job lined up, a rough idea of which neighbourhoods looked interesting, and what I thought was a reasonable budget. What I did not have was any idea how broken the rental search experience in this city actually is.

Within the first week I was refreshing Daft.ie on my phone during work meetings, copy-pasting the same inquiry email to thirty letting agents, and genuinely losing sleep over apartments I missed because I did not check listings fast enough. Coming from Amsterdam I thought I knew expensive rental markets. Dublin turned out to be worse, with fewer tools to help you make sense of it.

After about a month of this, I started building HomeScout. Not because I wanted to launch a startup. Because I was tired of the way things worked and I knew they could be better. I ended up using HomeScout to find my own apartment.

The Problem Nobody Was Solving

You land in Dublin, you need a place to live, you open Daft.ie. It's the main listing site. Everyone uses it. And the search is terrible.

You know exactly what you want. A two-bedroom apartment near Google Docks, under €2,000, that allows pets. Simple enough. Instead of typing that sentence, you get 15 dropdown menus. Location picker. Min price. Max price. Bedrooms. Property type. And even after clicking through all of those, the results don't really match what you asked for.

The first five pages are dominated by expensive new-build developments. Shiny complexes charging €3,000-plus for a one-bed. The normal, affordable apartments that regular people actually rent are buried deep in the results.

Then there's the pricing problem. You find a one-bed in Rathmines listed at €1,800. Is that a good deal? Overpriced? About to go up? You have no way to know. No area data, no comparison tools, no market intelligence. You're making one of the biggest financial decisions of your month completely blind.

If you do find a place, the lease arrives. Forty pages of legal text. Clauses about things you've never heard of. Is this break clause normal in Ireland? Is that deposit retention term a red flag? You could hire a solicitor, but not for every lease you review.

Meanwhile you're emailing twenty-plus agents. Replies arrive at random times. Your inbox becomes chaos. It's a full-time job alongside your actual full-time job. Good properties disappear within hours. If you're not refreshing every twenty minutes, you miss them. Every inquiry email you send looks like everyone else's, one of fifty identical messages in the agent's inbox.

I dealt with all of this firsthand. Not as a product researcher. As a frustrated renter who could not believe how bad the experience was. So I built HomeScout to fix it. All of it.

What I Built to Fix It

Search That Understands English

This was the first thing I built, because it was the first thing that drove me up the wall. On HomeScout, you type what you want in plain English. "2 bed apartment in Rathmines under 2000 that allows pets." The AI picks up on what you mean and returns matching listings. No dropdowns. No guessing which filter combination might work.

You can be as specific or as vague as you want. "Something near a DART station with a balcony" works just as well as "3 bed house in Drumcondra between 1800 and 2200." The search adapts to how you think about your housing needs rather than forcing you into rigid categories.

AI Match Score + Value Score: Know If It's a Good Deal

Every property gets two scores. The AI Match Score tells you how well a listing fits what you actually asked for, explained in plain language ("matches your commute, over budget by €150, no balcony"). The Value Score tells you whether the asking rent is fair for that neighbourhood, based on comparable properties, location quality, condition, and BER energy rating.

No more guessing. No more overpaying because you didn't know the going rate for a two-bed in Stoneybatter. Agents and landlords have always had more information than tenants. These two scores finally flip the table.

AI Rental Agent: Stop Refreshing, Start Living

This one changed how I think about apartment hunting entirely. You describe your dream property once, budget, area, bedrooms, whatever matters, and the AI Rental Agent scans the market around the clock. The moment something matching your criteria appears, you get notified.

No more refreshing Daft every twenty minutes during your lunch break. No more missing a perfect apartment because you were in a meeting when it was listed. If you want to go further, the Agent can auto-send your pre-approved inquiry template the moment a match lands (capped at 5 sends per day with a kill switch on every email). The Dublin market moves fast, a good two-bed can get fifty inquiries in the first hour. Being notified instantly makes a real difference.

AI Contract Review: Your 30-Second Solicitor

You get a lease. It's forty pages. You upload the PDF to HomeScout. Within thirty seconds the AI has read every clause, flagged potential red flags, checked RPZ (Rent Pressure Zone) compliance, and highlighted anything unusual compared to standard Irish leases.

Is that deposit clause normal? Is this break clause fair? Can the landlord actually do that inspection thing? You get clear answers without booking a solicitor appointment. It doesn't replace legal advice for complex situations, but for the "is this lease reasonable?" question that every renter has, it's exactly what you need.

Smart Inbox: One Place for All Agent Communication

Instead of losing track of twenty email threads across your personal inbox, all your agent communication lives in one organised place inside HomeScout. Every conversation tied to the property it's about, with full history.

The real power is in AI email generation and reply analysis. When you reach out to an agent, the AI drafts a personalised inquiry using your renter profile, your employment status, your move-in timeline, relevant details that make you sound like a serious, organised applicant. Not a generic "Hi, is this still available?" that agents get hundreds of per day.

When the agent replies, the AI reads it, classifies the sentiment (positive / negative / needs info), and suggests next actions. You review everything before it sends. You can edit it, change the tone, add details. Nothing goes out without your approval.

Viewing Scheduler: No More Calendar Chaos

When you're viewing five or six properties in a week, keeping track of when and where becomes its own challenge. HomeScout has a built-in viewing scheduler with ICS calendar export. Book viewings, export them to your calendar, get reminders, and track which ones you've attended and what you thought of each.

Simple. But when I was hunting I once showed up to a viewing on the wrong day because I'd mixed up two properties in my head. That doesn't happen when everything is organised in one system.

Renter Resume: Stand Out From the Crowd

Dublin's rental market is brutally competitive. When an agent has fifty applications for one apartment, anything that makes you look more prepared and professional helps.

Your renter resume on HomeScout is a digital profile with your employment details, references, and key documents. When you apply for a property, you can share your complete profile with one click instead of rewriting your life story and attaching the same documents every single time. Faster for you, better impression on the agent.

Document Vault: Everything in One Secure Place

Payslips in your email. Lease in your downloads folder. Reference letter somewhere on your phone. Every application means hunting through folders and inboxes for the same files.

HomeScout's document vault is encrypted storage for all your rental documents, AES-256-GCM at rest, key derived per user. Leases, payslips, employer references, ID copies. When an agent asks for your last three payslips, you open the vault and share them. Your sensitive financial documents aren't sitting in a regular cloud folder.

Market Scout: Understand Dublin Before You Search

If you're new to Dublin, you probably don't know the difference between Rathmines and Ranelagh, or why Phibsborough costs half of what Ballsbridge does. Market Scout (formerly Area Explorer) is an interactive choropleth map of 28 Dublin neighbourhoods, colour-coded by real rent data and overlaid with 63 landmark markers.

Before you even run your first search, you can explore the city and understand what different areas actually cost. Orientation that takes weeks to figure out on your own, available in thirty seconds.

Property Comparison + Price History

Saved properties get side-by-side comparison mode and a price-history sparkline, so you can see whether that €2,100 listing was €1,850 three months ago. Useful both for knowing what's moving and for politely asking an agent why the price jumped.

What's Free and What's Not

I wanted HomeScout to be genuinely useful even if you never pay a cent.

Explorer (Free, forever):

20 AI searches per month
5 saved properties
1 lifetime free AI contract review
1 active AI Rental Agent brief + 1 match per week (blurred previews for the rest)
No Market Scout, no viewing scheduler, no email drafting

Enough to get a feel for the platform, try the AI search, and run one contract through the review.

HomeScout (€17.99/month, or €42.99 Season Pass for 3 months):

Unlimited AI searches, saved properties, saved searches, AI email drafting
Full Market Scout access
Unlimited AI Rental Agent (with auto-apply, 5 sends/day cap)
Unlimited AI contract review
Viewing scheduler + ICS calendar export
Commute calculator
Unlimited document vault
Property comparison + advanced filters
Priority support

The Season Pass works out to roughly €14.33/month, designed for the realistic length of a Dublin apartment hunt. I priced it below the cost of a single solicitor consultation because the tools should be accessible to normal renters.

Team plans are per-seat with volume discounts for relocation teams and HR departments moving multiple people into Dublin.

Try It Yourself

If any of this resonated with your own experience of apartment hunting in Dublin, give HomeScout a try. The free Explorer plan doesn't require a credit card.

I built this because I was tired of fighting with Daft.ie at 11pm on a Tuesday, wondering if that apartment in Stoneybatter was fairly priced or if I was about to get ripped off. If that sounds familiar, you'll probably get a lot out of it. And if you end up catching a listing twenty minutes after it goes live because the AI Rental Agent pinged you while you were actually enjoying your lunch break instead of doom-scrolling Daft, that's exactly why I built the thing.