The Starvard sealStarvard.
English
EnglishFrançaisEspañolहिन्दीPortuguêsBahasa IndonesiaAll languages →
Starvard University

The Starvard Blog

Notes from the free university

Your Next Coworker Is an Agent

October 20, 2026 · By the Starvard professors
A person and a small robot working side by side at adjacent desks, sharing a pot of coffee
Illustration by Starvard (AI)

Small teams are learning to work alongside AI agents all day: reviewing finished work over morning coffee, directing tireless digital coworkers, and discovering that the hard part is no longer doing the work but judging it. This post builds the idea from first principles, tours the tiny companies genuinely living this way, then gives the other side its full hearing: the productivity studies that cut against the hype, the token bills nobody mentions, the security traps, and what it all means for your job.

Let's start with a scene. It's a composite, not one real person, but every piece of it is drawn from people who describe their days this way in public.

It's 8:40 on a Tuesday. Maya runs product at a software company with seven employees. Before she's finished her coffee, she opens a dashboard and finds that overnight, four pieces of work got done that nobody on her team touched. A bug that a customer reported at 11pm has a proposed fix waiting for review, along with a note explaining what caused it. A competitor's pricing page changed, and there's a two-paragraph summary of what moved. The weekly metrics report is drafted. And one task failed: an agent tried to update the billing documentation, got confused by two contradictory pages, and stopped to ask a question instead of guessing.

Maya spends her first hour not doing work but reviewing it. She approves the bug fix after reading it carefully. She rejects the metrics report because it compared the wrong weeks. She answers the documentation question in two sentences. Then she writes three new task descriptions, hands them off, and goes into a meeting with an actual human customer.

If you're reading this and thinking "that's either the future or a LinkedIn fantasy," good. That's exactly the right instinct. Because the honest answer is: parts of that scene are completely real today, parts are real only for a small slice of people, and parts are still mostly marketing.

This post is about telling those parts apart.

We're going to build this up from the ground floor. First, what an "agent" actually is (it's simpler than the hype makes it sound). Then why this is suddenly happening now. Then a field trip to the small teams genuinely working this way, with real names and real numbers. Then the reality check, because there's a lot of it. Then the bill, the risks, and finally what you can actually do with all this.

Grab a snack. This is a long one.

Part 1: What Even Is an Agent?

Let's clear away the fog first, because "agent" has become one of those words that means everything and nothing. Gartner, the research firm, estimated in 2025 that out of thousands of companies selling "agentic AI," only about 130 were offering something genuinely agentic. The rest were doing what Gartner called "agent washing": slapping a new label on an old chatbot.

So what's the real thing?

Step 1: The chatbot

You already know the chatbot. You type a question, it types an answer. That's it. It's like a very well-read person sitting across a table from you who can only talk. They can't open your files, can't send an email, can't click anything. Every time you want something done, you have to go do it, then come back and report what happened.

Step 2: Give it hands

Now imagine you hand that well-read person some tools. A computer. Access to your files. The ability to run a search, write and run code, send a message. Suddenly they're not just advising you; they can actually do things.

In AI terms, these are called "tools," and modern AI models are trained to use them. The model decides "I should search for this," the software around it runs the search, and the result gets fed back to the model.

Step 3: Put it in a loop

Here's the part that turns a tool-using chatbot into an agent. Instead of doing one action and stopping, the model works in a loop:

  1. Look at the goal.
  2. Decide on the next step.
  3. Take that step using a tool.
  4. Look at what happened.
  5. Go back to step 1 until the goal is done (or it gets stuck).

That's it. That's the whole trick. An agent is an AI model, running in a loop, with tools, working toward a goal. Everything else is details.

The reason this matters so much is that a loop lets the AI recover from its own mistakes. If a chatbot writes code with a bug, you find the bug. If an agent writes code with a bug, it can run the code, see the error message, and fix it, without you ever seeing the broken version.

Step 4: Give it a long leash (or a short one)

The last ingredient is autonomy: how long can the agent run before a human checks in? A few seconds? An hour? Overnight?

Andrej Karpathy, a founding member of OpenAI and former head of AI at Tesla, has a useful way to picture this. In a 2025 talk at Y Combinator, he described an "autonomy slider." At one end, the AI just suggests things and you do everything. At the other end, it runs fully on its own. Most useful tools today, he argued, sit somewhere in the middle, and the human slides the dial up or down depending on how risky the task is. His favorite metaphor: build an Iron Man suit (a human made more powerful) rather than an Iron Man robot (a replacement that flies off on its own).

Hold onto that slider image. It's the single most useful mental model for this whole topic, and we'll keep coming back to it.

Part 2: Why Is This Happening Now?

Agents as an idea are decades old. Software that runs in loops is ancient. So why did 2025 and 2026 suddenly turn into the "year of agents"?

The short answer: the models got good enough to stay on track for long enough to be worth it.

The most important chart in AI (maybe)

There's a nonprofit research group called METR (pronounced "meter") that measures something clever. Instead of asking "how smart is this AI?", which is vague, they ask: "How long a task can this AI complete on its own?"

Here's how it works. They gather a big set of real tasks, mostly software engineering, and have skilled humans do them, timing how long each one takes. Some tasks take a human two minutes. Some take eight hours. Then they let AI agents attempt the same tasks, and find the task length where the agent succeeds about half the time. That's the AI's "time horizon."

The results are startling. Early models like GPT-2 could reliably handle tasks that take a human a couple of seconds. By 2025, frontier models were handling tasks that take humans an hour or two. In METR's original analysis, this time horizon was doubling roughly every seven months going back to 2019.

Then it sped up. In January 2026, METR released an updated methodology (they call it Time Horizon 1.1) with more long tasks, and the updated fit put the post-2023 doubling time at roughly four months. By spring 2026, METR reported that the strongest agents it had evaluated were estimated at roughly 16 to 20 hours at 50% reliability, and around three to four hours at 80% reliability. METR also said these top models were bumping against the ceiling of what its task suite could reliably measure.

Let's sit with what that means, and also what it doesn't.

What it means: The length of work you can hand to an agent and walk away from has been growing exponentially. "Fix this typo" became "fix this bug" became "build this feature" in about two years. That's the engine underneath everything else in this post.

What it doesn't mean: It doesn't mean an agent can do any 16-hour job. Notice the two numbers: at 50% reliability the horizon is long, but at 80% reliability it's much shorter. A coworker who finishes your day-long project correctly half the time is not a coworker you can stop supervising. And the tasks are mostly software, which is unusually friendly territory: code either runs or it doesn't, and tests can check the work automatically. Messier jobs, negotiating with a supplier, figuring out what a customer really wants, are harder to measure and, as we'll see, harder for agents too.

Still: an exponential curve that keeps doubling is the kind of thing that changes how people organize their work. And that's exactly what's happening.

Part 3: A Field Trip to the Teams Doing This

Enough theory. Who's actually working this way? Here are real examples, with a big caveat stapled to the front: almost all of these numbers come from the people themselves. Founders describing their own companies have every incentive to make the story sound good. That doesn't make them false. It means you should read them the way you'd read a restaurant's description of its own food.

The engineer who became a manager overnight

At Every, a small media-and-software company run by Dan Shipper, engineer Kieran Klaassen wrote a widely read 2025 piece about how his job changed. He described running several Claude Code agents in parallel, each working on a different feature in a separate copy of the codebase, while he reviewed and directed. His summary of the change was that the tool had turned him from a programmer into an engineering manager overnight.

Klaassen also coined a term that's caught on: "compound engineering." The idea is that each piece of work should make the next piece easier. When an agent makes a mistake, you don't just fix the mistake; you write down the lesson in a file the agents read every time they start (in Claude Code, that's a file called `CLAUDE.md`). Over weeks, the agents accumulate a sort of institutional memory. Every's podcast later featured an episode titled "How Two Engineers Ship Like a Team of 15." (That "15" is the team's own estimate, not an outside measurement.)

The team of one

Ryan Carson spent 25 years founding companies; his previous one, Treehouse, grew to roughly 110 employees. In a July 2026 interview on Greg Isenberg's YouTube channel, he described running his new company, Untangle (AI software for family law firms), entirely by himself. His setup: five to ten cloud-based coding agents running at once, with Carson merging somewhere between 22 and 40 code changes a day, often from his phone. He described his job as making 10 to 20 high-stakes decisions before lunch.

He was also candid about the cost: after one month where his token bill hit around $20,000, he settled on a budget of roughly $5,000 a month per person and started routing simpler work to cheaper models. (We'll come back to the money. It's a bigger deal than most people realize.)

The business that went from 20 people to 3

SaaStr, Jason Lemkin's community and events business for software founders, is probably the most-cited example of a whole small company reorganizing around agents. By Lemkin's account, SaaStr had more than 20 full-time employees in 2020. Today it runs at the same eight-figure revenue scale with three humans and about 20 AI agents handling content, sales outreach, event logistics, and finance tasks. Lemkin has said one of the agents closed a $70,000 sponsorship deal on its own.

But the most interesting part of the SaaStr story isn't the headline. It's two details Lemkin is upfront about:

That second point is, I think, one of the most important lessons in this whole post. Hang onto it.

More small teams

And at bigger companies

Small teams aren't only startups; they're also squads inside large companies. In April 2025, Shopify CEO Tobi Lütke posted an internal memo stating that before asking for more headcount, teams must demonstrate why AI can't do the work. The memo asked teams to imagine what their area would look like if autonomous agents were already part of the team. Microsoft's 2025 Work Trend Index, a survey of 31,000 people across 31 countries, coined the phrase "agent boss" for someone who builds, delegates to, and manages agents, and proposed that companies track a "human-agent ratio."

Even Anthropic (which makes Claude, the AI writing this sentence alongside a human editor, full disclosure) studied its own staff. In an August 2025 internal study of 132 engineers and researchers, people reported using Claude in roughly 59% of their work, up from 28% a year earlier, and said they could fully delegate somewhere between 0% and 20% of their tasks. About 27% of the Claude-assisted work, they reported, was work that wouldn't have been done at all otherwise. Worth noting: that's a company surveying its own employees about its own product, and the productivity figures are self-reported.

The skeptic who changed his workflow

Here's my favorite data point, because it's a person changing his mind in public. In October 2025, Andrej Karpathy (our autonomy-slider friend) went on Dwarkesh Patel's podcast and said, essentially, that agents "just don't work" yet, that we were at the start of a decade of agents, not a single year of them. He pointed to missing pieces: they can't learn continuously, can't remember what you told them, aren't reliable enough.

Five months later, in March 2026, Karpathy appeared on the No Priors podcast and described his days as spending 16 hours expressing his will to his agents. He'd coined a new term, "agentic engineering," for a style of work where you're orchestrating agents and providing oversight rather than writing code directly.

Is that a contradiction? Not really. It's the autonomy slider in action. Karpathy never said agents were useless; he said they weren't employees you could hire and forget. Both things can be true at once: agents aren't independent coworkers yet, and the best practitioners spend their whole day directing them.

Part 4: The New Job Description

So what are these people actually doing all day, if not the work itself? Let's break it down, because this is the part that's most useful if you want to work this way yourself.

You become a manager, of very strange employees

Every single practitioner above uses the same metaphor: they went from doing to managing. But agents are very weird employees, and understanding the weirdness is the job.

An agent is like a new hire who:

Managing that kind of worker requires a specific set of skills. They break down into roughly four things.

Skill 1: Writing the task clearly

When you hand work to a person, a lot of context flows invisibly: they've been in the meetings, they know the customer, they know what "good" looks like at your company. An agent knows none of that. Every assumption you don't write down is a coin flip.

This is why practitioners keep saying that working with agents is a writing skill. The people who get the most out of agents tend to be the ones who can describe a goal, the constraints, what done looks like, and what not to do, in plain language.

Skill 2: Checking the work

This is the big one. Reviewing is now the main job. And here's the uncomfortable math: if an agent can produce work ten times faster than you, but you have to review all of it, your review speed becomes the bottleneck.

This is why the most successful agent work happens in places where checking is cheap. Code is the obvious example: you can run tests, and the computer tells you if it broke. Anthropic's internal study found engineers delegated mostly tasks that were "easily verifiable." Writing a marketing email is easy to check (you read it). Deciding whether a contract clause exposes you to legal risk is hard to check, which makes it a terrible place to let an agent run unsupervised.

A practical rule: the further right you push the autonomy slider, the cheaper and faster your checking needs to be.

Skill 3: Writing things down so the agents get smarter

This is the "compound engineering" idea from Every, and it generalizes beyond code. Since agents don't remember yesterday, the team's knowledge has to live in documents the agents read: style guides, lists of past mistakes, explanations of how your systems fit together. Every correction you make should become a permanent instruction, so you never make the same correction twice.

Funnily enough, this is just good management. The companies that already had clear documentation are finding agents much easier to onboard. The ones running on tribal knowledge and hallway conversations are struggling.

Skill 4: Protecting your own attention

Remember SaaStr cutting from 30 agents back to 20? This is the lesson. The limiting resource in a human-plus-agent team is not compute. It's human attention.

Every agent you add is another stream of output to review, another set of instructions to maintain, another thing that can quietly go wrong. Ryan Carson checks his important threads on a fixed rhythm rather than constantly. Lemkin found that merging agents beat adding them. Microsoft's "human-agent ratio" idea points in the same direction: there's an optimal number of agents per human, and it's not infinity.

Here's a way to picture it. Imagine you're a chef. Hiring more line cooks helps, right up until the moment you can't taste every plate before it leaves the kitchen. After that, more cooks means more bad plates reaching customers. The skill isn't "hire as many cooks as possible." It's "run a kitchen where you can still taste everything that matters."

Part 5: The Reality Check

Okay. Deep breath. We've seen the exciting stories. Now let's go looking for evidence that might contradict them, because a good explainer should try as hard to disprove its thesis as to prove it.

There's a lot of it.

Reality check #1: People are bad at judging their own speed

In 2025, METR ran what may be the most careful study ever done on AI coding tools. They recruited 16 experienced open-source developers, people working on large codebases they'd contributed to for years, and gave them 246 real tasks. For each task, a coin flip decided whether AI tools were allowed.

Before starting, the developers predicted AI would make them about 24% faster.

The measured result: with AI, they were about 19% slower.

And here's the part that should make everyone nervous: after the study, the developers still believed AI had sped them up by about 20%. They felt faster while actually being slower. Watching an agent generate code feels productive. Waiting, prompting, reading, and fixing its output takes real time that's easy to not notice.

Now, fairness matters here, and the follow-up story is fascinating. METR tried to rerun the study in late 2025 and early 2026 with newer tools. The study basically broke. A large share of developers refused to participate because they didn't want to work without AI anymore, which itself tells you something. METR also cut the pay rate and found it hard to time developers who were running multiple agents at once. The data that did come in pointed toward developers now being somewhat faster with AI, but METR said plainly that it considered the results unreliable, with error bars wide enough to include no effect.

So where does that leave us? Two honest conclusions:

  1. Tools improved, and they probably help experienced developers more now than in early 2025. METR itself thinks so.
  2. Your gut feeling about your own productivity is not evidence. If you're going to reorganize a team around agents, measure actual outcomes, shipped work, error rates, customer results, not how busy everyone feels.

Reality check #2: Agents are much better at code than at office work

Researchers at Carnegie Mellon built a benchmark called TheAgentCompany: a simulated small software company with 175 realistic tasks across engineering, project management, finance, HR, and admin. Agents had to browse internal websites, write code, fill in spreadsheets, and message simulated coworkers.

In the 2025 results, the best agent completed about 30% of tasks. The public leaderboard has since crept up to the low 40s. The pattern was revealing: agents did relatively better on software tasks and worse on administrative and finance work, and especially struggled with tasks involving communication with coworkers and clunky web interfaces.

Salesforce ran a similar benchmark for sales and customer-service work, and found agents scoring around 58% on single-step tasks but dropping to about 35% on multi-step conversations.

These benchmarks use older models than today's best, and agents have improved since. But the shape of the finding still matters: the jobs that look "simple" to humans, sending the right message to the right person, navigating a messy internal tool, are often the hard ones for agents. Coding got good first because coding is the easiest kind of work to check automatically.

Reality check #3: The big-company track record is mixed

In June 2025, Gartner predicted that more than 40% of agentic AI projects will be canceled by the end of 2027, citing escalating costs, unclear business value, and inadequate risk controls. One of its analysts described most projects at the time as hype-driven experiments that were often misapplied.

The most famous cautionary tale is Klarna, the Swedish payments company. In early 2024, Klarna announced its AI assistant had taken on about 75% of customer chats, some 2.3 million conversations in its first month, and said it was doing the work of roughly 700 human agents. It froze hiring. Then, in 2025, CEO Sebastian Siemiatkowski told Bloomberg the company was hiring human customer service staff again, acknowledging that the cost-focused push had led to lower quality. His reasoning was that customers need to know there will always be a human if they want one.

Klarna didn't abandon AI. It moved the slider back a few notches. That's the lesson: pushing autonomy too far in customer-facing work can cost you more in trust than it saves in salaries.

Reality check #4: The revenue-per-employee stories have survivorship bias

You've probably seen charts of AI startups making millions of dollars per employee. Some of those numbers are real and remarkable, Lovable, a Stockholm-based app builder, reportedly reached $400 million in annual recurring revenue in early 2026 with about 146 full-time employees, according to TechCrunch reporting cited by Forbes.

But be careful with what these numbers prove. First, we hear about the winners, not the thousands of tiny teams that quietly went nowhere. Second, many of these companies sell AI, during a historic boom in demand for AI, which inflates revenue in ways that have nothing to do with how they staff. Third, a lot of the figures are company-reported projections. And fourth, high revenue per employee says nothing about whether the business is profitable once you count the AI bill, which brings us to our next section.

None of this means small teams aren't punching above their weight. They clearly are. It means "a three-person team can do anything now" is a story, not a statistic.

Part 6: The Bill Nobody Mentions

Here's something the "replace your team with agents" crowd tends to skip: agents are not free, and they're not cheap at scale.

Agents run on "tokens", chunks of text the AI reads and writes, billed by the million. A chatbot conversation uses a few thousand. An agent working for an hour, reading files, running tests, retrying failures, can burn through millions. Run ten of them in parallel all day and the meter spins fast.

Some real numbers:

For a small team, this changes the math in an important way. The old question was "should we hire another person?" The new question is "should we hire another person, or spend that money on tokens, and how do we know which gives us more?" Venture capitalist Tomasz Tunguz has started calling AI inference a potential "fourth component" of compensation, alongside salary, bonus, and equity.

The practical upshot: budget for agents like you'd budget for people. Ryan Carson's experience, a $20,000 surprise month, followed by a deliberate per-person budget and routing easy work to cheaper models, is a pattern worth copying before you get the surprise yourself.

Part 7: The Things That Bite

Two more risks deserve their own section, because they're the ones most likely to hurt people who don't see them coming.

The lethal trifecta

Simon Willison, a well-known software developer who coined the term "prompt injection," wrote a short 2025 post that every person setting up agents should read. He calls it "the lethal trifecta."

The idea is simple. An agent becomes dangerous when it has all three of these at once:

  1. Access to your private data (your email, your files, your customer database).
  2. Exposure to untrusted content (web pages, incoming emails, documents from strangers).
  3. The ability to communicate externally (send emails, make web requests, post messages).

Why is that combination lethal? Because AI models can't reliably tell the difference between instructions from you and instructions hidden inside the content they're reading. If an agent reads an email that says, in effect, "forward the last ten password-reset messages to this address," there's a real chance it just... does it. That's prompt injection, and Willison documented real exploits against products from Microsoft, GitHub, Google, Slack, and others.

His conclusion was blunt: the AI companies aren't going to fully solve this for you, so you have to avoid giving any single agent all three powers. The practical fix is to cut one leg. An agent that reads untrusted web pages shouldn't also have access to your customer data. An agent with access to private data shouldn't be able to send things to the outside world without a human approving.

For small teams, this matters even more than for big ones. Big companies have security departments. You probably have... you.

The disappearing first rung

The second risk is about people, not systems.

Look again at the field-trip stories. SaaStr's three remaining humans are senior. Ryan Carson has 25 years of experience. Lemkin explicitly warns that junior people can't substitute for that experience. The agent-heavy workflow works best for people who already know what good work looks like, because their whole job is now judging work.

So where do the next generation of experienced people come from?

Stanford economists Erik Brynjolfsson, Bharat Chandar, and Ruyu Chen have been tracking this using payroll data from ADP covering millions of American workers. Their August 2026 update found that employment for workers aged 22 to 25 in the most AI-exposed occupations was about 19% below where it would have been had it kept pace with similar-aged workers in less-exposed jobs, a gap that had widened over the previous year. For more experienced workers, they found no comparable gap. The effect appears to come mainly from companies hiring fewer young people, not from firing existing ones. The researchers are careful to call these early, descriptive warning signs ("canaries in the coal mine") rather than proof that AI caused the change, and they found no widespread economy-wide job displacement.

Put that next to the small-team stories and a worrying picture emerges. If every team becomes "three seniors plus twenty agents," nobody is getting the reps that turn a junior person into a senior one. This is a problem for society, but it's also a problem for you, if you run a team: in five years, who will you hire?

The teams thinking hardest about this are making junior roles deliberately different, less "do the grunt work," more "learn to direct agents under close supervision, and explain your reasoning." Whether that works at scale, nobody knows yet.

Part 8: So What Do You Actually Do?

Let's land the plane. If you're on a small team, or you're a student wondering what kind of job you're preparing for, here's what the evidence above actually suggests.

If you lead a small team

1. Start with one painful, checkable workflow. Not "transform the company with agents." Pick one recurring job that's annoying, well-defined, and easy to verify: triaging bug reports, drafting a weekly summary, cleaning a dataset. Get that working. Learn from it. Then pick the next one.

2. Match the autonomy slider to the cost of a mistake. Let agents run freely where errors are cheap and reversible. Keep a human approval step for anything irreversible, customer-facing, legal, or financial. Klarna's lesson is that customers notice when you slide too far.

3. Write everything down. Treat your team's knowledge as something agents need to read: how you do things, what went wrong last time, what "good" looks like. Every correction becomes a permanent instruction. This is the cheapest productivity upgrade available, and it helps your human teammates too.

4. Count your attention, not your agents. Ask: how many agents can each person genuinely supervise? SaaStr found that merging and cutting beat adding. More streams of output are only better if someone is actually checking them.

5. Measure, don't feel. METR's study showed that experienced developers felt 20% faster while being 19% slower. Track real outcomes: things shipped, errors caught after release, customer satisfaction, time to resolve issues.

6. Budget tokens like salaries. Set a monthly limit per person. Route simple work to cheaper models. Look at the bill weekly at first.

7. Break the lethal trifecta. For every agent, list what private data it can see, what untrusted content it reads, and what it can send outward. If all three boxes are checked, remove one.

8. Keep hiring juniors, on purpose. Design their roles around learning judgment, not just doing tasks. You'll need senior people in five years, and they don't grow on trees.

If you're a student or early in your career

The honest picture is mixed, so here's the honest advice:

The Slider, One More Time

Let's go back to Maya, our composite product lead at 8:40 on a Tuesday.

Here's what's real about her morning: agents genuinely can fix bugs overnight, summarize a competitor's changes, and draft a report. Small teams genuinely are doing this today. The capability underneath it is growing on a curve that has been doubling every few months.

Here's what's easy to miss: Maya's most important moments were the ones where she caught something. The metrics report that compared the wrong weeks. The documentation agent that, crucially, stopped and asked instead of guessing. Her value didn't disappear when the agents arrived. It concentrated. Her job became judgment, taste, context, and responsibility, the parts that were always the hard parts anyway.

And here's what's still mostly marketing: the idea that you can hire a team of agents, walk away, and come back to a working company. The best evidence we have says agents are powerful and unreliable at the same time, that people overestimate how much they help, that costs climb fast, that security is genuinely tricky, and that the humans who do best with them are the ones who already know their craft.

Karpathy's Iron Man metaphor holds up well. The suit is real, and it's getting stronger every few months. But there's still a person inside, and the suit is only as good as the person flying it.

Your next coworker might well be an agent. Just make sure you're the kind of coworker who knows how to check its work.

Why this belongs at Starvard

A free university exists to teach the skills a working life actually demands, and directing agents is fast becoming one of them. The argument of this post is that the durable skills are judgment, clear writing, and knowing your craft well enough to check a machine's work, and all three are teachable. If the machinery itself is still foggy, start with How AI Works, our plain-English tour of what a model is and does. Then take AI Agents: Your First $10,000, which is devoted to putting agents to work on real tasks of your own. And if the disappearing first rung is the part that worries you, Career Growth 101 covers building a career that keeps compounding while the tools change. All three are free, like everything at Starvard.

Watch

Sources

Tagged: Technology · Career · AI Agents · AI at Work

Back to the blog

A note on accuracy: Much of what you read at Starvard was created with help from AI agents, working alongside people. We check what we can, but we cannot guarantee that everything here is true, current, or complete. If something really matters, your health, your money, a grade, a job, please verify it with a trusted source before you rely on it.