Showing posts with label Claude Code. Show all posts
Showing posts with label Claude Code. Show all posts

21.6.26

Anthropic Just Made Claude Agents Boring. That's the Whole Point.

 The flashy AI announcements get the headlines — new model, higher benchmark, longer context. But if you've ever tried to actually deploy an agent inside a company with a security team, you know the model was never the hard part. The hard part is the question every CISO asks in the first meeting: how does this thing touch our systems without becoming the breach we read about next quarter?

On June 18, Anthropic answered the last open piece of that question. And the answer is delightfully unglamorous.

The news: identity finally caught up

Anthropic shipped Enterprise-Managed Authorization for Claude's MCP connectors. In plain terms: an admin provisions a connector once through the company's identity provider, and every employee inherits access automatically on first login. No individual OAuth consent screens. No "click allow" forty thousand times across the org. When someone leaves or changes roles, their connector access gets revoked alongside every other app — because it's governed by the same identity rules.

Okta is the first identity provider, using its Cross App Access plumbing. The connectors live at launch: Asana, Atlassian, Canva, Figma, Granola, Linear, and Supabase, with Slack rolling out. It's in beta, Team and Enterprise plans only.

If you've never run IT for a large org, this sounds like a footnote. If you have, you know it's the difference between "we piloted it with five people" and "it's live for the whole company."

The two pieces this builds on

Here's the context most of the recap posts are getting wrong: this isn't a standalone drop. It's the capstone on two features Anthropic shipped a month earlier, on May 19. Together the three are the actual enterprise story.

Self-hosted sandboxes (public beta) moved tool execution out of Anthropic's infrastructure and into an environment you control — your own infra, or a managed provider like Cloudflare, Daytona, Modal, or Vercel. The clever bit is the split: the agent loop that handles orchestration, context, and error recovery stays on Anthropic's side, but the code actually runs inside your perimeter. Your files don't leave. Your network policies and audit logging already apply. You set the compute.

MCP tunnels (research preview) solved the other half. Your agents can now reach MCP servers sitting inside your private network without exposing them to the public internet. A lightweight gateway you deploy makes a single outbound connection — no inbound firewall rules, no public endpoint, encrypted end to end. Your internal Postgres, your private APIs, your ticketing system become tools the agent can call, and none of them ever face the open web.

Why the trio matters

Line them up and you can see the strategy. The classic enterprise objection to AI agents has always been some version of "we can't let an external service into our internal systems." Anthropic just dismantled that objection at three different layers at once.

Tunnels mean no public endpoint and no VPN exceptions. Sandboxes mean code execution never leaves your walls. And enterprise-managed auth means access is provisioned and revoked through the identity system you already trust. Each one removes a specific veto that a security team can throw. Stack them and the "no" gets very hard to justify.

That's the real shift here. The bottleneck for enterprise AI was never reasoning quality. It was governance, and governance is exactly what this release is about.

The honest caveats

I'd be doing you a disservice if I made this sound finished. MCP tunnels is still a research preview — you request access, it's not broadly available. Self-hosted sandboxes is public beta, which means it's real but you should expect rough edges. And the enterprise-managed auth is beta, Team and Enterprise only, with Okta as the sole identity provider for now. If your stack runs on a different IdP, you're waiting.

So this is a direction, not a finished product. But it's the right direction, and it's further along than anything comparable from the other labs.

The takeaway

This release won't trend the way a new model does. There's no benchmark to screenshot. But if your job is getting agents past a security review and into production, this is the most important thing Anthropic has shipped this quarter. They made the deployment story boring — predictable, governable, auditable — and boring is precisely what enterprise buyers have been waiting for.

The model was always good enough. Now the plumbing is catching up.

20.6.26

Can You Really Build a Whole AI Marketing Team? A Friendly Look at the Idea

 There's a popular video going around that promises something pretty wild: turn Claude into a full marketing team — five "agents" and a dozen "skills" — all working together to research, write, design, and even build landing pages for you. And the best part of the pitch? "Even if you're not technical, let's go."

It's a genuinely exciting idea. But before you dive in, here's an honest, plain-English take on what's great about it, what's tricky, and the one rule you should never skip.



What's the big idea?

Think of it like hiring a small team that never sleeps. You give the AI some "skills" (reusable instructions for tasks you do all the time, like making a branded slide deck or writing a blog post) and a few "agents" (specialists, like a data analyst or a content writer). Then you hand it a job — "launch our summer campaign" — and it produces research, social posts, images, and a landing page, mostly on its own.

In the video, it works impressively well. The decks follow the brand template, the images match the style, and the whole package looks professional.

What's genuinely good about this

The most appealing part is the time saved. Tasks that used to eat a whole afternoon — drafting posts, pulling a report together, mocking up a deck — can come back in minutes. For a small business or a solo marketer, that's a real gift.

It's also more approachable than it used to be. You're mostly talking to the AI in normal language, not writing code. And the idea of building reusable "skills" is smart: you teach it your style once, and it remembers. That consistency is hard to get when you're rushing.

Finally, it lowers the barrier to trying things. Want three versions of a campaign to compare? You can have them quickly, then pick what actually works.

What's not so easy (especially if you're non-technical)

Here's the honest part. The video says "even if you're not technical," but the setup involves downloading VS Code, installing tools, connecting "MCPs," and editing configuration files. That's a fair bit more technical than the friendly framing suggests. None of it is impossible to learn, but expect a real learning curve, not a five-minute setup.

There's also a cost to maintaining all this. Skills and agents need updating as your brand and goals change. And the more you pile on, the more you have to keep organized.

The rule you should never skip: check everything

This is the most important point, so I'll say it plainly. AI makes mistakes, and a human always needs to check the work.

Even in the video, the creator admits the result is "90% done" and that some charts still need fixing. That last 10% matters enormously. AI can confidently state facts that are wrong, invent statistics, misquote a source, or get your pricing or product details subtly off. It won't always tell you when it's unsure — it often sounds just as confident when it's wrong as when it's right.

So treat every output as a first draft, never a finished product. Before anything goes public:

  • Fact-check the claims and numbers against a trusted source.
  • Read it for tone and accuracy — does it actually sound like your brand, and is everything true?
  • Double-check names, prices, links, and dates, which AI gets wrong surprisingly often.

You are the editor-in-chief. The AI is a fast, tireless assistant — not a replacement for your judgment.

The bottom line

Building an "AI marketing team" is a powerful idea, and the tools really can save you hours. If you're non-technical, go in knowing the setup is more involved than it looks, and start small with one or two simple skills.

Most of all, keep a human in the loop. AI can do the heavy lifting, but a person should always have the final read before anything reaches your audience.

12.9.25

How to Build High-Quality Tools for LLM Agents — Lessons from Anthropic

 As agents become more central to AI workflows, what separates a good agent from a great one often comes down to the tools it has—and how well those tools are designed. In “Writing effective tools for agents — with agents,” Anthropic shares a practical roadmap for building better tools powered by tools themselves, using Claude and the Model Context Protocol (MCP) as real-use labs.


What are “tools” in the agentic context?

Unlike conventional software APIs—deterministic functions that always give the same output for the same input—tools for agents must be built to coexist with non-deterministic systems. Agents like Claude must decide when to use tools, how to parse their output, and how to call them responsibly. A tool here is not just an API call; it's part of an interface contract between predictable software and unpredictable agent behavior. Tools are the mechanisms by which agents expand what they can reliably do. 


Key workflows: prototyping, evaluating, and iterating

Anthropic emphasizes an iterative workflow:

  1. Prototype early: Build simple versions of your tools. Use MCP servers or desktop extensions to connect your tool to Claude Code, allowing rapid experimentation and detection of rough edges. Include clear documentation that the agent can consume. 

  2. Run realistic evaluations: Create evaluation tasks that reflect real-world usage (multiple tool calls, complex chains, integration with other services). Use verifiable outcomes, not just “it seems right.” Capture metrics such as tool calls, token consumption, runtime, errors. Avoid toy tasks that underrepresent complexity. 

  3. Use agents to improve tools: Let Claude analyze transcripts and feedback to suggest refinements—maybe better prompt descriptions, more efficient tool outputs, clearer schemas. Anthropic reports improvements even for tools built by internal experts, purely by letting agents inspect tools’ performance. 


Best practices and guiding principles

Anthropic distills the lessons into a set of design principles. Key among them:

  • Choosing tools selectively: Not every API needs to become a tool. Tools should cover high-impact, repeated workflows—not wrapping every possible existing endpoint. Also, consolidate when possible. 

  • Namespaces and naming clarity: Clear, consistent naming helps agents pick the right tool. Avoid ambiguous names or overlapping functionality. Group related tools under logical prefixes or categories. 

  • Return meaningful, concise context: Tools should return high-signal info. Avoid overwhelming the agent with technical IDs, long metadata unless necessary. Also allow “concise” vs “detailed” response modes. 

  • Optimize for token efficiency: Use truncation, filtering, pagination. Prompt agents to use fewer tool calls or more precise queries. Efficient context limits make downstream tasks more reliable. 

  • Clear tool specs and descriptions: Explicit parameter naming, clear input/output formats, good examples. Prompt engineering of tool descriptions can significantly impact performance. 


Why this matters

Tools shape what agents can do. When tools are poorly described, overly broad, or return huge dumps of irrelevant context, agents waste resources, produce hallucinations, or fail to successfully orchestrate workflows. On the other hand, well-designed tools reduce ambiguity, reduce token use, reduce error, and let agents scale reliably across real-world tasks.

Especially as agents connect to many tools (hundreds via MCP servers), these design principles become the difference between brittle behavior and something that feels reliable and intuitive. Anthropic’s experience shows that many improvements come not from changing the LLM itself but refining the tools around it.


If you’re building agent tools or service/tool APIs for agents, following Anthropic’s workflow—prototype → evaluate → iterate—and using clear naming, context-efficient returns, and good documentation will set you up for tools agents actually use well.

Link: https://www.anthropic.com/engineering/writing-tools-for-agents

21.6.25

Anthropic Empowers Claude Code with Remote MCP Integration for Streamlined Dev Workflows

 Anthropic Enhances Claude Code with Support for Remote MCP Servers

Anthropic has announced a significant upgrade to Claude Code, enabling seamless integration with remote MCP (Model Context Protocol) servers. This feature empowers developers to access and interact with contextual information from their favorite tools—such as Sentry and Linear—directly within their coding environment, without the need to manage local server infrastructure.


🔗 Streamlined, Integrated Development Experience

With remote MCP support, Claude Code can connect to third-party services hosting MCP servers, enabling developers to:

  • Fetch real-time context from tools like Sentry (error logs, stack traces) or Linear (project issues, ticket status)

  • Maintain workflow continuity, reducing context switching between IDE tab and external dashboards

  • Take actions directly from the terminal, such as triaging issues or reviewing project status

As Tom Moor, Head of Engineering at Linear, explains:

“With structured, real-time context from Linear, Claude Code can pull in issue details and project status—engineers can now stay in flow when moving between planning, writing code, and managing issues. Fewer tabs, less copy-paste. Better software, faster.” 


⚙️ Low Maintenance + High Security

Remote MCP integrations offer development teams a hassle-free setup:

  • Zero local setup, requiring only the vendor’s server URL

  • Vendors manage scaling, maintenance, and uptime

  • Built-in OAuth support means no shared API keys—just secure, vendor-hosted access without credential management 


🚀 Why This Empowers Dev Teams

  • Increased Productivity: Uninterrupted workflow with real-time insights, fewer context switches

  • Fewer Errors: Developers can debug and trace issues precisely without leaving the code editor

  • Consistency: OAuth integration ensures secure, standardized access across tools


🧭 Getting Started

Remote MCP server support is available now in Claude Code. Developers can explore:

  • Featured integrations like Sentry and Linear MCP

  • Official documentation and an MCP directory listing recommended remote servers 


✅ Final Takeaway

By enabling remote MCP server integration, Anthropic deepens Claude Code’s role as a next-gen development interface—bringing tool-derived context, security, and actionability into the coding environment. This update brings developers closer to a unified workflow, enhances debugging capabilities, and accelerates productivity with minimal overhead.

 Fable is back, it's brilliant, and it will happily drain your wallet. One creator spent over $1,400 in the first four hours after rele...