u/Smart_War3981 — reddlx

▲ 1 r/GPT3+2 crossposts

Has anybody else tried Hyperagent?

I never see many people discussing Hyperagent so I just wanted to post my experience and wondered has anybody else tried it?

Spun up a Hyperagent DevOps agent this morning. Had a few real issues, there always are, right? The actual difference was in the platform giving the agent the ability to correct course, for more than just the session.

The task: TypeScript Fastify gateway for three internal services. OAuth2 + API keys, Zod, rate limiting, structured logs, Vitest suite, Docker image, and CI/CD on tag.

The runtime: 3 hours. Straight.
My active time: Maybbeee, 35 mins?

The agent got the core path right out of the gate. Auth middleware, proxying, rate limits, request ID prop—all clean. The subagent even caught a header-stripping bug on 401 responses that I would've 100% shipped.

About 45 minutes in, the agent tried to pull a specific internal dependency that had been recently deprecated in our registry. Since the agent's knowledge cutoff predates that change, it didn't know the replacement existed. I told the agent that it had been deprecated, normal course correction. What was impressive was how the agent was able to handle that. It didn't just blindly swap the lines. It removed the old dep, searched for an equivalent, updated the relevant import paths to match the new API surface, and kept the tests running. But the real kicker? The agent also added a memory without me saying a word, using Hyperagent's built-in Memory. It logged that specific deprecation into its persistent system. In my experience it’s one thing to give an agent a tool for memory. It’s another to create one and the agent persistently use it without having to request it directly. Hyperagent closes that gap well.

Beyond that one hiccup, everything else was smooth. Wrote the GitHub Actions YAML from scratch, built the multi-stage Dockerfile, and hit a clean 94% test coverage, zero lint errors, and a ~38MB image on the first tag push.

The real math:
My old workflow for this exact spec (scaffold, wire auth, manual curl debugging, hand-write CI, fight registry permissions) takes me a whole day, maybe 4-5 hours. Hyperagent allowed me to manage this from my phone, and I some 35 minutes instead of 4-5 hours.

This run only costed me $66.80. And that $66.80 came from signup credits, so essentially costed me nothing.

I’ve worked with AI since they were made available to the public, and I’m honestly impressed with the platform. If you haven’t checked it out, do it. A couple google searches will get you credits. The links are out there. https://hyperagent.com also had the agent make that cool little photo for the post 😂😂

u/Smart_War3981 — 13 days ago

▲ 2 r/Claudeopus+3 crossposts

I shipped a production API gateway end-to-end today without rage-quitting six times

Spun up a DevOps agent in Hyperagent this morning with a clear brief: TypeScript gateway in front of three internal services, OAuth2 + API key auth, request validation, rate limiting, structured logging, full test suite, Docker image, and CI that deploys on tag.

Connected GitHub through a protected skill workflow (creds never hit the prompt), gave it shell + git, and locked four rules:

- Full test suite after every change

- TypeScript strict + Zod on every inbound/outbound payload

- Conventional commits + semver after green runs

- Coverage/lint/build report on every push

Runtime ~3 hours. My active time maybe 35 minutes.

Rough sequence:

Scaffolded Fastify, esbuild, vitest, lint-staged. Hit our token introspection endpoint early — docs were wrong on the claim names. It paused, asked one clarifying question, I answered, it moved on.

Core path landed first: auth middleware, route proxying, per-key rate limits, request ID propagation. Tests green, clean commit to a feature branch.

While it wrote the Dockerfile and multi-stage build, a subagent ran integration tests against mocked upstreams. Caught a header-stripping bug that dropped `X-Request-Id` on 401s — unit tests never hit that path. Parent patched it, re-ran everything: 52 tests, all green. Then wrote GitHub Actions from scratch — lint/test, build + push image to GHCR on version tag. No template.

Final check: pointed it at a real staging upstream. First request authenticated, rate-limited, and logged correctly. It also dropped a runbook into the repo (auth flow, how to rotate keys, common failure modes) without being asked.

94% coverage. Image ~38MB. Zero lint errors. One tag push from staging.

Only blocker: no npm in the sandbox; I asked my agent how we could install it. 3 minutes later I had a working, reusable skill file and script to download npm whenever I needed it.

Old workflow for me: scaffold locally, wire auth, miss edge cases, rewrite, manual curl debugging, hand-write CI, fight the registry, deploy. Easy 1-2 days. Agent did it in an afternoon with tighter tests than I usually ship, and caught a bug I would’ve merged.

Cost: $41.80 for this run. ~$58 total across this plus two other agents from the starting $1,000. So literally FREE.

Anyone else tried Hyperagent yet? What’s the most non-trivial thing you’ve actually shipped this way? If you haven't try it out. https://hyperagent.com

u/Smart_War3981 — 21 days ago

▲ 21 r/ChatGPT

AI shouldn’t be put in a special “safety” box that would break society if applied anywhere else

I’m sorry but this whole “a model *could* be jailbroken or misused, therefore access should be removed” standard is insane.

Every powerful tool can be misused. Every single one.

A phone can be used to coordinate crimes.
Google can teach you dangerous shit.
GitHub can host exploit code.
A compiler can build malware.
A car can kill someone.
A nurse or doctor has access to knowledge, meds, private info, and vulnerable people.
A gun can kill someone.
A lighter can start a house fire.
The internet can be used as a national security thread at a mass scale. (is the internet banned the internet yet?)

We don’t ban all of those things because someone finds a contrived way they *could* be abused. We punish the person who actually abuses them.

That’s the part that feels completely backwards with AI right now. People are trying to shove AI into this separate “safety” category where normal logic stops applying. If the same standard were applied across the board, modern society couldn’t function, the entire infrastructure the modern world is built from would collapse if this standard were applied across the board.

A jailbreak existing should not be enough to pull a model. Every model can be jailbroken. There isn’t a model released that I cannot find a jailbreak for in 5 minutes on Reddit. That’s not some shocking discovery. That’s what happens when you build something that can reason through language. Language can manipulate humans too. You don’t solve that by banning humans from having jobs.

\*\*The standard should be actual harm, not hypothetical harm.\*\*

If a model is causing a massive wave of illegal activity, and the provider refuses to fix it, fine, then intervene. At that point it’s a real system problem.

But if 1 out of 100,000 users finds some weird edge-case prompt that makes a model say or do something it shouldn’t, that’s not a reason to remove access for everyone. That’s a person abusing a tool to commit a crime. It happens and is accepted every single day. So notify the provider, make it harder to repeat it, and if someone committed a crime, prosecute that person. End of story.

The government should not be able to point at a lab demo or a “potential jailbreak” and use that as a kill switch for public access to intelligence. They should not have that kind of power, especially without justification.

That’s not safety. That’s pre-crime logic.

Regulate actual illegal acts. Hold providers accountable if they knowingly enable mass abuse or refuse to fix proven real-world harm. But stop pretending AI needs a totally different standard that would make every other powerful technology illegal if we applied it honestly.

If things continue on this path regular users will end up with no AI access at all. Thats where this leads.

reddit.com

u/Smart_War3981 — 2 months ago

▲ 1 r/GPT3+1 crossposts

I built a coding agent last week that shipped a production MCP server while I was at lunch.

I'm a developer. I've been scaffolding and wiring up MCP servers manually for months — scaffold locally, write tests, catch the edge cases I missed, rewrite, test against a separate MCP client, write the CI config, debug the CI config, publish. That's a solid 2–3 days of focused engineering work per server. I was curious if an agent could do it better.

So I built a "Project Developer" agent inside Hyperagent. Its job: take a brief, scaffold a TypeScript MCP server from scratch, implement the tools, test everything, and ship to npm with working CI/CD. I connected it to my GitHub via a protected skill workflow — the key is stored outside the chat, never injected into a session. I gave it four standing rules:

Run the full MCP test suite after every code change. No exceptions.
Enforce TypeScript strict mode. Validate all API responses against Zod schemas.
Commit with semantic versioning after every passing test run.
After every push: generate a markdown report of test coverage, lint status, and build health.

Then I kicked it off.

Here's what happened:

The agent scaffolded the project — TypeScript, esbuild, vitest, lint-staged — and got to work. It hit the first real wall about 20 minutes in: our internal API uses a custom auth header that isn't well documented. Instead of guessing and burning through credits, it paused and asked me one specific multiple-choice question about the auth flow. I answered. It kept going.

By hour 2, it had three core MCP tools implemented and passing: query_resource, validate_payload, and sync_batch. Clean conventional commit. Pushed to a feature branch via the native Git integration.

I came back at hour 4. The agent had already spun up subagents — one handling the integration testing layer, another working the npm packaging and README in parallel. The subagent flagged something I hadn't asked it to look for: a race condition in sync_batch that unit tests don't catch. It reported back to the primary agent, which patched the bug, regenerated the lockfile, launched another subagent to harden the test infrastructure, and re-ran the full suite. 47 tests. All green. I didn't touch anything.

The CI/CD workflow came next — GitHub Actions, automated testing across Node 18/20/22, version-tag publish job. Written from scratch, no template. Another clean commit.

I went to lunch.

Hour 7: I came back and it was still running. The full MCP server was live inside the agent's VM, executing final integration tests against itself. Then it did something I hadn't asked for: it generated a skill file documenting the architecture, API patterns, and a troubleshooting guide — and saved it directly to Hyperagent's skills integration. Reusable on every future MCP project. It built its own institutional memory.

Final numbers:

Test coverage: 94%
Bundle size: 42KB
Lint errors: 0
Agent runtime: 7 hours, 23 minutes
My active time: ~8 minutes
Total cost: $52.40 (Claude Opus 4.6)

The race condition catch alone was worth it. That's exactly the kind of bug that makes it into production and stays quiet until it isn't quiet anymore.

The part I keep coming back to: the agent didn't just write code. It reasoned about architecture, caught a concurrency bug I would have shipped, and generated a reusable skill so the next MCP project starts with a head start. My previous version of this workflow was 2–3 days. This was 8 minutes of my time and $52.

If you want to try it yourself, sign up with this link! https://hyperagent.com/refer/VVPNKZCF Signing up now with my referral gets you $1,000 in Hyperagent credits to start building.

Has anyone else used agents for serious backend work? What's the most complex thing you've handed off?

https://preview.redd.it/17ng3ojtt43h1.png?width=1344&format=png&auto=webp&s=78721d9e65e4dce130da463873d12869cc74f6dd

reddit.com

u/Smart_War3981 — 3 months ago