Kajima’s decision to move core application development in‑house — building what the company calls Kajima ChatAI and shifting systems that use critical internal data away from traditional vendor-led projects — marks a clear pivot from procurement-driven IT toward platform‑led, data‑centric engineering that aims to protect competitive advantage while accelerating delivery.
Kajima, a long‑established Japanese construction and civil‑engineering group with roots stretching back to 1840, has publicly signaled in its 2024–26 medium‑term business plan an ambition to become a more technology‑driven company and to create new value together with society and customers. The organization’s IT leadership reports that the need to exploit sensitive, high‑value internal data (project histories, engineering models, operational telemetry) and to respond faster to market change pushed the company to re‑examine a long‑standing outsourcing model and to build internal development capabilities instead.
Shifts like Kajima’s echo a broader enterprise trend: companies that hold unique, mission‑critical data increasingly perceive in‑house development and domain‑tuned AI agents as the safest and most strategic way to capture value from that data while maintaining governance, IP control, and responsiveness. Microsoft’s portfolio — including low‑code agent tools, model hosting and routing, and code modernization agents — has been positioned by customers and analysts as the kind of platform stack organizations use when they want to “bring AI and agentic workflows in‑house” rather than rely on repeated third‑party custom projects.
That potential comes with an equal measure of responsibility: strong governance, careful rollout, and an operational commitment to model and data lifecycle management are prerequisites for turning initial productivity gains into durable business advantage. Microsoft’s ecosystem provides many of the building blocks — low‑code agent tooling, multi‑model runtimes, code modernization agents and security controls — and real customer deployments show practical paths forward. However, the technical and organizational discipline to run these systems responsibly is what ultimately decides whether an internal program like Kajima’s becomes a sustainable center of innovation or a brittle, high‑risk experiment. fileciteturn1file17turn1file4turn1file8
Source: Microsoft Kajima uses Microsoft Unified CodeWith to embark on the path to in-house development | Microsoft Customer Stories
Kajima, a long‑established Japanese construction and civil‑engineering group with roots stretching back to 1840, has publicly signaled in its 2024–26 medium‑term business plan an ambition to become a more technology‑driven company and to create new value together with society and customers. The organization’s IT leadership reports that the need to exploit sensitive, high‑value internal data (project histories, engineering models, operational telemetry) and to respond faster to market change pushed the company to re‑examine a long‑standing outsourcing model and to build internal development capabilities instead.Shifts like Kajima’s echo a broader enterprise trend: companies that hold unique, mission‑critical data increasingly perceive in‑house development and domain‑tuned AI agents as the safest and most strategic way to capture value from that data while maintaining governance, IP control, and responsiveness. Microsoft’s portfolio — including low‑code agent tools, model hosting and routing, and code modernization agents — has been positioned by customers and analysts as the kind of platform stack organizations use when they want to “bring AI and agentic workflows in‑house” rather than rely on repeated third‑party custom projects.
Overview: What Kajima announced and why it matters
Kajima’s summary decision has three tightly linked goals:- Use internal, sensitive data directly in app logic to create differentiated services and preserve IP.
- Shorten development cycles and increase iteration speed compared with vendor‑managed, waterfall engagements.
- Build an internal capability to design, tune and operate conversational/agentic AI (Kajima ChatAI) and other systems that require domain expertise and rapid change.
Why in‑house matters for Kajima’s sector
Construction and infrastructure firms possess decades of project documentation, design standards, regulatory histories, and site telemetry — datasets that are:- Highly sensitive (commercial & safety implications).
- Combinatorially valuable (patterns across projects generate new insights).
- Frequently changing (standards, contracts, materials).
Technical baseline: plausible architecture and Microsoft tooling alignment
The Microsoft ecosystem that customers use to build internal, data‑grounded assistants and developer platforms includes several consistent elements. Kajima’s published intent (build conversational Kajima ChatAI and move to in‑house systems) strongly suggests a stack that follows these design patterns:- Retrieval‑augmented generation (RAG) pattern: index documents, compute embeddings, run vector and keyword search, then ground LLM responses on retrieved evidence. This pattern is standard in enterprise assistants and is widely used in Azure architectures.
- Multi‑model hosting and routing: host or route queries across different model families for cost, capability and latency tradeoffs. Azure AI Foundry (multi‑model runtime) and model orchestration tooling let teams pick the best model per task. Enterprises often combine first‑party Microsoft models with partner or open models for specialized reasoning.
- Low‑code agent construction and governance: Copilot Studio provides a low‑code authoring layer to build agent flows, apply prompts, and attach connectors to enterprise systems while providing governance controls (DLP, identity). For organizations that want business teams to prototype agents quickly while IT retains control, this is the typical path.
- Developer acceleration and in‑house code modernization: GitHub Copilot’s app‑modernization features and Microsoft’s agentic tooling reduce the calendar time for creating maintainable code, scaffolding IaC and generating testable branches — important for organizations shifting to internal engineering at scale.
Strengths and immediate opportunities
- Faster iteration and domain fit: In‑house teams can iterate on system prompts, grounding strategies and user intents much faster than vendor engagement cycles typically allow. This improves accuracy and adoption for specialized workflows.
- Better IP and data control: Keeping model inputs and fine‑tuning materials inside the corporate cloud and tenancy reduces third‑party exposure and supports stricter legal/compliance treatment of sensitive project data.
- Integration with operational systems: Embedding agents directly into scheduling, procurement, and BIM workflows allows Kajima to automate cross‑system actions (e.g., generate a compliant inspection checklist, create procurement RFQs from defect reports) rather than only returning conversational answers.
- Building a reuseable platform: A disciplined in‑house platform (data ingestion, vector store, agent templates, developer golden paths) lets multiple business units build verticalized assistants and apps without starting from zero each time. Several Microsoft customers report creating internal “AI academies” and templates to scale builder skills and share patterns.
- Developer productivity gains: Using GitHub Copilot and modernization agents as part of the internal engineering workflow can dramatically reduce scaffolding and refactoring time, especially when teams adopt modern CI/CD and IaC patterns.
Risks, gaps, and governance considerations
Moving sensitive, decision‑influencing systems in‑house and exposing them as conversational agents carries real operational and legal risks. The most salient items are:- Data leakage and provenance: Conversational AI that synthesizes answers from indexed content needs strict provenance tracking and conservative summarization policies. Without audit trails, the organization risks relying on hallucinated or insufficiently evidenced outputs. Enterprises must log source documents, retrieval hits and the exact prompts used to produce an answer.
- Model hallucinations and safety: Even grounded RAG flows can generate incorrect or overconfident outputs. For engineering or safety‑critical responses (construction safety, structural interpretation), the assistant must force human sign‑off or fall back to a non‑generated answer. Architectural guardrails and red‑team testing are essential.
- Compliance and data residency: Construction contracts and governmental permits often impose data residency and retention constraints. The hosting environment, backup policies and legal agreements must align with local regulations and client obligations.
- Operational ownership and productization: Building an assistant is not “one‑and‑done.” It requires product management, SRE/ops, lifecycle updates to models and data, monitoring for drift, and ongoing security reviews. Many organizations underestimate the operational cost and governance required to run agentic systems at scale.
- Skills and cultural change: Transitioning from vendor delivery to internal engineering requires upskilling: prompt engineering, data engineering for vector stores, responsible‑AI expertise, and DevOps for models. Without a deliberate training and governance program (Kajima’s internal AI Academy model from other enterprises is a useful playbook), projects can stall.
- Vendor and platform lock‑in: Using a single cloud or vendor’s end‑to‑end tooling can accelerate delivery but also concentrate dependencies (runtime models, managed services, agent frameworks). A multi‑model/portable design and clear exit plans mitigate this risk.
Practical checklist: safe steps for in‑house AI and platform build‑out
- Data inventory and classification
- Catalog datasets to be used (contracts, BIM, calendars, telemetry).
- Classify sensitivity and contractual constraints.
- Grounding and retrieval design
- Build an indexed store that preserves document metadata and provenance.
- Use hybrid retrieval (BM25 + vector) and validate hit precision before exposing results to users.
- Governance and DLP
- Apply DLP policies at ingestion and agent runtime.
- Implement identity, RBAC and agent‑scoped credentials for each connector.
- Human‑in‑the‑loop and escalation paths
- Require human approval for safety‑critical outputs.
- Log all interactions, retrievals and prompt contexts for audit.
- Testing and red‑teaming
- Conduct adversarial prompt testing and scenario walkthroughs.
- Measure hallucination rates for representative queries.
- Observability and measurement
- Instrument retrieval success, human override rates, user satisfaction and safety incidents.
- Tie expansion decisions to measurable thresholds.
- Developer platform and golden paths
- Provide templates, CI/CD pipelines and IaC to reduce duplication.
- Use Copilot/automation for scaffolding but apply strict code review gates. fileciteturn1file4turn1file17
Real‑world precedents and validation
Several enterprise customer stories and independent reporting describe very similar adoption paths across sectors:- Financial and healthcare firms have used retrieval‑augmented assistants and Azure model routing to unlock decades of institutional content and reduce search times from hours to seconds while keeping models and hosting within their tenants. These deployments rely on Azure AI Search, Databricks for ETL, and Foundry/hosting for model routing. Those cases illustrate the practical RAG pattern Kajima will likely use. fileciteturn1file2turn1file14
- Public‑sector and large engineering customers are building agentic workflows and production platform engineering stacks (open SDKs, agent runtimes and orchestration) to manage agent fleets with observability and governance; Microsoft’s Agent Framework and Foundry tooling are commonly referenced as the backbone for these initiatives. Treat these tools as previews in some cases and validate suitability for production. fileciteturn1file8turn1file3
- Construction and infrastructure examples show practical value of internal copilots: firms are embedding Copilot agents into inspection, document drafting and on‑site support workflows to accelerate decision cycles and reduce rework — but they pair these rollouts with strong HR + IT operating models and staged expansion. These precedents provide a blueprint Kajima can adapt for its industry context. fileciteturn1file18turn1file15
Strategic recommendations for Kajima and firms following the same path
- Define a product roadmap, not a project: Treat ChatAI and related apps as products with roadmaps, user cohorts, KPIs and lifecycle budgets. This prevents underinvestment after the initial build.
- Start with high‑value, low‑risk pilots: Focus on internal knowledge retrieval, templated document drafting, and productivity assistants before moving to automated decision agents for field safety or contract negotiation.
- Invest in governance early: DLP, identity, auditing, and model provenance should be baked into the platform from day one, not bolted on later.
- Hybrid model strategy: Use multi‑model routing — cheaper, faster models for routine tasks and higher‑capability models for complex reasoning — to control costs and resilience. Azure Foundry and similar platforms explicitly support this pattern.
- Build a “model ops” practice: version models, monitor behavior, regularly run evaluation suites, and maintain rollback and incident plans.
- Measure impact in business terms: Track time saved, error reduction, rework decreases, and user engagement to justify ongoing investment and to prioritize new agent workstreams.
Cautions and unverifiable items to confirm
- Branding and product names: some public summaries use proprietary or campaign‑level terms that can be ambiguous (for example, terminology like “Unified CodeWith” in secondary reporting can be a shorthand or misnomer). Confirm exact product/service names and contractual terms before procurement or partner engagements.
- Preview vs production: several Microsoft offerings (agent frameworks, some Copilot modernization flows, and specific Foundry features) have historically entered customer environments in preview phases. Enterprises must verify GA status and commercial SLAs before depending on a preview feature for mission‑critical workflows. fileciteturn1file4turn1file8
- Claimed performance metrics: vendor case studies often report headline improvements; those figures should be validated against your own baseline metrics and pilot tests. Treat vendor claims as directional until reproduced in‑house.
Conclusion
Kajima’s move to in‑house development and the creation of Kajima ChatAI is a pragmatic response to a common enterprise dilemma: how to harness unique internal data quickly, securely and with competitive effect. Building agents and developer platforms internally gives firms complete control over provenance, integration and IP — and it shortens the loop between idea and production.That potential comes with an equal measure of responsibility: strong governance, careful rollout, and an operational commitment to model and data lifecycle management are prerequisites for turning initial productivity gains into durable business advantage. Microsoft’s ecosystem provides many of the building blocks — low‑code agent tooling, multi‑model runtimes, code modernization agents and security controls — and real customer deployments show practical paths forward. However, the technical and organizational discipline to run these systems responsibly is what ultimately decides whether an internal program like Kajima’s becomes a sustainable center of innovation or a brittle, high‑risk experiment. fileciteturn1file17turn1file4turn1file8
Source: Microsoft Kajima uses Microsoft Unified CodeWith to embark on the path to in-house development | Microsoft Customer Stories