WEBVTT

00:00:00.000 --> 00:00:03.560
여러분의 AI 플로우가 실패한 이유는 AI 때문이 아니라 여러분을 믿었기 때문입니다.

00:00:03.680 --> 00:00:05.340
아무도 듣고 싶어하지 않는 이야기죠.

00:00:05.500 --> 00:00:08.040
여러분은 자동화 시스템을 구축하고는 스마트하다고 불렀지만

00:00:08.040 --> 00:00:11.220
정작 금요일 오후에 누군가 대충 작성한 엉성한 데이터를 입력했습니다.

00:00:11.480 --> 00:00:13.360
자동화는 곧 신뢰성이라고 가정했겠지만

00:00:13.360 --> 00:00:18.520
사실 자동화는 여러분의 실수를 그 어떤 인턴보다 더 빠르고 자신있게 증폭시킬 뿐입니다.

00:00:18.720 --> 00:00:20.660
비즈니스 언어로 다시 말씀드리죠.

00:00:20.840 --> 00:00:24.360
여러분의 코파일러 스튜디오 플로우가 무너진 건 마이크로소프트의 잘못이 아닙니다.

00:00:24.540 --> 00:00:27.700
잘못된 입력 데이터를 절대적인 진실처럼 처리했기 때문에 무너진 것입니다.

00:00:27.700 --> 00:00:29.900
필드 하나가 빠지고 이메일 하나가 잘못 입력되는 순간

00:00:29.900 --> 00:00:32.540
여러분의 데이터버스는 어린아이가 정리한 것처럼 엉망이 됩니다.

00:00:32.740 --> 00:00:33.880
AI는 잘못이 없습니다.

00:00:34.180 --> 00:00:36.640
AI는 여러분이 시킨 일을 그대로 완벽하게 잘못 처리했을 뿐입니다.

00:00:36.800 --> 00:00:37.920
그렇다면 무엇이 문제일까요?

00:00:38.220 --> 00:00:38.860
거버넌스입니다.

00:00:39.100 --> 00:00:40.400
진정한 검증이 필요합니다.

00:00:40.580 --> 00:00:44.920
보시 앞서 나가기 전에 사람이 자동화를 잠시 멈추고 현실을 확인하는 순간이 필요합니다.

00:00:45.140 --> 00:00:48.260
거기에 정보요청, RFI, 액션이 개입하게 됩니다.

00:00:48.520 --> 00:00:50.300
이를 인간 방화벽이라고 생각하세요.

00:00:50.600 --> 00:00:53.340
쓰레기 같은 데이터가 자동화를 망치지 못하게 막아줍니다.

00:00:53.340 --> 00:00:57.520
데이터를 격리하고 사람의 검토를 강제한 뒤에야 플로우를 계속 진행하게 합니다.

00:00:57.700 --> 00:01:02.100
이 영상이 끝날 때 쯤이면 데이터 부릴지, 널루프, 엉뚱한 AI 액션이 왜 계속 발생하는지,

00:01:02.380 --> 00:01:05.560
그리고 작은 규정 준수 메커니즘 하나가 어떻게 이 세 가지를 해결하는지 알게 될 것입니다.

00:01:05.740 --> 00:01:10.560
스포일러를 드리자면, 문제는 플로우가 너무 자동화된 것이 아니라 거버넌스가 부족하다는 것입니다.

00:01:10.780 --> 00:01:12.720
AI 자동화에 불편한 진실입니다.

00:01:12.960 --> 00:01:14.560
AI는 정밀함을 좋아합니다.

00:01:14.840 --> 00:01:16.260
사용자는 혼돈을 좋아하죠.

00:01:16.460 --> 00:01:19.280
그것이 기업 자동화에서 거버넌스의 거대한 사각지대입니다.

00:01:19.280 --> 00:01:23.940
모든 코파일러 스튜디오 애호가 들은 AI가 처리하기 때문에 자신의 플로우가 완벽하다고 믿습니다.

00:01:24.140 --> 00:01:27.600
하지만 진실은, AI는 여러분이 주는 것이 좋든 나쁘든 판단 없이 모두 처리한다는 것입니다.

00:01:27.760 --> 00:01:29.740
AI는 지능적인 것이 아니라 순종적인 것입니다.

00:01:29.900 --> 00:01:33.540
AI는 이 방문자가 연구소 출입 보안 허가를 받았는지 확실합니까? 라고 묻지 않습니다.

00:01:33.780 --> 00:01:38.100
그저 회의를 예약하고 기록을 업데이트하며, 법무팀이 알아차리지 않기만을 바랄 뿐입니다.

00:01:38.280 --> 00:01:41.120
시설 출입 요청을 관리하기 위해 만든 플로우를 상상해보세요.

00:01:41.420 --> 00:01:44.860
직원이나 외부 방문자의 양식 응답을 받아 데이터버스 테이블에 추가합니다.

00:01:45.020 --> 00:01:47.080
머릿속으로는 깔끔하게 처리된다고 생각하겠죠.

00:01:47.240 --> 00:01:50.040
하지만 현실에서는 누군가 방문 목적 필드를 비워두거나 회의라고만 적습니다.

00:01:50.040 --> 00:01:52.340
그건 방문 목적이 아니라 그냥 대충 넘기는 것에 불과합니다.

00:01:52.480 --> 00:01:55.460
그런데 여러분의 자동화는 이를 유효한 데이터로 읽고 보안팀에 기꺼이 전달합니다.

00:01:55.580 --> 00:01:56.160
축하합니다.

00:01:56.400 --> 00:02:00.480
신원 미상의 인물이 회의를 목적으로 제한구역에 들어가는 것을 승인해버린 셈입니다.

00:02:00.680 --> 00:02:05.500
감사팀이 이를 검토하면 여러분의 플로우를 기술적 경이로움이 아닌 규정 준수 위험 요소로 낙인 찍을 것입니다.

00:02:05.660 --> 00:02:08.480
대부분의 AI 기반 워크플로우가 실패하는 방식이 바로 이렇습니다.

00:02:08.680 --> 00:02:11.600
로직 오류 때문이 아니라 사람의 입력 값을 맹목적으로 신뢰하기 때문입니다.

00:02:11.780 --> 00:02:14.080
자동화는 구조가 없는 곳에서도 구조가 있다고 가정합니다.

00:02:14.080 --> 00:02:16.140
사실이 아닌 진술을 그대로 받아들입니다.

00:02:16.300 --> 00:02:19.000
검증하도록 지시하지 않았기 때문에 유효성을 확인하지 않습니다.

00:02:19.180 --> 00:02:25.580
그렇게 결함 있는 데이터가 데이터버스, 파워비아이 대시 보드 또는 인사 시스템으로 전파되면 이후에 모든 기록을 오염시킵니다.

00:02:25.740 --> 00:02:28.700
편의를 위해 시작된 일이 시스템적인 부패로 변질됩니다.

00:02:28.920 --> 00:02:31.700
거버넌스팀은 이를 데이터 신뢰성 격차라고 부릅니다.

00:02:31.960 --> 00:02:35.380
모든 자동화된 결정은 검증된 입력 데이터에서 추적 가능해야 합니다.

00:02:35.600 --> 00:02:39.180
그러한 확인 절차가 없다면 자동화가 아니라 실수를 가속화하는 것뿐입니다.

00:02:39.180 --> 00:02:45.600
아이러니하게도 사람들은 인간의 개입을 줄이려 흐름을 설계하지만 더 현명한 방법은 올바른 지점에 전략적으로 다시 개입을 추가하는 것입니다.

00:02:45.760 --> 00:02:49.160
그래서 마이크로소프트는 마침내 여러분의 흐름이 쉽게 속지 않도록 만들기로 했습니다.

00:02:49.380 --> 00:02:54.100
정보유청, RFI, 작업은 순진한 시스템에 온 전성검사를 도입하는 그들의 방식입니다.

00:02:54.260 --> 00:02:58.300
흐름 중간에 실행을 멈추고 잠깐, 계속하기 전에 사람이 확인해야 합니다.

00:02:58.480 --> 00:02:59.400
라고 말하는 것이죠.

00:02:59.600 --> 00:03:03.580
그 기다림의 순간은 비효율성이 아니라 거버넌스 원칙이 실행되는 과정입니다.

00:03:03.580 --> 00:03:09.240
그렇게 생각하면 검증 없는 자동화는 발전이 아니라 화려한 사용자 인터페이스를 덧입힌 정책 위반입니다.

00:03:09.400 --> 00:03:15.720
검증되지 않은 모든 필드, 비어있는 드롭타운, 진실로 간주되는 모든 텍스트 상자는 규정 준수 위반의 소지가 있습니다.

00:03:16.000 --> 00:03:21.320
RFI 기능은 아울록 양식을 하나씩 처리하며 혼란을 다시 질서로 바꾸기 위해 존재합니다.

00:03:21.560 --> 00:03:26.760
잘못된 흐름 하나가 데이터 레이크를 오염시키는 것을 보고 나면 그 순간의 중요성을 알게 될 것입니다.

00:03:26.980 --> 00:03:30.240
대안은 더 빠른 자동화가 아니라 더 빠른 재앙이기 때문입니다.

00:03:30.240 --> 00:03:33.360
RFI, 즉 루프 속의 인간을 도입하십시오.

00:03:33.480 --> 00:03:37.960
정보 요청, RFI 작업은 자동화가 겸손을 배우는 순간입니다.

00:03:38.160 --> 00:03:43.600
이는 코파일럿 스튜디오가 디지털 손을 들고 잠깐, 다 망치기 전에 사람이 필요해 라고 말하는 것과 같습니다.

00:03:43.940 --> 00:03:45.840
네, 그게 바로 이 작업이 하는 일입니다.

00:03:46.020 --> 00:03:48.680
단순한 양식 채우기나 거창한 프롬프트가 아닙니다.

00:03:48.860 --> 00:03:53.580
이는 깨끗하고 검증된 데이터와 완전한 혼돈 사이를 지켜내는 컴플라이언스 수준의 검문소입니다.

00:03:53.800 --> 00:03:55.280
이 기능의 실체는 다음과 같습니다.

00:03:55.280 --> 00:04:02.100
RFI 작업은 에이전트 흐름 내부에 위치하여 누군가, 즉 실제 사람이 아울룩 실행 가능 메시지에 응답할 때까지 진행을 멈춥니다.

00:04:02.260 --> 00:04:04.480
그 메시지는 단순한 수동 알림이 아닙니다.

00:04:04.680 --> 00:04:11.060
이는 아울룩 내부에 포함된 미니 양식으로 흐름이 계속되기 전 수신자가 반드시 작성해야 하는 필수 필드로 구성되어 있습니다.

00:04:11.360 --> 00:04:16.720
답변을 고민하는 동안 여러분의 자동화는 지시를 기다리는 잘 훈련된 집사처럼 흐름 중간에 멈춰 있습니다.

00:04:17.060 --> 00:04:22.240
모든 필드가 채워지고 필요한 값이 제공되며 체크박스가 모두 선택되어야만 흐름이 다시 이어집니다.

00:04:22.240 --> 00:04:25.180
이를 워크플로우를 위한 조건부 액세스라고 생각하십시오.

00:04:25.280 --> 00:04:31.120
검증되지 않은 장치를 기업 네트워크에 연결하지 않듯, 검증되지 않은 데이터가 데이터버스 테이블에 들어오게 해서는 안됩니다.

00:04:31.320 --> 00:04:33.800
RFI는 바로 그러한 제동 장치를 강제합니다.

00:04:34.000 --> 00:04:36.580
정책과 현실이 일치할 때까지 실행은 일시 중지됩니다.

00:04:36.760 --> 00:04:38.220
여기 아주 영리한 반전이 있습니다.

00:04:38.500 --> 00:04:39.860
바로 동기식이라는 점입니다.

00:04:40.100 --> 00:04:42.220
즉, 흐름이 진실을 기다린다는 뜻입니다.

00:04:42.460 --> 00:04:47.780
추측하거나 추론하지 않고, 이 데이터는 이상 없음, 이라는 확답이 올 때까지 대기합니다.

00:04:48.120 --> 00:04:51.520
이제 AI 프롬프트가이 작업을 이미 처리한다고 생각하기 쉽습니다.

00:04:51.520 --> 00:04:53.880
결국 프롬프트는 지능적으로 들리니까요.

00:04:53.980 --> 00:04:57.180
세부 정보를 확인하고, 내용을 요약하며 누락된 필드를 강제하기도 합니다.

00:04:57.340 --> 00:04:58.860
하지만 프롬프트는 해석만 할 뿐입니다.

00:04:59.060 --> 00:05:00.560
정보가 그럴듯하다고 판단하는 것이죠.

00:05:00.740 --> 00:05:01.760
그들에게는 권한이 없습니다.

00:05:02.040 --> 00:05:03.640
RFI, 정보 요청,는 확정합니다.

00:05:03.820 --> 00:05:06.360
괜찮아 보이는 것들, 공식적으로 검증된 것으로 바꿉니다.

00:05:06.520 --> 00:05:09.980
프롬프트가 이해를 근사치로 구한다면, RFI는 규정 준수를 강제합니다.

00:05:10.160 --> 00:05:13.140
결합하면 하나는 논리를, 다른 하나는 책임을 확인하게 됩니다.

00:05:13.420 --> 00:05:14.780
실제 사례를 하나 들어보겠습니다.

00:05:15.180 --> 00:05:16.900
방문자 출입 요청을 처리하는 시설 흐름은,

00:05:16.900 --> 00:05:20.380
마이크로소프트 폼즈 위 입력을 검증하기 위해 AI 프롬프트를 사용했습니다.

00:05:20.560 --> 00:05:25.920
방문자가 실험실에 출입하려 할 때, AI는 안전정보, 작업 유형, 인가, 보호장비 등을 확인했습니다.

00:05:26.180 --> 00:05:29.120
사용자가 해당 섹션을 건너뛰면 프롬프트가 미완성으로 표시했습니다.

00:05:29.400 --> 00:05:30.940
이제 RFI가 등장합니다.

00:05:31.180 --> 00:05:33.700
흐름은 자동으로 제출자에게 메시지를 생성했습니다.

00:05:33.980 --> 00:05:36.860
출입 승인 전에 안전 관련 세부 정보를 제공해 주십시오.

00:05:36.860 --> 00:05:41.660
수신자는 아웃룩에서 실행 가능한 메시지를 열고, 필요한 정보를 입력한 뒤, 제출 버튼을 눌렀습니다.

00:05:41.860 --> 00:05:44.500
그제야 에이전트 흐름이 진행되어 데이터버스 기록을 업데이트하고,

00:05:44.820 --> 00:05:47.740
패스를 유효한 것으로 표시하며, 감사자가 만족할 수 있게 만들었습니다.

00:05:48.040 --> 00:05:51.640
네, 여러 사용자에게 할당할 수 있으며, 가장 먼저 응답한 사람이 승리합니다.

00:05:51.860 --> 00:05:55.660
이후 시도는 중복으로 잠겨 타임 스탬프 기반의 신뢰성을 보장하고,

00:05:55.800 --> 00:05:57.220
모순된 수정을 방지합니다.

00:05:57.480 --> 00:06:00.880
모든 RFI 제출은 법의학적으로 깔끔한 흔적을 남깁니다.

00:06:01.080 --> 00:06:03.680
누가, 언제, 무엇을 입력했는지 말이죠.

00:06:03.680 --> 00:06:06.680
이는 추적성에 집착하는 거버넌스 팀에게는 보물과 같습니다.

00:06:06.980 --> 00:06:10.300
RFI는 잘못된 데이터뿐만 아니라 잘못된 책임 소재까지 바로 잡습니다.

00:06:10.520 --> 00:06:13.600
아무도 어깨를 으쓱하며, 아, 시스템이 그랬어요, 라고 말할 수 없게 만듭니다.

00:06:13.740 --> 00:06:15.640
왜냐하면 데이터가 RFI 관문을 통과했다면,

00:06:16.020 --> 00:06:18.500
누군가는 자신의 이름을 걸고 제출 버튼을 눌러 둬야 하기 때문입니다.

00:06:18.660 --> 00:06:21.100
이것이 바로 양식 수준에서의 디지털 책임입니다.

00:06:21.340 --> 00:06:26.240
그렇게 자동화에 위도적으로, 명확하게, 당당하게 책임을 다시 삽입하는 것입니다.

00:06:26.480 --> 00:06:31.040
RFI는 속도를 늦추는 것이 아니라, 흐름이 규정 준수벽에 부딪히는 것을 방지합니다.

00:06:31.040 --> 00:06:37.700
이제 그 기능을 알아두니, 이 짧은 일시중지가 왜 자동화에 추가할 수 있는 가장 중요한 거버넌스 행위인지 이야기해봅시다.

00:06:37.880 --> 00:06:40.540
왜 거버넌스는 인간의 검증에서 시작되는지 말입니다.

00:06:40.780 --> 00:06:45.520
자동화는 루프에서 인간을 제거하기 위한 것이 아니라, 루프에서 인간의 나태함을 제거하기 위한 것이 없습니다.

00:06:45.840 --> 00:06:50.340
하지만 모든 것을 자동화하려는 경쟁 속에서 우리는 검증이 선택사항이라고 결정해버렸습니다.

00:06:50.560 --> 00:06:51.380
그렇지 않습니다.

00:06:51.640 --> 00:06:54.940
신뢰할 만한 모든 자동화에는 반드시 인간의 확인 절차가 포함되어야 합니다.

00:06:55.160 --> 00:06:58.080
누군가가 손가락을 들어, 네, 정확합니다, 라고 말하는 순간 말이죠.

00:06:58.080 --> 00:07:02.460
그렇지 않다면 그것은 비즈니스 프로세스를 구축하는 것이 아니라, 기계적인 효율성을 갖춘 소문공장을 만드는 것에 불과합니다.

00:07:02.600 --> 00:07:04.940
거버넌스 담당자들은 이를 본능적으로 이해합니다.

00:07:05.140 --> 00:07:10.680
ISO, SOC, GDPR 등 어떤 규정 준수 프레임워크 등 모두 추적가능한 위사결정 지점을 중심으로 돌아가기 때문입니다.

00:07:10.820 --> 00:07:15.040
누가 승인했는가? 언제 처리되었는가? 어떤 데이터 조건화에서 이루어졌는가?

00:07:15.040 --> 00:07:19.120
이는 관료적인 질문이 아니라 방어 가능한 자동화를 위한 기반입니다.

00:07:19.340 --> 00:07:23.120
RFI 액션은 이러한 책임 있는 순간을 워크플로우에 바로 삽입합니다.

00:07:23.340 --> 00:07:29.160
그렇지 않으면 감사보고서는 사건은 가득하지만 누가 원인인지 알 수 없는 추리소설처럼 읽힐 것입니다.

00:07:29.380 --> 00:07:34.420
그 차이를 이해하기 위해 RFI를 아웃룩에 포함된 디지털 서명 시트로 생각해보세요.

00:07:34.420 --> 00:07:39.640
사람의 전자 서명이 자동으로 기록될 때까지 워크플로우는 멈춥니다.

00:07:40.200 --> 00:07:45.660
사용자가 제출을 누르면 응답 내용, 이메일 식별자, 타임스탬프가 기록됩니다.

00:07:45.940 --> 00:07:53.260
즉, 방문자 출입 승인부터 거래 게시까지 모든 중요한 자동화 단계가 검증된 인간의 행동과 연결됩니다.

00:07:54.000 --> 00:07:58.160
필드를 비워두는 고집스러운 사람까지 데이터 개보를 추적할 수 있습니다.

00:07:58.440 --> 00:08:01.860
컴플라이언스 감사에서 이는 단순한 도움을 넘어 생존의 문제입니다.

00:08:01.860 --> 00:08:03.880
이제 신뢰성에 대해 이야기해봅시다.

00:08:03.880 --> 00:08:08.760
자동화는 엔지니어들이 말하는 조용한 실패, 즉 보이지 않게 고장나는 현상에 취약합니다.

00:08:08.920 --> 00:08:13.700
값이 누락되거나 조건이 어긋나도 결과물이 터무니없게 보이기 전까지는 아무도 알아차리지 못합니다.

00:08:13.900 --> 00:08:15.740
RFI는 이러한 침묵을 깹니다.

00:08:15.960 --> 00:08:17.940
눈에 띄는 체크포인트를 도입하는 것이죠.

00:08:18.120 --> 00:08:20.960
누락된 필드는 그냥 넘어가는 법이 없이 프로세스를 중단시킵니다.

00:08:21.120 --> 00:08:23.280
양식 건너뛰기나 이미 입력은 허용되지 않습니다.

00:08:23.480 --> 00:08:26.980
기계가 진행하기 전에 인간에게 즉각적인 조치를 요구하는 메시지가 전달됩니다.

00:08:27.180 --> 00:08:29.760
거버넌스 전문가들은 이를 예방적 통제라고 부릅니다.

00:08:29.760 --> 00:08:35.640
일반 사용자들은 이를 귀찮은 간섭이라고 부르지만 결국 컴플라이언스 팀에 사과 이메일을 쓰는 사람들도 바로 그들입니다.

00:08:35.800 --> 00:08:36.820
여기에 매력이 있습니다.

00:08:37.120 --> 00:08:41.260
인간의 검증을 포함함으로써 신뢰성을 추측이 아닌 수학적 확신으로 바꿀 수 있습니다.

00:08:41.520 --> 00:08:46.060
RFI 액션을 통해 검증된 데이터로 완료된 워크플로우의 수를 정확히 파악할 수 있습니다.

00:08:46.300 --> 00:08:48.820
각 단계가 측정 가능한 책임의 마디가 되는 것입니다.

00:08:49.020 --> 00:08:53.400
조직은 워크플로우가 안정적인 것 같다, 는 상태에서 우리는 그것을 증명할 수 있다, 는 상태로 나아갑니다.

00:08:53.400 --> 00:08:57.340
이것이 바로 관료주의가 아닌 텔레메트리로 정의되는 거버넌스의 성숙도입니다.

00:08:57.480 --> 00:09:02.140
뒷보는 것이 아니라 이 인간 확인 원칙은 부식이 아니라 시대를 초월한 것입니다.

00:09:02.400 --> 00:09:03.700
제조업을 생각해보세요.

00:09:03.940 --> 00:09:05.960
기계가 조립하고 검사원이 확인합니다.

00:09:06.160 --> 00:09:07.300
금융업도 생각해보세요.

00:09:07.580 --> 00:09:09.680
알고리즘이 계산하고 회계사가 서명합니다.

00:09:09.860 --> 00:09:12.120
감독 없는 자동화는 미완성된 방정식입니다.

00:09:12.320 --> 00:09:16.520
RFI 액션은 코파일러 스튜디오에 부족했던 절반인 사용자 검증 체크섬을 제공합니다.

00:09:16.720 --> 00:09:20.820
편리언만 있던 곳에 규율을 가져다 주며 물론 약간의 속도 지연은 발생합니다.

00:09:20.820 --> 00:09:22.940
그 지연은 결함이 아니라 기능입니다.

00:09:23.160 --> 00:09:28.560
검증 없는 속도는 브레이크 없는 스포츠카를 모는 것과 같아서 규정 준수라는 벽을 마주하기 전까지는 차릿하기만 합니다.

00:09:28.740 --> 00:09:33.480
루프 속의 인간은 브레이크 시스템 역할을 하며 혼란스러운 동력을 구조화된 데이터로 바꿔줍니다.

00:09:33.680 --> 00:09:38.800
일시 중지가 끝나면 자동화가 다시 가속되지만 이제는 법정에서도 방어 가능한 방향으로 나아갑니다.

00:09:38.980 --> 00:09:41.260
데이터 품질 감독과의 유사점은 명확합니다.

00:09:41.500 --> 00:09:46.900
기업 거버넌스에서 검증은 데이터 작성자를 불신하는 것이 아니라 그들에게 의존하는 시스템을 보호하는 것입니다.

00:09:46.900 --> 00:09:53.040
RFI 응답이 데이터버스에 입력되는 순간 그것은 검증 불가능한 텍스트 필드가 아니라 검증 가능한 사실이 됩니다.

00:09:53.260 --> 00:09:59.100
주관적인 것에서 객관적인 것으로의 변화가 자동화된 흐름을 단순히 편리한 수준에서 감사 준비가 된 수준으로 격상시킵니다.

00:09:59.300 --> 00:10:01.000
진정으로 영리한 부분이 무엇일까요?

00:10:01.220 --> 00:10:04.840
RFI와 생성형 AI 검증을 결합하면 이중 보증을 달성할 수 있습니다.

00:10:05.080 --> 00:10:07.680
AI는 논리를 검사하고 인간은 현실을 확인합니다.

00:10:07.840 --> 00:10:09.660
두 가지 렌즈, 하나의 진실.

00:10:09.660 --> 00:10:15.720
이것이 스테레오 거버넌스이며 책임 없는 자동화는 똑똑한 것이 아니라 무모하다는 결정을 내리는 순간 시작됩니다.

00:10:15.920 --> 00:10:18.820
4장 AI와 RFI 거버넌스 루프.

00:10:19.040 --> 00:10:20.520
AI 검증은 영리합니다.

00:10:20.720 --> 00:10:22.580
텍스트를 입력하면 판단을 내놓습니다.

00:10:22.880 --> 00:10:24.700
참, 거짓, 유효, 불안장.

00:10:24.960 --> 00:10:26.620
이는 기계가 눈썹을 치켜뜨는 것과 같습니다.

00:10:26.940 --> 00:10:29.520
하지만 권한 없는 판단은 여전히 추측에 불과합니다.

00:10:29.800 --> 00:10:31.660
그리고 자동화에서 추측은 적입니다.

00:10:31.960 --> 00:10:37.400
그렇기 때문에 AI 프롬프트와 RFI 작업을 결합하여 제가 거버넌스 루프라고 부르는 것을 만드는 것입니다.

00:10:37.400 --> 00:10:40.620
인공적인 추론과 인간의 확인 사이의 폐쇄외로입니다.

00:10:40.860 --> 00:10:42.980
AI가 제안하고 인간이 확인합니다.

00:10:43.140 --> 00:10:45.480
함께 힘을 합쳐 실제로 증명 가능한 신뢰성을 구축합니다.

00:10:45.680 --> 00:10:47.100
어떻게 진행되는지 살펴보겠습니다.

00:10:47.420 --> 00:10:51.840
코파일러 스튜디오 에이전트 흐름이 예를 들어 방문자 액세스를 요청하는 마이크로소프트 양식 제출을 수신합니다.

00:10:52.040 --> 00:10:53.420
세부 정보는 무해해 보입니다.

00:10:53.680 --> 00:10:56.060
제임스가 프로젝트 회의를 위해 본사를 방문합니다.

00:10:56.280 --> 00:10:59.780
AI 프롬프트는 사용자가 구축한 검증 논리를 통해 이를 평가합니다.

00:11:00.000 --> 00:11:03.500
회의 유형, 기간, 안전자격 증명이 포함되어 있습니까?

00:11:03.500 --> 00:11:11.040
모델 응답은 JSON 세부 정보, 유효성, 참 또는 거짓, 이유, 예상기간 누락 또는 필수 정보 포함을 지시합니다.

00:11:11.240 --> 00:11:13.020
이것이 첫 번째 체크 포인트입니다.

00:11:13.240 --> 00:11:15.620
프롬프트의 판결은 명령이 아니라 증거입니다.

00:11:15.860 --> 00:11:18.680
이제 RFI가 AI 가중단 한 지점부터 이어봤습니다.

00:11:18.860 --> 00:11:22.660
프롬프트의 출력이 거짓을 반환하면 흐름은 RFI 작업으로 분기됩니다.

00:11:22.840 --> 00:11:24.340
자동화가 일시 중지됩니다.

00:11:24.560 --> 00:11:29.780
본사 액세스 요청을 위한 추가 세부 정보 필요와 같은 제목의 아울룩 실행 가능한 메시지를 작성합니다.

00:11:29.780 --> 00:11:37.560
해당 메시지 내부에는 AI 가식별 한누락된 필드인 상세 설명, 예상기간 및 기타 규정 준수에 필요한 데이터가 정확히 포함됩니다.

00:11:37.800 --> 00:11:41.980
시스템은 양식의 디렉터리 아이디를 사용하여 원래 요청자에게 이를 할당합니다.

00:11:42.180 --> 00:11:47.440
메시지가 받은 편지함에 도착하고 완전히 자동화된 것처럼 보였던 워크플로우가 갑자기 정중하게 말합니다.

00:11:47.600 --> 00:11:48.900
무언가를 빠뜨리셨네요.

00:11:49.160 --> 00:11:49.960
수정해주세요.

00:11:50.140 --> 00:11:54.160
그들이 응답하면 해당 데이터는 단순히 기록을 수정하는 것 이상의 역할을 합니다.

00:11:54.160 --> 00:11:55.460
수정을 인증합니다.

00:11:55.840 --> 00:12:03.920
RFI는 타임스탬프, 사용자 아이디, 새 콘텐츠를 캡처한 다음 해당 세부 정보를 키 기반에 불변하는 구조화된 출력물로 저장합니다.

00:12:04.140 --> 00:12:09.980
에이전트 흐름이 재개되고 데이터버스 행을 업데이트하며 상태를 정보 필요에서 유효로 전환합니다.

00:12:10.180 --> 00:12:15.480
그 순간 여러분은 워크플로우를 완료했을 뿐만 아니라 감사 가능한 거버넌스 아티팩트까지 생성한 것입니다.

00:12:15.680 --> 00:12:21.000
AI 위 초기 평가, 인간의 수정, 최종 검증 상태 등 모든 결과가 문서화됩니다.

00:12:21.000 --> 00:12:23.620
이를 RFI가 없는 시나리오와 비교해보십시오.

00:12:23.740 --> 00:12:26.900
AI는 여전히 누락된 세부 정보를 플래그 지정하겠지만, 그 다음은 어떻게 될까요?

00:12:27.040 --> 00:12:32.220
오류를 게시하거나, 모호한 이메일을 보내거나, 누군가 수동으로 수정할 때까지 똑같은 질문을 무한히 반복할 수 있습니다.

00:12:32.420 --> 00:12:34.380
그것이 바로 악명높은 조용한 실패입니다.

00:12:34.600 --> 00:12:37.600
흐름은 기술적으로 실행되었지만, 그 결과물은 신뢰할 수 없습니다.

00:12:37.900 --> 00:12:40.480
RFI를 통합하면 침묵을 완전히 제거할 수 있습니다.

00:12:40.740 --> 00:12:43.600
흐름은 검증된 데이터가 도착할 때까지 눈에 띄게 대기해야 합니다.

00:12:43.800 --> 00:12:46.140
단순한 안전장치가 아니라 설계부터 결함이 방지된 상태입니다.

00:12:46.140 --> 00:12:47.980
물리적 보안과 비슷하다고 생각하세요.

00:12:48.180 --> 00:12:50.020
AI 프롬프트는 감시 카메라입니다.

00:12:50.220 --> 00:12:51.420
관찰하고 분석합니다.

00:12:51.640 --> 00:12:53.200
RFI는 잠긴 문입니다.

00:12:53.420 --> 00:12:56.440
검증된 자격 증명을 제시하기 전까지는 입장을 거부합니다.

00:12:56.640 --> 00:12:57.520
둘 다 필요합니다.

00:12:57.780 --> 00:13:00.940
카메라는 잘못된 행동을 억제하고, 잠금장치는 이를 예방합니다.

00:13:01.120 --> 00:13:03.820
거버넌스 세계에서 프롬프트는 불일치를 탐지합니다.

00:13:04.060 --> 00:13:06.480
RFI는 그것이 확산되는 것을 막습니다.

00:13:06.800 --> 00:13:12.060
함께하면 복잡하고 오류가 잦은 자동화를 데이터 품질을 위한 2단계 인증 프로세스로 변환합니다.

00:13:12.280 --> 00:13:14.880
각 RFI 출력은 하나의 소형감사 기록입니다.

00:13:14.880 --> 00:13:20.540
JSON 객체에는 제출된 값뿐만 아니라 누가, 언제, 어떤 맥락에서 제공했는지까지 포함됩니다.

00:13:20.700 --> 00:13:26.060
규정 준수 담당자는 이를 추상적인 검증 로직을 실질적인 증거로 변환해주기 때문에 매우 선호합니다.

00:13:26.280 --> 00:13:30.060
이제 AI 위 결정이 결코 자율적이지 않아 등을 입증할 수 있습니다.

00:13:30.340 --> 00:13:32.760
실시간으로 인간의 확인을 거쳤기 때문입니다.

00:13:33.000 --> 00:13:36.160
그것이 영리한 데모와 기업용 제어 시스템의 차이입니다.

00:13:36.400 --> 00:13:40.460
파워 플랫폼 거버넌스 모범 사례는 바로 이러한 이중 검증을 강조합니다.

00:13:40.720 --> 00:13:42.760
자동화된 추롬과 인간의 확인입니다.

00:13:42.760 --> 00:13:44.620
이는 반복 가능성을 보장합니다.

00:13:44.800 --> 00:13:48.000
내일 같은 프로세스를 다시 실행해도 검증 가능한 결과를 얻을 수 있습니다.

00:13:48.220 --> 00:13:49.740
이는 방어 가능성을 보장합니다.

00:13:49.960 --> 00:13:53.840
규제기관이 결정 과정에 대해 묻는다면 문자 그대로의 증거를 제시할 수 있습니다.

00:13:54.060 --> 00:13:55.520
또한 신뢰성을 보장합니다.

00:13:55.740 --> 00:14:00.800
흐름의 각 실행은 희망 섞인 과정이 아닌 측정된 신뢰도를 바탕으로 일관된 결과를 생성합니다.

00:14:01.060 --> 00:14:06.200
네, 이 방식은 사용자가 RFI를 완료하는 동안 보통 10에서 15초 정도의 지연을 초래합니다.

00:14:06.440 --> 00:14:12.220
하지만 그 짧은 멈춤이 잘못된 데이터가 확산되었을 때 겪을 몇 시간, 때로는 며칠에 걸친 사고 후 정리를 예방해줍니다.

00:14:12.220 --> 00:14:15.260
사람들은 RFI가 자동화 속도를 늦춘다고 불평합니다.

00:14:15.440 --> 00:14:18.040
그것은 자동차의 브레이크가 속도를 늦춘다고 불평하는 것과 같습니다.

00:14:18.300 --> 00:14:21.360
브레이크는 위도적으로 속도를 줄이며 덕분에 내일도 계속 운전할 수 있는 것입니다.

00:14:21.520 --> 00:14:25.740
결국 AI RFI 루프는 단순히 워크플로우를 수리하는 것이 아니라 책임의 개념을 재구성합니다.

00:14:25.740 --> 00:14:28.520
자동화 시스템에 회의적인 시각을 갖도록 가르치는 것입니다.

00:14:28.700 --> 00:14:31.700
AI는 이상을 감지하고 RFI는 수정을 확인합니다.

00:14:31.880 --> 00:14:35.120
이 둘이 결합하면 데이터는 소모품이 아닌 관리되는 자산이 됩니다.

00:14:35.400 --> 00:14:38.060
모든 항목은 확인, 기록, 검색이 가능해집니다.

00:14:38.240 --> 00:14:40.520
거버넌스는 관료적인 사후 처리가 아닙니다.

00:14:40.740 --> 00:14:42.380
그것은 엔지니어링의 기능이 됩니다.

00:14:42.740 --> 00:14:48.140
그리고 신중하고 위도적이며 책임감 있는 이 순환 속에서 진정한 기업의 신뢰성이 시작됩니다.

00:14:48.360 --> 00:14:51.040
RFI를 무시할 때 발생하는 일반적인 문제점들.

00:14:51.200 --> 00:14:54.420
RFI가 존재하지 않는 것처럼 행동할 때 어떤 일이 벌어지는지 이야기해봅시다.

00:14:54.420 --> 00:14:56.560
스포일러를 드리자면 결코 좋지 않습니다.

00:14:56.760 --> 00:14:59.120
RFI가 없는 흐름은 차키를 든 10대와 같습니다.

00:14:59.460 --> 00:15:01.880
기능은 하지만 감독이 없어 재앙을 부르죠.

00:15:02.060 --> 00:15:05.980
입력되는 데이터가 무엇이든 그대로 받아들이고 자신만만하게 재앙으로 향합니다.

00:15:06.200 --> 00:15:09.420
가장 예측 가능한 실패 유형인 널 입력부터 시작해보죠.

00:15:09.600 --> 00:15:15.140
흐름이 빈 필드, 옛 시설 방문객 수를 만나면 이를 그대로 처리하려고 합니다.

00:15:15.440 --> 00:15:21.780
그 널값은 하류로 전달되면서 조건을 무너뜨리고 병렬분기를 건너뛰며 모든 종속작업을 혼란에 빠뜨립니다.

00:15:21.780 --> 00:15:27.860
결국 파워 오토메이트 상으로는 성공하지만 기본적인 논리 테스트조차 통과하지 못하는 결과를 낳게 됩니다.

00:15:28.080 --> 00:15:30.860
그 다음은 데이터버스에 생성되는 유령 기록들입니다.

00:15:31.060 --> 00:15:35.600
타임 스탬프는 있지만 실제 데이터는 없는 빈행들이 디지털 먼지처럼 테이블을 뒤덮습니다.

00:15:35.840 --> 00:15:37.680
다음은 부정확한 승인 문제입니다.

00:15:37.900 --> 00:15:42.260
RFI 검증이 없으면 자동화는 양식 작성자가 모든 규칙을 이해했다고 가정해버립니다.

00:15:42.520 --> 00:15:43.660
사실은 그렇지 않죠.

00:15:43.820 --> 00:15:49.960
안전승인 없이 방문객 권한이 부여되거나 비용센터가 누락된 경비 승인, 신분확인 없이 추가된 신규채용 등이 발생합니다.

00:15:49.960 --> 00:15:53.780
운이 좋으면 재작업으로 끝나지만 운이 나쁘면 법적 책임 문제로 번집니다.

00:15:53.920 --> 00:15:58.080
데이터버스에 입력된 자동화된 승인은 귀사의 중법감시 기록의 일부가 된다는 점을 기억하십시오.

00:15:58.180 --> 00:16:01.340
일단 기록되면 감사인은 그게 자동화된 흐름의 결과였다는 변명을 듣지 않습니다.

00:16:01.540 --> 00:16:04.200
그들은 그것을 통제 실패라고 부를 것이며 그것이 정답입니다.

00:16:04.400 --> 00:16:07.440
네 물론 이런 혼란으로 인해 데이터버스 데이터도 손상됩니다.

00:16:07.640 --> 00:16:11.140
불완전한 정보가 들어올 때 마다 테이블 간의 관계는 파편화됩니다.

00:16:11.140 --> 00:16:17.520
조회는 실패하고 종속커리는 엉뚱한 값을 반환하며 대시보드의 합계는 재무팀을 경악하게 만듭니다.

00:16:17.700 --> 00:16:21.840
RFI 확인 지점이 없으면 이러한 공백은 생성 시점에 전혀 포착되지 않습니다.

00:16:22.040 --> 00:16:25.560
결국 보고 시즌이 오면 서로를 탓하는 상황만 누적될 뿐입니다.

00:16:25.760 --> 00:16:29.680
그 다음은 끝없는 AI 확인 루프, 즉 자동화의 비명입니다.

00:16:29.900 --> 00:16:36.640
AI 프롬프트가 누락된 세부 정보를 감지하고 다시 질문을 보내도 모호한 답변만 돌아오며 무한 반복되다 시간 초과가 발생합니다.

00:16:36.640 --> 00:16:40.600
주제는 잊어버렸는데 멈출 줄 모르는 챗북과 대화하는 것과 같습니다.

00:16:40.920 --> 00:16:45.180
모두 흐름을 일시 중지하고 사람이 검증한 수정사항을 기다릴 방법을 제공하지 않았기 때문입니다.

00:16:45.340 --> 00:16:47.080
그것이 바로 RFI 가하는 역할입니다.

00:16:47.280 --> 00:16:50.180
진실이 확인될 때까지 실행을 멈춤으로써 그 악순환의 고리를 끊어줍니다.

00:16:50.360 --> 00:16:53.640
RFI를 무시할 때 발생하는 비즈니스의 고통은 결국 모두 아래로 흐르게 됩니다.

00:16:53.880 --> 00:16:57.140
누가 무엇을 승인했는지 증명할 수 없기에 규제 노출 위험이 커집니다.

00:16:57.340 --> 00:17:01.120
증거체인이 불안전한 데이터에서 시작되므로 감사추적의 신뢰성이 떨어집니다.

00:17:01.120 --> 00:17:06.360
감사관이 누락된 값을 해석해서 재구성하는 일을 즐긴다고 생각하신다면 감사관을 제대로 만나본 적이 없는 게 분명합니다.

00:17:06.500 --> 00:17:08.180
그 비용을 구체적으로 따져봅시다.

00:17:08.380 --> 00:17:17.220
자동화가 잘못된 입력 때문에 조용히 실패할 때마다 누군가 수동으로 문제를 파악하고 데이터를 수정하며 흐름을 다시 실행하고 하위 시스템을 모두 검증해야 합니다.

00:17:17.460 --> 00:17:22.700
이걸 매달 수백 번이 트리거로 곱해보면 효율적이던 노코드 워크플로우에 어느새 전담 관리자가 붙어있게 됩니다.

00:17:22.920 --> 00:17:26.200
RFI 정보 요청은 초단위로 해결되지만 사후 수습은 며칠이 걸립니다.

00:17:26.200 --> 00:17:28.040
그럼에도 사람들은 여전히 거부합니다.

00:17:28.240 --> 00:17:32.040
RFI가 혁신을 늦추고 마찰을 일으키며 사람이 다시 개입하게 만든다고 주장하죠.

00:17:32.220 --> 00:17:32.980
맞는 말일까요?

00:17:33.220 --> 00:17:34.880
네, 아주 당연하고 훌륭한 일입니다.

00:17:35.040 --> 00:17:38.400
RFI를 무시하는 건 자유로운 움직임을 원한다며 안전벨트를 푸는 것과 같습니다.

00:17:38.680 --> 00:17:40.800
그건 태만함을 낙관주의로 포장하는 것뿐입니다.

00:17:41.000 --> 00:17:45.800
거버넌스가 존재하는 이유는 사람들이 세부사항을 잊고 서둘러 응답하며 기계가 나중에 알아서 고쳐줄 거라 믿기 때문입니다.

00:17:45.940 --> 00:17:47.120
기계는 고치지 않습니다.

00:17:47.400 --> 00:17:50.400
시스템이 고장난 뒤에 고통스럽게 수습하는 건 결국 사람입니다.

00:17:50.400 --> 00:17:57.700
그러니 RFI를 건너뛰고 싶다면 데이터 개보가 추측으로 엉망이 되어 다음 분기 규정 준수 보고서를 크레용으로 작성하는 자신의 모습을 상상해보세요.

00:17:57.940 --> 00:17:59.040
너무 극단적인가요?

00:17:59.280 --> 00:18:00.340
약간은 그렇겠네요.

00:18:00.560 --> 00:18:04.720
RFI가 없다면 당신의 자동화는 규정을 준수하는 게 아니라 타임스탬프가 찍힌 소설을 쓰는 것과 같습니다.

00:18:05.020 --> 00:18:10.960
생략된 모든 필드는 시스템이 스스로에게 하는 거짓말이며 검증되지 않은 기록은 적발을 기다리는 정책 위반입니다.

00:18:11.180 --> 00:18:15.260
RFI 도입의 성과는 행정적 승리가 아니라 운영상의 평온함입니다.

00:18:15.260 --> 00:18:21.640
흐름이 얼마나 깔끔하고 일관되며 감사 가능한 상태가 되는지 확인하고 나면 왜 그동안 그 혼란을 참았는지 의문이 될 것입니다.

00:18:21.820 --> 00:18:25.280
RFI는 자동화를 믿음의 영역에서 통제 시스템으로 바꿔줍니다.

00:18:25.460 --> 00:18:31.440
흐름이 계속 실패한다면 문제는 코파일럿이 아니라 사람이 관리하지 않는 상태에서 소프트웨어가 사람을 맹신하게 둔 탓일지도 모릅니다.

00:18:31.620 --> 00:18:34.240
당신이 미처 필요성을 몰랐던 거버넌스 업그레이드입니다.

00:18:34.420 --> 00:18:35.240
핵심은이 겁니다.

00:18:35.600 --> 00:18:40.800
신뢰성이 더 똑똑한 AI가 아니라 더 엄격한 거버넌스에서 나온다는 것을 대부분 결국 깨닫게 되죠.

00:18:40.800 --> 00:18:45.420
정보 요청이라는 과정은 선택적인 장식이 아니라 구조적 무결성입니다.

00:18:45.640 --> 00:18:50.000
우리 자동화가 돌아간다와 우리 자동화가 돌아감을 증명할 수 있다는 것의 차이입니다.

00:18:50.200 --> 00:18:54.560
코파일럿 스튜디오 흐름에 RFI를 통합하면 폐쇄형 책임루프가 만들어집니다.

00:18:54.760 --> 00:18:58.480
모든 결정은 검증되고 모든 불일치는 해결되며 모든 기록은 방어 가능해집니다.

00:18:58.640 --> 00:19:00.560
그것이 바로 여기서 말하는 진정한 마법입니다.

00:19:00.780 --> 00:19:05.580
RFI는 단순히 규정을 강제하는 게 아니라 추상적인 거버넌스를 실질적인 워크플로 행동으로 전환합니다.

00:19:05.780 --> 00:19:09.140
AI는 텍스트를 단순히 신뢰하는 것이 아니라 교차 검증을 수행합니다.

00:19:09.140 --> 00:19:12.760
당신의 흐름은 데이터를 기록하는 것을 넘어 품질보증을 요구하게 됩니다.

00:19:12.940 --> 00:19:17.560
기능으로 의장한 거버넌스, 그것이 바로 RFI가 조용히 신뢰성을 혁신하는 이유입니다.

00:19:17.720 --> 00:19:22.120
데이터 거버넌스, 규정 준수, 신뢰성을 같은 삼각형의 세각으로 생각해보세요.

00:19:22.360 --> 00:19:25.640
RFI가 없으면 그 구조는 지름길과 변명으로 무너져내립니다.

00:19:25.920 --> 00:19:28.800
RFI가 있다면 모든 변이 서로를 지탱해줍니다.

00:19:29.020 --> 00:19:34.360
데이터 품질은 규정 준수를 보장하고, 규정 준수는 추적성을 강제하며, 추적성은 신뢰성을 강화합니다.

00:19:34.580 --> 00:19:37.140
당신은 문제 해결을 멈추고 자신있게 감사를 시작하게 됩니다.

00:19:37.140 --> 00:19:39.540
네, 심지어 감사인들 조차 미소를 짓게 될 것입니다.

00:19:39.700 --> 00:19:41.380
당혹스럽지만 측정 가능한 결과 있죠.

00:19:41.600 --> 00:19:42.920
자, 여기서 얻을 교훈입니다.

00:19:43.120 --> 00:19:45.120
거버넌스를 불필요한 관료주의로 치부하지 마세요.

00:19:45.320 --> 00:19:46.220
그것은 갑옷입니다.

00:19:46.480 --> 00:19:50.300
RFI는 자동화가 잘못된 데이터로 인해 무너지지 않도록 지켜주는 방패입니다.

00:19:50.520 --> 00:19:54.460
아직 워크플로우에 도입하지 않았다면, 거버넌스를 하는 게 아니라 운에 맡기고 있는 것입니다.

00:19:54.680 --> 00:19:57.460
운은 언젠가 다 하기 마련이니, 지금 바로 흐름을 강화하세요.

00:19:57.700 --> 00:20:01.280
데이터 누락이나 오류가 문제를 일으킬 수 있는 모든 프로세스에 RFI를 추가하세요.

00:20:01.280 --> 00:20:04.060
AI 가가정하지 않고 검증하도록 가르치세요.

00:20:04.220 --> 00:20:08.520
모든 RFI 응답을 코드에 내장된 책임의 서명으로 간주하십시오.

00:20:08.640 --> 00:20:12.920
이 설명이 데이터 품질의 악몽을 한 번이라도 막아주었다면, 보답해주세요.

00:20:13.060 --> 00:20:16.480
구독과 팔로우, 알림 설정을 하고, 단순히 실행만 되는 것이 아니라,

00:20:16.700 --> 00:20:19.360
감사도 견뎌내는 코파일럿 스튜디오 흐름을 계속 만드세요.

00:20:19.540 --> 00:20:21.460
신뢰성 없는 효율성은 혼란일 뿐입니다.

00:20:21.680 --> 00:20:23.260
RFI가 그것을 체계화합니다.

00:20:23.260 --> 00:20:53.240
RFI가 그것을 체계화합니다.