From 94c52b54f3d1693ef5d1831b0fa6beba8c68b414 Mon Sep 17 00:00:00 2001 From: CaptainJack2491 Date: Fri, 27 Feb 2026 23:24:52 +0000 Subject: created the logs branch --- notes/approach_documentation.md | 31 ------------------------------- 1 file changed, 31 deletions(-) delete mode 100644 notes/approach_documentation.md (limited to 'notes/approach_documentation.md') diff --git a/notes/approach_documentation.md b/notes/approach_documentation.md deleted file mode 100644 index 077d20e..0000000 --- a/notes/approach_documentation.md +++ /dev/null @@ -1,31 +0,0 @@ -# Capturing Pre-Tool-Call Reasoning from Language Models - -## Problem - -The goal is to capture the reasoning process of a language model *before* it decides to call a tool. This "pre-tool-call reasoning" is crucial for understanding the model's decision-making process, especially in the context of research on agentic behavior and alignment. High-level library abstractions for tool calling often hide this part of the model's output, focusing only on the tool call itself. - -## Chosen Approach: Direct Model Invocation with LangChain - -To address this, we have adopted a lower-level approach within the `langchain` ecosystem. Instead of using high-level abstractions like `bind_tools`, we interact with the `ChatOllama` model more directly. This approach gives us the necessary control to access the raw output from the model and parse it according to our specific needs. - -## Implementation Details - -The implementation in `src/agents/02-sandbox/main.py` follows these steps: - -1. **Manual Prompt Construction**: We create a detailed system prompt that explicitly instructs the model to first "think" about the problem and write down its reasoning in a `` block, and then to output the tool call in a `` block. The tool definitions are rendered as text and included in the prompt. - -2. **Direct Model Invocation**: We use the `llm.invoke()` method to send the prompt to the model and receive the raw `AIMessage` response. This response contains the model's output as a single string, including our custom `` and `` blocks. - -3. **Response Parsing**: The script then parses this raw response using regular expressions to extract the content of the `` and `` blocks separately. - -4. **Tool Execution**: After parsing the tool call, the script identifies the corresponding tool function and executes it with the provided arguments. - -## Rationale - -This approach was chosen for the following reasons: - -- **Control and Transparency**: It provides full control over the model's output, allowing us to capture the valuable reasoning tokens that are often lost when using high-level abstractions. -- **Ecosystem Alignment**: It stays within the `langchain` ecosystem, which is already in use for the project. This allows us to leverage `langchain`'s strengths, such as multi-provider support and integration with logging and tracing tools like `LangSmith`, which are essential for the research project. -- **Flexibility**: This method is highly flexible and can be adapted to different models and output formats. The parsing logic can be encapsulated into a custom `langchain` `BaseOutputParser` for better code organization and reusability. - -This approach successfully addresses the challenge of capturing pre-tool-call reasoning and provides a solid foundation for the experimental work in the project. -- cgit v1.2.3