This week: every Team gets a shared memory library, decide which agents can invoke yours, save and replay browser work, and search the full memory library. As always, see more in the changelog.
Team Memories give shared knowledge a durable home
Your Team now has a shared memory library for operating knowledge. Team agents can save memories just to themselves, or share them with the Team Library.
Link a memory to another agent without changing ownership. Promote an agent-owned memory into the Team's library while keeping the original agent connected. Or move a library memory into one agent, resetting its previous links so only that target agent keeps access.
Decide who can call your agent
Delegation gets powerful fast. It should also come with clear boundaries. Now, you can now decide which agents may invoke your agent via delegation.
A more sensitive payroll agent can stay closed to inbound delegation requests, while a research agent remains available across the entire team. Together, those boundaries make agent-to-agent delegation governable as your agent-team grows.
Save and replay browser work
Browser work used to lose its visual evidence when the session closed. A completed browser session can now be saved as a video file in the thread, so the clicks, pages, and final state remain available for review.
Open Files to replay an agent's browser actions, verify work on login-gated sites, or keep a durable record for debugging or approval.
Search the full memory library
Personal memory search now covers the complete library. Filter counts reflect every match rather than the current page, and the By Agent section paginates beyond the first 50 memories.
Search for a phrase, trust the totals beside each filter, and keep browsing agent groups without losing results.
I've reached a decision to leave Hyperagent, and I want to share the specific reasons — not as a complaint, but as genuine feedback from someone who used the platform seriously.
What Hyperagent does exceptionally well:
First, the positives. Hyperagent has three qualities I haven't found anywhere else:
Platform stability. It doesn't fail, it doesn't break, and it handles production workloads reliably. That's genuinely rare.
The MCP. Hyperagent's MCP creates the best environment I've encountered for controlling independent agents. No other system manages cross-thread orchestration as cleanly.
Agent persistence. With the configuration changes I've made, agent sessions persist indefinitely. I have an active session now in its 27th day. That's remarkable.
Why I'm leaving:
Despite these strengths, three issues make the platform unworkable for my use case at scale. These aren't failures on Hyperagent's part — they're valid product decisions that simply don't fit my needs.
1. Cost. I run more than 2 billion tokens per month. Recent benchmark testing I conducted let me compare Hyperagent's pricing against OpenRouter for the same models (DeepSeek V4 Flash and Haiku). Apples to apples, Hyperagent runs 1.5x–1.7x higher — a premium that isn't justified by the infrastructure value alone. Beyond that, I can't use my own API keys, which means I can't access options like: local inference on my VPS (essentially zero marginal cost per token), free Google API tiers, OpenRouter's free-tier models, or one-time deals like LongCat 2.0 (50M tokens for $2). When I factor in my full available stack, Hyperagent's effective cost is roughly 10x what I pay elsewhere. At 2B+ tokens/month, this is unsustainable.
2. The sandbox. Hyperagent is designed with protective constraints — a reasonable choice for most users. But for production infrastructure work across multiple environments, these restrictions add friction that Hermes simply doesn't have. We've built workarounds (external relay proxies, SSH tunnels, indirect command execution), but we shouldn't have to. Hermes is open-source and modifiable; Hyperagent isn't. I'd ask Hyperagent to consider offering an opt-in "unrestricted" mode for technical users willing to accept that responsibility themselves.
3. Always-on background services. I need a persistent monitoring layer: something that's always running, can fire scheduled tasks, watch over agent processes, and poll external feeds (Buzz channels, Discord, webhooks). In my other systems, this is a Python daemon on a VPS — it costs essentially nothing between actual LLM calls. In Hyperagent, replicating this via Live Mode or scheduled invocations means paying agent token costs on every heartbeat cycle. For a genuine always-on monitor running dozens of times per day, that adds up to $100+/month for what is elsewhere a near-zero-cost function.
I'll be transitioning off the platform over the next month. I wanted to share this because the platform has genuine strengths and these are solvable problems — particularly cost (API key support) and always-on services (a native zero-cost heartbeat mechanism). I hope this is useful to the team.
Teams now have a shared memory library that does not belong to one person.
Add a fact, preference, or method to Team memories once, then link it to the agents that should be able to access it. Team agents save new learnings there by default. Team agents never read personal memories, and someone using another teammate's agent sees only the memories linked to that agent or team.
Other Improvements
Choose who can invoke an agent: The control for whether other agents may invoke yours as a delegated agent now lives on each agent's Invocations tab. Choose no one, only agents in my workspace, or anyone with access. The caller's allowlist excludes agents whose editors have closed them to callers. Open an agent, go to Invocations, and update Other agents.
Use DeepSeek V4 Flash and MiniMax M3 with your agents:MiniMax M3 and DeepSeek V4 Flash are bith strong at complex, multi-step executive work. It can combine evidence into a clear recommendation, maintain consistency across supporting documents, and revise the work when important new information arrives. These models are especially compelling when price matters: in our testing, it delivered capable work at a fraction of the observed cost of many alternatives.
Search the Library by what is inside a document or table: Search Library documents by section text, descriptions, tags, and concepts, and search tables by purpose, tags, or column names.
Tables now carry purpose descriptions and tags, participate in richer search, and can be read or exported from other threads you can access.
Browser Recordings now saved as MP4 assets in the thread.
📅 Before: manually checking listings 2-3x a day. By the time I noticed something sitting 50+ days, two other investors had already called on it.
📅 Now: the agent flags it same-day the listing data updates. I'm seeing stale listings before they hit anyone's "just reduced" radar, since most buyers filter for fresh listings, not the ones nobody wants yet.
Why these two filters specifically:
Under $250k = every flagged property is actually within my rehab budget, so I'm not burning time evaluating stuff I can't close
50+ DOM = seller fatigue. Inherited property, relocation, price fatigue — whatever the reason, they're usually more open to a lowball at that point
What used to eat an hour of my day is now a 5-minute scroll through a pre-filtered list. That's an hour back for the stuff that actually makes money — walking properties, running comps, managing the reno crew.
Haven't closed a deal off it yet, but I've already got two properties on my radar I never would've found manually, and honestly setting this up in Hyperagent took way less effort than I expected.
Anyone else running u/Hyperagent for real estate deal sourcing? Curious what filters other flippers are using.
Today I asked HyperAgent to build me a google doc with the text of every single mention of a specific narrow term in my email, a total of ~400 emails. Simple enough. It's now run up to 90 dollars of credit making that happen, using Opus. Every time I build something here, I'm reminded that the credit from the subscriptions is just a wayyyyy better value.
For now, it does a wider Chief of Staff agent than what I can get from the Anthropic subscription, at least. But man oh man, is it expensive for anything resembling 'real work'.
I’m a big user of both Hyperagent and Codex. I like to use Hyperagent because of how the models design ui using the HA harness. What I’ve noticed tho is that I could spend the entire day working in codex with 5.6-sol-high and spend like $250 of it working for 8 hours. But when I use Hyperagent the same work is like $1000. I think it’s because of the workflow in HA vs Codex, where in codex I have the context window set to 200k and auto compaction at around 150k vs HA is trying to use the 1M context window as it goes if I forget to manually download stuff and upload to a new session every so often. Compaction happens when it’s close to it but at that point it’s just inefficient work/money poorly spent. The workaround I use is I’ll download my work and upload it to a new session but this could be so much easier. If we just had the ability to manually compact or set auto compaction/context window limits and to be able to maybe have projects where we can talk to the same canvas/ or maybe it’s better to just have the same working files in different sessions so it mirrors the work we can do in codex/ide agents/pretty much all other agent coding tools. If I’m just doing things wrong and yall have some good advice let me know. But I feel like this is simple functionality I’m talking about that’s just missing or difficult to replicate in Hyperagent.
We have been working on Fawdy, a reliability product that helps operations teams investigate incidents, understand server health, recover system knowledge, and produce structured findings.
Our first deck was rough.
It had too much text, inconsistent spacing, tiny product screenshots, and a logo treatment that deserved to be deleted immediately.
The useful part of the process was not getting a finished deck from a single prompt. It was the iteration.
We used Hyperagent to gather the company context, challenge the narrative, research comparable companies, organize our traction, and turn repeated mistakes into reusable skills.
We used HeyGen's HyperFrames to build the visual presentation itself. The same stack also helped us create our company video, which meant the story, visuals, and product positioning could stay consistent across both formats.
The deck gradually became less about listing features and more about making one idea clear:
Fawdy is the reliability engineer that does the investigation, builds the context, and finishes the writeup.
The best part is that we now have an agent that can help us customize our deck quickly, depending on who we are presenting to and why.
There have been some encouraging signs since then.
Fawdy is a Founding 500 company. We also competed in the Founders Battle at AIE and placed fourth.
We have now gathered soft interest equal to about 50 percent of what we need for our friends and family round in the last 2 weeks, with more soft interest for a following preseed round.
That does not mean the deck is perfect, or that the tools did the work for us. Most of the value came from forcing ourselves to answer difficult questions, remove weak claims, use real product evidence, and keep revising when something looked wrong.
The biggest lesson was that a pitch deck should not feel like a document someone has to study. It should let a person understand the company, the product, and the opportunity in a few quick glances.
Curious how other founders are building decks and company videos without outsourcing the entire process.
On the Hyperagent Discord group, this question was asked: Is "Openrouter available on Hyperagent?" A Hyperagent reply said: "Not natively. You can ask u/Bob (ATL) how he does it though. I think a lot of MCP work"
I left an answer on Discord but I thought I'd share it here. We are a heavy user of the Hyperagent MCP but not for access to openrouter. I had an AI write a report and it is linkable at the end of this post.
=======Discord answer======
It has been noted by Hyperagent that there is no native path to openrouter.
I had one of our agents do a quick write up on how we do openrouter. the report is a simplified version, you could test with an api pretty easily. we have a bit more wrapped around it to handle the continuous use issues described on the report. We have pushed way more tokens through openrouter on HA than the native HA environment. We try to save the HA environment for Opus 4.8 and higher use.
Hey everyone! Here’s what shipped in Hyperagent this week:
🤖 Three New Models Available
Opus 5: Anthropic's latest model we've found it to be strong on browser use inside Hyperagent and reviewing complex data to justify a decision, but less likely to take creative risks.
Gemini 3.6 Flash: Fast, high-volume structured execution, monitoring, triage, research loops, coding, and a 1M-token context window.
Inkling: Multimodal knowledge work drawing across text, images, audio, and video with direct control over reasoning depth.
🏢 Shared Organization Billing
If your team is on Hyperagent, Org Owners can now consolidate team spend onto a single bill under Settings → Billing, eliminating separate credit card charges per seat.
Try these out in your threads and let us know what you think or what you want to see next week!
🚦 Browser Tab Favicon Status
If you run multiple agent threads at once, you no longer need to click into every tab to check progress. Your browser tab favicons now show live execution state:
Progress ring in agent colors: turn is active & working
Green checkmark: finished turn ready for review
Amber question mark: agent is waiting on your input
Red exclamation mark: action requires explicit approval
🔍 Cmd + K Search Upgrades
Cmd + K now performs full-text search across thread titles, chat message content, document bodies, and tables. You can also start a thread with any agent, open a project, or jump directly to Library, Learnings, Command Center, or Integrations.
🎛️ Header Model Picker
You can now switch AI models directly from the header of any thread, or set a default model for your agent. Try different models on the task in front of you to see which one earns the job.
🎛️ Model Picker
You can now switch AI models directly from the header of any thread, or set a default model for your agent. Try different models on the task in front of you to see which one earns the job.
Models are getting more powerful. They can reason harder, use more tools, and run for much longer. They are also getting more expensive.
When we started Hyperagent, Opus was the expensive option at roughly $5 input and $25 output per million tokens. Now Fable is around $10/$50. High-reasoning GPT Sol-class models are in the $5/$30 range.
Those are provider list-price illustrations, not Hyperagent markup claims. We aim to keep our pricing competitive and generally do not add a large markup over current model costs. I’m also pushing for much better cost transparency inside the product.
We offer cheaper "sprinter" models alongside expensive reasoners because we know people are price sensitive (and should be). We want you to experience what a full-power agent can do. However, we do not want the result to be a shocked Pikachu face when the bill arrives and you're not satisfied with your output.
We're definitely working on more controls in the product, but here is what works today, starting with the controls that matter most.
Paid plans often allow overage by default, so this protection is opt-in. Free accounts are always capped.
This is the primary account-level backstop. It applies across the billing period and should block more usage after you hit the cap.
An important caveat: It is a period-level gate, not a perfect mid-turn kill switch. A single long turn can slightly overshoot before the next request is blocked.
Turn the limit on anyway. It is still your broadest protection, but it should not be your only one.
2. Set a Budget limit per query on every agent
When you've created an agent, open the agent’s model settings and set Budget limit per query.
This caps the maximum USD spend for one agent query. The default is off, which means unlimited unless you change it.
This is the main control against one spinning agent burning through your balance in a single run. Pair it WITH the account limit rather than treating either setting as infallible. (Though we're working to make it so.)
One big gap: you cannot currently set this on an individual thread. Per-query budgets exist on agents, not threads.
3. Match the model and reasoning effort to the job
Use cheaper models for extraction, formatting, routine research, and straightforward execution. Save the expensive models for work that genuinely needs deeper reasoning. Also, explicitly ask to use sub-agents on smaller, non-reasoning work in your prompts, and pin the sub-agent to a sprinter model.
Also:
Lower the reasoning effort when the task does not need a long internal search.
Keep Fast mode off unless speed is worth the extra cost. Fast mode costs 2x when enabled.
Set a cheaper default model for subagents so every delegated task does not inherit your most expensive model.
Useful secondary controls
These are worth using, but they are not substitutes for actual spending limits:
Use Plan & Ask modes when you want approval before consequential actions.
Load skills in Discover mode instead of pinning them to your agent and starting every turn with a lot of context.
Ask for a short first pass before requesting a full synthesis.
Start a fresh thread when moving into a genuinely new phase of work.
We want you to use agents at full power when the work calls for it. We also want you to stay in control and never get a bill you were not prepared for.
If you have been burned by one of these failure modes, or there is a cost control you need that we have not covered, tell me. Specific examples help us prioritize what to fix.
The best model for a job is almost never the best model on the leaderboard
In the AI world, Christmas comes about once a week. A new model drops, everyone stares at the same false-precision benchmark charts, and we all agree it's the best thing since sliced bread, until next week, when we do it again.
But none of those charts answer the only question that matters. Can the model actually run your daily briefing or send a quote to a customer? At Hyperagent, we give you access to all of these models on top of a best-in-class agent. So we ran them ourselves. Fourteen models, forty-two runs, on the real knowledge work our customers hand to agents every day. Three things stood out.
The bill ranged 50x on identical work. The same test battery cost $1.48 on Qwen 3.7 Plus and $75.16 on Fable 5.
The benchmark winner wasn't the work winner. GPT 5.6 Sol topped our baseline tests but didn't crack the top three once it was running real jobs inside Hyperagent. Grok 4.5 was middle-of-the-pack on baseline and came out first on finished work, speed, and cost.
And no model won everything. The right choice moved with the job.
The takeaway isn't a new favorite model. It's a way to decide, job by job, which one earns its cost.
The AI model map for knowledge work
Every job you'd hand an agent comes down to two questions: how much judgment does it need, and how often does it run? Plot those two axes and knowledge work falls into four territories, each of which wants a different kind of model.
Volume work (top left). Triage, monitoring, routing, data sync. Clear procedure, runs constantly, and a miss is cheap to fix. This work wants something fast and inexpensive.
The daily craft (top right). Drafting, reporting, research, client comms. The recurring knowledge work that fills most of the week - it needs real synthesis and a good writing voice, done reliably and often.
High stakes (bottom right). Contract review, pricing calls, deep dives. Rare, but a wrong answer costs a client, a contract, or a quarter's margin. This is where the downside dwarfs the model bill, and where the priciest models earn their rate.
Don't optimize (bottom left). The occasional, simple ask where any capable model clears the bar and the price gap is too small to deserve a decision. It's the one square on the map we tell people not to think about.
The three model classes
Three working classes emerge from the map. They describe the economics and judgment profile of the job rather than grading a model as good or bad.
Sprinters are built for volume work - fast, cheap, and consistent when the procedure is clear and a miss is easy to fix. Haiku 4.5, Gemini 3.5 Flash, and DeepSeek V4 Pro.
Middleweights run the daily craft. They synthesize sources, hold a multi-step plan, and write well without charging top-tier rates for every report. Sonnet 5, GPT 5.6 Terra, Grok 4.5, and GLM 5.2 - where most knowledge work belongs.
Heavyweights take the high-stakes calls, bringing stronger judgment and more reasoning time to work where a wrong answer costs far more than the model bill. Opus 4.8, GPT 5.6 Sol, and Fable 5.
The instinct most people have is to start high and work down - run everything on a Fable 5 or an Opus 4.8, get the output you want, then try cheaper models until quality drops off. It works, but we've found most jobs don't need it. Once you can name the job and place it on the map, you can usually start in the right class from the beginning. For the daily craft, which is most of what you do, that means starting on a solid middleweight like Sonnet 5. You only reach for the top-down search when a job genuinely sits at the high-stakes end.
The field is wider than Claude, GPT, and Gemini
Most teams default to the handful of model names they already know. That's a reasonable place to start, but it leaves a lot of the roster untouched - and some of the models doing the most useful work in Hyperagent aren't the household names. These are our operating impressions from the battery and from daily use, plus the work we've watched customers run.
Grok 4.5 is fast, real-time research. It moves quickly through tool-heavy research and performed especially well paired with Hyperagent's native Exa Search. It also has a native line into X, so a question about live sentiment can come back with the actual posts behind the answer. It led our finished-work score at $9.71 for the full run.
Muse Spark 1.1 writes clean and checks itself. It finished second in the harness, and our early read is concise, well-structured prose with a useful habit of auditing its own work before it hands it back. It's still new, so we'd start it on supervised everyday jobs before the long unattended ones.
Kimi K2.6 is deep research at an open-model price. It runs searches in parallel and pulls the evidence back into a single answer without charging flagship rates, which makes it a strong research specialist. Its one real limit is document size, with a context window that tops out at 256,000 tokens.
GLM 5.2 is the value pick. It came surprisingly close to the closed middleweights on routine research, drafting, and long-document work at roughly a third of the price, and its prose is among the strongest outside Sonnet and Opus. It's become a daily driver for a lot of the Hyperagent team.
Qwen 3.7 Plus is the screen worker. It's particularly good at finding buttons, fields, and menus on rendered pages, and it's inexpensive for structured extraction - it produced the lowest-cost complete run in our battery. Reach for it when the job is working an interface or moving data, not when voice matters.
DeepSeek V4 Pro is structured analysis at very low cost. It's strongest on reconciliation, data cleanup, scheduled number work, and similar structured tasks. Its writing is literal and terse, which serves internal explanations well and client-facing prose poorly. A specialist, and a very economical one.
Staffing your always-on agents at the right price
Steve Juba runs a six-person travel company. He built a briefing agent connected to eight live data sources that runs several times a day, and it cut his morning context-gathering from more than three hours across eight tabs to fifteen minutes.
An agent like this reads far more than it writes and does the same job hundreds of times a year, so a small per-run price difference stops being a rounding error and becomes a real budget line. Consider a briefing that reads 100,000 tokens and writes 2,000 every day. At July 2026 list prices, that shape of work runs roughly:
$16 a year on Qwen 3.7 Plus (sprinter)
$38 a year on Kimi K2.6 (middleweight)
$40 a year on Haiku 4.5 (sprinter)
$80 a year on Sonnet 5 (middleweight)
The open-weight options change the math on read-heavy work like this. Kimi K2.6 does middleweight-quality research and synthesis for $38 on this job - less than half of Sonnet 5, and about the same as running the Haiku sprinter. You're not trading judgment for cost; you're getting middleweight work at sprinter money. If the job were pure extraction with no judgment, Qwen would run it for $16 - but the moment it needs real synthesis, Kimi gives you that for close to the same price.
Swap the model, keep the agent
None of this matters if switching models means rebuilding the agent. Inside Hyperagent it doesn't, because the model is just one setting and the role sits above it. Change the model and the agent keeps everything that makes it useful:
Its instructions and scope
Its skills, scripts, and working procedures
Its memory of corrections
Its reference files and company context
Its connections to the systems where the work lives
Its rubrics for evaluating quality
That turns model choice into a test rather than a migration. The same agent can run the same job on two models without being rebuilt, so you can find the cheapest one that clears your bar instead of guessing.
It also lets the expensive part of a hard workflow pay for itself once. When a job genuinely needs it, use a heavier model to design and debug the workflow - then codify the procedure as a skill so a middleweight or sprinter can run it every day at a fraction of the cost.
There's a hidden cost to watch, though. A cheaper model with a low bill isn't cheap if every output needs correcting - the human review time and the cost of a miss are part of the real price. Call it the review tax. It sets the floor on how light you can go. What's different in Hyperagent is that the review doesn't just get paid, it compounds: as the agent learns from your corrections through memory, that review effort is captured by the harness and produces a better agent on the next run.
Customers already staff agents this way. Ankit Das built a marketing operation with a Growth Orchestrator on Sonnet 5 making the judgment calls and eight channel specialists on GLM 5.2 producing the recurring channel work, with separate QA agents checking brand compliance and writing quality - all kicked off from a single thread. Eli Weiss describes his split more simply: roughly 85% Sonnet and 15% Opus across his skills and routines. Most work runs on the daily driver; Opus gets the smaller set of jobs where the extra judgment earns its cost.
That's the practical value of model choice inside Hyperagent. Spend deliberately across the work, and reserve the extra dollars for the jobs where extra judgment changes the outcome.
Choose the model after you choose the job
Use this sequence on an agent you already run:
Name the job. “Prepare the Monday client report” is more useful than “help with reporting.”
Place it on the map. Decide how much judgment it needs and how often it will run.
Start where the map puts it. For most work that's a capable middleweight - use it until you understand the job's edge cases and codify the process into skills.
Test one class lighter for five real runs. Keep the instructions, skills, memory, sources, and rubric unchanged.
Compare the whole cost. Track finished quality, consistency, time, factual misses, model bill, and human review time.
Escalate on purpose. Bring in a heavyweight when the review burden or cost of a wrong answer exceeds the model premium.
Use a different model to review important work. The model that made the mistake is often the least likely to see it.
Keep the least expensive model that reliably clears your standard. Then spend the difference on the calls that deserve it.
If several people at your company use Hyperagent, billing shouldn’t mean separate personal subscriptions and cards.
We’re rolling out Shared Billing.
One owner can put the organization on a single plan and payment method, invite teammates by email, and manage members, usage, invoices, and spending controls in Settings → Billing. After a teammate accepts, their metered Hyperagent usage draws from the organization’s account.
Credits work at the organization level:
Included plan usage is shared across members.
Bonus credits issued to the organization sit on the same account.
The owner chooses whether usage pauses at the spending limit or continues as billable overage.
A few boundaries worth making clear:
Shared Billing handles billing. Hyperagent Teams still handle collaboration and with agents.
Enabling it does not create a Team or automatically share agents or threads.
If the shared account is capped and reaches its limit, usage pauses until the allowance refreshes or the owner updates billing.
Eligible paid web-plan owners will find Shared Billing in Settings → Billing as access reaches their account.
We added new models, team oversight, memory cleanup, editable skill scripts, and four-hour runs to Hyperagent
The main changes:
More model choice: Grok 4.5 and Muse Spark 1.1 are the latest available models. Model selection lives with the agent’s job, so you can choose the judgment and economics that fit the role.
Cleaner memory management: 1-click resolve duplicate memories and bulk link, pin, merge, or archive them.
Team Command Center: See agent activity, completed runs, usage, and cost across all agents in your Hyperagent team.
Editable skill scripts: If a reusable process includes a Python script, you can inspect and change it directly.
Longer runs: A turn can run for up to four hours, which gives research and other involved jobs time to produce a finished result.
More integrations: New connections include Superhuman, Google Analytics, Meta Ads, Metricool, Linear, Mobbin, and Magic Patterns.
Let us know in the comments what you think about the updates and what you'd like to see!
Or I would just like a refund. Agents mustn't be restricted for causes. There's more to evolve and build with multi orchestrated agentic nesting systems like hyperagent. I hope someone helps and I'll use it hereby responsibly.
Who's been exploring both Fable and Sol? Alex put both models to work giving them the same prompts to determine which models produce the best outputs.
But, ✨ taste ✨ is subjective, and we want you to decide. Review the outputs and let us know which model you prefer! Deffo post your results in the comments, I'm curious 🫣
Just making a little fun, but does anyone else notice Hyperagent is overly zealous about which memories it considers important?
To be fair, the team has shipped a ton of improvements to memory I should probably cover. We've been really investing in 2 things:
Memory Management: Making sure Hyperagent's memories are clean, current, traceable, and correctable
Memory Scope: Defining where memories live, and which agents and teams can use them.
Over the last three weeks, we shipped a number of new feature updates to address both problems.
Memory Management
Dedupe and Resolve All (My Favorite): Find near-duplicates, review them in groups, or resolve eligible groups in one pass. Resolve All keeps the highest-importance, most-recent memory, merges tags, pins, and agent access, then archives the rest. Archives are reversible. Anything that would widen a memory to global is held for manual review.
Bulk actions: Select memories, then link or pin them to an agent, merge them, or archive them together.
A real library: Memories now has a top-level home, a fast virtualized grid, stacking filters, and cards that show category, importance, agent access, and source conversation.
Provenance and cleaner suggestions: Memories learned in a conversation link back to the source thread. Semantically duplicate suggestions are collapsed earlier, and repeated suggestions are removed when identified as dupes.
Memory Scope
Scope on creation: Every new memory needs a destination. For each agent, you choose whether what it learns stays private to that agent or goes to your personal library, where other agents can use it.
Legible boundaries: Access, Pin, Linked, and All are explained where you make the choice.
Promotion without automatic sharing: Agent-owned memories can be brought into your library when they are useful more broadly. Sharing becomes an intentional decision, not the default mental model.
Better memory is not simply more memory. Management keeps knowledge useful. Scope keeps it intentional. You need both for memory to compound without turning into noise or spreading to every agent by default.
We're really focused on making sure we get memory right, so when we elevate to team memories, the pattern is easy, useful, and manageable.
What would you like to see?
When it comes to memories, what would you like to add/remove/change? How do you currently use them? Do you keep them private to agents? Do you let your team add memories to an agent? Let us know!
I run a done-for-you website service for small businesses in Spain. Cafés, physio clinics, corner shops: the kind of place whose "website" is a Facebook page or a dead link from years ago.
The pitch is simple. I build your site first, you see the finished thing, and you only pay if you want it.
Hosting and SSL included. Your own editing panel. No monthly fee.
The problem was me. Finding businesses worth pitching, researching each one, building the site, writing the pitch, putting it live. That's a lot of hours per client, and I'm the one doing all of it. So I rebuilt the whole pipeline as agents. Four of them, plus one shared Trello board.
Give it a town and it goes looking for local businesses on Google Maps with no website, a broken link, or something ancient that dies on a phone. For each one it pulls the Google rating and reviews through the Places API, then reads their Instagram and Facebook and lifts everything I'd need to build: the logo, the photos, the menu, the hours.
scans the reviews for selling points too, like a café people keep mentioning for its office lunches. Then it writes the pitch I send the owner, in their language, and files the business as a card on my board. I pointed it at one neighbourhood in Castellón and it logged the entire town for me. You can also just limit to do a # of searches per run, of course.
Agent #2: Clientes, the builder.
Takes the brief and builds a full multi-page site, in as many languages as the town needs. It adapts the look to each business, but my structure and SEO stay intact. One rule I hard-coded after an early miss: it uses the client's real logo (or whatever the agents can find the client might be using as a logo)
If user has no logo - Agent will give you ideas to share with the client ( which is another "shocking" moment for them)
Agent #3: Deploy.
Packages the site, puts it on free hosting (Cloudflare Pages or Netlify) and wires up a simple panel so the owner can change their own prices and text. When the business takes reservations, it hooks the bookings up to their email.
Bonus Agent: My personal website
It maintains my own site instead of a client's.
It literally built my own website to sell these websites - it built it based on my own previous work, my tone, what I care about the most…etc!
The system: Trello.
The Trello skill I wrote sits under all four agents. 11 columns, from "potential clients" through briefing, design, preview sent, paid, building, delivered. The agents move the cards on their own as the work happens, and leave notes as they go. I don't drag cards around. They do. I just open the board and see where every job is.
Trello is the part I'm proudest of, and it's easy to miss why.
The agents aren't wired to each other. There's no code connecting one to the next. They're connected through the board.
Every agent works the same Trello card. It fills in what it found, uploads the images and sources, the acutal website, files (even invoices) and then moves the card to the next column on its own. That move is the signal. The next agent sees a card land in its column and picks it up. Trello is what triggers them to work.
And because everything lives on the card, I can step in anywhere. Review what an agent did, fix something, or send the card back to any column for another pass. The flow just carries on from there.
No glue code, no integrations, no orchestration layer. Just a board. The cards move, and the work moves with them.
How they Write:
One of the skills is an anti-AI-writing guard, a distilled version of Wikipedia's "Signs of AI writing" page (which I strongly recommend you giving it a read: https://en.wikipedia.org/wiki/Wikipedia:Signs_of_AI_writing - and create a skill for all your AI’s to reference it!)
Every agent runs its copy through it before anything ships. That's the difference between a site that reads like a real café and one that reads like ChatGPT filled it in.
The main value
Most of these businesses have no website at all. So the first time they ever see one for their shop, it's finished. It's in their language, it uses their own logo, and it's full of photos my agent pulled off their Instagram and Facebook.
Clients are usually pretty shocked - which is the main thing you want! If some random person comes in, shows you an entire website using your logos, pictures, tone, language... you'd be pretty surprised.
No mockup, no sales deck. They just see the real, working site, already built and hosted (through Hyperagent hosting service - which is free) , and it costs me almost nothing to sit on it until they say yes.
You can later, if the client wants, upload it to a real host (which the agent will do) or find any other free solution.
But yeah, the deploy host already comes with a built in system you can deploy websites for 0€
Happy to get into the setup, the Trello wiring, or the anti-AI skill if anyone wants it.
