Koca Ventures Ltd
71-75 Shelton Street
Covent Garden, London
WC2H 9JQ, United Kingdom
Registered in England & Wales — 16231043
INTERNAL TOOLS & CUSTOM SOFTWARE
Internal tools your team actually lives in —real software, fully owned.
AI builders get you about 70% of the way to a working app like magic. The last 30% — complex business logic, legacy integrations, auth and validation that hold at scale, performance, on-prem — is the hard part, and it's where they stall. We build that 30%, with the code and the infrastructure owned by you, plus an optional agentic layer that does the busywork while a human stays in control.
▶Walkthrough — an ops dashboard with an agent draft → review → approve panel (coming soon)
WHAT WE BUILD
The software your operations run on
01
Ops Dashboards & Admin Panels
The control surface your team runs the business from — real-time status, role-based views, the polish of a product instead of a generic admin skin. One place that connects enquiries, scheduling, approvals, and reporting, not another disconnected single-problem app.
02
Brokerage-Style CRMs
Leads, deals, viewings, and commissions in a Kanban pipeline with multi-agent permissions — the kind of operations CRM we've shipped and run. Designed around your real workflow and the rules that are specific to your business, not a CRUD form generator.
03
B2B Dealer & Partner Portals
Self-serve portals where dealers, partners, and field teams place orders, check stock, and track status — wired into your existing ERP, billing, and inventory systems through real integrations, including legacy systems without clean connectors.
04
Approval, Billing & Cross-System Workflows
The workflow logic that ties siloed tools together: approval chains, billing runs, reconciliation, and reporting — with an audit trail. Consolidation, not more apps, so leadership gets a clear view of where work actually sits.
THE AGENT LAYER (OPTIONAL)
Agents draft, humans decide
A plain internal tool is a window: a person reads dashboards, copies between systems, decides, and clicks. Add an agentic layer and the tool becomes an operator with a supervisor seat — the agent does the reading and correlating, the dashboard stays the place where a human approves. Every action follows the same path: agent prepares the work with a full audit trail → a person reviews the context and reasoning → the person authorizes → the agent executes, logged.
01
Draft
The agent reads and reasons across long documents and records, then drafts the output — a memo, a reply, a structured summary — inside the tool. A person reviews the draft and the reasoning, then signs off. It removes the bottleneck of reading and correlating, not the decision.
02
Triage
Incoming work gets classified and routed: the high-volume, low-risk 80% is handled in place, and the hard 20% is sent to a human with the synthesis already drafted. The dashboard stays the locus of approval — the agent just arrives with the homework done.
03
Reconcile
When two systems disagree — billing vs finance, invoice vs PO, inventory vs orders — the agent compares the records, flags the mismatches, investigates the context, and escalates only what crosses a threshold. Everything it touches is logged for audit.
04
Monitor & Escalate
The agent watches for conditions and, when one fires, prepares the escalation with full context and hands it to a person cleanly. The quality marker isn't that agents never fail — it's that they fail gracefully, routing to a human with the whole picture instead of dumping a half-finished task.
VS LOW-CODE / AI BUILDERS
Where a custom build earns its keep
01
Ownership, not lock-in
Your code, your repo, your infrastructure. No non-exportable JSON holding your app hostage, no managed database you can't migrate off, no per-seat tax that scales from a rounding error to tens of thousands a year as the team grows. You can run and extend it without us.
02
Complex logic & legacy integrations
Multi-step rules that don't fit a single low-code component or one prompt, and deep integrations with ERPs, billing, and internal APIs that have no clean connectors — exactly where drag-drop canvases and rigid node structures go stiff.
03
Performance & on-prem
Sub-second where it matters, not seconds-to-minutes workflow latency. And real on-premise, offline-capable deployment with your own keys — not a hosted-only platform that assumes your data can always leave the building.
04
Real agents, done right
A properly engineered agentic layer — human-in-the-loop, audit trails, RBAC, guardrails, and evals — instead of a chatbot bolted onto an admin panel. This is the part the builders can't reach.
To be fair: low-code and AI builders are excellent for prototypes, MVPs, and simple CRUD — and we'll tell you when that's the right call rather than sell you a custom build you don't need. A respected 2026 pattern is even hybrid: an auditable low-code backbone for moving data, with a code-based reasoning layer over the top. We build the part those tools can't — the hard 30%, and the agents.
BUILT AND RUN BY US
Real shipped capability, not slideware
01
An operations CRM for a property brokerage
A full brokerage CRM — leads, deals, viewings, and commissions in a Kanban pipeline with multi-agent permissions — built around the firm's real workflow and run on its own hardware. The same system carries a local-first document-intelligence layer that answers questions over the firm's documents with citations, with nothing leaving the building unless explicitly enabled. (Customer redacted by design.)
02
A B2B dealer portal and admin systems
A B2B dealer/partner portal and the admin systems behind it, integrated with existing inventory and billing — self-serve ordering and status for partners, real-time operational visibility for leadership. Production internal software behind the same engineering bar we bring to every client. (Customer redacted by design.)
🖼System diagram — internal tool, data layer, and agentic layer (coming soon)
Also under custom software: SaaS product builds and transaction & ledger systems. The same engineering team builds the agent loop, the data layer, and the interface as one system you keep.
QUESTIONS
Straight answers
Can't we just use Retool, Lovable, or n8n?
Often, yes — and we'll tell you when that's the right call. Low-code builders (Retool, Appsmith, Budibase, Windmill, n8n) and AI app builders (Lovable, v0, Bolt) are genuinely great for prototypes, MVPs, and simple CRUD. They get you about 70% of the way to production like magic. We build the remaining 30%: complex business logic that doesn't fit one component or one prompt, deep integrations with legacy systems, performance where it matters, real on-prem deployment, and a properly engineered agentic layer. That 30% is where those tools stall.
Will the agent act without us approving it?
No — human-in-the-loop is the default, not an add-on. The pattern is consistent: the agent prepares the action with a full audit trail, a person reviews the context and the reasoning, the person authorizes, and only then does the agent execute, with the human attribution logged. We auto-handle the routine, low-risk volume and require explicit approval for anything irreversible, regulated, or material. Autonomy is a privilege you grant per action, not a feature switched on globally.
Do we own the code?
Yes. Your repo, your infrastructure, your data. There's no non-exportable JSON locking your app definition inside a vendor (the Retool problem), no managed database you can't leave (the Lovable/Bolt Supabase problem), and no per-seat tax that quietly scales into tens of thousands a year as your team grows. We hand over a system your own engineers can run and extend. Discretion is part of the deal — we don't put your name on our website either.
Can it run on-prem, on our own servers?
Yes. On-premise and offline-capable deployment is a first-class option, not a fallback — self-hosted inference, local data stores, role-based access, and audit logs, with sensitive data staying inside your network. This isn't aspirational: it maps directly onto on-prem document-intelligence systems we've already built and run, where the documents never leave the building unless explicitly enabled.
What does it cost?
Per engagement, after we understand the workflow — there's no per-seat list price. A typical path is a short, paid discovery that scopes one real workflow and leaves you owning the spec (a transferable asset — you can take it to another shop for a competing quote), then a fixed-scope or sprint-based build, then an optional monthly maintenance-and-iteration retainer. The agentic layer is priced as an explicit add-on phase, because it carries real extra work: prompt and retriever iteration, eval suites, guardrails, audit logging, and the approval UI. Tell us the pain point and we'll scope it honestly.
What if the agent makes a mistake?
We design for it. Agents can fail in ways rule-based software can't — runaway loops, misread policy, hallucinated references — so we ground them in a verified knowledge base, require explicit approval for high-risk actions, and build audit logs, decision logs, and RBAC into the orchestration. On the consequential paths a person stays in the loop, and every escalation arrives with full context. The honest answer is that fully autonomous is rarely what you want; the value is an agent that handles the routine and routes the hard cases to a person, pre-drafted.
Last reviewed:
READY TO TALK?
Start with one workflow that hurts
Not a generic software pitch — share one process your team fights with: a manual reconciliation, an approval chain that lives in email, a dealer portal you've outgrown. We'll scope a small, owned build around your real data before any larger commitment.