details about Claude Models , Claude Tools, Memory , Environments and Interfaces

 Claude Models 

=============

Claude Code uses Claude models to understand your code and reason about tasks. Claude can read code in any language, understand how components connect, and figure out what needs to change to accomplish your goal. For complex tasks, it breaks work into steps, executes them, and adjusts based on what it learns.

Multiple models are available with different tradeoffs. Sonnet handles most coding tasks well. Opus provides stronger reasoning for complex architectural decisions. Switch with /model during a session or start with claude --model <name>.

Claude Tools

===========

Tools are what make Claude Code agentic. Without tools, Claude can only respond with text. With tools, Claude can act: read your code, edit files, run commands, search the web, and interact with external services. Each tool use returns information that feeds back into the loop, informing Claude’s next decision.

The built-in tools generally fall into five categories, each representing a different kind of agency.

Category What Claude can do

File operations Read files, edit code, create new files, rename and reorganize

Search Find files by pattern, search content with regex, explore codebases

Execution Run shell commands, start servers, run tests, use git

Web Search the web, fetch documentation, look up error messages

Code intelligence See type errors and warnings after edits, jump to definitions, find references (requires code intelligence plugins)

Claude chooses which tools to use based on your prompt and what it learns along the way. When you say “fix the failing tests,” Claude might:

Run the test suite to see what’s failing

Read the error output

Search for the relevant source files

Read those files to understand the code

Edit the files to fix the issue

Run the tests again to verify

Each tool use gives Claude new information that informs the next step. This is the agentic loop in action.

Extending the base capabilities: The built-in tools are the foundation. You can extend what Claude knows with skills, connect to external services with MCP, automate workflows with hooks, and offload tasks to subagents. These extensions form a layer on top of the core agentic loop. 

What Claude can access

When you run claude in a directory, Claude Code gains access to:

Your project. Files in your directory and subdirectories, plus files elsewhere with your permission.

Your terminal. Any command you could run: build tools, git, package managers, system utilities, scripts. If you can do it from the command line, Claude can too.

Your git state. Current branch, uncommitted changes, and recent commit history.

Your CLAUDE.md. A markdown file where you store project-specific instructions, conventions, and context that Claude should know every session.

Auto memory. Learnings Claude saves automatically as you work, like project patterns and your preferences. The first 200 lines or 25KB of MEMORY.md, whichever comes first, load at the start of each session.

Extensions you configure. MCP servers for external services, skills for workflows, subagents for delegated work, and Claude in Chrome for browser interaction.

Because Claude sees your whole project, it can work across it. When you ask Claude to “fix the authentication bug,” it searches for relevant files, reads multiple files to understand context, makes coordinated edits across them, runs tests to verify the fix, and commits the changes if you ask. This is different from inline code assistants that only see the current file.

Environments and interfaces

The agentic loop, tools, and capabilities described above are the same everywhere you use Claude Code. What changes is where the code executes and how you interact with it.

​

Execution environments

Claude Code runs in three environments, each with different tradeoffs for where your code executes.

Environment Where code runs Use case

Local Your machine Default. Full access to your files, tools, and environment

Cloud Anthropic-managed VMs, or self-hosted environments your organization operates Offload tasks, work on repos you don’t have locally

Remote Control Your machine, controlled from a browser Use the web UI while execution and your files stay local

Work with sessions

Claude Code saves your conversation locally as you work. Each message, tool use, and result is written to a plaintext JSONL file under ~/.claude/projects/, which enables rewinding, resuming, and forking sessions. Before Claude makes code changes, it also snapshots the affected files so you can revert if needed. For paths, retention, and how to clear this data, see application data in ~/.claude.

Sessions are independent. Each new session starts with a fresh context window, without the conversation history from previous sessions. Claude can persist learnings across sessions using auto memory, and you can add your own persistent instructions in CLAUDE.md.

​

Work across branches

Each Claude Code conversation is a session tied to your current directory. The /resume picker shows sessions from the current worktree by default, with keyboard shortcuts to widen the list to other worktrees or projects. See Manage sessions for the full list of picker shortcuts and how name resolution works.

Claude sees your current branch’s files. When you switch branches, Claude sees the new branch’s files, but your conversation history stays the same. Claude remembers what you discussed even after switching.

Since sessions are tied to directories, you can run parallel Claude sessions by using git worktrees, which create separate directories for individual branches.

​

How Claude Code works - Basics

Claude Code is an agentic coding tool that reads your codebase, edits files, runs commands, and integrates with your development tools. Available in your terminal, IDE, desktop app, and browser.

Claude Code is an AI-powered coding assistant that helps you build features, fix bugs, and automate development tasks. It understands your entire codebase and can work across multiple files and tools to get things done.

Claude Code runs on several surfaces: the terminal, IDE extensions, a desktop app, and the web. Choose one from the tabs below to get started. Most surfaces require a Claude subscription or Anthropic Console account. The Terminal CLI and VS Code also support third-party providers.

Claude Code is an agentic assistant that runs in your terminal. While it excels at coding, it can help with anything you can do from the command line: writing docs, running builds, searching files, researching topics, and more.

The agentic loop

When you give Claude a task, it works through three phases: gather context, take action, and verify results. These phases blend together. Claude uses tools throughout, whether searching files to understand your code, editing to make changes, or running tests to check its work.

The loop adapts to what you ask. A question about your codebase might only need context gathering. A bug fix cycles through all three phases repeatedly. A refactor might involve extensive verification. Claude decides what each step requires based on what it learned from the previous step, chaining dozens of actions together and course-correcting along the way.

You’re part of this loop too. You can interrupt at any point to steer Claude in a different direction, provide additional context, or ask it to try a different approach. Claude works autonomously but stays responsive to your input.

The agentic loop is powered by two components: models that reason and tools that act. Claude Code serves as the agentic harness around Claude: it provides the tools, context management, and execution environment that turn a language model into a capable coding agent.

Kiro with MCP kb

 

You already have a Knowledge Base

If your team already uses Amazon Bedrock Knowledge Bases, whether it was built for a chatbot, an internal search tool, or a customer-facing assistant, you don’t need to rebuild anything. Your existing Knowledge Base works with Kiro out of the box.

Here’s the approach:

1. Tag your existing Knowledge Base with mcp-multirag-kb=true. This is how the MCP server discovers it.
2. Configure the MCP server in Kiro (covered in the next section). Your documents, your embeddings, your vector store, all stay exactly where they are.

The official awslabs.bedrock-kb-retrieval-mcp-server auto-discovers Knowledge Bases with that tag. If you have multiple Knowledge Bases (one for API docs, another for architecture decisions, a third for runbooks), tag them all. Kiro can query across your tagged Knowledge Bases.

LLM watermark

 Announcements

How Claude’s text watermark works

14 Aug 2026

Future Claude models will generate text that contains a watermark. This is a way of determining the likelihood that Claude was involved in writing the text, and we, along with several other major AI providers, are implementing this change to comply with the EU AI Act.

In this article, we share answers to some of the questions we’ve received about how our chosen watermarking method works, whether it affects Claude’s outputs, and why we’re making this change. To summarize:

• We use a method of watermarking that does not have any practical impact on the quality or content of Claude’s outputs;
• The difference between watermarked and un-watermarked text will not be distinguishable to readers;
• Nothing is added to the text and there are no hidden characters;
• Watermarking doesn’t require extra tokens, and will not be more expensive;
• Watermarking carries no identifying information and can’t be traced to a specific person, organization, or chat;
• Watermarking won’t be specific to Claude. As of August 2, the EU requires AI providers serving its market to mark AI-generated content. Other major model developers have signed the same Code of Practice and will be implementing their own watermarks.

What is watermarking?

Large language models like Claude work by generating one word at a time. Each time the model decides on the next word, it chooses among a list of potential candidates, ultimately selecting the most sensible or likely based on the preceding text. Take the sentence “The weather today was cold and…”. The next word is very unlikely to be “sugary.” But it is quite likely to be “overcast” or “grey.” Under most circumstances, it doesn’t matter much to the reader which of these latter two words the model ultimately chooses—the meaning of the sentence is largely the same either way. In cases like this, the choice is settled by a random number.

Watermarking uses low-stakes choices like these—which occur many times over a piece of generated text—to leave a pattern in Claude’s responses. That pattern is undetectable to the reader, but is detectable to anyone who has a key that encodes it. When watermarking is used, choices are still made at random, but the source of the randomness is different. Instead of using an arbitrary random number generator to pick the next word, watermarking uses the key and a few words that come before to settle what word the model should pick. That is, the words that Claude picks are still random, but now, one can check the sequence of words and see if it’s consistent with the choices Claude would make if it was using the key. If it is, one can assign a probability that the text was generated by Claude.

Importantly, it isn’t that the model will now always be biased toward overcast or grey. Just as with non-watermarked text, overcast might be selected in one sentence, grey in the next, depending on the words that came before. And it’s not the case that the watermarking method pushes Claude to choose a word it wouldn’t have considered anyway (for instance, it wouldn’t make Claude pick a word like “nubilous”—an obscure¹ synonym for overcast or grey that Claude almost certainly wouldn’t use under normal circumstances).

What is Wikipedia Stream event?

 

The [https://stream.wikimedia.org/v2/stream/recentchange](https://stream.wikimedia.org/v2/stream/recentchange) endpoint is part of the Wikimedia EventStreams service. It provides a real-time, public "firehose" of activity happening across all Wikimedia wikis (including all language versions of Wikipedia, Wiktionary, Commons, etc.).

Here are the key details about how it works and how to use it:

1. How It Works

Format: It uses Server-Sent Events (SSE), an HTTP-based standard that allows servers to "push" data to clients.

Protocol: You connect to it as a standard HTTP stream. In most programming languages, you use an EventSource client library.

Underlying Tech: The stream is backed by Apache Kafka, which aggregates events from various MediaWiki installations before broadcasting them.

2. What Data You Get

Every time an action occurs on a Wikimedia site, a JSON-formatted event is pushed through the stream. These events include:

Edits: The most common event, detailing changes to articles.

User actions: New page creations, user registrations, and other log actions.

Metadata: Information like the wiki (e.g., enwiki), the user (or IP for anonymous edits), the title of the page, a timestamp, and the comment (edit summary).

3. Best Practices for Implementation

Use a Custom User-Agent: Wikimedia strictly requires a descriptive User-Agent header for all requests to their APIs/streams to identify your project and contact information. Requests with default or missing headers are frequently blocked or rate-limited.

Handle "Canary" Events: Occasionally, you will receive "canary" events used for monitoring the stream itself. You should filter these out (they are usually identified by meta.domain === 'canary').

Client-Side Filtering: The stream is a massive firehose. Since server-side filtering is not natively supported by the HTTP endpoint, your client code must perform filtering (e.g., by checking server_name or wiki) to process only the data you care about.

Resilience: Because network connections to a live stream can drop, implement an infinite loop with a reconnection strategy (as you did in your code) to ensure your service remains unattended and active.

Summary of Resources

Official Documentation: Wikitech: EventStreams.

MediaWiki API Help: API:Recent changes stream.

What is Muse Glimmer . How to get started with it in Ollama

Muse Glimmer is a 30-billion-parameter causal language model with a dedicated perception encoder, distilled from Muse Spark and purpose-built for autonomous agentic tasks on consumer hardware. The model integrates multi-step reasoning, reliable tool use, multimodal understanding, and failure recovery into a single model that runs locally without requiring cloud infrastructure or network access.

Get started

To download and run Muse Glimmer with Ollama, use:

ollama run muse-glimmer

Ollama’s MLX engine provides state-of-the-art performance on Apple Silicon, with support for DFlash and image input:

ollama run muse-glimmer:30b-mlx

Model information

End-to-end Agentic Task Completion. Muse Glimmer achieves strong success rates on full-task benchmarks including DeepSearch QA, MCP-Atlas, 𝛕3-Bench and SWE-Bench, which measure its ability to work within scaffolds, write and debug code, and resolve multi-turn requests from start to finish.

Reliable Tool Use. The model handles a wide range of function calls, invoking tools with precise schemas throughout extended workflows.

Multi-Step Reasoning. Muse Glimmer chains reasoning over long horizons, sustaining coherent plans across complex, extended workflows.

Failure Recovery. When a tool call fails or returns an unexpected result, the model diagnoses the error and retries rather than halt.

Multimodal Input and Reasoning. Through a dedicated perception encoder, the model accepts interleaved text and images. This enables agents to interpret screenshots, charts, and documents alongside conversation.

Scaffold Compatibility. Muse Glimmer works across OpenClaw, Hermes Agent, and other agentic orchestration patterns.

Controllable Effort. The model supports different reasoning strengths to select the right balance between quality and speed.

Multilingual. Muse Glimmer is trained on data from more than 100 languages.

What are the major differences between dot product vs Cosine similarity ?