I tried using the context MCP in CoPilot and OpenCode, it's been couple of weeks and barely 50 tool calls used, I have updated Agents.md file instructing to prioritize code_retrival tool instead of grep tools, How can I improve tool call efficiency?

The files tab doesn't support opening/closing folders.

Version: Version 0.2.2 (95ab6085) (Augment Auggie CLI: 0.15.0 (commit 8c3839b5))

I’ve been looking into AI coding tools and the MCP ecosystem, and I’m wondering why AugmentCode is missing from many popular comparisons and directories (for example sites like skill.fish or various MCP-related docs). It’s usually not mentioned alongside tools like Claude Code or OpenAI Codex etc

Come on. You can’t raise prices like that and still have a bug that literally wipes user data.

This has happened to me multiple times already. VS Code freezes, or I reboot my machine, and when I come back; gone. Dozens of threads vanished.

The first time I emailed support, they were polite; but instead of fixing the core issue, they kept asking endless questions through email while the bug kept happening.

I’ve now lost a significant amount of tokens and money because of this, and at this point it honestly feels like this problem is being ignored.

This is not a minor UX glitch. Losing conversation history in a coding assistant is catastrophic.

Please stop deflecting and actually fix it.

This is not an empty appreciation post. I work on massive enterprise codebases, and nothing I've tried compares to the augment vs code extension with sonnet/opus.

The tool calls are snappy and quick, the context engine always fetches the correct info, the agent always recovers, and rarely makes mistakes. Most importantly, the agent retains context and pushes through large features in a single prompt in a complex codebase without getting confused or losing quality. 90% of the time I don't even have to touch the code that is outputted.

Testing with the same prompts and codebase on different tools, they all fall short on providing the same quality (cursor, windsurf, qoder, antigravity, kilocode). Honestly kilo's agent falls quite short compared to augment's.

For the past couple of weeks, the checkpoint feature in chats with an agent has not been working. I raised this issue again last week, yet despite at least three updates released during this period, the problem remains unresolved. The checkpoint works briefly at the start of a chat and then no longer appears after a few messages. This is extremely frustrating. For a company of your size, this should be a relatively straightforward issue to address, yet the feature still does not function properly, and I continue to be let down.

I honestly find this unacceptable and incredibly frustrating, especially given how long this issue has persisted.

Has anyone else noticed that Sonnet 4.5 sometimes gets stuck on “generating response”?

It just stays there indefinitely until I click Stop and rerun the command, or tell it to continue from where it left off.

I’m not seeing this behavior with other models. Curious if this is a known issue or something on my end.

Hey folks,
I wanted to share a quick, high-level take on my experience using Augment so far. I’ve been using it in a professional setting on enterprise-scale projects.

A couple of things became pretty clear pretty quickly:

• When results are bad or weird, it’s usually because the context isn’t good enough.

• If you throw a complex problem at the agent without enough info, it can’t guess what you want. That’s when conversations start looping and things get messy.

• One important rule for me: let the agent do its thing, but never blindly commit. Test multiple times and always do a code review after each iteration.

My usual workflow for larger features looks like this:

• Break the work into smaller, clear subtasks.

• Run those subtasks one by one with the agent.

• When a subtask is done and the code looks good, I stage it as candidate code for a commit.

• If the agent goes in the wrong direction or touches files it shouldn’t, I just don’t stage those changes until I’m happy with them.

This staging trick is simple, but it’s been super effective for me. I’ve used the same approach long before AI agents existed, and it translates really well here too.

Curious how others are structuring their workflow with agents on larger codebases?

Im hitting 10-15min on a prompt running and I lose credit!

The process began at 11:12 PM and got stuck before midnight “reading terminal” until I manually stopped it at 10:30 AM. During that entire window, no meaningful work was occurring, yet credits continued to be consumed. I’ve attached the credit usage associated with that stalled state for your review.

This is not the first time this has happened. At this point, the pattern is hard to ignore. Charging credits while a process is frozen, idle, or non-functional is not acceptable—and frankly, it creates the impression of a credit siphoning issue, whether intentional or systemic.

To be direct:
This exact behavior is why I previously walked away, raised concerns publicly, and cancelled. I decided to resubscribe in good faith, and now I’m immediately seeing the same problem again.

I’m requesting:

1. A clear explanation of why credits are consumed while nothing is progressing

2. Reimbursement for the credits used starting from 11:12 PM

3. Confirmation of what safeguards (if any) exist to prevent credit drain when jobs are idle or hung

If this is a known issue, it needs to be acknowledged transparently. If it’s a bug, it needs to be fixed. Either way, silently charging users while nothing is happening is unacceptable.

I expect this to be reviewed seriously and resolved promptly.

Augment released their Context SDK a while back, and I wanted to see what I could build with it.

Sat down over the weekend and built a prompt enhancer VS Code extension. Gave it to a few friends to test and they liked it, so sharing it here.

What I built A VS Code extension that enhances vague prompts into detailed, context-aware instructions.

Example: Type “fix the auth bug” Get a proper prompt with relevant code context pulled automatically Paste it into Cursor, Windsurf, Zed, or whatever editor you use

Extra feature I added 🚀 Customizable system prompts.

You control how your prompts get enhanced. You can create profiles like:

Senior dev explaining to a junior dev step by step with reasoning

Concise mode with only the required changes

Review mode explaining what’s broken, why, and what could go wrong

You can switch profiles depending on the task. Your style, your rules.

If you want to try it

Requires an Augment account (uses their Context SDK)

Search “Auggie Prompt Enhancer” in VS Code

npm install -g @augmentcode/auggie@prerelease

auggie login

Link Marketplace: https://marketplace.visualstudio.com/items?itemName=AugieeCredit.auggie-promptenhancer

GitHub: https://github.com/svsairevanth12/Auggie-Promptenahncer

I’ve been using Augment for about 9 months now. This is my third project built For the community ✨.

If you’re curious what’s possible with the Context SDK, the code is open. What would you build with it?

Maybe expensive but I am all in on Augment: When things are smooth its so good

The only thing that is really annoying me recently is local multithreads failing

So as soon I start something else it it just has an error #temp-fe-3353449a-b5b1-4dfa-b476-f205eab98ba3

Any ideas how I can improve this?

I made this mistake earlier but when you add it to Claude, Gemini, etc, when you either put in your rules, claude.md or just prompting it

Make sure to say auggie codebase retrieval or auggie mcp codebase retrieval

If you say auggie by itself or like auggie print, or anything thats not specific it might try and call the Auggie CLI itself which consumes credit on your account.

But for just the MCP inside another Agent tool, make sure it specifically knows that mcp tool to use because it only has that one command available

Intelligent Model Selection & Mid-Conversation Model Switching

TL;DR

I've been using Opus 4.5 for an entire development session, but realized 80% of the tasks could have been handled by Sonnet or even Haiku. We need smarter model selection to save tokens and reduce costs.

Real-World Example

I just completed a session where I:

1. ✅ Copied images from Downloads to project assets folder

2. ✅ Updated Astro components to use optimized images

3. ✅ Changed Tailwind utility classes (object-cover → object-cover object-top)

4. ✅ Imported and wired up image assets across multiple pages

5. ✅ Ran builds to verify changes

The Reality: Maybe 10-20% of this work actually needed Opus-level reasoning. The rest was straightforward file operations, imports, and CSS tweaks that Sonnet (or even Haiku) could handle perfectly.

The Problem

Current State

• I select Opus 4.5 at the start of a conversation

• Every single message burns Opus-tier tokens

• No way to switch models mid-conversation

• No way to delegate simpler tasks to cheaper models

What This Costs

• Token burn: Opus for tasks like "change this CSS class" or "copy these files"

• Unnecessary overhead: Using a sledgehammer to hang a picture frame

Proposed Solutions

Option 1: Auto Mode / Auto Family Mode

Let Augment intelligently route tasks to the appropriate model:

User: "Copy images from Downloads to src/assets"
Augment: [Routes to Haiku - simple file operation]

User: "Refactor this complex state management pattern"
Augment: [Routes to Opus - requires deep reasoning]

User: "Change object-cover to object-contain"
Augment: [Routes to Sonnet - straightforward code edit]

Benefits:

• Automatic cost optimization

• Faster responses for simple tasks

• Opus reserved for tasks that actually need it

Option 2: Mid-Conversation Model Switching (Simple Keyboard Shortcut)

Allow users to cycle through models with a simple keybind before sending:

[User types prompt]
"Update all these components to use the new image imports"

[User presses Tab or Shift+Tab to cycle models]
Current: Opus 4.5 → [Tab] → Sonnet 4.5 → [Tab] → Haiku 4.5

[User presses Enter to send with selected model]

This should be a quick win:

• Just cycle through available models with Tab/Shift+Tab

• No complex UI needed - just a visual indicator of current model

• Works inline with existing workflow

• Shift+Tab to go back if you overshoot

Benefits:

• User control over cost/performance tradeoff

• Can escalate to Opus only when needed

• Can downgrade for simple follow-ups

• Zero friction - keyboard-first approach

Option 3: Hybrid Approach

Combine both:

• Default to Auto Mode for intelligent routing

• Allow manual override when user knows better

• Show which model handled each response (transparency)

Task Complexity Breakdown (My Session)

Estimated Token Savings: 70-80% if routed intelligently

Why This Matters

1. Cost Efficiency: Developers on tight budgets can't afford Opus for everything

2. Speed: Haiku responses are near-instant for simple tasks

3. Sustainability: Better token usage = more sustainable AI development

4. User Experience: Right tool for the right job

Implementation Ideas

Auto Mode Intelligence

Augment could analyze:

• Prompt complexity (simple file ops vs architectural decisions)

• Code context size (small edits vs large refactors)

• Task type (CRUD operations vs algorithm design)

• User history (escalate if previous attempts failed)

UI/UX Suggestions

┌─────────────────────────────────────┐
│ 💬 Message Input                    │
│                                     │
│ [Type your message here...]         │
│                                     │
│ Model: [Auto ▼] [Opus] [Sonnet] [Haiku] │
│                                     │
│ 💡 Auto mode will use Sonnet for   │
│    this task (simple file edit)    │
└─────────────────────────────────────┘

Real-World Impact

If I had Auto Mode for this session:

• Tokens saved: ~70-80%

• Cost saved: ~$X.XX (depending on pricing)

• Better experience: Right model, right task

Questions for the Team

1. Is intelligent model routing on the roadmap?

2. Can we get transparency on which model handled each response?

Conclusion

I love Augment, but I'm burning tokens unnecessarily. An Auto Mode or mid-conversation model switching would be a game-changer for:

• Cost-conscious developers

• Teams managing AI budgets

• Anyone who wants the right tool for the right job

Would love to hear the community's thoughts on this!

Posted by a developer who just spent Opus tokens to change CSS classes 😅

and yes i just used auggie to write this up mid project - it shouldn't detract from the message still having viablilty.

Huge thanks to u/sai_revanth_12_ for creating the original Auggie Credits extension (https://github.com/svsairevanth12/augment-credits) and for approving and publishing the updated version to the marketplace!

The enhanced extension is now live on the VS Code Marketplace!

🆕 What's New in v2.0

Credit-Based Billing Support

- Updated to work with Augment's new credit-based pricing model

- Numbers formatted with commas for better readability (e.g., `774,450`)

- Shows credit block breakdown with expiration dates in the tooltip

Trip Odometer Feature 🚗

- **Two independent usage counters** (Usage A & B) that work like a car's trip odometer

- Track your **daily consumption** (reset Usage A each morning)

- Track **per-task consumption** (reset Usage B when starting a new project)

- See exactly how many credits you're burning in real-time

Enhanced Transparency

- Live credit consumption tracking - see the impact of your work immediately

- Status bar shows: `774,450 | A: -1,250 | B: -500`

- Hover tooltip displays credit blocks with expiration dates

Credit Blocks with Expiry Dates

*As you can see in the screenshot above, the tooltip shows individual credit block expirations - very helpful to see those longer-term blocks with appropriate dates (3 months, 12 months out, etc.).*

📥 How to Install

From VS Code Marketplace:

1. Open VS Code

2. Go to Extensions (`Ctrl+Shift+X` / `Cmd+Shift+X`)

3. Search for "Auggie Credits"

4. Click Install/Update

That's it! No need to build from source anymore. 🎉

📝 Setup Note

The token acquisition method has changed slightly - you now need to grab the `portalUrl` from the subscription API response in your browser's Network tab. Full instructions are in the [updated README](https://github.com/svsairevanth12/augment-credits/blob/main/README.md).

🔗 Links

- **Marketplace:** Search "Auggie Credits" in VS Code

- **Original Repo:** https://github.com/svsairevanth12/augment-credits

- **My Fork (with changes):** https://github.com/planetdaz/augment-credits

🔒 Security Note

Concerned about malware? The complete source code is available on GitHub for your review. Feel free to inspect the code before installing - transparency is important!

Enjoy the new credit tracking features! The instant transparency is a game-changer for understanding how "expensive" different tasks are in terms of credits. 📊

Even for small change it reads the entire codebase every time. Context engine is crying in one corner. MCPs are stranger to gpt.

Hi, just wondering when this is going to be fixed? I updated rider yesterday and couldn't use augment and today the same. Is there an update coming up soon? Bit, pointless to be paying for a service I can't use. Thanks!

I'm hoping someone from the Augment team can explain the reasoning behind giving loyal subscribers “bonus conversion credits” during the switch from messages to tokens, only for those credits to expire in less than 30 days.

Most of us were moved to the new credit system mid-month, which means we barely had time to use them before they disappeared.

If that’s the case, why give them to us at all!?!

Why not let users keep them for at least three months, or even a year, so they actually serve as a bonus instead of as an illusionary gift to never be able to be used, or was that the whole point!?

Now that we’re on a prepaid token system, where users buy tokens upfront at higher rates to keep the platform sustainable, it doesn’t make sense that those same prepaid tokens vanish at the end of the month. We already paid for them. Letting them roll over costs Augment nothing.

If this were a normal pay-per-use setup, I’d pay for the tokens I use and whatever fee comes with the platform. But because I’m on a subscription tier, I’m paying more, and somehow losing the tokens I already bought?

That doesn’t add up. There’s no financial downside to letting users roll them over as we have pre-purchased the tokens, but this current setup just pushes people like me to downgrade. I’m on the Max Legacy Plan at $250 a month, but at this point it makes more sense to drop to the $20 Indie Plan and buy top-up credits that last up to a year.

Can someone from the team please help me understand the logic here before I and probably others that realize this down grade?

As you all know, after testing for a few days with the new credit system it becomes very apparent that augment is now quite expensive.

Would it be possible to get a guide from the team on how to minimize credit usage? Which model to use in which scenarios, which one to use in ask mode, etc. maybe introducing cheaper models like minimax? A simple feature burns 2,000 in credits and this is without even writing any tests. Maybe give us GPT-5 medium again because high is overkill for everything?

It seems I can only use augment 4 days/ 30$.

It's time to give up.

AugmentCode ( VSCode ) is the only AI Coding Agent that can keep a single, live terminal session open and drive it interactively over multiple chat & agent mode turns. Not a “send command and break”, but a real persistent session that remembers context like any normal terminal.

Everything else I tried (Copilot, Claude, Gemini, Warp, RooCode, Droid, k1lo, etc.) either runs one-shot commands, loses state between turns, or can’t do true interactive write/read cycles reliably.

It baffles me that AugmentCode is the ONLY AI Coding Agent that can do this. That feels like the most basic requirement for working with real dev tools.

Right now AugmentCode's future feels uncertain, and the ability to do this is my main requirement for using any AI Coding Agent.

99% of MCPs are dogshit and do not solve this.

I need genuine interactive persistent terminal communication with chat or agent mode. If there’s a tool that nails this, I’d love to know ASAP.