DEV Community: Vladyslav Donchenko

From Startup to Award Winner: Engineering Lessons from Germany's #1 PropTech

Vladyslav Donchenko — Sun, 21 Jun 2026 22:13:26 +0000

Winning the PropTech Germany Award: What It Actually Took

In 2024, the AI Real Estate Data Intelligence platform built by VSBD was awarded the PropTech Germany Award as the #1 Asset and Portfolio Management Tool in the German real estate market. Award recognition is satisfying, but the more valuable outcome was the $1M ARR the platform was generating in production — proof that the engineering quality delivered real business value, not just demo-ware.

Here are the engineering lessons that made the difference.

Lesson 1: Architecture Decisions Made at POC Stage Define Your Ceiling

The most consequential engineering decisions happen in the first two months — not when you're scaling. When VSBD began the Real Estate Data Intelligence project, the team made deliberate choices that might have seemed over-engineered for a POC: Kubernetes from day one, Terraform IAC from the first infrastructure deployment, a microservices architecture with clear service boundaries defined before a line of product code was written.

These choices added complexity early but eliminated re-architecture later. When the platform needed to scale from the MVP to support enterprise clients processing terabytes of property data, the infrastructure scaled with it — without rebuilding.

Lesson 2: Security by Design, Not Security as an Afterthought

Real estate data is sensitive. Portfolio valuations, tenant financial data, investment strategies, and acquisition targets are all information that enterprise clients need to protect. Platforms that treat security as a feature to be added before enterprise sales lose deals and spend twice — once on quick fixes and once on proper implementation.

VSBD's platform underwent penetration testing at every major release milestone, with identified vulnerabilities addressed before shipping. Security architecture decisions — data encryption at rest and in transit, network isolation, access control granularity — were documented as architecture decisions before implementation began.

Lesson 3: Quality Engineering Is a Multiplier, Not a Cost Center

The 90% reduction in testing time achieved on the award-winning platform was not achieved by testing less — it was achieved by testing smarter through automation. VSBD's QA approach included:

Smoke, regression, usability, acceptance, integration, E2E, and load testing — automated wherever possible
A fully automated release candidate pipeline that gates production deployments on test outcomes
Allure reporting for test visibility across the engineering and product teams
A 99% success release ratio — measured by P0 production incidents — that gave the client confidence to ship faster

When quality is automated, it compounds: each new test suite protects against regressions in all previous functionality, and the team's ability to ship safely increases with each release cycle.

Lesson 4: The Right Team Composition Is Non-Negotiable

The 9-month delivery timeline was only possible with a team that had every required skill represented from day one. The VSBD team composition for the award-winning platform:

Product Owner — ensuring business priorities drove sprint planning
Solution Architect — maintaining technical coherence across service boundaries
MLOps/DevOps Engineer — owning the infrastructure and model deployment pipeline
UI/UX Designer — translating complex AI outputs into intuitive interfaces
Lead Engineer + 2 Backend Engineers — core product development
Frontend Engineer — building the asset manager-facing application
Manual QA — exploratory testing and acceptance validation

Each role was filled before development began. Bringing specialists in mid-project to address gaps is expensive and disruptive — team ramp-up time consumes the productivity gains you hoped to capture.

Lesson 5: Transparency Wins Enterprise Clients

The enterprise real estate clients who commissioned the award-winning platform had been burned before by software projects that promised delivery and delivered delays. What differentiated VSBD was radical transparency: weekly status updates with actual KPI data, an open change log tracking every discovered and resolved bug, and a governance model with clear escalation paths at every organizational level.

When clients can see exactly what the engineering team is doing, what risks are being managed, and what the delivery trajectory looks like — trust follows. That trust is what turned a successful MVP deployment into a multi-year, multi-scope engagement that continues to generate value.

What Comes Next for PropTech Engineering

The German real estate market that validated this platform is not unique. The same demand for AI-driven asset management, automation, and data intelligence exists across EU and US PropTech markets. The engineering playbook that produced a PropTech Germany Award winner is repeatable — for the right team, working with the right partners, with the right architecture decisions made early.

If you're building the next PropTech platform, the question isn't whether to invest in engineering excellence — it's how quickly you can get there.

Originally published on the VSBD blog.

KPI-Driven Engineering Culture: How PropTech Leaders Measure What Matters

Vladyslav Donchenko — Sun, 21 Jun 2026 22:13:18 +0000

Why Most Engineering Teams Measure the Wrong Things

PropTech engineering teams typically track what's easy to measure: story points completed, PRs merged, tickets closed. These metrics create perverse incentives — rewarding volume over value, and making the team appear productive while the product moves in the wrong direction. A KPI-driven engineering culture is different: it aligns technical metrics directly to business outcomes and makes the value of engineering investment visible at every level of the organization.

The KPI Pyramid: From Business Outcomes to Engineering Practices

VSBD's engineering culture is organized around a KPI Pyramid with four levels:

Level 1: Business KPIs (Top Line)

Revenue generated or protected by the platform
Cost reduction attributable to automation
Customer acquisition and retention metrics

Level 2: Value & Satisfaction KPIs

Percentage of validated user stories that deliver measurable business value
Customer satisfaction score (NPS, CSAT)
Stakeholder and team satisfaction ratings

Level 3: Delivery Pipeline KPIs (DORA Metrics)

Deployment Frequency: How often code reaches production. High-performing teams deploy multiple times per day.
Lead Time for Changes: Time from code commit to production deployment. Measures the friction in your delivery pipeline.
Change Failure Rate: Percentage of deployments that cause a production incident. Measures deployment quality.
Mean Time to Restore (MTTR): How quickly the team recovers from production incidents.

Level 4: Engineering Practice KPIs

Unit test coverage and quality
Technical debt ratio (measured by static analysis tools)
Code review turnaround time
Defect Containment Effectiveness (DCE) — what percentage of bugs are caught before production

Transparency Toolset: Making KPIs Visible

KPIs only drive behavior when they're visible to everyone who can influence them. VSBD's transparency toolset includes:

Real-time team KPI dashboards visible to both engineering and business stakeholders
Sprint-level tracking of story point accuracy vs. team velocity baselines
Technical debt tracking integrated into the development workflow — not a separate process
Release health monitoring showing P0/P1 incident rates per deployment

The transparency is bidirectional: engineering teams can see the business impact of their work, and business stakeholders can see the engineering metrics that predict upcoming delivery performance.

The 70% Budget Planning Accuracy Achievement

One of the most valuable outcomes of VSBD's KPI-driven approach is budget planning accuracy. Historical data from KPI tracking enables more accurate estimation of future work — not because estimation gets easier, but because the team has reliable baselines for velocity, defect rates, and infrastructure costs that make planning models more precise.

In one engagement, VSBD achieved 70% budget planning accuracy versus the client's previous proprietary estimations — a significant improvement that enabled the client to plan quarterly investments with much greater confidence.

Building a KPI Culture in a PropTech Engineering Team

The most common failure mode for KPI programs in engineering organizations is top-down imposition without team buy-in. Engineers who don't understand why a metric matters will game it — and gaming KPIs produces exactly the wrong behaviors.

VSBD's approach: involve the engineering team in selecting the metrics that matter for their context, explain the business rationale for each metric, and review KPI trends together in retrospectives. When every voice is heard in the KPI design process, the metrics become a shared language rather than a management surveillance tool.

Originally published on the VSBD blog.

Microservices Architecture for High-Scale Real Estate Data Platforms

Vladyslav Donchenko — Sun, 21 Jun 2026 22:08:14 +0000

Why Microservices for Real Estate SaaS?

Real estate data platforms face a unique architectural challenge: they must simultaneously handle high-volume, low-latency data ingestion (property listings, sensor readings, transaction events) and low-volume, high-complexity processing (AI model inference, document extraction, financial reconciliation). A monolithic architecture cannot optimize for both. Microservices, when designed correctly, allow you to scale hot paths independently while keeping cold paths cheap.

Defining Service Boundaries for Real Estate Domains

The most common microservices mistake is decomposing by technical layer (API service, database service, auth service) rather than by business domain. For real estate platforms, the right decomposition maps to the core business entities and workflows:

Property Intelligence Service: Responsible for property data normalization, enrichment, and AI-driven valuation. Scales independently based on the volume of property updates ingested.
Portfolio Management Service: Handles portfolio composition, performance tracking, and reporting. Typically lower volume but higher complexity — benefits from dedicated compute.
Document Processing Service: Orchestrates LLM-based document extraction pipelines. Asynchronous by design, with a queue-based architecture that handles burst processing without blocking user-facing APIs.
Integration Gateway: A thin adapter layer that normalizes data from external systems (CRMs, ERPs, valuation APIs) into the platform's internal data model.
Notification & Workflow Service: Manages event-driven workflows, approval chains, and alerting — often the glue between other services.

Kubernetes Architecture for PropTech Platforms

In the VSBD AI Real Estate Data Intelligence platform, Kubernetes was chosen from day one — not as a future-proofing decision, but as a prerequisite for the scalability requirements the client needed. Key architectural decisions:

Namespace isolation per tenant for multi-tenant data security, with network policies enforcing service-to-service communication boundaries
Horizontal Pod Autoscaling (HPA) on the Document Processing Service — the highest-variance workload — with CPU and custom metrics triggers
StatefulSets for data services that require stable network identities and persistent storage
Ingress controllers with rate limiting to protect AI inference endpoints from runaway usage

Terraform IAC: Reproducible Infrastructure at Scale

Infrastructure-as-Code is not optional for enterprise real estate platforms. When a client needs their own deployment in a specific cloud region for data sovereignty reasons, the ability to spin up an identical environment in hours (rather than weeks) is a competitive advantage. VSBD's Terraform IAC approach includes:

Modular workspace organization with separate state files per environment (dev/staging/prod)
Remote state storage in a secure backend (S3/GCS with encryption and versioning)
Variable-driven configuration for multi-region deployment without code duplication
Automated drift detection via CI/CD pipeline integration

Data Pipeline Architecture for Multi-Source Ingestion

Real estate platforms typically ingest data from 5–20 external systems: property listing feeds, valuation APIs, land registry data, building sensor platforms, and internal ERPs. A configurable data pipeline architecture — rather than hardcoded integrations — is essential for long-term maintainability.

The approach VSBD uses: a pipeline configuration schema that allows new data sources to be added through configuration rather than code, with transformation rules defined declaratively. This reduced integration time for new data sources from weeks to days in production deployments.

Backup, Restore, and Disaster Recovery

For enterprise real estate clients, data loss is not acceptable. The platform VSBD delivered included automated backup/restore mechanisms with:

Point-in-time recovery for all stateful services
Cross-region replication for tier-1 data
Automated restore testing in the CI pipeline — not just backup, but verifiable recovery
RTO and RPO commitments documented in the architecture decision records

The result: a platform that enterprise clients could trust with their most sensitive portfolio data from day one.

Originally published on the VSBD blog.

LLM Automation in Property Management: A $6.5M Cost Reduction Case Study

Vladyslav Donchenko — Sun, 21 Jun 2026 22:08:06 +0000

The $6.5M Opportunity Hidden in Manual Workflows

Following a large acquisition, a leading European real estate provider faced a mandate from its board: reduce total operating costs by $6.5 million. The initial instinct was headcount reduction. The actual solution was smarter: identify every workflow where a human was performing a task that a language model could handle with equal or greater accuracy — then automate it.

VSBD was engaged as the implementation partner alongside AlphaPrompt, the LLM automation platform selected by the provider. What followed was one of the most ambitious PropTech automation deployments in the European market.

The Automation Target: Asset Manager Workflows

Asset managers in large real estate organizations spend a disproportionate amount of time on tasks that are high-volume, low-variability, and document-intensive: lease review, covenant monitoring, rent reconciliation, reporting, and communication drafting. Each of these is an LLM-ready workflow when paired with the right data pipeline.

The project began by mapping every workflow the asset management team performed, measuring time-per-task and frequency, and scoring each against LLM automation viability criteria:

Is the task based on reading and extracting information from structured or semi-structured documents?
Does the output follow a predictable schema?
Is human review of the LLM output feasible and sufficient as a quality gate?

The workflows that scored highest became the first automation wave.

Phase 1: POC to Production (July 2023 – December 2023)

VSBD was initially engaged to replace an asset managers' project for a subsidiary of the client organization. The first POC moved into production in December 2023 — just five months after initial engagement. This speed was possible because the engineering team resisted the temptation to build everything at once: the POC focused on a single, high-value workflow with clear measurability.

The engineering stack chosen for the automation platform:

Azure Cloud for enterprise compliance and data residency requirements
Python for ML pipeline development and LLM orchestration
React for the asset manager-facing review interface
React Native for mobile access during property inspections

Phase 2: MVP and Market Validation (May 2024 – September 2024)

The MVP was delivered for a "friends and family" rollout in May 2024, allowing the team to gather real-world feedback before broader deployment. The solution was presented at the PropTech Summit in Germany, generating high client engagement and industry recognition.

By September 2024, the solution was awarded end-to-end #1 Asset and Portfolio Management Tool in the German Real Estate Market — validating both the product approach and the engineering quality.

Phase 3: Scale and Book-of-Work (December 2024 – January 2025)

The success of the initial automation scope led to a "Book-of-Work" engagement: VSBD was commissioned to identify additional cost-saving opportunities through LLM automation across the organization. The SaaS platform was released to full production in January 2025, generating $1M in monthly recurring revenue.

Measurable Outcomes

30% increase in deal processing speed
Significant decrease in human error across automated workflows
20% increase in deal closure rate
84% employee satisfaction rating through post-deployment feedback and iterative adjustment
25% decrease in contractor FTE expenses

The Engineering Lessons

LLM automation projects fail when they are treated as purely AI projects. The technical foundation — data pipelines, integration architecture, review UX, monitoring — is what determines whether the model outputs are actually usable in a real business context. VSBD's approach of combining ML engineering with quality engineering, DevOps, and transparent KPI tracking is what made the difference between a demo and a $6.5M cost reduction.

Originally published on the VSBD blog.

Agentic AI Best Practices: Shipping Reliable Agents in Production

Vladyslav Donchenko — Sun, 21 Jun 2026 22:03:01 +0000

The Demo-to-Production Gap

An agent that books a viewing or drafts a lease summary is easy to demo and hard to ship. The demo runs once, on a clean input, with a human watching. Production runs thousands of times a day on messy real-world data with no one watching — and a single bad action can email the wrong tenant, mis-price a property, or trigger a payment that should not have happened.

Closing that gap is an engineering-discipline problem, not a model problem. Below are the practices VSBD builds into every agentic orchestration layer we ship for PropTech clients — the same work behind our PropTech 2026 Awards nomination.

1. Constrain the Decision Space

Full autonomy is rarely what you want. A real estate workflow has a known shape: you almost always classify the document before you extract from it, and you always verify before you act. Encode that shape. Use deterministic routing and explicit state machines for the parts of the workflow that are predictable, and reserve open-ended agent reasoning for the genuinely ambiguous steps.

The rule of thumb: autonomy where it pays off, determinism everywhere else. Every degree of freedom you remove is a class of failure you no longer have to test for.

2. Make Every Tool a Typed Contract

Agents act on the world through tools. If a tool accepts free-form input and returns free-form output, you have no way to catch a malformed action before it hits your database. Give every tool a validated schema for both directions:

(Diagram in the original article.)

This single decision converts a whole category of "the model hallucinated a field" problems into ordinary, catchable validation errors. It also makes your agents portable: swap the underlying model and the contracts still hold.

3. Ground Everything in Retrieved Data

An agent reasoning about a property should never rely on the model's parametric memory for facts. Retrieve the lease, the valuation history, the tenant record, and the policy document, and require the agent to ground its output in what it retrieved. Grounding is what turns a plausible-sounding answer into a defensible one — and in real estate, defensibility is the whole game.

4. Put a Human in the Loop on High-Stakes Actions

Not every action deserves the same level of trust. Reading a document is low-stakes; sending a payment, signing a contract, or messaging a tenant is not. Classify your actions by reversibility and value, and require explicit human approval on the consequential ones.

Done well, this is not friction — it is leverage. The agent does 95% of the work (gathering, drafting, checking) and a person spends ten seconds approving a fully-prepared action instead of ten minutes doing it from scratch. Every approval is logged, giving you a complete audit trail for compliance.

5. Trace, Replay, and Evaluate Every Run

You cannot improve what you cannot see. Instrument every agent step so that a full run can be replayed and inspected: what the agent was asked, what it retrieved, which tools it called, and what it returned. Then score those runs against an evaluation suite — a curated set of real cases with known-good outcomes.

Evals are your regression test for non-deterministic systems. Before any prompt change, model upgrade, or new tool ships, run it against the eval suite and confirm you have not regressed on cases that used to pass. Without this, every change to a production agent is a gamble.

6. Control Cost and Latency Deliberately

Token spend and response time are product features, not afterthoughts. The levers that keep both predictable as volume grows:

Model routing — send simple classification to a small, fast model and reserve the most capable model for genuinely hard reasoning. Most steps in a real estate workflow do not need your largest model.
Prompt caching — cache the stable parts of prompts (system instructions, policy documents, tool definitions) so you are not paying to re-process them on every call.
Bounded context — externalize state and retrieve only what each step needs, instead of growing the prompt unboundedly as a workflow runs.
Fallbacks and circuit breakers — when an agent or model call fails, degrade gracefully to a simpler path or a human queue rather than cascading the failure.

7. Fail Safe, Not Silent

When something goes wrong — a tool errors, validation fails, a model times out — the worst outcome is an agent that quietly does the wrong thing. Design every failure path to stop and escalate rather than guess. A workflow that lands in a human review queue is a minor inconvenience; a workflow that silently corrupts a tenant record is a crisis.

The Payoff

Teams that treat agentic AI as a prompt-engineering exercise ship impressive demos and fragile products. Teams that treat it as a distributed-systems and reliability-engineering problem ship agents that run unattended at scale. The practices above are what let a real estate platform hand a large share of its routine asset operations to agents and still sleep at night.

VSBD builds production-grade agentic orchestration layers for PropTech and real estate companies across Europe and the USA. If you want an agent layer your compliance team trusts and your operators rely on, we can help you build it right the first time.

Originally published on the VSBD blog.

Building an Agentic Orchestration Layer for PropTech Platforms

Vladyslav Donchenko — Sun, 21 Jun 2026 22:02:54 +0000

The Problem With Bolt-On LLM Features

Most PropTech platforms started their AI journey the same way: a chatbot here, a document summarizer there, a lease-clause extractor wired into one workflow. Each feature works in isolation, but none of them talk to each other, share context, or compose into anything larger. The result is a patchwork of point solutions that is expensive to maintain and impossible to govern.

The next stage of maturity is an agentic orchestration layer: a single control plane that coordinates specialized AI agents, gives them safe access to your systems of record, and executes multi-step real estate workflows end to end. This is the architecture VSBD built for a production PropTech platform — and the work behind our PropTech 2026 Awards nomination.

What "Agentic" Actually Means Here

An agent is an LLM given a goal, a set of tools it can call, and the autonomy to decide which tools to use and in what order. "Agentic orchestration" is the layer above the individual agents that decomposes a goal, routes sub-tasks to the right specialist agent, manages shared state and memory, and enforces guardrails on everything that crosses a boundary.

The mental model is a control plane, not a single mega-prompt:

(Diagram in the original article.)

The Five Components Every Orchestration Layer Needs

1. The orchestrator. This is the brain that receives a goal, breaks it into steps, and decides which agent handles each step. Keep it deterministic where you can — explicit routing rules and state machines beat a fully autonomous planner for reliability and auditability. Reserve open-ended planning for the genuinely ambiguous cases.

2. Specialized agents. A document agent that classifies and extracts from leases is a different beast from a valuation agent that reasons over comparables. Narrow agents with focused tool sets and tight prompts outperform one generalist agent trying to do everything. They are also far easier to evaluate and improve in isolation.

3. Typed tool contracts. Every action an agent can take — query the CRM, draft an email, schedule a contractor — is exposed as a tool with a validated input and output schema. This is the single most important reliability decision you will make. Typed contracts turn "the model said something weird" into a caught validation error instead of a corrupted record.

4. Shared memory and state. Agents need short-term working memory for the current task and longer-term context (this tenant, this property, this portfolio). Externalize state into a store the orchestrator owns rather than stuffing everything into the prompt — it keeps token costs bounded and makes runs replayable.

5. The guardrail and approval layer. Between the agents and your systems of record sits a band of validation, policy enforcement, and human-in-the-loop gates. Irreversible or high-value actions — sending a payment, signing a document, emailing a tenant — pause for human confirmation. The agent proposes; a person approves.

Why Real Estate Is a Perfect Fit for Agentic Workflows

Real estate operations are full of multi-step, document-heavy, cross-system workflows that are too variable to hard-code but too repetitive to keep doing by hand. Consider tenant onboarding: parse the application, verify income documents, run a background check via a third-party API, generate the lease, route it for signature, and provision access. That is five systems and four document types — exactly the kind of workflow an orchestration layer collapses into a single supervised run.

Other high-value targets we see across European and US PropTech platforms:

Lease abstraction at portfolio scale — extract key terms, dates, and obligations from thousands of agreements and push structured data into the asset management system.
Maintenance triage and dispatch — classify an inbound request, check the SLA, find an available contractor, and schedule — with human approval on anything above a cost threshold.
Valuation and comps assembly — gather market data, retrieve comparable transactions, and draft a defensible valuation narrative for an analyst to review.
Tenant communication — draft grounded, policy-checked responses to inbound tenant queries, escalating anything sensitive to a human.

Build vs. Bolt-On: The Architecture Decision

The temptation is to keep adding LLM calls inside existing services. That works until you need two features to share context or coordinate — at which point the lack of a central orchestrator becomes a wall. Investing in the orchestration layer early means every new agent you add composes with the ones already there, rather than becoming another island.

The orchestration layer is also where your governance lives. Auditors and compliance teams do not want to hear "the AI decided." They want a trace: what triggered the run, what the agent proposed, what data it grounded on, who approved the action, and what changed. A control plane gives you that for free; scattered LLM calls never will.

Where to Start

You do not need to orchestrate everything on day one. Pick one workflow that is painful, repetitive, and cross-system — tenant onboarding and lease abstraction are common first wins — and build the orchestrator, one or two agents, typed tool contracts, and a human-approval gate around just that. Get the observability and evals in place from the first run. Once the pattern proves out, every additional agent is incremental.

VSBD designs and ships agentic orchestration layers for PropTech platforms across Europe and the USA — from the first supervised workflow to a full multi-agent control plane. If you are weighing whether to bolt on another LLM feature or build the layer properly, we can help you make that call.

Originally published on the VSBD blog.

Self-Improving AI Agents: Why Evolving Agentic Systems Win in Real Estate

Vladyslav Donchenko — Sun, 21 Jun 2026 21:54:21 +0000

What "Self-Improving AI Agents" Actually Means

"Self-improving AI agents" is one of the most over-used phrases in enterprise AI — and one of the least defined. Most teams using it mean nothing more than "we update our prompts sometimes." Real self-improvement is narrower and far more valuable: an agentic system that measurably gets better at a task over repeated runs, without a human rewriting it each time and without retraining the underlying model.

For real estate and PropTech operators, this is the difference between an AI pilot that plateaus after launch and a production system that compounds in value. An agent that abstracts leases at 82% accuracy on day one and stays there is a cost. One that climbs to 95% because it learns from its own mistakes is an asset.

The mechanism behind credible self-improvement is not magic, and it is not bigger models. It is a disciplined loop — and recent research on evolving "meta-skills" for multi-agent systems has made the pattern concrete enough to engineer.

Evolve the Orchestration, Not the Model Weights

There are two common ways to make an AI system "learn from experience," and both have a ceiling. Fine-tuning bakes experience into model weights, but it is expensive, slow to iterate, and hard to scale to frontier models. Pure inference-time agents use a frozen, capable model but repeat the same searches forever — they never retain what worked last time.

The more practical third path is to treat the high-level know-how of an agentic system as an explicit, evolvable asset — sometimes called a meta-skill. That know-how is the orchestration: how to decompose a task (the what), which specialized agents to deploy (the who), and how to wire them together (the how). You improve that — in plain text and structured rules — instead of touching the weights. It is cheaper, auditable, and transfers across tasks and even across different models.

The Loop: Rollout, Reflection, and Reusable Principles

A self-improving agentic system runs a closed optimization loop. Each cycle makes the orchestration a little sharper:

Multi-trajectory rollout → Score & select hard cases → Contrastive reflection → Distill into the meta-skill → ↻ next round starts from the improved orchestration

1. Multi-trajectory rollout. For each task, the system attempts it several ways under the current orchestration, producing a spread of outcomes rather than a single answer. That spread is the raw signal — it shows where the strategy is reliable and where it is fragile.

2. Score and select. Not every task is worth learning from. The system measures per-task uncertainty and difficulty, then focuses its effort on the high-leverage cases — the ones where behaviour is inconsistent or failure is common.

3. Contrastive reflection. This is the heart of it: compare the high-scoring trajectories against the low-scoring ones for the same task. What did the wins do that the failures did not? That contrast surfaces concrete success factors, failure modes, and root causes instead of vague "do better" feedback.

4. Distill into reusable principles. The lessons are generalized into strategy-level rules and folded back into the orchestration — a sharper task decomposition, a new validation agent, a backtracking rule, a re-execution authority. Crucially, these are reusable: a principle learned on one workflow often lifts performance on unseen ones.

Why Real Estate Is Where This Pays Off

Real estate operations are full of high-volume, high-variability, document-heavy workflows — exactly the conditions where a static agent underperforms and a self-improving one shines. The system meets enough edge cases to actually learn, and the cost of each small accuracy gain is real money saved.

Lease abstraction at portfolio scale. Every unusual clause the system gets wrong becomes a contrastive example that hardens extraction for the next thousand agreements.
Maintenance triage and dispatch. The orchestration learns which request patterns it misroutes and adds the routing rules that fix them.
Valuation and comps assembly. Reflection on which valuations analysts accepted versus revised teaches the system what a defensible narrative looks like.
Tenant communication. The set of replies that got escalated by a human becomes the training signal for better grounding and safer auto-responses.

How to Make Self-Improvement Safe — Not a Liability

An agent that rewrites its own behaviour is also an agent that can regress. The discipline that makes this production-grade is the same discipline that makes any agentic system trustworthy:

Evaluations as the gate. Every evolved version of the orchestration is scored against a held-out benchmark before it ships. No automatic improvement reaches production without beating the version it replaces. This is the single most important control.

Observability and replay. Per-step tracing and replayable runs mean you can see exactly why a version changed its behaviour — and roll back instantly if a "smarter" orchestration quietly broke an edge case.

Versioning and rollback. Treat the meta-skill like code: every round is a versioned artifact with a diff and an owner. Improvement you cannot reverse is a risk, not a feature.

Human-in-the-loop on irreversible actions. Self-improvement optimizes the strategy; it never removes the approval gate on sending a payment, signing a document, or emailing a tenant. The agent proposes; a person approves.

Common Pitfalls

"Self-improving" that is really just prompt tweaking. If a human edits the prompt after every failure, that is maintenance, not a learning loop.
Optimizing without a benchmark. Change with no held-out evaluation is drift. You will feel productive and ship regressions.
Learning from the wrong tasks. Spending compute reflecting on cases the system already nails wastes the loop. Prioritize uncertainty and difficulty.
No rollback path. If you cannot revert to last week's orchestration in minutes, you do not have a safe improvement system.

Where to Start

You do not need a full self-optimizing platform on day one. Pick one painful, repetitive workflow — lease abstraction and maintenance triage are common first wins — stand up the orchestration, and instrument it with evaluations and replayable traces from the very first run. Once you can measure quality reliably, adding the rollout-and-reflection loop on top is incremental. Without that measurement foundation, "self-improving" is just a word.

VSBD designs and ships agentic AI systems for PropTech platforms across Europe and the USA — including the evaluation, observability, and orchestration foundations that make self-improvement safe rather than risky. It is the work behind our PropTech 2026 Awards nomination for agentic AI orchestration.

This article was first published on the VSBD blog.