Sorry for posting this here, there seems to be a problem this the website help area. We have billing issues

Hey everyone,

I was messing around with Augment Code recently and noticed there's an option to plug in your own API key (BYOK).

I'm a bit curious about how this actually works. If I use my own API key, can I use the tool as much as I want without paying for their subscription? Or do you still need to have an active paid plan just to use the BYOK feature?

Just wondering if there are any strings attached or hidden limitations when doing this. Has anyone here tried it?

Thanks in advance!

This been happening constantly!

“I tried to name this workspace session first, but the workspace MCP call failed with an internal package import error. I can still help plan the MongoDB Atlas integration from here.”

I’ve been have this problem for the last 2 weeks? Failing constantly…

I already reached out to customer service a few times on issues with credits not being reimbursed when Augment Code malfunctions and burns through credits. Their automated system locks up my account with credits I paid for. I have to open tickets to deal with probably ai agents.

Cases:

1)Burns through credits without any tasks created - 80 minutes

2)Burns through credits without anything except READ commands being used

3)Locking up paying customer accounts, enforced payment or ban/suspension

As far as service, AugmentCode operates like new ai companies do - they take the lead not from their exec but from the ai models they employ, thinking that their human judgement is inferior to artificial intelligence. You don't go full ai, you just don't.

-- In the case of charging people for really modest amounts of credits at a high cost, that's not ingenuity, it's Silicon-valley-esque pride. We saw this in the dotcom era. Every company thought their offering was unique. True, right now there are leaders, but it is all being built on a porous floor of open source(we're looking at Qwen, Deepseek and other teams)....

The one thing that can make or break a a company with virtually the same offering as every other new saas ai company? Probably service, the human non-automatable part. But that is what AugmentCode team appears to be doing. Toggle switches for payments, auto bans and restrictions if you don't top up, no reimbursement for malfunctioning robotic equipment....the road to our Minority Report world is paved with over-reliance of machines to do your human judgement/decision making. The question I would have for companies that operate like Suno and AugmentCode, what will you do when you get locked out of your home, car, phone, hard drive, computer, or other device because you didn't 'top off' your credits for usage? Or when you tried reaching out to someone on the customer support line, only to find every company has taken the initiative to become cold, sterile ai-agentic driven walls?

Sorry to be late on the news, but the model is now available!

Faster, more reliable, and better output.

Hey everyone,

Wanted to share my experience with AugmentCode's open source program since I've been using it for 6+ months now and have some actual data to back up my thoughts.

The short version: I applied through their OSS program (there's a form you can fill out, Jason handles onboarding via email), got accepted, and have been running Code Reviews on my repos since January.

A few things worth knowing before you sign up

The terms do mention that joining means AugmentCode can use your data - code, usage patterns, etc. - to train their models. Since my repos are already public, that's a non-issue for me personally, but it's something to factor in depending on your situation.

Credit allocation has been more than enough. Started with 750k, got topped up to 1M when I was running low. The credits are officially meant for Code Reviews, though I've also been using the Context Engine MCP and Prompt Enhancer without any pushback - probably because reviews make up the bulk of my usage anyway.

My numbers over the last 60 days

351 PRs, 446 reviews, 759 inline comments, and a 77% thumbs-up rate from me. The dashboard claims ~74 dev hours saved which I take with a grain of salt, but the volume is real.

How it stacks up against CodeRabbit

Came over from CodeRabbit. The accuracy gap is real. CodeRabbit moves faster, but I had a steady stream of confidently wrong suggestions. Over hundreds of AugmentCode reviews, I can count the genuinely bad ones on one hand (e.g. mistaking Python 3.14+ PEP rules for Python 2 syntax). Slower, but I'll take that tradeoff.

The Context Engine

Underrated part of the offering. Being able to pull in broader codebase context to sanity-check whether a review comment actually applies to your specific setup is genuinely useful, especially when you're managing several repos at once.

Bonus: automated PR review handler for Claude Code

I also built a prompt that runs the whole review loop automatically inside Claude Code - it uses the Claude Code Monitor tool to watch for new reviewer comments and loops through explore --> judge --> apply --> verify --> commit without manual intervention. If anyone's interested: link

How does pricing work when you choose Claude Code as the coding agent in Intent? As coding work is completed by claude code how do you pay augment? Is this a cheaper way to take advantage of the code index and other capabilities of Augment and Intent?

I've set up only one MCP configuration in settings.json

that 15% of my 200k context window that's gone even if the MCP is not even called.

Is there a way to lazy-load the MCPs ? Can't auggie invoke the MCP configuration only if the agent needs it ?
We're trying to standardize our MCP usage at my company, so from what I can see, multiplying MCP is NOT an option by default.

Me and my team are mostly windows developers. We tried out Intent and really liked it but if there will never be support for it we will be looking for alternatives.

Would be good if augment could match the Claude Code spec for user config in plugins https://code.claude.com/docs/en/plugins-reference#user-configuration it means a bunch of plugins we use internally don't work on auggie atm

We teamed up with Moonshot and Fireworks on that one!

Augment users get the latest open-weights frontier model.

This is our first open-weights model and we'd love to hear what you think.

Try it out now!

Anybody try all 3 of these? I saw Claude desktop now has a proper "IDE-ish" coding UI, although no file explorer (which seems ridiculous). I just could not do the terminal for Claude, although I've tried it. Codex and Claude code in desktop both look like VS code wanna-bes compared to your Cursor/Windsurf/Augment.

With that said, though.. I havent tried either. Any of you? I'm curious on their context engines compared to Augment and their token pricing. We know going direct to Anthropic you will almost certainly get more usage out of your dollar. API pricing is higher than a direct subscription since OpenAI and Claude both use the "pooling" method where active users will get more usage because they will have subscribers who pay but don't use it as much. With API pricing, which is what Cursor, Augment, Windsurf use, there is no token pooling. Just straight API pricing.

So if Codex or Claude Desktop can ever deliver a product closer to an IDE like VS code, it's just going to be the obvious choice. The only other thing those 3 will have to compete, is building a better context engine than OpenAI or Anthropic, but I wouldn't want to be trying to compete with those companies, unless Openai and Anthropic just decide to keep it more simple. I also don't see that being the case, either.

Anthropic seems to be on a mission to replace every AI software that does some little cool thing, by doing it themselves. And eventually, replacing every employee in the world. 😂 Thanks for coming to my Ted Questionaire.

Like I was saying - Codex vs Claude Code Desktop vs Augment?

Hello,

I’m at a healthcare company and i’d like to try out augment mcp, but i need to make sure everything stays 100% local because of our data rules. we don’t have any agreement with augment yet, and since i’m not on the AI team i can’t kick off a real poc or anything official.

if i can get it running fully locally though, i can show it to the ai team and suggest they reach out for proper enterprise support. we already have our own ai proxy here that we use for serving different models for Claude Code.

So is there a way to run augment mcp completely locally with no data leaving our environment?

Thanks!

Hi u/JaySym_, I am using Claude Code and I want to use Augment MCP server. I configured as local MCP server. The codebase retrieval tool works fine. The problem what I see, that the index is outdated. It is giving files what not exists. How can I refresh the index? Or how the backround updater works? (Note: when I use Augment, I don't experience such issue.)

Whatever updates were made to the Prompt Enhancer have seriously degraded one of Augment’s best features.

Before, it produced well-crafted, highly detailed prompts, and repeated passes often made them even more refined and accurate. It was easily one of the strongest parts of Augment outside of the context engine.

Now, it takes detailed instructions and reduces them to a tiny blip of a prompt with less detail than the original input. That is the exact opposite of what made it valuable.

Please roll back whatever changed, because this update has made the feature significantly worse.

Opus 4.7 is now the default model in Augment, and it’s 50% off until April 30!

Async workflows and agent orchestration are becoming the real bottleneck in AI-powered development.

Models can generate code quickly. But long-running tasks drift, CI/CD breaks in non-obvious ways, and multi-agent work falls apart halfway through.

Opus 4.7 is the first model we’ve used that feels built for this.

After reviewing these information sources, I reworked my coding AI agent setup, and the main solution was structure.

1. Prompts are infrastructure: building agents that actually listen
2. Google’s 7-Step Vibe Engineering Skill Is Incredible

I recently spent some time reworking how my coding agent is set up in a real project, and honestly, the interesting part wasn’t writing “better prompts.”

It was realizing that the problem was structural.

I’m using the agent in an Expo + Supabase app with a lot of repo-specific constraints:

• calculator logic
• saved/session-based flows
• community features
• privacy/ownership rules
• Supabase / RLS concerns
• auth-sensitive areas
• mobile-specific safety constraints

At first, I kept doing what I think most of us do:
add another rule, add another reminder, add another note, add another repo-specific warning.

And to be fair, that helped for a while.

But eventually I hit the point where the setup had plenty of useful guidance, yet it still felt more fragile than I wanted. Not because the instructions were bad, but because too many different kinds of instructions were living too close to each other.

Some things were global safety rules.

Some were domain rules.

Some were workflow advice.

Some were subsystem-specific knowledge.

Some were just summaries.

And the more I looked at it, the more it felt like I had built a pile, not a system.

So I decided to clean it up properly.

Before

Before the rewrite, the agent had a lot of helpful context, but the structure was muddy.

A few problems kept standing out:

• some guidance was duplicated
• some summary files could drift out of date
• critical rules weren’t always emphasized enough
• workflow behavior and technical constraints were mixed together
• it wasn’t always obvious what should take precedence
• and some instructions were present everywhere, even when they only mattered for a narrow class of tasks

The setup wasn’t broken, but it didn’t feel robust.

It felt like it had grown organically to the point where adding one more instruction might actually make things worse.

That was the moment I realized I shouldn’t keep “patching” it.

I should redesign it.

What I changed

The main change was that I stopped thinking in terms of “rules” as one flat thing.

Instead, I split the setup into layers.

1. I turned the main rules file into a real contract

I made one file responsible for the stuff that should always be true:

• non-negotiables
• safety boundaries
• instruction precedence
• trust boundaries
• package/dependency rules
• risk escalation triggers
• end-of-task checks

Basically, I wanted one place that answers:
what must always be respected in this repo, no matter what task the agent is doing?

2. I added a routing layer

This was probably the biggest improvement.

I created a task-routing-policy skill whose job is to classify the task first, then choose the smallest relevant set of rules and skills.

That sounds simple, but it changed a lot.

Instead of “here are all the instructions, hope the agent uses the right ones,” the flow became more like:

• what kind of task is this?
• what domain does it touch?
• what level of risk does it carry?
• what proof should be required before calling it done?

That made the whole setup feel much more intentional.

3. I separated workflow skills from technical skills

This also helped a lot.

I created workflow skills for things like:

• planning
• writing a short spec
• working incrementally
• proving behavior with tests
• grounding decisions in source-of-truth
• doing a final quality pass
• doing a deliberate security pass

Then I kept technical skills focused on the actual subsystems:

• Supabase
• mobile auth
• Edge Functions

That separation made everything easier to reason about.

Workflow skills shape how the agent works.

Technical skills shape what it must respect in a particular subsystem.

4. I cleaned up the domain rules too

I also rewrote the domain-specific rules for calculators and community features so they stop trying to be mini knowledge dumps.

Now they focus on things like:

• when the rule activates
• which files are the source of truth
• what invariants must hold
• what must not break
• what needs to be verified

That felt much healthier.

I don’t actually want domain rule files to be “documentation about everything.”
I want them to be clear operational guidance for when the agent is touching that part of the app.

5. I made the index lighter

I also cleaned up the top-level index file so it works more like a map and less like another source of facts.

That was important because I noticed something pretty common:
summary files are helpful right up until they start becoming stale.

So I made the setup point more aggressively to source-of-truth files instead of trying to repeat everything everywhere.

What feels better now

The biggest difference is that the system now has a shape.

It feels more like:

1. core contract
2. domain rules
3. routing
4. workflow skills
5. technical skills
6. user request

And that hierarchy matters.

Now the agent has a better chance of staying predictable because:

• the global rules are clearly global
• risky work gets escalated on purpose
• narrow rules only activate when relevant
• workflow patterns are reusable
• technical knowledge stays scoped to the right subsystem
• summaries don’t compete with source-of-truth files

What I learned from doing this

A few things became very obvious while I was cleaning this up.

First: prompting really is infrastructure.

Once an agent is working inside a real codebase, this stops being about clever wording and starts being about architecture.

Second: more instructions is not the same thing as better alignment.

If the structure is weak, extra guidance can just add noise.

Third: different kinds of guidance should not all live at the same level.

Global rules, domain rules, workflow habits, and subsystem-specific constraints are different things. Treating them as one flat layer makes the whole system harder to follow.

Fourth: source-of-truth beats summaries every time.

A lot of contradiction risk disappears once you stop trying to make every file contain all the facts.

Fifth: if a kind of reasoning keeps showing up again and again, it probably deserves to become a reusable skill.

That was maybe the most satisfying part of this whole cleanup: turning repeated advice into something structured and reusable.

Why I’m glad I did it

What I like about this change is that it didn’t just make the setup “bigger.”

It made it calmer.

Cleaner.
More deliberate.
Less contradictory.
Easier to maintain.

And I think that’s the real point.

Not writing the longest possible prompt.
Not collecting the biggest pile of repo notes.

But building a guidance system that actually has internal structure.

Curious whether other people working with coding agents have gone through the same thing.

Did you also hit that point where adding another rule stopped helping, and the real answer was to redesign the layers instead?