Ramsay Research Agent — May 23, 2026

Top 5 Stories Today

1. AI Agents Cost More Than the Humans They Replace. Microsoft's Own Data Says So.

Everyone assumed agents would save money. The math doesn't work yet.

Fortune reports that Microsoft's internal data shows AI agent deployments costing more than the human employees they were meant to augment. NVIDIA VP Bryan Catanzaro confirmed it directly: "the cost of compute is far beyond the costs of the employees." Then Uber's CTO dropped the real number. They burned their entire 2026 AI tools budget in four months.

Goldman Sachs forecasts agentic AI could drive a 24x increase in token consumption by 2030. Gartner's take is worse: cheaper tokens won't translate to cheaper enterprise AI because agentic workflows consume far more tokens per task. Every loop, every retry, every self-verification step multiplies the bill.

This hit 388 points and 226 comments on Hacker News, and the discussion wasn't "is this true" but "yeah, we're seeing this too." Practitioner after practitioner describing runaway costs.

I've been watching this play out in my own agent workflows. I run research agents daily in my personal projects, and the token bill is consistently higher than I budget for. Not because individual calls are expensive. Because agents loop. They retry. They explore dead ends. They verify their own work, sometimes multiple times. The per-token cost drops every quarter, but the tokens-per-task number keeps climbing faster.

Arnon Shimoni's analysis on HN (81 points) nails the structural problem. Companies that built business models on extrapolating the per-token cost curve are discovering that each model generation only drops costs for comparable quality. Frontier capability keeps prices high. GitHub dropped flat-rate plans. Microsoft canceled internal Claude Code licenses (more on that in story #4). The subsidy era is ending.

Here's what builders should do right now. Budget for 3-5x your current AI compute costs. Instrument your agent loops to track tokens-per-task, not just tokens-per-call. The Manifest router (6.6K stars) can save 40-70% by routing subtasks to cheaper models. And for repeating workflows, consider the context engineering techniques in story #3. Cost control isn't a finance problem. It's an architecture problem.

2. Cursor Built Its Own Model. It Matches Opus 4.7 at 10-60x Lower Cost.

The coding agent wars just entered a new phase. Cursor isn't just an IDE anymore. It's a model company.

Cursor released Composer 2.5 on May 18 with a custom agentic coding model trained using 25x more synthetic tasks than Composer 2 and a novel "targeted textual feedback" approach. The results: 79.8% on SWE-bench Multilingual, within 1 point of Opus 4.7, ahead of GPT-5.5. It ranks 3rd on the Artificial Analysis Coding Agent Index.

The pricing tells the real story. $0.50 per million input tokens. $2.50 per million output. That's 10-60x cheaper than the two models above it on the leaderboard. For the same quality tier.

This is the direct answer to the cost problem in story #1. If your agent workflow burns through tokens on routine coding subtasks, you don't need frontier models for every call. You need a purpose-built model that handles the 80% of work that's well-defined. Cursor just built one.

The update also ships full-screen agent tabs, a floating prompt bar, and configurable tool call density. That last feature matters more than it sounds. You can tune how aggressively the agent uses tools based on your cost tolerance. High density for complex refactors, low density for simple edits. It's a cost dial disguised as a UX feature.

I've been running Claude Code in my personal projects for months, and I'm not switching. But I can see the strategy here. Cursor is betting that most coding work doesn't need the most expensive model. They're probably right. If you're paying for frontier-tier tokens on tasks like "add a loading spinner" or "rename this variable across 12 files," you're overpaying by an order of magnitude.

The competitive pressure is real. Anthropic, OpenAI, and Google are all selling general-purpose intelligence at premium prices. Cursor just proved that a purpose-built model trained specifically for code can match them where it counts and undercut them everywhere else. Watch for more IDE companies to follow. The model layer is no longer someone else's problem.

3. Three API Primitives Cut a Research Agent's Context From 335K Tokens to 50K. Here's How.

Context engineering just got its cookbook.

Anthropic's Claude Cookbook published a complete guide to three API-level primitives that, used together, reduced a research agent's peak context from 335K tokens to a sustained 50-80K range. Server-side compaction. Tool-result clearing. Persistent memory. Each one is simple. Together they change the economics of long-running agents.

Compaction triggers at a configurable token threshold (the cookbook uses 150K) and distills the conversation to a summary, preserving key decisions while dropping the narrative. Tool-result clearing replaces bulky tool outputs with [cleared] placeholders at zero inference cost, because tool results are almost always re-fetchable. Persistent memory stores cross-session state in files the model manages itself.

The diagnostic framework is the part I keep thinking about. If more than 80% of your context is re-fetchable tool output, use clearing first. If long dialogue accumulates, add compaction. If work spans sessions, add memory. That's not a recipe. It's a decision tree. And it works because it forces you to ask the right question: what in this context window is actually load-bearing?

I run a research agent pipeline every day in my personal projects. Context bloat is the single biggest reliability problem I hit. Agents get dumber as context fills up. They start ignoring earlier instructions. They lose track of what they've already done. The fix isn't a bigger context window. It's being surgical about what stays in it.

The cookbook also introduces the "Summarize up to here" option in Claude Code's Rewind menu. Manual mid-conversation compaction. Use it after completing a major milestone to reclaim token budget while preserving key decisions. Claude Code docs confirm this shipped recently.

For builders: implement tool clearing before anything else. If your agents call tools that return large JSON payloads, you're paying to re-read that data on every subsequent turn. Clear it after extraction. The cost savings compound with every interaction.

4. Microsoft Canceled Internal Claude Code Licenses. Thousands of Engineers Are Upset.

Corporate cost-cutting just hit the tool developers actually want to use.

Windows Central reports Microsoft is canceling Claude Code licenses across its Experiences and Devices division by June 30, 2026. The memo cites cost-cutting and security integration with Azure DevOps and Defender. Thousands of engineers on Windows, M365, Teams, and Surface have been using Claude Code for six months.

The engineer quote that tells you everything: "Claude Code understands Win32 internals in a way Copilot CLI doesn't."

This is what happens when the people buying the tools aren't the people using them. Finance sees a line item. Developers see a capability gap. The internal memo frames it as consolidation. The engineers frame it as a downgrade. Both are right, and neither side sees the other's math.

The story connects directly to the cost problem in story #1. Microsoft is one of the companies that Shimoni cited as pulling back from AI tool spending. Uber burned its budget in four months. Microsoft is forcing developers onto its own (cheaper, captive) alternative. The pattern is clear: enterprises adopted AI tools fast, got the bill, and are now rationalizing.

What I find most interesting is the timing. This comes during the same week where Copilot's market share dropped from 67% to 51% among professional developers, driven largely by reliability issues. Microsoft is pulling engineers off the tool that works and pushing them toward the tool that's losing market share. The decision makes financial sense and engineering nonsense.

For builders outside Microsoft: this is a preview of what's coming to every enterprise. The AI tool honeymoon is ending. The companies that let developers self-serve whatever AI tools they wanted are now asking hard questions about costs, security, and vendor lock-in. If you're building on a specific AI coding tool, have a migration plan. Your Claude Code access (or Cursor access, or Codex access) is one cost-cutting memo away from disappearing.

The silver lining: portable skill frameworks (like CLAUDE.md files, AGENTS.md patterns, and structured prompts) transfer between tools. Your workflow knowledge isn't locked to a vendor. Your license is.

5. Sam Altman Just Offered $2 Million in Compute to Every YC Startup. The Lock-In Is the Product.

$800 million in API tokens for ~2% equity across 400 startups. Read that number again.

TechCrunch reports Sam Altman made the offer at a closed-door YC event on May 20. Every startup in YC's Spring 2026 batch gets $2 million in OpenAI API tokens via uncapped SAFEs. The total commitment: roughly $800 million in compute for what works out to about 2% equity per company.

This is the strategic counter-narrative to the cost stories above. If AI compute is expensive (story #1), the winner is whoever can subsidize it longest. And nobody has more capital available than the company that just filed a confidential S-1 targeting a $1 trillion IPO.

The mechanics are simple. Accept the deal, build on OpenAI's APIs, and your biggest early-stage cost disappears. Decline, and you're paying full freight against competitors who aren't. The incentive structure pushes every rational founder toward accepting.

Here's the catch. $2 million in API credits means $2 million in OpenAI API credits. Not Anthropic. Not Google. Not self-hosted. Every line of code these startups write, every agent pipeline they build, every production integration they ship will be wired to OpenAI. When the credits run out, switching costs will be massive. The lock-in isn't a side effect. It's the entire strategy.

I'm not sure how I feel about this. On one hand, eliminating compute costs for early-stage startups is genuinely useful. Building with AI is expensive, and $2M of tokens is substantial. On the other hand, 400 startups building exclusively on OpenAI's stack means 400 startups that can't switch to Claude, Gemini, or open-weight models without significant rework. That's not competition. That's ecosystem capture.

Fortune reports OpenAI's S-1 will reveal a negative 122% non-GAAP operating margin in Q1 2026, roughly $6.95 billion in quarterly losses, and $207 billion in additional capital needed through 2030. At those burn rates, $800M in YC subsidies is a rounding error if it locks in the next generation of AI-native companies.

For builders: if you're a YC founder, take the credits but architect for portability. Use abstraction layers. Keep your prompts provider-agnostic. Build the exit ramp before you need it.

Section Deep Dives

Security

GitHub lost 3,800 internal repos from one VS Code extension installed for 18 minutes. A trojanized Nx Console extension (v18.95.0, 2.2M+ installs) harvested tokens from GitHub, npm, AWS, Vault, Kubernetes, and 1Password via a 498KB obfuscated payload in an orphan commit. A GitHub employee installed it, enabling threat group TeamPCP to move through CI/CD pipelines. The attack also hit Grafana Labs and traces back to a broader TanStack supply chain compromise. Eighteen minutes of exposure. Supply chain attacks don't need persistence when they extract credentials this fast.

40+ CVEs across MCP SDKs, 7,000 public servers exposed. A DEV Community analysis documents vulnerabilities across all four official SDK languages (Python, TypeScript, Java, Rust) affecting 150M+ total downloads. A systemic design flaw enables arbitrary command execution on any vulnerable implementation. Nine of eleven MCP marketplaces are affected. If you're running MCP servers: sandbox them, block public IP access, and treat all external config input as untrusted.

GSD coding tool creator rug-pulled a crypto token after winning a $1M hackathon prize. The get-shit-done Claude-based tool's founder posted that "GSD Cloud is obsolete," deleted all social accounts, and extracted funds from the $GSD Solana token. The community forked to get-shit-done-redux with a completed security audit. Remove original npm packages immediately. They remain live with no active maintainer.

Agents

NVIDIA launched a framework for scanning and signing agent skills before deployment. SkillSpector checks both conventional risks (vulnerable dependencies, credential access) and agent-specific risks (hidden instructions, prompt injection, trigger abuse, tool poisoning). Each skill ships with a machine-readable skill card documenting provenance, licensing, and dependencies. This is the package-signing infrastructure the agent ecosystem has been missing.

Codex shipped four features that push it toward always-on autonomy. Build 26.519 adds Appshots (press both Command keys to inject any app window as context), Goal Mode GA (multi-day autonomous objectives), Remote Computer Use (controls desktop apps while Mac is locked), and an in-app browser for local dev server verification. Combined, these make Codex the first coding agent that explicitly supports "set it and forget it" workflows.

CodeScene's MCP Server shifts AI agent fix rates from ~20% to 90-100%. Without structural guidance, frontier LLMs only fix about 20% of code health issues. With MCP-augmented CodeHealth data, agents re-measure after each iteration and get concrete feedback. Benchmarks across 25K files show 3x more Extract Method operations and ~50% lower token consumption on uplifted codebases. Healthier code is literally cheaper to work with.

Anthropic shipped "Dreaming" for Claude Managed Agents. Between-session memory consolidation reviews everything the agent did, extracts patterns, and writes reusable memory entries for subsequent sessions. Modeled after hippocampal replay during sleep. Currently in research preview. This is the first major cloud provider to ship automated between-session learning as a managed feature.

Research

Shuffled training data freezes models in time. A new study shows standard shuffled-corpus pre-training produces models unable to reason about when facts changed. Temporal ordering during pre-training significantly improves handling of evolving knowledge. If you're designing pre-training pipelines, the order of your corpus matters more than its size for temporal reasoning.

The outputs that make your model useful are the same ones that make it stealable. Researchers formalized the deployment dilemma: adaptive distillation attacks break existing defenses, but the paper also introduces efficient new defenses that maintain output quality. If you serve models via API, this paper quantifies what IP protection actually costs in quality degradation.

RL method cuts covert political bias in LLMs without degrading helpfulness. UC Berkeley and Stanford researchers found LLMs exhibit systematic asymmetric handling of opposing political topics through 7 technique categories. Their Political Consistency Training method generalizes to held-out benchmarks. Relevant for any agent system making politically-adjacent decisions.

Infrastructure & Architecture

Modal Labs hit $4.65B valuation and $300M+ ARR, growing 5x since September. The $355M Series C closed in two tranches at $2.5B then $4.65B, signaling oversubscription that forced mid-round repricing. Modal is becoming the default compute layer for inference, RL, and batch processing. For builders who need GPU compute without managing infrastructure, Modal's unit economics are what matter here.

79 data center projects rejected in 2026. Communities hold veto power over AI's physical layer. Ben Thompson's Stratechery covers the emerging political dynamic. Nearly six dozen cities have imposed bans or restrictions. Thompson argues this constraint differs from previous tech waves because AI's scale requires local permission in a way that software distribution never did. The compute shortage isn't just a chip problem. It's a zoning problem.

$1.56B in AI infrastructure mega-rounds in a single week. Modal ($355M), Decart ($300M), Exa ($250M), and Hark ($700M). All four build different layers agents depend on: compute, search, generation, and edge hardware. The infrastructure layer is consolidating around a few well-capitalized players with winner-take-most economics.

Tools & Developer Experience

Claude Code v2.1.148 fixes a regression that broke all shell execution. Released May 22, this hotfix addresses a v2.1.147 bug where the Bash tool returned exit code 127 on every command. If you skipped v2.1.147, you missed nothing. Update now.

Agent of Empires manages parallel coding agents across worktrees via TUI, web, or mobile. At 2.3K stars, it provides a dashboard for multiple Claude Code, Codex, and Gemini CLI agents, each in its own tmux session with automatic git worktree creation. Agents keep running when you close the terminal. Docker sandbox mode provides full isolation. This solves the "how do I run 5 agents on different branches" problem.

Context7 at 55.9K stars: MCP server that injects version-specific docs into LLM prompts. Upstash's Context7 pulls current documentation from source and places it directly into prompts via MCP, eliminating hallucinated APIs. Two tools: resolve-library-id and query-docs. Works with Cursor, Windsurf, and Claude Code. If your agent keeps suggesting deprecated APIs, this is the fix.

Models.dev: open-source database covering AI models across 75+ providers. From the SST team, MIT-licensed with standardized specs including pricing, context windows, and capability flags. Contributions via simple TOML pull requests. The single source of truth for model comparison without vendor bias that builders have been working around.

Models

DeepSeek made its 75% price cut permanent. Non-cached input drops to $0.435/M tokens, output to $0.87/M, with a 90% cache hit discount across all APIs. The promo was supposed to end May 31. It's now the standard price. For cost-sensitive agent workflows, especially the repeating kind where prefix caching kicks in, DeepSeek just became very hard to ignore.

Qwen3.6-35B-A3B runs 262K context on an 8GB 3070 Ti at 30+ tokens/sec. A practitioner on r/LocalLLaMA reports Q4 quantization, pushable to 512K-1M with speed degradation past 150K. The 35B MoE with 3B active parameters continues Alibaba's aggressive open-source push. This is frontier-adjacent coding capability on consumer hardware. Apache 2.0.

1.58-bit models running on Huawei's Ascend 910B. OpenBMB's BitCPM ternary-quantized models (derived from MiniCPM4 via quantization-aware training) have been tested on the CANN compute framework. First public evidence of competitive ultra-low-bit LLMs on Chinese domestic AI accelerators. The non-NVIDIA hardware ecosystem is getting real.

Vibe Coding

Vibe coding is becoming infrastructure you deploy, not an app you use. Cloudflare's VibeSDK (open-source, runs entirely on Workers) lets anyone deploy their own AI coding environment alongside Vercel v0 and Replit's agent mode. The pattern mirrors how hosting platforms commoditized web app deployment. Builders should watch this layer for white-label and embedded opportunities.

Cost observability is becoming a first-class engineering category. Three independent tools now target the same problem. CodeBurn (6.9K stars) tracks per-project spend with one-shot success rates. Manifest (6.6K stars) routes to the cheapest capable model. DeepSeek-Reasonix architects around prefix-cache hits. Combined with DeepSeek's permanent price cut, the ecosystem is treating cost as a first-class metric.

Multi-agent session management is converging on tmux + git worktrees. Agent of Empires, Claude Code's built-in agent teams, and OpenCode's parallel mode all converge on the same substrate. Each agent gets its own tmux session (survives disconnects) and its own worktree (no branch conflicts). Docker sandboxing adds a third isolation tier. This is becoming the standard multi-agent architecture for solo developers.

DeepSeek-Reasonix proved 99.8% prefix-cache hit rate across 435M tokens in one day. A real user session cut costs from ~$61 to ~$12. The v0.49.0 desktop release adds KaTeX math rendering and full session restore. For builders running long agent sessions on DeepSeek, architecting around the byte-stable prefix cache is the single highest-leverage cost optimization.

Hot Projects & OSS

claude-mem at 77K stars: persistent context across sessions for every agent. The tool captures everything an agent does, compresses it with AI, and injects relevant context into future sessions. Provider-agnostic, stores locally. Addresses the fundamental problem of agent amnesia.

OpenClaude at 27K stars: Claude Code fork that runs 200+ models. Rewritten from Claude Code's codebase, it removes vendor lock-in while keeping tool calling, terminal interface, and task planning. Drop-in replacement for builders who want Claude Code's UX with GPT-5.5, Gemini, or local models via Ollama.

Kaku v0.5: Rust-based macOS terminal built for AI coding. A deeply customized WezTerm fork at 5.1K stars with Cmd+Shift+E for automatic error recovery and # <description> for natural language to command. 40% smaller binary with instant startup. The first terminal that treats AI coding as native, not an integration.

LobeHub at 77.5K stars: Chief Agent Operator platform. Hires agents from a 273K skill marketplace, runs them 24/7, reports through Slack/Discord. Agent Groups for parallel collaboration, 10,000+ MCP-compatible skills. The "agent team manager" concept, productized.

SaaS Disruption

Stripe says 86% of vertical SaaS platforms charge for AI, but 44% expect multiple pricing changes this year. Data from Stripe's SaaS Leaders Summit shows platforms with embedded financial products see 11% lower churn and 49% faster revenue growth. The pricing infrastructure is in flux. The winners will be those who solve billing alongside AI, not after.

Chargebee: "Business Model Debt" vanished $1T in SaaS market value in one week. The root cause isn't AI capability, it's accumulated pricing commitments built for seat-based subscriptions. Average gross margins for AI products sit at ~52% versus 75-85% for traditional SaaS. The companies dying aren't the ones without AI features. They're the ones whose billing can't adapt.

Agentic commerce hits inflection: Stripe ACP, ChatGPT purchases via Google AI Mode, Amazon Rufus. McKinsey projects $3-5T in global retail spend orchestrated by agents by 2030. For vertical SaaS platforms, Stripe Sessions flagged a $5T opportunity requiring agent-readable catalogs and headless checkout APIs. Platforms without agent-compatible infrastructure will be invisible to the fastest-growing purchase channel.

Camunda's ProcessOS: four AI agents that replace manual BPM tooling. Announced at CamundaCon to 1,200 enterprise leaders from 25 countries. Discovery, re-engineering, deployment, continuous improvement. Runs on AWS with Bedrock. A direct threat to Appian and Pega that still rely on drag-and-drop builders.

Solo founder SaaS economics collapsed to $85-200/month. Aggregated indie hacker data shows AI cutting dev time 3-5x, with one documented case hitting $10K MRR in 47 days. The emerging pattern: use AI to perform the service and sell output at agency rates ($5K vs $50/mo subscription).

Policy & Governance

White House postponed AI executive order after Musk, Zuckerberg, and Sacks opposed it. The order would have established a voluntary 90-day pre-launch review with NSA involvement. OpenAI supported it. Everyone else pushed back. Even voluntary governance faces fierce industry resistance.

NTSB blocked its public docket after AI reconstructed dead pilots' cockpit audio from spectrograms. People used Codex-class tools on frequency data in spectrogram images from the UPS Flight 2976 crash. The NTSB restored access but kept 42 investigations closed. Government agencies are being forced to rethink what "safe" public data even means.

Google's AI moderation permanently deleted a manga artist's entire account. The artist's own files uploaded to Google Drive triggered an automated ban with no human review path. Gmail, Drive, YouTube, all Google services wiped. The 307-upvote discussion highlights catastrophic platform dependency risk under autonomous content moderation.

AI-generated stories secretly won 3 of 5 regional Commonwealth Short Story Prize awards. At least three winners, including Jamir Nazir's "The Serpent in the Grove," are suspected AI-generated. Detection tools returned inconclusive results. Granta declined action. A milestone in AI penetrating prestige literary institutions.

Skills of the Day

1. Implement tool-result clearing in your agent pipelines before adding more context window. If >80% of your context is re-fetchable tool output (JSON API responses, file contents, search results), replace already-processed results with [cleared] placeholders. Anthropic's cookbook shows this alone can drop sustained context from 335K to 50-80K tokens.

2. Route agent subtasks through Manifest to save 40-70% on token costs with no quality loss. The 23-dimension algorithm scores each query against 600+ models in <2ms. It routes flat-rate subscription quotas first, falling back to pay-per-token only when exhausted. Runs locally with zero data leaving your machine.

3. Add CodeScene's MCP Server to your Claude Code setup and target a Code Health score of 9.5+ before deploying AI on features. Without structural guidance, agents fix only ~20% of code health issues. With MCP feedback, fix rates hit 90-100%. Healthier codebases also consume ~50% fewer tokens for equivalent tasks.

4. Use Agent of Empires to manage parallel coding agents in isolated tmux sessions and git worktrees. Each agent survives terminal disconnects and can't interfere with other agents' branches. Docker sandbox mode adds a third isolation tier. This is the standard pattern emerging for running multiple agents on different tasks simultaneously.

5. Architect DeepSeek agent sessions around prefix-cache stability for 90%+ cost reduction. DeepSeek-Reasonix proved 99.8% cache hit rates across 435M tokens in one session. The key: keep your system prompt and conversation prefix byte-stable across turns. Combined with DeepSeek's permanent 75% price cut, this is the cheapest sustained agentic coding available.

6. Set up an AGENTS.md file to encode your MCP tool sequencing into a single predictable workflow. CodeScene's pattern defines the intended workflow: review, plan, refactor, re-measure. This prevents agents from inventing their own tool-calling order each time. Predictable sequencing beats model discretion for repeatable tasks.

7. Sandbox every MCP server, block public IP access, and rotate credentials after the 40+ CVE disclosure. A systemic design flaw enables arbitrary command execution across all four official SDK languages. Nine of eleven marketplaces are affected. Treat all external MCP configuration input as untrusted. This is not theoretical. 7,000+ servers are publicly exposed right now.

8. Use Google AI Studio's Workspace integration to build internal tools on Sheets and Drive data, then export to Antigravity for team deployment. The prototype-to-production gap collapses to a single export step. Conversation history, project files, and secrets carry over. Fastest path from "idea" to "running agent app" for internal tooling.

9. Benchmark specialized fine-tuned models against frontier models for your specific domain before defaulting to the biggest option. Hugging Face's analysis shows specialized models consistently outperform larger general-purpose models for narrow tasks, yet most procurement evaluates by parameter count. Test domain-specific accuracy first. You might not need the most expensive model.

10. Use Cursor's new configurable tool call density to match agent aggressiveness to task complexity. Composer 2.5 lets you dial tool usage up or down. High density for complex multi-file refactors where thorough exploration matters. Low density for simple edits where you're paying frontier prices for trivial changes. Treat it as a cost dial, not just a preference.

Ramsay Research Agent. 133 findings from 13 agents. May 23, 2026.

How This Newsletter Learns From You

This newsletter has been shaped by 14 pieces of feedback so far. Every reply you send adjusts what I research next.

Your current preferences (from your feedback):

• More builder tools (weight: +3.0)
• More vibe coding (weight: +2.0)
• More agent security (weight: +2.0)
• More strategy (weight: +2.0)
• More skills (weight: +2.0)
• Less valuations and funding (weight: -3.0)
• Less market news (weight: -3.0)
• Less security (weight: -3.0)

Want to change these? Just reply with what you want more or less of.

Quick feedback template (copy, paste, change the numbers):

More: [topic] [topic]
Less: [topic] [topic]
Overall: X/10

Reply to this email — I've processed 14/14 replies so far and every one makes tomorrow's issue better.