Modelagem de Estados Mentais BDI

Esta habilidade deve ser usada ao modelar estados mentais de agentes com conceitos BDI: crenças, desejos, intenções, transformações RDF em crenças, traços de agência racional, agentes cognitivos, ontologias BDI e integração de IA neuro-simbólica.

O que é Modelagem de Estados Mentais BDI?

Esta habilidade capacita agentes a transformar contexto RDF externo em estados mentais formais (crenças, desejos, intenções) usando padrões de ontologia BDI. Ela é essencial para construir agentes cognitivos com raciocínio deliberativo, explicabilidade e interoperabilidade semântica em sistemas multiagente. Suporta frameworks BDI estabelecidos como SEMAS, JADE e JADEX, além de integrar-se com técnicas de Geração Aumentada por Lógica (LAG) para restringir saídas de LLMs com estruturas ontológicas. O fluxo de trabalho principal segue o paradigma Triples-para-Crenças-para-Triples (T2B2T), permitindo que agentes consumam dados semânticos de entrada e projetem seus estados mentais de volta em RDF, fechando o ciclo entre percepção, deliberação e ação. A habilidade enfatiza a importância de justificativas rastreáveis, dimensões temporais e decomposição composicional de estados mentais para garantir transparência e manutenibilidade em sistemas de agência racional.

Funciona com~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/muratcankoylan/Agent-Skills-for-Context-Engineering/tree/main/skills/bdi-mental-states

Installed? Explore more Programação e Desenvolvimento skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

O que Modelagem de Estados Mentais BDI faz?

Transforme contexto RDF externo em estados mentais de agente (crenças, desejos, intenções) usando padrões formais de ontologia BDI. Esta habilidade permite que agentes raciocinem sobre o contexto por meio de arquitetura cognitiva, suportando raciocínio deliberativo, explicabilidade e interoperabilidade semântica em sistemas multiagente.

Quando Ativar

Ative esta habilidade quando:

  • Processar contexto RDF externo para crenças do agente sobre estados do mundo
  • Modelar agência racional com ciclos de percepção, deliberação e ação
  • Habilitar explicabilidade por meio de cadeias de raciocínio rastreáveis
  • Implementar frameworks BDI (SEMAS, JADE, JADEX)
  • Aumentar LLMs com estruturas cognitivas formais (Geração Aumentada por Lógica)
  • Coordenar estados mentais em plataformas multiagente
  • Rastrear evolução temporal de crenças, desejos e intenções
  • Vincular estados motivacionais a planos de ação

Não ative esta habilidade para trabalhos adjacentes de propriedade de outras habilidades:

  • Explicações gerais de janela de contexto ou mecânicas de atenção: context-fundamentals.
  • Memória persistente de usuário, entidade ou conversa sem estado BDI formal: memory-systems.
  • Decisões de topologia de supervisor, enxame ou handoff: multi-agent-patterns.
  • Rubricas gerais de avaliação de agentes ou portões de qualidade: evaluation.

Conceitos Centrais

Arquitetura da Realidade Mental

Separe os estados mentais em duas categorias ontológicas porque o raciocínio BDI requer distinguir o que persiste do que acontece:

Estados Mentais (Endurantes) -- modele-os como atributos cognitivos persistentes que se mantêm ao longo de intervalos de tempo:

  • Belief: Representa o que o agente considera verdadeiro sobre o mundo. Fundamente cada crença em uma referência de estado do mundo.
  • Desire: Representa o que o agente deseja realizar. Vincule cada desejo de volta às crenças que o motivam.
  • Intention: Representa o que o agente se compromete a alcançar. Uma intenção deve cumprir um desejo e especificar um plano.

Processos Mentais (Perdurantes) -- modele-os como eventos que criam ou modificam estados mentais, porque rastrear transições causais permite explicabilidade:

  • BeliefProcess: Dispara a formação/atualização de crenças a partir da percepção. Sempre conecte a um estado do mundo gerador.
  • DesireProcess: Gera desejos a partir de crenças existentes. Preserva a cadeia motivacional.
  • IntentionProcess: Compromete-se com desejos selecionados como intenções acionáveis.

Padrão de Cadeia Cognitiva

Conecte crenças, desejos e intenções em cadeias direcionadas usando propriedades bidirecionais (motivates/isMotivatedBy, fulfils/isFulfilledBy) porque isso permite tanto o raciocínio direto (o que o agente deve fazer?) quanto o rastreamento reverso (por que o agente agiu?):

:Belief_store_open a bdi:Belief ;
    rdfs:comment "A loja está aberta" ;
    bdi:motivates :Desire_buy_groceries .

:Desire_buy_groceries a bdi:Desire ;
    rdfs:comment "Desejo comprar mantimentos" ;
    bdi:isMotivatedBy :Belief_store_open .

:Intention_go_shopping a bdi:Intention ;
    rdfs:comment "Comprarei mantimentos" ;
    bdi:fulfils :Desire_buy_groceries ;
    bdi:isSupportedBy :Belief_store_open ;
    bdi:specifies :Plan_shopping .

Fundamentação em Estado do Mundo

Sempre fundamente estados mentais em referências de estado do mundo, em vez de descrições em texto livre, porque crenças não fundamentadas quebram a consulta semântica e a interoperabilidade entre agentes:

:Agent_A a bdi:Agent ;
    bdi:perceives :WorldState_WS1 ;
    bdi:hasMentalState :Belief_B1 .

:WorldState_WS1 a bdi:WorldState ;
    rdfs:comment "Reunião agendada para as 10h na Sala 5" ;
    bdi:atTime :TimeInstant_10am .

:Belief_B1 a bdi:Belief ;
    bdi:refersTo :WorldState_WS1 .

Planejamento Orientado a Objetivos

Conecte intenções a planos via bdi:specifies, e decomponha planos em sequências ordenadas de tarefas usando bdi:precedes, porque essa separação permite reutilização de planos em diferentes intenções, mantendo a ordem de execução explícita:

:Intention_I1 bdi:specifies :Plan_P1 .

:Plan_P1 a bdi:Plan ;
    bdi:addresses :Goal_G1 ;
    bdi:beginsWith :Task_T1 ;
    bdi:endsWith :Task_T3 .

:Task_T1 bdi:precedes :Task_T2 .
:Task_T2 bdi:precedes :Task_T3 .

Paradigma T2B2T

Implemente Triples-para-Crenças-para-Triples como um pipeline bidirecional porque os agentes devem consumir contexto RDF externo e produzir novas asserções RDF. Estruture cada implementação T2B2T em duas fases explícitas:

Fase 1: Triples-para-Crenças -- Traduza triplas RDF recebidas em instâncias de crença. Use bdi:triggers para conectar o estado do mundo externo a um BeliefProcess, e bdi:generates para produzir a crença resultante. Isso preserva a proveniência dos dados de origem até a cognição interna:

:WorldState_notification a bdi:WorldState ;
    rdfs:comment "Notificação push: Solicitação de pagamento R$250" ;
    bdi:triggers :BeliefProcess_BP1 .

:BeliefProcess_BP1 a bdi:BeliefProcess ;
    bdi:generates :Belief_payment_request .

Fase 2: Crenças-para-Triples -- Após a deliberação BDI selecionar uma intenção e executar um plano, projete os resultados de volta em RDF usando bdi:bringsAbout. Isso fecha o ciclo para que sistemas downstream possam consumir as saídas do agente como dados vinculados padrão:

:Intention_pay a bdi:Intention ;
    bdi:specifies :Plan_payment .

:PlanExecution_PE1 a bdi:PlanExecution ;
    bdi:satisfies :Plan_payment ;
    bdi:bringsAbout :WorldState_payment_complete .

Seleção de Notação por Nível

Escolha a notação com base no nível de abstração C4 sendo modelado, porque misturar notações no nível errado obscurece em vez de esclarecer a arquitetura cognitiva:

Nível C4NotaçãoRepresentação do Estado Mental
L1 ContextoArchiMateLimites do agente, fontes de percepção externas
L2 ContainerArchiMateMotor de raciocínio BDI, armazenamento de crenças, executor de planos
L3 ComponenteUMLGerenciadores de estado mental, manipuladores de processo
L4 CódigoUML/RDFClasses Crença/Desejo/Intenção, instâncias de ontologia

Justificativa e Explicabilidade

Anexe instâncias bdi:Justification a toda entidade mental usando bdi:isJustifiedBy, porque estados mentais injustificados tornam o raciocínio do agente opaco e intraceável. Cada justificativa deve capturar a evidência ou regra que produziu o estado mental:

:Belief_B1 a bdi:Belief ;
    bdi:isJustifiedBy :Justification_J1 .

:Justification_J1 a bdi:Justification ;
    rdfs:comment "Anúncio oficial recebido por e-mail" .

:Intention_I1 a bdi:Intention ;
    bdi:isJustifiedBy :Justification_J2 .

:Justification_J2 a bdi:Justification ;
    rdfs:comment "Pré-condição de localização satisfeita" .

Dimensões Temporais

Atribua intervalos de validade a cada estado mental usando bdi:hasValidity com instâncias TimeInterval, porque crenças sem limites temporais não podem ser coletadas como lixo ou verificadas quanto a conflitos durante o raciocínio diacrônico:

:Belief_B1 a bdi:Belief ;
    bdi:hasValidity :TimeInterval_TI1 .

:TimeInterval_TI1 a bdi:TimeInterval ;
    bdi:hasStartTime :TimeInstant_9am ;
    bdi:hasEndTime :TimeInstant_11am .

Consulte estados mentais ativos em um momento específico usando filtros temporais SPARQL. Use este padrão para resolver conflitos quando múltiplas crenças sobre o mesmo estado do mundo se sobrepõem no tempo:

SELECT ?mentalState WHERE {
    ?mentalState bdi:hasValidity ?interval .
    ?interval bdi:hasStartTime ?start ;
              bdi:hasEndTime ?end .
    FILTER(?start <= "2025-01-04T10:00:00"^^xsd:dateTime &&
           ?end >= "2025-01-04T10:00:00"^^xsd:dateTime)
}

Entidades Mentais Composicionais

Decomponha crenças complexas em partes constituintes usando relações bdi:hasPart, porque crenças monolíticas forçam substituição completa em atualizações parciais. Estruture crenças compostas para que cada subcrença possa ser atualizada, consultada ou invalidada independentemente:

:Belief_meeting a bdi:Belief ;
    rdfs:comment "Reunião às 10h na Sala 5" ;
    bdi:hasPart :Belief_meeting_time , :Belief_meeting_location .

# Atualizar apenas o componente de localização sem tocar no horário
:BeliefProcess_update a bdi:BeliefProcess ;
    bdi:modifies :Belief_meeting_location .

Orientação Prática

Construa um Modelo BDI em Seis Passagens

Use este fluxo de trabalho ao converter contexto semântico externo em uma representação BDI:

  1. Defina o substrato de estado do mundo: Identifique os fatos ou eventos externos que o agente pode perceber. Modele-os como estados do mundo antes de criar crenças.
  2. Crie instâncias de crença: Traduza cada estado do mundo relevante em uma crença com proveniência, validade temporal e uma referência de justificativa.
  3. Derive desejos de crenças: Adicione desejos apenas quando uma crença criar uma motivação relevante para um objetivo. Vincule cada desejo à crença que o motiva.
  4. Comprometa intenções deliberadamente: Promova um desejo a uma intenção apenas quando o agente se comprometer com um plano. Registre o plano selecionado e as pré-condições.
  5. Projete resultados de ação de volta em triplas: Após a execução, emita os estados do mundo resultantes como RDF para que sistemas downstream possam consumir o novo estado.
  6. Valide com perguntas de competência: Consulte proveniência, motivação, sequência do plano e janelas de validade ativas antes de confiar no modelo.

Mantenha a Ontologia Pequena

Comece com Agent, WorldState, Belief, Desire, Intention, Plan, Task, Justification e TimeInterval. Adicione classes especializadas somente depois que as perguntas de competência provarem que o modelo central não pode responder às consultas necessárias. Uma ontologia compacta é mais fácil de serializar em prompts, mais fácil de validar e menos propensa a criar cadeias de raciocínio frágeis.

Use BDI Apenas Quando a Semântica do Estado Mental Importar

A modelagem BDI é justificada quando o sistema precisa de agência explicável: por que um agente acreditou em algo, que desejo essa crença criou, qual intenção foi selecionada e qual plano foi executado. Se o sistema só precisa lembrar fatos entre sessões, use memory-systems. Se só precisa dividir o trabalho entre agentes, use multi-agent-patterns.

Tópicos Detalhados

Padrões de Integração

Geração Aumentada por Lógica (LAG)

Use LAG para restringir saídas de LLM com estrutura ontológica, porque a geração não restrita produz triplas que violam as restrições de classe BDI. Serialize a ontologia no contexto do prompt, depois valide as triplas geradas contra ela antes de aceitá-las:

def augment_llm_with_bdi_ontology(prompt, ontology_graph):
    ontology_context = serialize_ontology(ontology_graph, format='turtle')
    augmented_prompt = f"{ontology_context}\n\n{prompt}"

    response = llm.generate(augmented_prompt)
    triples = extract_rdf_triples(response)

    is_consistent = validate_triples(triples, ontology_graph)
    return triples if is_consistent else retry_with_feedback()

Tradução de Regras SEMAS

Traduza padrões de ontologia BDI em regras de produção executáveis ao implantar em plataformas de agentes baseadas em regras. Mapeie cada link da cadeia cognitiva (crença-para-desejo, desejo-para-intenção) para uma regra HEAD/CONDITIONALS/TAIL, porque isso preserva a semântica deliberativa enquanto permite execução em tempo real:

% Crença dispara a formação de desejo
[HEAD: belief(agent_a, store_open)] /
[CONDITIONALS: time(weekday_afternoon)] »
[TAIL: generate_desire(agent_a, buy_groceries)].

% Desejo dispara o comprometimento da intenção
[HEAD: desire(agent_a, buy_groceries)] /
[CONDITIONALS: belief(agent_a, has_shopping_list)] »
[TAIL: commit_intention(agent_a, buy_groceries)].

Diretrizes

  1. Modele estados do mundo como configurações independentes de perspectivas do agente, fornecendo substrato referencial para estados mentais.
  2. Distinga endurantes (estados mentais persistentes) de perdurantes (processos mentais temporais), alinhando-se com a ontologia DOLCE.
  3. Trate objetivos como descrições, não como estados mentais, mantendo a separação entre camadas cognitivas e de planejamento.
  4. Use relações hasPart para estruturas meronímicas que permitem atualizações seletivas de crenças.
  5. Associe cada entidade mental a construtos temporais via atTime ou hasValidity.
  6. Use pares de propriedades bidirecionais (motivates/isMotivatedBy, generates/isGeneratedBy) para consultas flexíveis.
  7. Vincule entidades mentais a instâncias Justification para explicabilidade e confiança.
  8. Implemente T2B2T através de: (1) traduzir RDF para crenças, (2) executar raciocínio BDI, (3) projetar estados mentais de volta para RDF.
  9. Defina restrições existenciais em processos mentais (por exemplo, BeliefProcess ⊑ ∃generates.Belief).
  10. Reutilize ODPs estabelecidos (EventCore, Situation, TimeIndexedSituation, BasicPlan, Provenance) para interoperabilidade.

Perguntas de Competência

Valide a implementação com estas consultas SPARQL:

# CQ1: Que crenças motivaram a formação de um determinado desejo?
SELECT ?belief WHERE {
    :Desire_D1 bdi:isMotivatedBy ?belief .
}

# CQ2: Qual desejo uma intenção específica cumpre?
SELECT ?desire WHERE {
    :Intention_I1 bdi:fulfils ?desire .
}

# CQ3: Qual processo mental gerou uma crença?
SELECT ?process WHERE {
    ?process bdi:generates :Belief_B1 .
}

# CQ4: Qual é a sequência ordenada de tarefas em um plano?
SELECT ?task ?nextTask WHERE {
    :Plan_P1 bdi:hasComponent ?task .
    OPTIONAL { ?task bdi:precedes ?nextTask }
} ORDER BY ?task

Exemplos

Exemplo 1: Notificação RDF para cadeia BDI

Estado do mundo de entrada:

:WorldState_invoice_due a bdi:WorldState ;
    rdfs:comment "A fatura INV-42 vence amanhã" ;
    bdi:atTime :Time_2026_05_15 .

Projeção BDI:

:Belief_invoice_due a bdi:Belief ;
    bdi:refersTo :WorldState_invoice_due ;
    bdi:isJustifiedBy :Justification_billing_system ;
    bdi:motivates :Desire_avoid_late_fee .

:Desire_avoid_late_fee a bdi:Desire ;
    bdi:isMotivatedBy :Belief_invoice_due .

:Intention_pay_invoice a bdi:Intention ;
    bdi:fulfils :Desire_avoid_late_fee ;
    bdi:specifies :Plan_pay_invoice .

Exemplo 2: Decisão de limite

Se a tarefa for "lembrar que Alice prefere resumos concisos", use memory-systems. Se a tarefa for "representar por que o agente acredita que Alice prefere resumos concisos, que desejo essa crença cria e que intenção segue", use esta habilidade.

Referências

  • Rao, A. S., & Georgeff, M. P. (1995). BDI Agents: From Theory to Practice. Proceedings of the First International Conference on Multi-Agent Systems.
  • Braubach, L., Pokahr, A., & Lamersdorf, W. (2005). Jadex: A BDI Agent System Combining Middleware and Reasoning. Software Agent-Based Applications, Platforms and Development Kits.
  • DOLCE: A Descriptive Ontology for Linguistic and Cognitive Engineering. http://www.loa.istc.cnr.it/dolce/overview.html
  • SPARQL 1.1 Query Language. W3C Recommendation. https://www.w3.org/TR/sparql11-query/

Individual skills in this repo

This repo contains 19 individual skills — each has its own dedicated page.

advanced-evaluation

This skill should be used for advanced LLM evaluation: LLM-as-judge systems, direct scoring, pairwise comparison, rubric calibration, evaluator bias mitigation, confidence scoring, and automated quality assessment.

book-sft-pipeline

This skill should be used for book-to-SFT pipelines: ePub extraction, literary segmentation, author-voice dataset construction, style-transfer training, LoRA workflows, and model evaluation for voice replication.

comprehensive-research-agent

Ensure thorough validation, error recovery, and transparent reasoning in research tasks with multiple tool calls

context-compression

This skill should be used when long-running agent sessions need context compression, structured summarization, compaction, token-per-task optimization, or durable handoff summaries that preserve decisions, files, risks, and next actions.

context-degradation

This skill should be used for diagnosing and mitigating context degradation: lost-in-middle failures, context poisoning, context clash, context confusion, attention-pattern issues, and agent performance degradation caused by accumulated or conflicting context.

context-fundamentals

This skill should be used to explain or reason about the foundational concepts of context engineering: what context is, the anatomy of a context window, how attention mechanics work, the U-shaped attention curve, why context quality matters more than quantity, and the mental models needed to interpret every other context-engineering decision. Use this for conceptual explanation, onboarding, and background reading. Route operational work to the specialized skills: debugging attention failures goes to context-degradation, token-efficiency work goes to context-optimization, conversation summarization goes to context-compression, and project-shape decisions go to project-development.

context-optimization

This skill should be used for improving context efficiency: context budgeting, observation masking, prefix or KV-cache strategy, partitioning, token-cost reduction, retrieval scoping, and extending effective context capacity without lowering answer quality.

evaluation

This skill should be used when building agent evaluation systems: deterministic checks, regression suites, multi-dimensional rubrics, quality gates, production monitoring, baseline comparison, and outcome measurement for agent pipelines.

filesystem-context

This skill should be used when agent work needs file-backed context: durable scratchpads, tool-output offloading, just-in-time discovery, cross-agent handoff files, filesystem memory, or cleanup policies for context stored outside the prompt.

harness-engineering

This skill should be used when designing autonomous agent harnesses: research loops, evaluation scaffolds, locked and editable surfaces, durable logs, novelty gates, pruning, rollback, PR preparation, and human approval boundaries.

hosted-agents

This skill should be used when designing hosted or background agent infrastructure: sandboxed execution, remote coding environments, warm pools, session persistence, multiplayer collaboration, self-spawning agents, or Modal-style sandboxes.

latent-briefing

This skill should be used when the user asks to "share memory between agents", "KV cache compaction for multi-agent", "orchestrator worker context", "latent briefing", "reduce worker tokens", "cross-agent memory without summarization", or discusses Attention Matching compaction, recursive language models with workers, or token explosion in hierarchical agents.

long-horizon-prompting

This skill should be used when writing, enhancing, or evaluating the launch prompt for a long-running autonomous agent or a parallel multi-agent orchestration attacking a hard problem: pseudo-formal task briefs that define terms and an exact success predicate linguistically, enumerate non-counting outcomes, set persistence rules with explicit stop and return conditions and effort floors, manage a diverse portfolio of parallel approaches with an approach registry and blocked-route bookkeeping, and gate the return on adversarial audit. Route agent topology and coordination protocols to multi-agent-patterns, runtime control surfaces and loop governance to harness-engineering, evaluator and quality-gate construction to evaluation, judge design to advanced-evaluation, and compaction or memory mechanics to context-compression and memory-systems.

memory-systems

This skill should be used for persistent semantic memory in agent systems: cross-session knowledge retention, entity tracking, temporal validity, graph or vector retrieval, memory consolidation, and memory benchmark selection. Route file-backed scratchpads to filesystem-context, handoff summaries to context-compression, and token-efficiency tactics to context-optimization.

multi-agent-patterns

This skill should be used when designing multi-agent systems that need context isolation, supervisor or swarm coordination, explicit handoffs, parallel execution, or a decision on whether multiple agents are justified.

project-development

This skill should be used for project-level decisions about LLM-powered systems: whether an LLM is the right primitive for the task at hand, the shape of a multi-stage batch or agent pipeline, token and cost estimation, choosing between single-agent and multi-agent at the project level, structured output design for downstream parsing, and structuring agent-assisted iteration. Use this when the unit of work is a whole project or a multi-stage pipeline. Route individual tool design to tool-design and individual skill-loading or context-budget tactics to context-optimization.

self-improvement-loops

This skill should be used when the harness, scaffold, workflow, or optimizer itself is the optimization target: recursive self-improvement (RSI) loops, meta-harnesses, self-improving harnesses that mine their own failures and propose bounded edits, evolutionary or population-based search over agent scaffolds, acceptance gates for self-modifying systems, and agentic context evolution where the mechanism that produces context is versioned and evolved. Route governance of a single autonomous loop (locked surfaces, durable logs, rollback, novelty gates, approval boundaries) to harness-engineering, measurement and quality-gate design to evaluation, judge design to advanced-evaluation, and remote sandbox infrastructure to hosted-agents.

self-managed-context

This skill should be used when a model gets read-write control over its own live context window instead of a harness-scheduled compaction policy: the context exposed as an editable file the model rewrites with code tools, model-driven eviction and in-place updates, the harness invariants that keep self-editing safe (pinned prefix, edit gate, edit receipts, budget readouts, rollback on overflow), the prefix-cache cost of mid-context edits, and steering or training the model's own context-editing strategy. Route note content and fixed-threshold summarization to context-compression, cache-stable layout under harness control to context-optimization, file offloading to filesystem-context, and loop governance to self-improvement-loops.

tool-design

This skill should be used for the tool-interface layer of an agent system specifically: writing tool descriptions agents can route on, designing tool schemas and response formats, naming conventions, actionable error recovery messages, MCP server design, tool-set consolidation, and deciding when to add or remove an individual tool. Use this when the unit of work is a single tool or a set of tools. Route project-shape, pipeline architecture, and task-model-fit decisions to project-development; route deciding whether to introduce sub-agents to multi-agent-patterns.

Habilidades Relacionadas