the next billion dollar ai company is the one cleaning up after the other ai companies.
traversal just raised $120M at a $1B valuation to figure out why prod broke.
we spent two years making code cheap to write. now we're paying to understand it.
We just raised $120M, with a $1B valuation, to build software that keeps itself running.
AI is writing more code than ever. It’s also making production less reliable: more code, shipped faster, understood by few.
@traversal_ai understands how production systems fit together, finds the root cause of incidents, and helps prevent the next one.
Engineers at Nubank, Harvey, PepsiCo, DigitalOcean, and a growing list of Fortune 100 companies use Traversal every day.
Here’s production without the drama 👇
the viral ai demo is free market research for the incumbent. if your whole product is one feature, it ships as a button inside something people already pay for. the ones that survive own the workflow or the audience before that happens.
the cheapest distribution channel right now is answering the questions your customers keep googling, in public, every day. most founders still save that energy for the launch post.
an ai changed 0.016% of another model's weights and made it up to 6x better at math.
no gradients. no training run. no new data.
if this holds up, fixing a model stops being a training problem and turns into editing a file.
We asked GPT-6 Astra to edit Qwen3.5-0.8B weights to improve math.
It directly changed only 0.016% of weights, fixing 0.8B's reasoning loops & improving math up to 6x and even instruction following 3x, without gradients or training.
We call this Weight-Space Programming: frontier LLMs can now natively read/write neural network weights! 🧵
Blog: rikiyat.github.io/blog/weigh…
small ai products that seem to make money tend to share a few things:
> one industry, picked early
> sold where that industry already hangs out
> priced next to a salary line on the budget
the ones that stall usually built for everyone and ended up competing with a $20 chatbot subscription.
parts of an AI business that still look underpriced to me:
> proprietary usage data
> a channel you actually own
> boring integrations nobody wants to build
> support that answers the same day
model prices keep falling. none of these get cheaper
me realizing ai can handle customer calls and book appointments while i still rehearse saying “hello” before calling the dentist
AVARITCALL V2 ÇIKTI, GENEL KULLANIMA AÇILDI!
işletmenin telefonu çaldığında müşterinin ne istediğini öğrenen, bilgilerini toplayan ve randevu akışını yürütebilen bir ai asistanını artık chatgpt’ye tek bir prompt girerek kurabiliyorsunuz.
ister panelden, ister api veya mcp üzerinden. asistanın görevinden konuşma tonuna kadar ayarlayabiliyorsunuz.
dahili chatbot, crm, her personel için ayrı takvim, görev takibi ve notion’dan bitrix24’e kadar hazır entegrasyonlar da var.
bir oto servis üzerinden kurulumunu, kullanımını ve maliyetini açalım.
the mispricing around sonnet 5.5 isn't its benchmark score.
it's what a cheaper, faster execution layer does to distribution.
anthropic reports 30%+ faster output and up to 30% lower cost for most work. use it for bounded, repeatable jobs. reserve opus for ambiguity, architecture, and final judgment.
the saved cost can buy more iterations, shorter wait times, or lower prices. that changes who can ship a useful loop at scale.
the advantage won't belong to the team with the best model spreadsheet.
it'll belong to the team that converts inference savings into product velocity, margin, or reach.
i think cats in Türkiye do this exercise.
geçen ay tiktokta bu arkadaşın bu challengeına denk geldim, kullanıcı adı: taylar holliday
gördükten bir gün sonra hemen bu challenge’a başladım, 1.5-2 ay önceki fiziğimden eser yok şimdi, kollar dahs geniş, six-packsler daha belirgin. herkese tavsiye ediyorum. en azından deneyin, sağlık her şeyimiz…
the market keeps treating distribution as the last step after the product works.
for agent businesses, it is part of the product.
every handoff creates a chance to learn what users ask for, where they abandon the flow, which exceptions need a human, and what should become a default action.
the company that owns that loop can improve acquisition and automation at the same time.
the mispriced asset is not reach.
it is the feedback path between demand and execution.
the agent demo proves the model can act.
retention is decided by what happens after the action: retries, approvals, state, exceptions, and the handoff back to a human...
that layer is boring plumbing, so it gets less attention than the model. but it is where a one-off capability becomes a daily habit, and where the vendor learns what the customer actually values.
the market is pricing autonomy as the product. the durable advantage is recovery.
whoever owns the recovery loop owns the cost, the trust, and eventually the workflow.
the hackers told 404 media this wasn’t financially motivated. they described their plans as coercion. that makes the alleged family information especially concerning.
404 media examined a sample appearing to contain 5,000 employee records and corroborated some phone/name matches. that doesn’t independently establish that every employee and applicant was exposed. the FBI hadn’t responded to the outlet when the article was published.
if authentic, the records could support fake recruitment messages to applicants, impersonation targeting spouses, or harassment outside work. those are potential consequences, not incidents confirmed with this dataset.
for anyone building products that collect sensitive data, there’s a practical question here: does the business actually need every personal detail it stores?
an emergency contact field might look harmless inside an HR dashboard. in a stolen export, it could expose someone who never had an account.
getting the portal back online can’t be the entire recovery plan.
claude opus 5.5 is interesting for a reason that has almost nothing to do with another benchmark win.
anthropic cut pricing to $4/m input + $20/m output. GPT-6 Astra is $10/m + $50/m. on raw token pricing, Astra is 2.5x more expensive.
that gap barely matters for one prompt. it matters a lot once the product is an agent making dozens of calls across research, coding, retries, tool use and long-running workflows.
this is where model economics start turning into product economics.
lower cost per loop means you can run more attempts, keep margins healthier, or price the end product more aggressively without changing the business model.
the next frontier fight isn’t just who has the smartest model. it’s who can deliver enough intelligence per dollar that entire categories of agent products suddenly make economic sense.
your business eventually becomes a visible version of your internal operating system.
every pricing decision, hire, delay, risk, compromise and standard compounds from what you believe about money, yourself and what you deserve.
people think they’re building a company.
most of the time, they’re building a mirror.
mispriced retweeted
The next big advantage in AI won’t come from writing better prompts.
It will come from building better systems around the models.
Think about AI coding agents. Instead of repeatedly asking them to write cleaner code, you can define project-specific rules, give them access to the right tools, provide examples of acceptable output, and automatically test their work.
The difference is significant: you’re no longer relying on a single instruction to produce the right result every time.
You’re creating an environment where the model has the context, constraints, and feedback it needs to work more reliably.
The real skill is shifting from telling AI what to do to designing systems that help it consistently do the right thing.
prompt engineering is starting to feel like legacy terminology.
the model isn’t really being steered by one prompt anymore. in a good ai system, behavior gets distributed across layers:
> rules
> skills
> tools
> examples
> schemas
> evals
the prompt is just one control surface.
instead of telling a model to write good code, you encode repo rules, define when tools should be used, show examples of acceptable output, constrain responses with schemas, then run evals to see if the whole thing actually works.
that’s the shift: less wordsmithing, more environment design.
the gap between good and bad ai users probably won’t come down to who writes the cleverest prompt. it’ll come down to who builds the better environment around the model.
prompt engineering is shrinking.
system design is becoming the actual skill.
mispriced retweeted
the bigger consequence is that company knowledge has to become executable.
today a lot of important judgment still lives in people's heads:
- when to escalate.
- what counts as risky.
- which exceptions are acceptable.
- how quality gets checked.
- which tools are allowed.
if agents are going to do real work, that knowledge can't stay tribal.
it has to get encoded into rules, tools, schemas, evals and approval boundaries.
prompt engineering was mostly about communicating with a model.
the next skill is turning how a business operates into an environment a model can reliably act inside.
prompt engineering is starting to feel like legacy terminology.
the model isn’t really being steered by one prompt anymore. in a good ai system, behavior gets distributed across layers:
> rules
> skills
> tools
> examples
> schemas
> evals
the prompt is just one control surface.
instead of telling a model to write good code, you encode repo rules, define when tools should be used, show examples of acceptable output, constrain responses with schemas, then run evals to see if the whole thing actually works.
that’s the shift: less wordsmithing, more environment design.
the gap between good and bad ai users probably won’t come down to who writes the cleverest prompt. it’ll come down to who builds the better environment around the model.
prompt engineering is shrinking.
system design is becoming the actual skill.
prompt engineering is starting to feel like legacy terminology.
the model isn’t really being steered by one prompt anymore. in a good ai system, behavior gets distributed across layers:
> rules
> skills
> tools
> examples
> schemas
> evals
the prompt is just one control surface.
instead of telling a model to write good code, you encode repo rules, define when tools should be used, show examples of acceptable output, constrain responses with schemas, then run evals to see if the whole thing actually works.
that’s the shift: less wordsmithing, more environment design.
the gap between good and bad ai users probably won’t come down to who writes the cleverest prompt. it’ll come down to who builds the better environment around the model.
prompt engineering is shrinking.
system design is becoming the actual skill.
if your ai support agent uses a frontier model to answer "where is my invoice?", you're paying for a specialist to read a label.
- classify the request
- retrieve the account context
- draft the routine reply
- escalate ambiguity
the mispriced asset isn't intelligence. it's the boundary that decides when intelligence is worth buying. the operator who owns it captures the margin.
the more interesting consequence is economic.
once tiny decisions become cheap enough, you stop asking one expensive model to "run the agent."
you start building a hierarchy of intelligence.
cheap models handle reflexes.
frontier models handle uncertainty.
code handles authority.
that's when agents start looking less like chatbots with tools and more like actual software systems.
i think people are misunderstanding what jev is.
it's not another model that's supposed to replace claude code or codex.
it's more interesting as the decision layer sitting next to them.
claude/codex are good at the expensive stuff:
understanding a repo
planning
writing code
debugging
reasoning through weird edge cases
but real agents also make hundreds of tiny decisions:
should i retry?
which tool should run?
is this action risky?
did the task actually finish?
does this require human approval?
which model should handle the next step?
using a frontier reasoning model for every one of those decisions is overkill.
jev is designed for this layer.
you give it some state and ask structured questions.
it can return a choice, a score, or basically a probability that something is true.
so a coding agent could look more like:
claude code / codex
> understand + execute the task
jev
> route, classify, score risk, decide retry/escalation
deterministic code
> enforce permissions and hard rules
human
> handle high-risk or low-confidence cases
example:
codex changes authentication code.
jev checks:
"does this touch a sensitive system?"
"how risky is this diff?"
"should a human review it?"
high confidence + low risk > keep going
uncertain > send it back to claude/codex for deeper reasoning
high risk > stop and ask a human
same thing works for browser agents.
you don't need a giant model reasoning for 10 seconds before every click.
let the fast model handle the reflexes and wake up the expensive model when actual reasoning is required.
that's the part i find interesting.
the future agent stack probably isn't one giant model doing everything.
it's multiple intelligence layers:
fast decisions.
slow reasoning.
deterministic rules.
human escalation.
aka less "one ai agent"
and more an actual cognitive architecture.
token pricing makes inference read as a commodity. the hidden bill is the serving shape: long prompts, output length, cache misses, queueing, retries, and the hardware sitting idle between bursts. two teams can pay the same per-token rate and get radically different gross margins. the leverage moves to whoever designs the request path, not whoever memorizes the model menu. a cheaper input matters only when utilization, latency, and recovery remain inside the customer’s promised boundary.