GPT-6 Astra сжигает лимит за два дня — вот как это исправить

Problem: Why GPT-6 “Astra” burns weekly limits fast

In polished demos, GPT-6 Astra can produce a lot quickly (e.g., assembling a site in one prompt or building an app in an evening). But when working on a serious project, weekly token/usage limits can be exhausted in ~2 days.

The model itself isn’t blamed directly. Instead, the issue is attributed to an agent/context problem:

• The agent repeatedly loads extra manuals
• It loads hundreds of lines of login
• It includes a bloated memory file
• It re-reads all of this on every message, inflating the context size and token usage

Core optimization claim (five principles)

The speaker proposes five principles to reduce token waste without losing quality:

1. Measurement (find where tokens actually go first)
2. Cleaning of MCP (remove/limit external connectors)
3. Memory file optimization (compress/trim agent memory)
4. Skills & data filtering by model
5. Verification by task numbers

Main tool / product: CodebrN (Codeburn / Codburn) plugin

The central guide is installing a tool referred to in subtitles as CodebrN / Codburn / Codeburn (spelling varies). It includes:

• Installable via one terminal command
• A dashboard widget in the menu bar to show current token statistics across subscriptions
• Two key commands: Overview and Optimize

1) “Overview” (audit / reporting)

Used to audit current usage, including:

• Which models/projects were used
• Which instruments/connectors were involved
• Dates and directions of limit spending (when and where usage occurred)

It can show high-level stats and deeper breakdowns (with the option to query further if the output isn’t detailed enough).

2) “Optimize” (context cleanup recommendations)

Analyzes sessions/files and “garbage”/unused items, including:

• Unused MCP servers/connectors
• Unused skills
• Context components that can be removed or changed

Outputs concrete suggestions on what to move/remove to significantly optimize future context. The speaker recommends running it regularly.

Step-by-step optimization areas

A) MCP servers/connectors: avoid loading too many into context

Key claim: Most MCP connectors, once installed, effectively stay in the context even if you don’t use them.

Result: even a simple “hello” can load ~50,000 tokens, due to:

• system instructions + tool descriptions
• large tool metadata

Example mentioned: installing a GitHub MCP allegedly introduces ~26,000 context tokens just by being installed.

Recommended practices:

• Delete connectors you haven’t used in a long time
• Prefer connectors with lazy loading / on-demand tool loading:
  • only a table-of-contents/short description goes into context
  • full instructions load only when the tool is actually called
• If lazy loading isn’t available, follow three rules:
  1. Don’t keep everything enabled (MCPs still add context overhead even with TOC)
  2. Choose MCPs with few operations rather than hundreds of endpoints
  3. When possible, replace MCP with CLI-based integration (e.g., GitHub CLI / Google Workspace-style flows)

B) Skills hygiene: global skill overload wastes context and reduces quality

Skills have two-part context cost:

• Name/description is always loaded into context every session

With dozens/hundreds of skills, their descriptions can consume lots of context and also confuse the agent, causing:

• worse routing (agent may pick unnecessary skills)
• reduced final quality

Recommendation: regularly audit skills/tools (using the Codeburn-based approach) and avoid unnecessary global skill installation.

C) Agent memory file (“agents.md”): compress it

The agents.md file (project main memory) can become very large. Since it’s reloaded into context every new session, it increases token usage.

Fix: use “cavem compress” to analyze and compress agent memory without losing quality.

D) Additional startup tooling (3 useful steps out of 7)

The speaker describes an “entry/agent” setup with multiple steps (7 listed, but only 3 mandatory/useful):

• commands to measure token expenditure
• an implementation step to fix the same context problems (as an alternative to the Codeburn-based skill)
• wrapping the model/hardware (e.g., “code/claude”) using an “entrance”/space command

The goal is to feel the difference when using the improved entry/config.

E) Grapify: speed up large-project navigation

Problem: In large repositories, when the agent starts or changes tasks, it effectively “researches” the project to find relevant files—costing many tokens/actions.

Solution tool: grapify / graphify (spelled inconsistently)

• Builds a graph of file relationships across the repository
• Lets the agent read a table-of-contents/map and open only relevant files
• Reduces brute-force searching through folders

Claimed setup:

• two terminal commands
• then a Codex skill to install/create the graph automatically
• the graph is created once and reused, avoiding rebuilding from scratch

Where downloads/links are provided

The speaker says links and an archive/settings bundle are provided via Telegram (in the description and/or the first pinned comment).

The package includes:

• Codeburn / CodebrN
• the cavem compress tool
• a skill that analyzes context/limits
• grapify

Main speakers / sources

Primary source / speaker

• A single tutorial narrator (author of the Telegram program + demo/install instructions)

Tools referenced as sources/products

• Codeburn / CodebrN / Codburn plugin (audit: Overview, optimization: Optimize)
• Cavem (memory compression: compress)
• Grapify / Graphify repository plugin
• MCP servers/connectors and skills (conceptual components used with the agent)

Additional human speakers

• No specific additional human speakers are identified in the subtitles.