"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>ARCH EDIFICIOS CORPORATIVOS FII</NomeFundo>
		<CNPJFundo>35765826000126</CNPJFundo>
		<DataFuncionamento>2020-09-02</DataFuncionamento>
		<PublicoAlvo>Investidores em Geral</PublicoAlvo>
		<CodigoISIN>BRAIECCTF009</CodigoISIN>
		<QtdCotasEmitidas>4824987</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Classificacao>Tijolo</Classificacao>
			<Subclassificacao>Renda</Subclassificacao>
			<TipoGestao>Ativa</TipoGestao>
			<SegmentoAtuacao>Escritórios</SegmentoAtuacao>
		</Autorregulacao>
		<PrazoDuracao>Indeterminado</PrazoDuracao>
		<DataPrazoDuracao xsi:nil="true"/>
		<EncerramentoExercicio>31/12</EncerramentoExercicio>
		<MercadoNegociacao>
			<Bolsa>true</Bolsa>
			<MBO>false</MBO>
			<MB>false</MB>
		</MercadoNegociacao>
		<EntidadeAdministradora>
			<BVMF>true</BVMF>
			<CETIP>false</CETIP>
		</EntidadeAdministradora>
		<NomeAdministrador>	MAF DISTRIBUIDORA DE TITULOS E VALORES MOBILIARIOS S.A.</NomeAdministrador>
		<CNPJAdministrador>13486793000142</CNPJAdministrador>
		<Logradouro>Rua Alves Guimarães, 1216</Logradouro>
		<Numero>1212</Numero>
		<Complemento xsi:nil="true"/>
		<Bairro>Pinheiros</Bairro>
		<Cidade>São Paulo</Cidade>
		<Estado>SP</Estado>
		<CEP>05410-002</CEP>
		<Telefone1>(11) 3509-0600</Telefone1>
		<Telefone2 xsi:nil="true"/>
		<Telefone3 xsi:nil="true"/>
		<Site>www.apexgroup.com/apex-brazil/</Site>
		<Email>infolegal@apexgroup.com</Email>
		<Competencia>2025-12-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>AUTONOMY INVESTIMENTOS LTDA</Nome>
				<CNPJ>13189560000188</CNPJ>
				<Endereco>Av Nações Unidas, 14171, Torre B, Cj 802, Vila Gertrudes, São Paulo/SP</Endereco>
				<telefone>(11) 3524-2500</telefone>
			</Gestor>
			<Custodiante>
				<Nome>MAF DISTRIBUIDORA DE TITULOS E VALORES MOBILIARIOS S.A.</Nome>
				<CNPJ>36864992000142</CNPJ>
				<Endereco>R. Alves Guimarães, 1212 - Pinheiros, São Paulo - SP, 05410-002</Endereco>
				<telefone>(11) 3133-0350</telefone>
			</Custodiante>
			<AuditorIndependente>
				<Nome>KPMG AUDITORES INDEPENDENTES LTDA</Nome>
				<CNPJ>57755217000129</CNPJ>
				<Endereco>Rua Verbo Divino, 1400 - Chácara Santo Antonio, São Paulo</Endereco>
				<telefone>(11) 3940-1500</telefone>
			</AuditorIndependente>
			<FormadorMercado>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</FormadorMercado>
			<DistribuidorCotas>
				<Nome>BANCO J. SAFRA S.A.</Nome>
				<CNPJ>3017677000120</CNPJ>
				<Endereco>Av. Paulista, 2100, São Paulo - SP	</Endereco>
				<telefone>(11) 3175-8602</telefone>
			</DistribuidorCotas>
			<ConsultorEspecializado>
				<Nome>AUTONOMY INVESTIMENTOS LTDA</Nome>
				<CNPJ>13189560000188</CNPJ>
				<Endereco>Av Nações Unidas, 14171, Torre B, Cj 802, Vila Gertrudes, São Paulo/SP</Endereco>
				<telefone>(11) 3524-2500</telefone>
			</ConsultorEspecializado>
			<EmpEspecializadaAdmLocacoes>
				<Nome>AUTONOMY INVESTIMENTOS LTDA</Nome>
				<CNPJ>13189560000188</CNPJ>
				<Endereco>Av Nações Unidas, 14171, Torre B, Cj 802, Vila Gertrudes, São Paulo/SP</Endereco>
				<telefone>(11) 3524-2500</telefone>
			</EmpEspecializadaAdmLocacoes>
			<OutrosPrestadores>
				<Prestador>
					<Nome>MAF DISTRIBUIDORA DE TITULOS E VALORES MOBILIARIOS S.A.</Nome>
					<CNPJ>36864992000142</CNPJ>
					<Endereco>R. Alves Guimarães, 1212 - Pinheiros, São Paulo - SP, 05410-002</Endereco>
					<telefone>(11) 3133-0350</telefone>
				</Prestador>
			</OutrosPrestadores>
		</PrestadoresServicos>
		<InvestimentosFII>
			<NegociosRealizadosPeriodo>
				<RelacaoAtivosAdquiridos>
				</RelacaoAtivosAdquiridos>
			</NegociosRealizadosPeriodo>
		</InvestimentosFII>
		<ProgramaInvestimentos>N/A</ProgramaInvestimentos>
		<AnaliseAdministrador>
			<ResultadoFundo>No exercício social findo em 31/12/2025, o Fundo, foi apurado um lucro contabil no montante de R$28.059.845,72.</ResultadoFundo>
			<ConjunturaEconomica>N/A</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>O AIEC11 é lastreado por dois ativos de alta qualidade, localizados em São Paulo e Rio de Janeiro, atualmente com 75% de ocupação. O Standard Building atingiu 100% de ocupação após a locação para um inquilino de primeira linha, a Rede D’Or, em fevereiro de 2026. Já o Rochaverá apresenta perspectivas positivas de redução de vacância, sustentadas pelo elevado volume de negociações em estágio avançado com potenciais locatários. Em ambos os mercados (São Paulo e Rio de Janeiro) houve queda consistente da vacância nos últimos trimestres.</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>ROCHAVERÁ DIAMOND TOWER	</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>277023000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0228</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>STANDARD BUILDING	</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>57169000</Valor>
				<PercentValorizacaoDesvalorizacao>-0.2452</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>Método de capitalização da renda e fluxo de caixa descontado para determinação do valor justo dos imóveis.</CriteriosAvaliacao>
		<ProcessosJudiciais>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos>Não há processos judiciais em que o fundo esteja envolvido</AnaliseImpactos>
		<AssembleiaGeral>
			<EnderecoFisicoDocsAssembleias>Rua Alves Guimarães nº 1.216, Bairro Pinheiros, Cidade de São Paulo Estado de São Paulo</EnderecoFisicoDocsAssembleias>
			<EnderecoEletronicoDocsAssembleias>www.mafdtvm.com.br</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>A Administradora disponibilizará, na mesma data de convocação, todas as informações e documentos necessários ao exercício informado do direito de voto em assembleias gerais (i) em sua página na rede mundial de computadores, (ii) no Sistema de Envio de Documentos disponível na página da CVM na rede mundial de computadores, e, conforme o caso, (iii) na página da entidade administradora do mercado organizado em que as Cotas de emissão do Fundo sejam admitidas à negociação, todas as informações e documentos necessários ao exercício informado do direito de voto em assembleia geral de Cotistas, em conformidade ao art. 19-A da ICVM 472/2008.</MeiosComunicacao>
			<RegrasProcParticipacaoCotistas>Somente podem votar na assembleia geral os Cotistas inscritos no registro de Cotistas na data da convocação da assembleia, seus representantes legais ou procuradores constituídos há menos de 1 (um) ano. Os Cotistas poderão enviar seu voto por correspondência e/ou por correio eletrônico, desde que a convocação indique essa possibilidade e estabeleça os critérios para essa forma de voto, que não exclui a realização da reunião de Cotistas, no local e horário estabelecidos, cujas deliberações serão tomadas pelos votos dos presentes e dos recebidos por correspondência. A critério da Administradora, que definirá os procedimentos a serem seguidos, as deliberações da assembleia poderão ser tomadas por meio de consulta formal, sem reunião de Cotistas, em que (i) os Cotistas manifestarão seus votos por correspondência, correio eletrônico ou telegrama; e (ii) as decisões serão tomadas com base na maioria dos votos recebidos e desde que sejam observadas as formalidades previstas neste Regulamento e na regulamentação aplicável.</RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico>A critério da Administradora, que definirá os procedimentos a serem seguidos, as deliberações da assembleia poderão ser tomadas por meio de consulta formal, sem reunião de Cotistas, em que (i) os Cotistas manifestarão seus votos por correspondência, correio eletrônico ou telegrama; e (ii) as decisões serão tomadas com base na maioria dos votos recebidos e desde que sejam observadas as formalidades previstas neste Regulamento e na regulamentação aplicável.</PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>O Administrador fará jus a uma taxa anual equivalente de até 0,75% incidentes sobre (i) o valor de mercado, caso as cotas do Fundo integrem o Índice de Fundos de Investimentos Imobiliários (IFIX), conforme definido na regulamentação aplicável aos fundos de investimento imobiliário, ou (ii) o valor do Patrimônio Líquido do Fundo, caso não aplicável o critério previsto no item “i” deste item (“Taxa de Administração”). A Taxa de Administração de 0,75% representa a taxa cheia de administração e gestão.  O valor da Taxa de Administração, a qual será apropriada por dia útil como despesa do Fundo, com base em um ano de 252 dias úteis, deverá ser paga, mensalmente, no 5º (quinto) dia útil de cada mês subsequente.</PoliticaRemuneracao>
			<ValorPagoAno>1725470.22</ValorPagoAno>
			<PercentPatrimonioContabil>0.0091</PercentPatrimonioContabil>
			<PercentPatrimonioValorMercado>0.0146</PercentPatrimonioValorMercado>
		</RemuneracaoAdministrador>
		<Governanca>
			<RepresentantesCotistas>
				<Representante1>
					<Nome/>
					<Idade/>
					<CPF/>
					<Email/>
					<Profissao/>
					<FormacaoAcademica/>
					<FormaRemuneracao/>
					<ValorPagoAno xsi:nil="true"/>
					<PercentPatrimonioContabil xsi:nil="true"/>
					<PercentPatrimonioValorMercado xsi:nil="true"/>
					<QtdCotasDetidasFII xsi:nil="true"/>
					<QtdCotasFIICompradas xsi:nil="true"/>
					<QtdCotasFIIVendidas xsi:nil="true"/>
					<DataEleicaoAssembleia xsi:nil="true"/>
					<TerminoMandato xsi:nil="true"/>
					<ExperienciasProfUltimosCincoAnos>
					</ExperienciasProfUltimosCincoAnos>
					<FundosExercaFuncaoRepresentante>
					</FundosExercaFuncaoRepresentante>
					<Eventos>
						<CondenacaoCriminal xsi:nil="true"/>
						<CondenacaoProcAdminCVM xsi:nil="true"/>
					</Eventos>
				</Representante1>
				<Representante2>
					<Nome/>
					<Idade/>
					<CPF/>
					<Email/>
					<Profissao/>
					<FormacaoAcademica/>
					<FormaRemuneracao/>
					<ValorPagoAno xsi:nil="true"/>
					<PercentPatrimonioContabil xsi:nil="true"/>
					<PercentPatrimonioValorMercado xsi:nil="true"/>
					<QtdCotasDetidasFII xsi:nil="true"/>
					<QtdCotasFIICompradas xsi:nil="true"/>
					<QtdCotasFIIVendidas xsi:nil="true"/>
					<DataEleicaoAssembleia xsi:nil="true"/>
					<TerminoMandato xsi:nil="true"/>
					<ExperienciasProfUltimosCincoAnos>
					</ExperienciasProfUltimosCincoAnos>
					<FundosExercaFuncaoRepresentante>
					</FundosExercaFuncaoRepresentante>
					<Eventos>
						<CondenacaoCriminal/>
						<CondenacaoProcAdminCVM/>
					</Eventos>
				</Representante2>
				<Representante3>
					<Nome/>
					<Idade/>
					<CPF/>
					<Email/>
					<Profissao/>
					<FormacaoAcademica/>
					<FormaRemuneracao/>
					<ValorPagoAno xsi:nil="true"/>
					<PercentPatrimonioContabil xsi:nil="true"/>
					<PercentPatrimonioValorMercado xsi:nil="true"/>
					<QtdCotasDetidasFII xsi:nil="true"/>
					<QtdCotasFIICompradas xsi:nil="true"/>
					<QtdCotasFIIVendidas xsi:nil="true"/>
					<DataEleicaoAssembleia xsi:nil="true"/>
					<TerminoMandato xsi:nil="true"/>
					<ExperienciasProfUltimosCincoAnos>
					</ExperienciasProfUltimosCincoAnos>
					<FundosExercaFuncaoRepresentante>
					</FundosExercaFuncaoRepresentante>
					<Eventos>
						<CondenacaoCriminal/>
						<CondenacaoProcAdminCVM/>
					</Eventos>
				</Representante3>
				<Representante4>
					<Nome/>
					<Idade/>
					<CPF/>
					<Email/>
					<Profissao/>
					<FormacaoAcademica/>
					<FormaRemuneracao/>
					<ValorPagoAno xsi:nil="true"/>
					<PercentPatrimonioContabil xsi:nil="true"/>
					<PercentPatrimonioValorMercado xsi:nil="true"/>
					<QtdCotasDetidasFII xsi:nil="true"/>
					<QtdCotasFIICompradas xsi:nil="true"/>
					<QtdCotasFIIVendidas xsi:nil="true"/>
					<DataEleicaoAssembleia xsi:nil="true"/>
					<TerminoMandato xsi:nil="true"/>
					<ExperienciasProfUltimosCincoAnos>
					</ExperienciasProfUltimosCincoAnos>
					<FundosExercaFuncaoRepresentante>
					</FundosExercaFuncaoRepresentante>
					<Eventos>
						<CondenacaoCriminal/>
						<CondenacaoProcAdminCVM/>
					</Eventos>
				</Representante4>
				<Representante5>
					<Nome/>
					<Idade/>
					<CPF/>
					<Email/>
					<Profissao/>
					<FormacaoAcademica/>
					<FormaRemuneracao/>
					<ValorPagoAno xsi:nil="true"/>
					<PercentPatrimonioContabil xsi:nil="true"/>
					<PercentPatrimonioValorMercado xsi:nil="true"/>
					<QtdCotasDetidasFII xsi:nil="true"/>
					<QtdCotasFIICompradas xsi:nil="true"/>
					<QtdCotasFIIVendidas xsi:nil="true"/>
					<DataEleicaoAssembleia xsi:nil="true"/>
					<TerminoMandato xsi:nil="true"/>
					<ExperienciasProfUltimosCincoAnos>
					</ExperienciasProfUltimosCincoAnos>
					<FundosExercaFuncaoRepresentante>
					</FundosExercaFuncaoRepresentante>
					<Eventos>
						<CondenacaoCriminal/>
						<CondenacaoProcAdminCVM/>
					</Eventos>
				</Representante5>
			</RepresentantesCotistas>
			<DiretorResponsavel>
				<Nome>Ernane Divino dos Santos Alves</Nome>
				<Idade>49</Idade>
				<CPF>27499578852</CPF>
				<Email>ernane.alves@apexgroup.com</Email>
				<Profissao>Administrador de empresas</Profissao>
				<FormacaoAcademica>Superior Completo</FormacaoAcademica>
				<DataInicioFuncao>2025-08-13</DataInicioFuncao>
				<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
				<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
				<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
				<ExperienciasProfUltimosCincoAnos>
					<Experiencia>
						<NomeEmpresa>Apex Holding Ltda</NomeEmpresa>
						<Periodo>Desde 08/2025</Periodo>
						<CargoFuncoes>Diretor Executivo Adm Fiduciária e Produtos</CargoFuncoes>
						<AtividadePrincipalEmpresa>Administrador fiduciário</AtividadePrincipalEmpresa>
					</Experiencia>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal/>
					<CondenacaoProcAdminCVM/>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento numCotistas="13548" numCotasDetidas="3988578" percDetidoRelTotal="0.8267" percDetidoPF="0.5273" percDetidoPJ="0.2993"/>
			<AcimaCincoAteDezPorcento numCotistas="2" numCotasDetidas="836409" percDetidoRelTotal="0.1733" percDetidoPF="0" percDetidoPJ="0.1734"/>
			<AcimaDezAteQuinzePorcento/>
			<AcimaQuinzeAteVintePorcento/>
			<AcimaVinteAteTrintaPorcento/>
			<AcimaTrintaAteQuarentaPorcento/>
			<AcimaQuarentaAteCinquentaPorcento/>
			<AcimaCiquentaPorcento/>
		</DistribuicaoCotistas>
		<TransacoesInstrucaoCVM>
		</TransacoesInstrucaoCVM>
		<PoliticaDivulgacao>
			<PoliticaDivulgacaoAtoFatoRelevante>http://www.mafdtvm.com.br/</PoliticaDivulgacaoAtoFatoRelevante>
			<PoliticaNegociacaoCotas>O Fundo tem por objetivo a obtenção de renda, mediante locação ou arrendamento, com a exploração comercial de empreendimentos imobiliários no segmento de lajes corporativas, em especial empreendimentos imobiliários destinados a escritórios localizados no território nacional.</PoliticaNegociacaoCotas>
			<PoliticaExercicioDireitoVoto>A Gestora adota política de exercício de direito de voto em assembleias, que disciplina os princípios gerais, o processo decisório e quais são as matérias relevantes obrigatórias para o exercício do direito de voto. A política de voto utilizada pelo Gestor pode ser encontrada na sua página na Internet (https://autonomyinvestimentos.com.br/responsaveis/#governanca).</PoliticaExercicioDireitoVoto>
			<FuncResponsaveisPoliticaDivulgacao>ANA CAROLINA FERRACCIU COUTINHO MOURA - CNPJ 082.603.027-05 - Diretora responsável pelo Departamento Jurídico.</FuncResponsaveisPoliticaDivulgacao>
		</PoliticaDivulgacao>
		<RegrasPrazosChamadaCapital>As Chamadas de Capital serão realizadas pela Administradora mediante orientações e diretrizes estabelecidas pela Gestora, conforme prazo e procedimento estabelecido no Compromisso de Integralização, até que 100% (cem por cento) das Cotas subscritas tenham sido integralizadas pelos cotistas. Conforme definido em Boletim de subscrição.</RegrasPrazosChamadaCapital>
	</InformeAnual>
</DadosEconomicoFinanceiros>
"